Clean up (not compiling because of DVec2 clamping)

Author: Keavon

node-graph/gcore/src/vector/generator_nodes.rs

@@ -150,11 +150,11 @@ impl GridSpacing for DVec2 {
 }
 
 #[node_macro::node(category("Vector: Shape"), properties("grid_properties"))]
-fn grid<T: GridSpacing>(
+fn grid<T: GridSpacing + std::cmp::PartialOrd + FromPrimitive>(
 	_: impl Ctx,
 	_primary: (),
 	grid_type: GridType,
-	#[min(0.)]
+	#[hard_min(0.)]
 	#[default(10)]
 	#[implementations(f64, DVec2)]
 	spacing: T,

node-graph/gcore/src/vector/vector_nodes.rs

@@ -879,8 +879,8 @@ async fn generate_handles(
 // 	_: impl Ctx,
 // 	source: VectorDataTable,
 // 	#[default(1.)]
-// 	#[min(1.)]
-// 	#[max(8.)]
+// 	#[hard_min(1.)]
+// 	#[soft_max(8.)]
 // 	subdivisions: f64,
 // ) -> VectorDataTable {
 // 	let source_transform = source.transform();

node-graph/node-macro/src/validation.rs

@@ -21,67 +21,58 @@ pub fn validate_node_fn(parsed: &ParsedNodeFn) -> syn::Result<()> {
 
 fn validate_min_max(parsed: &ParsedNodeFn) {
 	for field in &parsed.fields {
-		match field {
-			ParsedField::Regular {
-				number_hard_max,
-				number_hard_min,
-				number_soft_max,
-				number_soft_min,
-				pat_ident,
-				..
-			} => {
-				match (number_soft_min, number_hard_min) {
-					(Some(soft_min), Some(hard_min)) => {
-						let soft_min_value: f64 = soft_min.base10_parse().unwrap_or_default();
-						let hard_min_value: f64 = hard_min.base10_parse().unwrap_or_default();
-						if soft_min_value == hard_min_value {
-							emit_error!(
-								pat_ident.span(),
-								"Unnecessary #[soft_min] attribute on `{}` as #[hard_min] equals to it.",
-								pat_ident.ident;
-								help = "You can safely remove the #[soft_min] attribute from this field.";
-								note = "The #[hard_min] also limits the range to same without #[soft_min]",
-							);
-						} else if soft_min_value < hard_min_value {
-							emit_error!(
-								pat_ident.span(),
-								"The #[soft_min] attribute exists on `{}` and is lower than #[hard_min].",
-								pat_ident.ident;
-								help = "You probably meant to reverse the two macros";
-								note = "Allowing the possible range in slider to be more than #[hard_min] doesn't make sense",
-							);
-						}
-					}
-					_ => (),
+		if let ParsedField::Regular {
+			number_hard_max,
+			number_hard_min,
+			number_soft_max,
+			number_soft_min,
+			pat_ident,
+			..
+		} = field
+		{
+			if let (Some(soft_min), Some(hard_min)) = (number_soft_min, number_hard_min) {
+				let soft_min_value: f64 = soft_min.base10_parse().unwrap_or_default();
+				let hard_min_value: f64 = hard_min.base10_parse().unwrap_or_default();
+				if soft_min_value == hard_min_value {
+					emit_error!(
+						pat_ident.span(),
+						"Unnecessary #[soft_min] attribute on `{}`, as #[hard_min] has the same value.",
+						pat_ident.ident;
+						help = "You can safely remove the #[soft_min] attribute from this field.";
+						note = "#[soft_min] is redundant when it equals #[hard_min].",
+					);
+				} else if soft_min_value < hard_min_value {
+					emit_error!(
+						pat_ident.span(),
+						"The #[soft_min] attribute on `{}` is incorrectly greater than #[hard_min].",
+						pat_ident.ident;
+						help = "You probably meant to reverse the two attribute values.";
+						note = "Allowing the possible slider range to preceed #[hard_min] doesn't make sense.",
+					);
 				}
+			}
 
-				match (number_soft_max, number_hard_max) {
-					(Some(soft_max), Some(hard_max)) => {
-						let soft_max_value: f64 = soft_max.base10_parse().unwrap_or_default();
-						let hard_max_value: f64 = hard_max.base10_parse().unwrap_or_default();
-						if soft_max_value == hard_max_value {
-							emit_error!(
-								pat_ident.span(),
-								"Unnecessary #[soft_max] attribute on `{}` as #[hard_max] equals to it.",
-								pat_ident.ident;
-								help = "You can safely remove the #[soft_max] attribute from this field.";
-								note = "The #[hard_max] also limits the range to same without #[soft_max]",
-							);
-						} else if soft_max_value < hard_max_value {
-							emit_error!(
-								pat_ident.span(),
-								"The #[soft_max] attribute exists on `{}` and is greater than #[hard_max].",
-								pat_ident.ident;
-								help = "You probably meant to reverse the two macros";
-								note = "Allowing the possible range in slider to be more than #[hard_max] doesn't make sense",
-							);
-						}
-					}
-					_ => (),
+			if let (Some(soft_max), Some(hard_max)) = (number_soft_max, number_hard_max) {
+				let soft_max_value: f64 = soft_max.base10_parse().unwrap_or_default();
+				let hard_max_value: f64 = hard_max.base10_parse().unwrap_or_default();
+				if soft_max_value == hard_max_value {
+					emit_error!(
+						pat_ident.span(),
+						"Unnecessary #[soft_max] attribute on `{}`, as #[hard_max] has the same value.",
+						pat_ident.ident;
+						help = "You can safely remove the #[soft_max] attribute from this field.";
+						note = "#[soft_max] is redundant when it equals #[hard_max].",
+					);
+				} else if soft_max_value < hard_max_value {
+					emit_error!(
+						pat_ident.span(),
+						"The #[soft_max] attribute on `{}` is incorrectly greater than #[hard_max].",
+						pat_ident.ident;
+						help = "You probably meant to reverse the two attribute values.";
+						note = "Allowing the possible slider range to exceed #[hard_max] doesn't make sense.",
+					);
 				}
 			}
-
-			_ => (),
 		}
 	}
 }