diff --git a/src/execute/layer.rs b/src/execute/layer.rs index e14600548..0d5790edc 100644 --- a/src/execute/layer.rs +++ b/src/execute/layer.rs @@ -819,7 +819,7 @@ fn process_annotation_layer(layer: &mut Layer, dialect: &dyn SqlDialect) -> Resu // non-positional scalar parameters (e.g., PLACE rule SETTING stroke => 'red') if annotation_params.is_empty() { // Add a dummy column so we can generate a valid VALUES clause - annotation_params.push(("__ggsql_dummy__".to_string(), ParameterValue::Number(1.0))); + annotation_params.push(("__ggsql_dummy__".to_string(), 1.0.into())); } // Step 3: Determine max array length from all annotation parameters @@ -1003,16 +1003,9 @@ mod tests { let mut layer = Layer::new(Geom::text()); layer.source = Some(DataSource::Annotation); // Put values in parameters (not mappings) - process_annotation_layer will process them - layer - .parameters - .insert("pos1".to_string(), ParameterValue::Number(5.0)); - layer - .parameters - .insert("pos2".to_string(), ParameterValue::Number(10.0)); - layer.parameters.insert( - "label".to_string(), - ParameterValue::String("Test".to_string()), - ); + layer.parameters.insert("pos1".to_string(), 5.0.into()); + layer.parameters.insert("pos2".to_string(), 10.0.into()); + layer.parameters.insert("label".to_string(), "Test".into()); let result = process_annotation_layer(&mut layer, &AnsiDialect).unwrap(); @@ -1045,13 +1038,8 @@ mod tests { ArrayElement::Number(3.0), ]), ); - layer - .parameters - .insert("pos2".to_string(), ParameterValue::Number(10.0)); - layer.parameters.insert( - "label".to_string(), - ParameterValue::String("Same".to_string()), - ); + layer.parameters.insert("pos2".to_string(), 10.0.into()); + layer.parameters.insert("label".to_string(), "Same".into()); let result = process_annotation_layer(&mut layer, &AnsiDialect).unwrap(); @@ -1125,16 +1113,9 @@ mod tests { fn test_annotation_mixed_types() { let mut layer = Layer::new(Geom::text()); layer.source = Some(DataSource::Annotation); - layer - .parameters - .insert("pos1".to_string(), ParameterValue::Number(5.0)); - layer - .parameters - .insert("pos2".to_string(), ParameterValue::Number(10.0)); - layer.parameters.insert( - "label".to_string(), - ParameterValue::String("Text".to_string()), - ); + layer.parameters.insert("pos1".to_string(), 5.0.into()); + layer.parameters.insert("pos2".to_string(), 10.0.into()); + layer.parameters.insert("label".to_string(), "Text".into()); let result = process_annotation_layer(&mut layer, &AnsiDialect).unwrap(); @@ -1151,7 +1132,7 @@ mod tests { use arrow::datatypes::DataType; // Date literal should parse to Date32 type - let array = literal_to_array(&ParameterValue::String("1973-06-01".to_string()), 5); + let array = literal_to_array(&"1973-06-01".into(), 5); assert_eq!( array.data_type(), &DataType::Date32, @@ -1166,10 +1147,7 @@ mod tests { use arrow::datatypes::{DataType, TimeUnit}; // DateTime literal should parse to Timestamp type - let array = literal_to_array( - &ParameterValue::String("2024-03-17T14:30:00".to_string()), - 3, - ); + let array = literal_to_array(&"2024-03-17T14:30:00".into(), 3); assert!( matches!( array.data_type(), @@ -1186,7 +1164,7 @@ mod tests { use arrow::datatypes::{DataType, TimeUnit}; // Time literal should parse to Time64 type - let array = literal_to_array(&ParameterValue::String("14:30:00".to_string()), 4); + let array = literal_to_array(&"14:30:00".into(), 4); assert_eq!( array.data_type(), &DataType::Time64(TimeUnit::Nanosecond), @@ -1201,7 +1179,7 @@ mod tests { use arrow::datatypes::DataType; // Non-temporal string should remain Utf8 type - let array = literal_to_array(&ParameterValue::String("not a date".to_string()), 2); + let array = literal_to_array(&"not a date".into(), 2); assert_eq!( array.data_type(), &DataType::Utf8, @@ -1216,13 +1194,8 @@ mod tests { let mut layer = Layer::new(Geom::rule()); layer.source = Some(DataSource::Annotation); // Only non-positional, non-required scalar parameters - layer.parameters.insert( - "stroke".to_string(), - ParameterValue::String("red".to_string()), - ); - layer - .parameters - .insert("linewidth".to_string(), ParameterValue::Number(2.0)); + layer.parameters.insert("stroke".to_string(), "red".into()); + layer.parameters.insert("linewidth".to_string(), 2.0.into()); let result = process_annotation_layer(&mut layer, &AnsiDialect); diff --git a/src/execute/mod.rs b/src/execute/mod.rs index baa2c4270..c6df96dd1 100644 --- a/src/execute/mod.rs +++ b/src/execute/mod.rs @@ -658,18 +658,11 @@ fn handle_missing_facet_columns( None => return Ok(()), }; - // Get the missing setting (default to "repeat") let missing_setting = facet .properties .get("missing") - .and_then(|v| { - if let ParameterValue::String(s) = v { - Some(s.as_str()) - } else { - None - } - }) - .unwrap_or("repeat"); + .and_then(ParameterValue::as_str) + .expect("missing default filled by facet resolution"); // If null, do nothing (existing behavior handles this) if missing_setting == "null" { diff --git a/src/execute/position.rs b/src/execute/position.rs index add4e064a..c6f065adf 100644 --- a/src/execute/position.rs +++ b/src/execute/position.rs @@ -62,7 +62,7 @@ mod tests { use crate::df; use crate::plot::facet::{Facet, FacetLayout}; use crate::plot::layer::{Geom, Position}; - use crate::plot::{AestheticValue, Mappings, ParameterValue, Scale, ScaleType}; + use crate::plot::{AestheticValue, Mappings, Scale, ScaleType}; use arrow::array::Array; fn make_continuous_scale(aesthetic: &str) -> Scale { @@ -235,9 +235,7 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); layer.position = Position::dodge(); - layer - .parameters - .insert("width".to_string(), ParameterValue::Number(0.6)); + layer.parameters.insert("width".to_string(), 0.6.into()); // Create spec with pos1 as discrete and pos2 as continuous let mut spec = Plot::new(); @@ -316,9 +314,7 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); layer.position = Position::jitter(); - layer - .parameters - .insert("width".to_string(), ParameterValue::Number(0.6)); + layer.parameters.insert("width".to_string(), 0.6.into()); // Create spec with pos1 as discrete and pos2 as continuous let mut spec = Plot::new(); diff --git a/src/execute/scale.rs b/src/execute/scale.rs index 8dad88479..f78528452 100644 --- a/src/execute/scale.rs +++ b/src/execute/scale.rs @@ -1769,10 +1769,7 @@ mod tests { // Disable expansion for predictable test values let mut scale = crate::plot::Scale::new("pos1"); - scale.properties.insert( - "expand".to_string(), - crate::plot::ParameterValue::Number(0.0), - ); + scale.properties = crate::params! { "expand" => -0.0 }; spec.scales.push(scale); // Simulate post-merge state: mapping is in layer let layer = Layer::new(Geom::point()) @@ -1817,10 +1814,7 @@ mod tests { let mut scale = crate::plot::Scale::new("pos1"); scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); // Disable expansion for predictable test values - scale.properties.insert( - "expand".to_string(), - crate::plot::ParameterValue::Number(0.0), - ); + scale.properties = crate::params! { "expand" => -0.0 }; spec.scales.push(scale); // Simulate post-merge state: mapping is in layer let layer = Layer::new(Geom::point()) @@ -1911,10 +1905,7 @@ mod tests { let mut scale = crate::plot::Scale::new("pos1"); scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Null]); // Disable expansion for predictable test values - scale.properties.insert( - "expand".to_string(), - crate::plot::ParameterValue::Number(0.0), - ); + scale.properties = crate::params! { "expand" => -0.0 }; spec.scales.push(scale); // Simulate post-merge state: mapping is in layer let layer = Layer::new(Geom::point()) @@ -1955,10 +1946,7 @@ mod tests { let mut scale = crate::plot::Scale::new("pos1"); scale.input_range = Some(vec![ArrayElement::Null, ArrayElement::Number(100.0)]); // Disable expansion for predictable test values - scale.properties.insert( - "expand".to_string(), - crate::plot::ParameterValue::Number(0.0), - ); + scale.properties = crate::params! { "expand" => -0.0 }; spec.scales.push(scale); // Simulate post-merge state: mapping is in layer let layer = Layer::new(Geom::point()) diff --git a/src/execute/table/format.rs b/src/execute/table/format.rs index 52f61ea1b..dd3e4b2fd 100644 --- a/src/execute/table/format.rs +++ b/src/execute/table/format.rs @@ -24,7 +24,7 @@ pub(super) fn setup_formats( ) -> Result> { for (idx, format) in formats.iter().enumerate() { format - .validate_settings() + .resolve_settings() .map_err(|e| GgsqlError::ValidationError(format!("FORMAT {}: {}", idx + 1, e)))?; } @@ -47,7 +47,12 @@ pub(super) fn setup_formats( } // A column no clause claimed a section for resolves to the body. + // Settings were validated per clause above; resolving again post-merge + // only fills defaults. for format in resolved.values_mut() { + format.settings = format + .resolve_settings() + .map_err(GgsqlError::ValidationError)?; format.target.get_or_insert(ColumnSection::Body); } Ok(resolved) @@ -186,7 +191,7 @@ mod tests { Format { columns: vec!["price".to_string(), "currency".to_string()], wildcard: false, - ..format_with_hjust(ParameterValue::String("left".to_string())) + ..format_with_hjust("left".into()) }, ]; @@ -196,10 +201,7 @@ mod tests { // the earlier template survives; its settings are added. let price = resolved.get("price").unwrap(); assert_eq!(price.value_template.as_deref(), Some("{:num %.2f}")); - assert_eq!( - price.settings.get("hjust"), - Some(&ParameterValue::String("left".to_string())) - ); + assert_eq!(price.settings.get("hjust"), Some(&"left".into())); let amount = resolved.get("amount").unwrap(); assert_eq!(amount.value_template.as_deref(), Some("{:num %.2f}")); @@ -207,10 +209,7 @@ mod tests { let currency = resolved.get("currency").unwrap(); assert_eq!(currency.value_template, None); - assert_eq!( - currency.settings.get("hjust"), - Some(&ParameterValue::String("left".to_string())) - ); + assert_eq!(currency.settings.get("hjust"), Some(&"left".into())); } #[test] @@ -317,8 +316,7 @@ mod tests { } fn format_with_hjust(hjust: ParameterValue) -> Format { - let mut settings = Parameters::new(); - settings.insert("hjust".to_string(), hjust); + let settings = crate::params! { "hjust" => hjust }; Format { columns: Vec::new(), wildcard: false, @@ -333,11 +331,11 @@ mod tests { fn resolve_column_properties_defaults_hjust_by_dtype_when_absent() { assert_eq!( resolve_column_properties(&DataType::Float64, None).get("hjust"), - Some(&ParameterValue::Number(1.0)) + Some(&1.0.into()) ); assert_eq!( resolve_column_properties(&DataType::Utf8, None).get("hjust"), - Some(&ParameterValue::Number(0.0)) + Some(&0.0.into()) ); } @@ -354,38 +352,38 @@ mod tests { assert_eq!( resolve_column_properties(&DataType::Utf8, Some(&format)).get("hjust"), - Some(&ParameterValue::Number(1.0)) + Some(&1.0.into()) ); } #[test] fn resolve_column_properties_standardises_keywords_to_numbers() { - let format = format_with_hjust(ParameterValue::String("left".to_string())); + let format = format_with_hjust("left".into()); assert_eq!( resolve_column_properties(&DataType::Utf8, Some(&format)).get("hjust"), - Some(&ParameterValue::Number(0.0)) + Some(&0.0.into()) ); - let format = format_with_hjust(ParameterValue::String("centre".to_string())); + let format = format_with_hjust("centre".into()); assert_eq!( resolve_column_properties(&DataType::Utf8, Some(&format)).get("hjust"), - Some(&ParameterValue::Number(0.5)) + Some(&0.5.into()) ); - let format = format_with_hjust(ParameterValue::String("right".to_string())); + let format = format_with_hjust("right".into()); assert_eq!( resolve_column_properties(&DataType::Utf8, Some(&format)).get("hjust"), - Some(&ParameterValue::Number(1.0)) + Some(&1.0.into()) ); } #[test] fn resolve_column_properties_keeps_an_explicit_number_unchanged() { - let format = format_with_hjust(ParameterValue::Number(0.25)); + let format = format_with_hjust(0.25.into()); assert_eq!( resolve_column_properties(&DataType::Float64, Some(&format)).get("hjust"), - Some(&ParameterValue::Number(0.25)) + Some(&0.25.into()) ); } } diff --git a/src/execute/table/layout.rs b/src/execute/table/layout.rs index a884a2eea..23f5d700b 100644 --- a/src/execute/table/layout.rs +++ b/src/execute/table/layout.rs @@ -496,18 +496,9 @@ mod tests { .get("hjust") .cloned() }; - assert_eq!( - hjust(0, TableCellKind::ColumnLabel), - Some(ParameterValue::Number(1.0)) - ); - assert_eq!( - hjust(0, TableCellKind::Body), - Some(ParameterValue::Number(1.0)) - ); - assert_eq!( - hjust(1, TableCellKind::Body), - Some(ParameterValue::Number(0.0)) - ); + assert_eq!(hjust(0, TableCellKind::ColumnLabel), Some(1.0.into())); + assert_eq!(hjust(0, TableCellKind::Body), Some(1.0.into())); + assert_eq!(hjust(1, TableCellKind::Body), Some(0.0.into())); } #[test] @@ -555,7 +546,7 @@ mod tests { let mut table = Table::new(); table.spans = vec![ spanner(&["a", "b"]), - spanner_with_setting(&["b", "c"], "level", ParameterValue::Number(1.0)), + spanner_with_setting(&["b", "c"], "level", 1.0.into()), ]; assert!(resolve_cells(&frame, &table).is_err()); diff --git a/src/params.rs b/src/params.rs index d74d63254..fbc807f90 100644 --- a/src/params.rs +++ b/src/params.rs @@ -42,6 +42,47 @@ pub enum ParameterValue { /// A collection of named parameter values, typically from `SET` clauses. pub type Parameters = HashMap; +impl From<&str> for ParameterValue { + fn from(s: &str) -> Self { + ParameterValue::String(s.to_string()) + } +} + +impl From for ParameterValue { + fn from(s: String) -> Self { + ParameterValue::String(s) + } +} + +impl From for ParameterValue { + fn from(n: f64) -> Self { + ParameterValue::Number(n) + } +} + +impl From for ParameterValue { + fn from(b: bool) -> Self { + ParameterValue::Boolean(b) + } +} + +/// Build a `Parameters` map from `key => value` pairs: keys and values are +/// converted via `Into`, so literals need no construction noise. +/// Test-only. +/// +/// ```ignore +/// let p = crate::params! { "free" => "x", "ncol" => 2.0, "clip" => true }; +/// ``` +#[cfg(test)] +#[macro_export] +macro_rules! params { + ($($k:expr => $v:expr),* $(,)?) => { + ::std::collections::HashMap::from([ + $(($k.to_string(), $crate::params::ParameterValue::from($v))),* + ]) + }; +} + impl std::fmt::Display for ParameterValue { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { @@ -1025,7 +1066,13 @@ impl ParamConstraint { } } - /// String enum or Array of strings from same enum - for `free` parameter + /// String enum or Array of strings from same enum - for `free` parameter. + /// + /// Not actually used for `free`: its accepted values are the coord's + /// position names, which arrive as runtime strings (custom position + /// names are allowed), while this constructor needs `&'static` values. + /// `free` uses [`Self::string_or_string_array_unconstrained`] plus a + /// separate membership check instead. #[allow(dead_code)] pub const fn string_or_string_array(values: &'static [&'static str]) -> Self { Self { @@ -1095,67 +1142,6 @@ impl ParamConstraint { } } -/// Validate a parameter value against a constraint. -/// -/// Returns Ok(()) if the value passes validation, or Err with a descriptive -/// error message if validation fails. -pub fn validate_parameter( - param_name: &str, - value: &ParameterValue, - constraint: &ParamConstraint, -) -> Result<(), String> { - match value { - ParameterValue::Number(n) => match &constraint.number { - TypeConstraint::Forbidden => { - Err(type_not_allowed_error(param_name, "Number", constraint)) - } - TypeConstraint::Any => Ok(()), - TypeConstraint::Constrained(c) if !c.units.is_empty() => Err(format!( - "'{}' should be a number followed by {}, not {}", - param_name, - crate::or_list_quoted(c.units, '\''), - n - )), - TypeConstraint::Constrained(c) => validate_number(param_name, *n, c), - }, - ParameterValue::String(s) => match &constraint.string { - TypeConstraint::Forbidden => match &constraint.number { - // A number with a unit arrives as a string ('240px'), so it - // lands here even though the constraint lives on `number`. - TypeConstraint::Constrained(c) if !c.units.is_empty() => { - validate_number_with_unit(param_name, s, c) - } - _ => Err(type_not_allowed_error(param_name, "String", constraint)), - }, - TypeConstraint::Any => Ok(()), - TypeConstraint::Constrained(c) => validate_string(param_name, s, c), - }, - ParameterValue::Boolean(_) => match &constraint.boolean { - TypeConstraint::Forbidden => { - Err(type_not_allowed_error(param_name, "Boolean", constraint)) - } - TypeConstraint::Any | TypeConstraint::Constrained(()) => Ok(()), - }, - ParameterValue::Array(arr) => match &constraint.array { - TypeConstraint::Forbidden => { - Err(type_not_allowed_error(param_name, "Array", constraint)) - } - TypeConstraint::Any => Ok(()), - TypeConstraint::Constrained(c) => validate_array(param_name, arr, c), - }, - ParameterValue::Null => { - if constraint.allow_null { - Ok(()) - } else { - Err(format!( - "Parameter '{}' is required (cannot be null)", - param_name - )) - } - } - } -} - fn validate_number(name: &str, n: f64, c: &NumberConstraint) -> Result<(), String> { // Check whole number constraint first if c.whole && n.fract() != 0.0 { @@ -1327,6 +1313,85 @@ pub struct ParamDefinition { } impl ParamDefinition { + /// Validate a value against this definition's constraint. + /// + /// Absence (`None`) is always valid: there is nothing to check, and no + /// parameter is required — every definition has a default or treats + /// absence as semantic. An explicit `ParameterValue::Null` is checked + /// against `allow_null`. + /// + /// Returns Ok(()) if the value passes validation, or Err with a descriptive + /// error message if validation fails. + pub fn validate(&self, value: Option<&ParameterValue>) -> Result<(), String> { + let Some(value) = value else { + return Ok(()); + }; + let param_name = self.name; + let constraint = &self.constraint; + match value { + ParameterValue::Number(n) => match &constraint.number { + TypeConstraint::Forbidden => { + Err(type_not_allowed_error(param_name, "Number", constraint)) + } + TypeConstraint::Any => Ok(()), + TypeConstraint::Constrained(c) if !c.units.is_empty() => Err(format!( + "'{}' should be a number followed by {}, not {}", + param_name, + crate::or_list_quoted(c.units, '\''), + n + )), + TypeConstraint::Constrained(c) => validate_number(param_name, *n, c), + }, + ParameterValue::String(s) => match &constraint.string { + TypeConstraint::Forbidden => match &constraint.number { + // A number with a unit arrives as a string ('240px'), so it + // lands here even though the constraint lives on `number`. + TypeConstraint::Constrained(c) if !c.units.is_empty() => { + validate_number_with_unit(param_name, s, c) + } + _ => Err(type_not_allowed_error(param_name, "String", constraint)), + }, + TypeConstraint::Any => Ok(()), + TypeConstraint::Constrained(c) => validate_string(param_name, s, c), + }, + ParameterValue::Boolean(_) => match &constraint.boolean { + TypeConstraint::Forbidden => { + Err(type_not_allowed_error(param_name, "Boolean", constraint)) + } + TypeConstraint::Any | TypeConstraint::Constrained(()) => Ok(()), + }, + ParameterValue::Array(arr) => match &constraint.array { + TypeConstraint::Forbidden => { + Err(type_not_allowed_error(param_name, "Array", constraint)) + } + TypeConstraint::Any => Ok(()), + TypeConstraint::Constrained(c) => validate_array(param_name, arr, c), + }, + ParameterValue::Null => { + if constraint.allow_null { + Ok(()) + } else { + Err(format!( + "Parameter '{}' is required (cannot be null)", + param_name + )) + } + } + } + } + + /// The effective value for this parameter: the user's value if present + /// (validated against the constraint), otherwise the default. + /// + /// Returns Ok(None) when the parameter is absent and the default is Null. + pub fn resolve( + &self, + value: Option<&ParameterValue>, + ) -> Result, String> { + self.validate(value)?; + Ok(value.cloned().or_else(|| self.to_parameter_value())) + } + /// Convert the default value to a ParameterValue, if not Null pub fn to_parameter_value(&self) -> Option { match &self.default { @@ -1338,10 +1403,194 @@ impl ParamDefinition { } } +/// Reject any `properties` key that doesn't name a definition. +/// +/// `context` identifies the parameter set in the error, e.g. "FACET +/// setting" or "cartesian projection property". With an empty definition +/// list every key is rejected: "{context} should be absent, not '{key}'". +pub fn reject_unknown_parameters( + properties: &Parameters, + definitions: &[ParamDefinition], + context: &str, +) -> Result<(), String> { + let allowed: Vec<&str> = definitions.iter().map(|p| p.name).collect(); + let unknown: Vec<&str> = properties + .keys() + .map(String::as_str) + .filter(|key| !allowed.contains(key)) + .collect(); + if unknown.is_empty() { + return Ok(()); + } + if allowed.is_empty() { + return Err(format!( + "{context} should be absent, not {}", + crate::and_list_quoted(&unknown, '\'') + )); + } + Err(format!( + "{context} should be {}, not {}", + crate::or_list_quoted(&allowed, '\''), + crate::and_list_quoted(&unknown, '\'') + )) +} + +/// Validate `properties` against `definitions` and resolve each parameter +/// to its effective value: the user's value if present, otherwise the +/// definition's default. Returns a new map with defaults filled. +pub fn resolve_parameters( + properties: &Parameters, + definitions: &[ParamDefinition], + context: &str, +) -> Result { + reject_unknown_parameters(properties, definitions, context)?; + let mut resolved = properties.clone(); + for param in definitions { + if let Some(value) = param.resolve(properties.get(param.name))? { + resolved.entry(param.name.to_string()).or_insert(value); + } + } + Ok(resolved) +} + #[cfg(test)] mod tests { use super::*; + fn validate_parameter( + param_name: &'static str, + value: &ParameterValue, + constraint: &ParamConstraint, + ) -> Result<(), String> { + ParamDefinition { + name: param_name, + default: DefaultParamValue::Null, + constraint: *constraint, + } + .validate(Some(value)) + } + + #[test] + fn param_definition_resolve_prefers_user_value_then_default() { + let def = ParamDefinition { + name: "bins", + default: DefaultParamValue::Number(30.0), + constraint: ParamConstraint::count(1.0), + }; + let present = Some(10.0.into()); + // User value wins over the default, absent falls back to the default, + // and a Null default means no value. + assert_eq!(def.resolve(present.as_ref()).unwrap(), Some(10.0.into())); + assert_eq!(def.resolve(None).unwrap(), Some(30.0.into())); + let no_default = ParamDefinition { + default: DefaultParamValue::Null, + ..def + }; + assert_eq!(no_default.resolve(None).unwrap(), None); + } + + #[test] + fn reject_unknown_parameters_lists_valid_names() { + let defs = [ParamDefinition { + name: "bins", + default: DefaultParamValue::Null, + constraint: ParamConstraint::count(1.0), + }]; + let mut properties = crate::params! { "bin" => 10.0 }; + let err = crate::params::reject_unknown_parameters(&properties, &defs, "TEST setting") + .unwrap_err(); + assert_eq!(err, "TEST setting should be 'bins', not 'bin'"); + + // Every key is unknown when the definition list is empty + let err = + crate::params::reject_unknown_parameters(&properties, &[], "TEST setting").unwrap_err(); + assert_eq!(err, "TEST setting should be absent, not 'bin'"); + + // All offending keys are reported at once (in arbitrary HashMap order) + properties.insert("beans".to_string(), 10.0.into()); + let err = crate::params::reject_unknown_parameters(&properties, &defs, "TEST setting") + .unwrap_err(); + assert!(err.starts_with("TEST setting should be 'bins', not ")); + assert!(err.contains("'bin'")); + assert!(err.contains("'beans'")); + properties.remove("beans"); + + properties.insert("bins".to_string(), 10.0.into()); + properties.remove("bin"); + assert!( + crate::params::reject_unknown_parameters(&properties, &defs, "TEST setting").is_ok() + ); + } + + #[test] + fn resolve_parameters_fills_defaults_and_preserves_user_values() { + let defs = [ + ParamDefinition { + name: "bins", + default: DefaultParamValue::Number(30.0), + constraint: ParamConstraint::count(1.0), + }, + ParamDefinition { + name: "label", + default: DefaultParamValue::String("x"), + constraint: ParamConstraint::string(), + }, + ParamDefinition { + name: "flag", + default: DefaultParamValue::Boolean(true), + constraint: ParamConstraint::boolean(), + }, + ParamDefinition { + name: "optional", + default: DefaultParamValue::Null, + constraint: ParamConstraint::number_any(), + }, + ]; + let properties = crate::params! { "bins" => 10.0 }; + + let resolved = + crate::params::resolve_parameters(&properties, &defs, "TEST setting").unwrap(); + + assert_eq!(resolved.get("bins"), Some(&10.0.into())); + assert_eq!(resolved.get("label"), Some(&"x".into())); + assert_eq!(resolved.get("flag"), Some(&true.into())); + // A Null default fills nothing + assert!(!resolved.contains_key("optional")); + // The input map is untouched + assert_eq!(properties.len(), 1); + } + + #[test] + fn resolve_parameters_keeps_an_explicit_null() { + // Explicit null is a value, not "absent": the default doesn't replace it + let defs = [ParamDefinition { + name: "bins", + default: DefaultParamValue::Number(30.0), + constraint: ParamConstraint::count(1.0), + }]; + let properties = crate::params! { "bins" => ParameterValue::Null }; + + let resolved = + crate::params::resolve_parameters(&properties, &defs, "TEST setting").unwrap(); + assert_eq!(resolved.get("bins"), Some(&ParameterValue::Null)); + } + + #[test] + fn resolve_parameters_rejects_unknown_keys_and_invalid_values() { + let defs = [ParamDefinition { + name: "bins", + default: DefaultParamValue::Number(30.0), + constraint: ParamConstraint::count(1.0), + }]; + let mut properties = crate::params! { "bin" => 10.0 }; + let err = + crate::params::resolve_parameters(&properties, &defs, "TEST setting").unwrap_err(); + assert!(err.starts_with("TEST setting should be")); + + properties = crate::params! { "bins" => -5.0 }; + assert!(crate::params::resolve_parameters(&properties, &defs, "TEST setting").is_err()); + } + #[test] fn test_date_from_string() { let elem = ArrayElement::from_date_string("2024-01-15").unwrap(); @@ -1782,14 +2031,14 @@ mod tests { #[test] fn test_number_constraint_accepts_valid() { let constraint = ParamConstraint::number_min(0.0); - assert!(validate_parameter("test", &ParameterValue::Number(5.0), &constraint).is_ok()); - assert!(validate_parameter("test", &ParameterValue::Number(0.0), &constraint).is_ok()); + assert!(validate_parameter("test", &5.0.into(), &constraint).is_ok()); + assert!(validate_parameter("test", &0.0.into(), &constraint).is_ok()); } #[test] fn test_number_constraint_rejects_invalid() { let constraint = ParamConstraint::number_min(0.0); - let result = validate_parameter("test", &ParameterValue::Number(-1.0), &constraint); + let result = validate_parameter("test", &(-1.0).into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains(">= 0")); } @@ -1797,11 +2046,7 @@ mod tests { #[test] fn test_number_constraint_rejects_wrong_type() { let constraint = ParamConstraint::number_min(0.0); - let result = validate_parameter( - "test", - &ParameterValue::String("hello".to_string()), - &constraint, - ); + let result = validate_parameter("test", &"hello".into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains("should be Number")); } @@ -1809,15 +2054,15 @@ mod tests { #[test] fn test_count_constraint_accepts_whole() { let constraint = ParamConstraint::count(1.0); - assert!(validate_parameter("bins", &ParameterValue::Number(5.0), &constraint).is_ok()); - assert!(validate_parameter("bins", &ParameterValue::Number(1.0), &constraint).is_ok()); - assert!(validate_parameter("bins", &ParameterValue::Number(100.0), &constraint).is_ok()); + assert!(validate_parameter("bins", &5.0.into(), &constraint).is_ok()); + assert!(validate_parameter("bins", &1.0.into(), &constraint).is_ok()); + assert!(validate_parameter("bins", &100.0.into(), &constraint).is_ok()); } #[test] fn test_count_constraint_rejects_fractional() { let constraint = ParamConstraint::count(1.0); - let result = validate_parameter("bins", &ParameterValue::Number(5.5), &constraint); + let result = validate_parameter("bins", &5.5.into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains("whole number")); } @@ -1825,7 +2070,7 @@ mod tests { #[test] fn test_count_constraint_rejects_below_min() { let constraint = ParamConstraint::count(1.0); - let result = validate_parameter("bins", &ParameterValue::Number(0.0), &constraint); + let result = validate_parameter("bins", &0.0.into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains(">= 1")); } @@ -1833,22 +2078,13 @@ mod tests { #[test] fn test_string_option_accepts_valid() { let constraint = ParamConstraint::string_option(&["a", "b", "c"]); - assert!(validate_parameter( - "test", - &ParameterValue::String("a".to_string()), - &constraint - ) - .is_ok()); + assert!(validate_parameter("test", &"a".into(), &constraint).is_ok()); } #[test] fn test_string_option_rejects_invalid() { let constraint = ParamConstraint::string_option(&["a", "b", "c"]); - let result = validate_parameter( - "test", - &ParameterValue::String("d".to_string()), - &constraint, - ); + let result = validate_parameter("test", &"d".into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains("not 'd'")); } @@ -1856,7 +2092,7 @@ mod tests { #[test] fn test_string_option_rejects_wrong_type() { let constraint = ParamConstraint::string_option(&["a", "b", "c"]); - let result = validate_parameter("test", &ParameterValue::Number(1.0), &constraint); + let result = validate_parameter("test", &1.0.into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains("should be String")); } @@ -1865,29 +2101,15 @@ mod tests { fn test_number_with_unit_accepts_a_number_with_an_allowed_unit() { let constraint = ParamConstraint::number_with_unit(NumberConstraint::min(0.0), &["px", "%"]); - assert!(validate_parameter( - "width", - &ParameterValue::String("20%".to_string()), - &constraint - ) - .is_ok()); - assert!(validate_parameter( - "width", - &ParameterValue::String("240px".to_string()), - &constraint - ) - .is_ok()); + assert!(validate_parameter("width", &"20%".into(), &constraint).is_ok()); + assert!(validate_parameter("width", &"240px".into(), &constraint).is_ok()); } #[test] fn test_number_with_unit_applies_the_numeric_constraint() { let constraint = ParamConstraint::number_with_unit(NumberConstraint::min(0.0), &["px", "%"]); - let result = validate_parameter( - "width", - &ParameterValue::String("-20px".to_string()), - &constraint, - ); + let result = validate_parameter("width", &"-20px".into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains(">= 0")); } @@ -1907,7 +2129,7 @@ mod tests { fn test_number_with_unit_rejects_a_bare_number() { let constraint = ParamConstraint::number_with_unit(NumberConstraint::min(0.0), &["px", "%"]); - let result = validate_parameter("width", &ParameterValue::Number(20.0), &constraint); + let result = validate_parameter("width", &20.0.into(), &constraint); assert!(result.is_err()); } @@ -1915,11 +2137,7 @@ mod tests { fn test_number_with_unit_rejects_a_non_numeric_prefix() { let constraint = ParamConstraint::number_with_unit(NumberConstraint::min(0.0), &["px", "%"]); - let result = validate_parameter( - "width", - &ParameterValue::String("wide%".to_string()), - &constraint, - ); + let result = validate_parameter("width", &"wide%".into(), &constraint); assert!(result.is_err()); } @@ -1927,11 +2145,7 @@ mod tests { fn test_number_with_unit_rejects_a_disallowed_unit() { let constraint = ParamConstraint::number_with_unit(NumberConstraint::min(0.0), &["px", "%"]); - let result = validate_parameter( - "width", - &ParameterValue::String("20em".to_string()), - &constraint, - ); + let result = validate_parameter("width", &"20em".into(), &constraint); assert!(result.is_err()); } @@ -1939,31 +2153,21 @@ mod tests { fn test_number_with_unit_rejects_a_bare_unit() { let constraint = ParamConstraint::number_with_unit(NumberConstraint::min(0.0), &["px", "%"]); - let result = validate_parameter( - "width", - &ParameterValue::String("%".to_string()), - &constraint, - ); + let result = validate_parameter("width", &"%".into(), &constraint); assert!(result.is_err()); } #[test] fn test_boolean_accepts_valid() { let constraint = ParamConstraint::boolean(); - assert!(validate_parameter("reverse", &ParameterValue::Boolean(true), &constraint).is_ok()); - assert!( - validate_parameter("reverse", &ParameterValue::Boolean(false), &constraint).is_ok() - ); + assert!(validate_parameter("reverse", &true.into(), &constraint).is_ok()); + assert!(validate_parameter("reverse", &false.into(), &constraint).is_ok()); } #[test] fn test_boolean_rejects_wrong_type() { let constraint = ParamConstraint::boolean(); - let result = validate_parameter( - "reverse", - &ParameterValue::String("true".to_string()), - &constraint, - ); + let result = validate_parameter("reverse", &"true".into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains("should be Boolean")); } @@ -1974,7 +2178,7 @@ mod tests { NumberConstraint::min(0.0), ArrayConstraint::of_numbers_len(NumberConstraint::unconstrained(), 2), ); - assert!(validate_parameter("expand", &ParameterValue::Number(0.05), &constraint).is_ok()); + assert!(validate_parameter("expand", &0.05.into(), &constraint).is_ok()); } #[test] @@ -2006,11 +2210,7 @@ mod tests { NumberConstraint::min(0.0), ArrayConstraint::of_numbers_len(NumberConstraint::min(0.0), 2), ); - let result = validate_parameter( - "expand", - &ParameterValue::String("0.05".to_string()), - &constraint, - ); + let result = validate_parameter("expand", &"0.05".into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains("should be Number or Array")); } @@ -2038,7 +2238,7 @@ mod tests { NumberConstraint::min(1.0), ArrayConstraint::of_numbers(NumberConstraint::unconstrained()), ); - assert!(validate_parameter("breaks", &ParameterValue::Number(10.0), &constraint).is_ok()); + assert!(validate_parameter("breaks", &10.0.into(), &constraint).is_ok()); } #[test] @@ -2061,12 +2261,7 @@ mod tests { NumberConstraint::min(1.0), ArrayConstraint::of_numbers(NumberConstraint::unconstrained()), ); - assert!(validate_parameter( - "breaks", - &ParameterValue::String("1 month".to_string()), - &constraint - ) - .is_ok()); + assert!(validate_parameter("breaks", &"1 month".into(), &constraint).is_ok()); } #[test] @@ -2075,7 +2270,7 @@ mod tests { NumberConstraint::min(1.0), ArrayConstraint::of_numbers(NumberConstraint::unconstrained()), ); - let result = validate_parameter("breaks", &ParameterValue::Boolean(true), &constraint); + let result = validate_parameter("breaks", &true.into(), &constraint); assert!(result.is_err()); assert!(result .unwrap_err() @@ -2088,7 +2283,7 @@ mod tests { NumberConstraint::min(1.0), ArrayConstraint::of_numbers(NumberConstraint::unconstrained()), ); - let result = validate_parameter("breaks", &ParameterValue::Number(0.0), &constraint); + let result = validate_parameter("breaks", &0.0.into(), &constraint); assert!(result.is_err()); assert!(result.unwrap_err().contains(">= 1")); } @@ -2142,12 +2337,7 @@ mod tests { #[test] fn test_string_or_string_array_accepts_string() { let constraint = ParamConstraint::string_or_string_array(&["x", "y"]); - assert!(validate_parameter( - "free", - &ParameterValue::String("x".to_string()), - &constraint - ) - .is_ok()); + assert!(validate_parameter("free", &"x".into(), &constraint).is_ok()); } #[test] diff --git a/src/parser/builder.rs b/src/parser/builder.rs index aafb7c1ed..8d0717f9c 100644 --- a/src/parser/builder.rs +++ b/src/parser/builder.rs @@ -1594,10 +1594,7 @@ mod tests { .unwrap(); let table = specs[0].as_table().expect("expected a Table spec"); - assert_eq!( - table.spans[0].settings.get("width"), - Some(&ParameterValue::String("40%".to_string())) - ); + assert_eq!(table.spans[0].settings.get("width"), Some(&"40%".into())); } #[test] @@ -1693,10 +1690,7 @@ mod tests { let table = specs[0].as_table().expect("expected a Table spec"); assert_eq!(table.formats[0].columns, vec!["price"]); - assert_eq!( - table.formats[0].settings.get("width"), - Some(&ParameterValue::String("20%".to_string())) - ); + assert_eq!(table.formats[0].settings.get("width"), Some(&"20%".into())); assert_eq!( table.formats[0].value_mapping, Some(HashMap::from([("null".to_string(), Some("-".to_string()))])) @@ -1743,10 +1737,7 @@ mod tests { let project = specs[0].project.as_ref().unwrap(); assert_eq!(project.coord.coord_kind(), CoordKind::Polar); assert!(project.properties.contains_key("start")); - assert_eq!( - project.properties.get("start"), - Some(&ParameterValue::Number(90.0)) - ); + assert_eq!(project.properties.get("start"), Some(&90.0.into())); } #[test] @@ -3749,10 +3740,7 @@ mod tests { let scales = &specs[0].scales; // Check SETTING was parsed - assert_eq!( - scales[0].properties.get("reverse"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(scales[0].properties.get("reverse"), Some(&true.into())); // Check RENAMING was parsed let label_mapping = scales[0].label_mapping.as_ref().unwrap(); @@ -4271,7 +4259,7 @@ mod tests { // Color names are converted to hex codes during parsing assert_eq!( specs[0].layers[0].parameters.get("color"), - Some(&ParameterValue::String("#ff0000".to_string())) + Some(&"#ff0000".into()) ); } @@ -4292,7 +4280,7 @@ mod tests { // Color names are converted to hex codes during parsing assert_eq!( specs[0].layers[0].parameters.get("color"), - Some(&ParameterValue::String("#0000ff".to_string())) + Some(&"#0000ff".into()) ); } @@ -4313,11 +4301,11 @@ mod tests { // Color names are converted to hex codes during parsing assert_eq!( specs[0].layers[0].parameters.get("color"), - Some(&ParameterValue::String("#008000".to_string())) + Some(&"#008000".into()) ); assert_eq!( specs[0].layers[0].parameters.get("opacity"), - Some(&ParameterValue::Number(0.5)) + Some(&0.5.into()) ); } diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 0a0a3be34..701af0ea4 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -462,17 +462,17 @@ mod tests { // (transform_aesthetics_to_internal runs and transforms x→pos1, y→pos2) assert_eq!( specs[0].layers[1].parameters.get("pos1"), - Some(&ParameterValue::Number(5.0)), + Some(&5.0.into()), "x should be transformed to pos1 but remain in parameters at parse time" ); assert_eq!( specs[0].layers[1].parameters.get("pos2"), - Some(&ParameterValue::Number(10.0)), + Some(&10.0.into()), "y should be transformed to pos2 but remain in parameters at parse time" ); assert_eq!( specs[0].layers[1].parameters.get("label"), - Some(&ParameterValue::String("Hello".to_string())), + Some(&"Hello".into()), "label (required) also remains in parameters at parse time" ); diff --git a/src/plot/AGENTS.md b/src/plot/AGENTS.md index c78ebfe75..e3f6d3a59 100644 --- a/src/plot/AGENTS.md +++ b/src/plot/AGENTS.md @@ -7,7 +7,7 @@ For ggsql language semantics, see [`/doc/syntax/`](../../doc/syntax/). This file ## Top-level types Defined in `main.rs` (the `Plot` struct) and `types.rs` (input/value types). All are re-exported through `mod.rs`. -The `SETTING`-parameter machinery (`ParameterValue`, `Parameters`, `ArrayElement`, the constraint types, `validate_parameter`) lives one level up in [`../params.rs`](../params.rs), shared with `table/`; `types.rs` re-exports it, so `plot::` paths keep working. +The `SETTING`-parameter machinery (`ParameterValue`, `Parameters`, `ArrayElement`, the constraint types, `ParamDefinition::validate`) lives one level up in [`../params.rs`](../params.rs), shared with `table/`; `types.rs` re-exports it, so `plot::` paths keep working. `Labels` lives in [`../labels.rs`](../labels.rs), likewise shared with `table/` and re-exported from `main.rs`. | Type | Where | Role | diff --git a/src/plot/facet/resolve.rs b/src/plot/facet/resolve.rs index e2b0c4cc2..52aa0834b 100644 --- a/src/plot/facet/resolve.rs +++ b/src/plot/facet/resolve.rs @@ -2,7 +2,6 @@ //! //! Validates facet properties and applies data-aware defaults. -use crate::plot::types::validate_parameter; use crate::plot::ParameterValue; use crate::DataFrame; use std::collections::HashMap; @@ -81,14 +80,12 @@ fn compute_default_ncol(num_levels: usize) -> i64 { /// /// This function: /// 1. Skips if already resolved -/// 2. Validates all properties are allowed for this layout -/// 3. Validates property values using constraints from `default_properties()` -/// 4. Validates `free` property against position aesthetic names (coord-dependent) -/// 5. Validates ncol/nrow mutual exclusivity -/// 6. Normalizes the `free` property to a boolean vector (position-indexed) -/// 7. Applies defaults for missing properties: -/// - `ncol` (wrap only): computed from `context.num_levels` -/// 8. Sets `resolved = true` +/// 2. Validates all properties are allowed for this layout, validates +/// their values, and fills defaults (`resolve_parameters`) +/// 3. Validates and normalizes `free` against position aesthetic names (coord-dependent) +/// 4. Resolves ncol/nrow into a concrete ncol (wrap only: converted from +/// nrow or computed from `context.num_levels`) +/// 5. Sets `resolved = true` /// /// # Arguments /// @@ -107,45 +104,22 @@ pub fn resolve_properties( let defaults = facet.layout.default_properties(); - // Step 1: Validate all properties are allowed and validate their values - for (key, value) in facet.properties.iter() { - if let Some(param) = defaults.iter().find(|p| p.name == key) { - // Skip validation for 'free' - it has coord-dependent allowed values - if key != "free" { - validate_parameter(key, value, ¶m.constraint)?; - } - } else { - // Special error messages for ncol/nrow on grid facets - if key == "ncol" { - return Err( - "Setting 'ncol' is only allowed for 1 dimensional facets, not 2 dimensional facets".to_string(), - ); - } - if key == "nrow" { - return Err( - "Setting 'nrow' is only allowed for 1 dimensional facets, not 2 dimensional facets".to_string(), - ); - } - let allowed: Vec<&str> = defaults.iter().map(|p| p.name).collect(); + // ncol/nrow are wrap-only: on grid facets they get a targeted error. + for key in ["ncol", "nrow"] { + if facet.properties.contains_key(key) && !defaults.iter().any(|p| p.name == key) { return Err(format!( - "FACET setting should be {}, not '{}'", - crate::or_list_quoted(&allowed, '\''), - key + "Setting '{key}' is only allowed for 1 dimensional facets, not 2 dimensional facets" )); } } + facet.properties = + crate::params::resolve_parameters(&facet.properties, defaults, "FACET setting")?; - // Step 2: Validate free property against coord-dependent position names - validate_free_property(facet, position_names)?; + // Validate and normalize free against coord-dependent position names + resolve_free_property(facet, position_names)?; - // Step 3: Validate ncol/nrow mutual exclusivity - validate_layout_exclusivity(facet)?; - - // Step 4: Normalize free property to boolean vector - normalize_free_property(facet, position_names); - - // Step 5: Apply defaults for missing properties - apply_defaults(facet, context); + // Resolve ncol/nrow into a concrete ncol + resolve_layout(facet, context)?; // Mark as resolved facet.resolved = true; @@ -153,125 +127,60 @@ pub fn resolve_properties( Ok(()) } -/// Validate free property value -/// -/// Accepts: -/// - `null` (ParameterValue::Null) - shared scales (default when absent) -/// - A valid position aesthetic name (string) - independent scale for that axis only -/// - An array of valid position aesthetic names - independent scales for specified axes +/// Validate and normalize the free property against the coord's position names. /// -/// # Arguments -/// -/// * `facet` - The facet to validate -/// * `position_names` - Valid position aesthetic names (e.g., ["x", "y"] or ["angle", "radius"]) -fn validate_free_property(facet: &Facet, position_names: &[&str]) -> Result<(), String> { - if let Some(value) = facet.properties.get("free") { - match value { - ParameterValue::Null => { - // Explicit null means shared scales (same as default) - Ok(()) - } - ParameterValue::String(s) => { - if !position_names.contains(&s.as_str()) { - return Err(format!( - "invalid 'free' value '{}'. Expected one of: {} (or null)", - s, - crate::or_list_quoted(position_names, '\'') - )); - } - Ok(()) - } - ParameterValue::Array(arr) => { - // Validate each element is a valid position name - if arr.is_empty() { - return Err("invalid 'free' array: cannot be empty".to_string()); - } - if arr.len() > position_names.len() { - return Err(format!( - "invalid 'free' array: too many elements ({} given, max {})", - arr.len(), - position_names.len() - )); - } - - let mut seen = std::collections::HashSet::new(); - for elem in arr { - match elem { - crate::plot::ArrayElement::String(s) => { - if !position_names.contains(&s.as_str()) { - return Err(format!( - "invalid 'free' array element '{}'. Expected one of: {}", - s, - crate::or_list_quoted(position_names, '\'') - )); - } - if !seen.insert(s.clone()) { - return Err(format!( - "invalid 'free' array: duplicate element '{}'", - s - )); - } - } - _ => { - return Err(format!( - "invalid 'free' array: elements must be strings. Expected: {}", - crate::or_list_quoted(position_names, '\'') - )); - } - } - } - Ok(()) - } - _ => Err(format!( - "'free' must be null, a string ({}), or an array of position names", - crate::or_list_quoted(position_names, '\'') - )), - } - } else { - Ok(()) - } -} - -/// Normalize free property to a boolean vector -/// -/// Transforms user-provided values to a boolean vector (position-indexed): +/// The facet definitions' constraint has already pinned the shape (string / +/// array of strings / null); this validates what the constraint system can't +/// express statically — membership in `position_names`, element uniqueness, +/// and array length bounds (both derived from `position_names`) — and +/// normalizes the value to a position-indexed boolean vector: /// - User writes: `free => 'x'` → stored as: `free => [true, false]` -/// - User writes: `free => 'angle'` → stored as: `free => [true, false]` /// - User writes: `free => ['x', 'y']` → stored as: `free => [true, true]` /// - User writes: `free => null` or absent → stored as: `free => [false, false]` /// /// This allows the writer to use the vector directly without any parsing. -fn normalize_free_property(facet: &mut Facet, position_names: &[&str]) { - let mut free_vec = vec![false; position_names.len()]; - - if let Some(value) = facet.properties.get("free") { - match value { - ParameterValue::String(s) => { - // Single string -> set that position to true - if let Some(idx) = position_names.iter().position(|n| *n == s.as_str()) { - free_vec[idx] = true; - } - } - ParameterValue::Array(arr) => { - // Array -> set each position to true - for elem in arr { - if let crate::plot::ArrayElement::String(s) = elem { - if let Some(idx) = position_names.iter().position(|n| *n == s.as_str()) { - free_vec[idx] = true; - } - } - } - } - ParameterValue::Null => { - // Explicit null -> all false (already initialized) - } - _ => { - // Invalid type - should have been caught by validation +fn resolve_free_property(facet: &mut Facet, position_names: &[&str]) -> Result<(), String> { + // Collect the names the user freed, whatever the shape + let names: Vec<&str> = match facet.properties.get("free") { + Some(ParameterValue::String(s)) => vec![s.as_str()], + Some(ParameterValue::Array(arr)) => { + if arr.is_empty() || arr.len() > position_names.len() { + return Err(format!( + "invalid 'free' array: expected between 1 and {} element(s), got {}", + position_names.len(), + arr.len() + )); } + arr.iter() + .filter_map(|elem| match elem { + crate::plot::ArrayElement::String(s) => Some(s.as_str()), + // Non-strings rejected by the definition's constraint + _ => None, + }) + .collect() } + // Absent or null means shared scales + _ => vec![], + }; + + let mut free_vec = vec![false; position_names.len()]; + for name in names { + let Some(idx) = position_names.iter().position(|&n| n == name) else { + return Err(format!( + "invalid 'free' value '{}'. Expected one of: {} (or null)", + name, + crate::or_list_quoted(position_names, '\'') + )); + }; + if free_vec[idx] { + return Err(format!( + "invalid 'free' array: duplicate element '{}'", + name + )); + } + free_vec[idx] = true; } - // Store as boolean array let bool_array: Vec = free_vec .iter() .map(|&b| crate::plot::ArrayElement::Boolean(b)) @@ -279,54 +188,44 @@ fn normalize_free_property(facet: &mut Facet, position_names: &[&str]) { facet .properties .insert("free".to_string(), ParameterValue::Array(bool_array)); + Ok(()) } -/// Validate ncol and nrow mutual exclusivity +/// Resolve ncol/nrow into a concrete ncol for wrap facets. /// -/// They cannot both be specified at the same time. -/// Type and range validation is handled by the constraint system. -fn validate_layout_exclusivity(facet: &Facet) -> Result<(), String> { - let has_ncol = facet.properties.contains_key("ncol"); - let has_nrow = facet.properties.contains_key("nrow"); - - if has_ncol && has_nrow { - return Err( - "'ncol' and 'nrow' cannot both be specified. Use one or the other.".to_string(), - ); +/// ncol and nrow are mutually exclusive (type and range validation is +/// handled by the constraint system). A given nrow is converted to the +/// ncol it implies; with neither, ncol is computed from the panel count. +/// Grid facets take neither (rejected in step 1). +fn resolve_layout(facet: &mut Facet, context: &FacetDataContext) -> Result<(), String> { + // ncol/nrow are wrap-only; grid facets have already been rejected in step 1. + if !facet.is_wrap() { + return Ok(()); } - Ok(()) -} + // Null is the "computed from data" marker, so an explicit null counts as absent. + let ncol = facet.properties.get("ncol").and_then(|v| v.as_number()); + let nrow = facet.properties.get("nrow").and_then(|v| v.as_number()); -/// Apply default values for missing properties -fn apply_defaults(facet: &mut Facet, context: &FacetDataContext) { - // Note: absence of 'free' property means fixed/shared scales (default) - // No need to insert a default value - - // Handle ncol/nrow for wrap facets - if facet.is_wrap() { - let has_ncol = facet.properties.contains_key("ncol"); - let has_nrow = facet.properties.contains_key("nrow"); - - if has_nrow && !has_ncol { - // User provided nrow: compute ncol from it - if let Some(ParameterValue::Number(nrow)) = facet.properties.get("nrow") { - let nrow_val = *nrow as usize; - let ncol = ((context.num_levels as f64) / (nrow_val as f64)).ceil() as i64; - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(ncol as f64)); - facet.properties.remove("nrow"); - } - } else if !has_ncol && !has_nrow { - // Neither provided: apply default ncol - let default_cols = compute_default_ncol(context.num_levels); - facet.properties.insert( - "ncol".to_string(), - ParameterValue::Number(default_cols as f64), - ); + let ncol: f64 = match (ncol, nrow) { + (Some(_), Some(_)) => { + return Err( + "'ncol' and 'nrow' cannot both be specified. Use one or the other.".to_string(), + ) } - } + (Some(ncol), None) => ncol, + // User provided nrow: compute ncol from it + (None, Some(nrow)) => (context.num_levels as f64 / nrow).ceil(), + // Neither provided: compute default ncol from the panel count + (None, None) => compute_default_ncol(context.num_levels) as f64, + }; + + facet + .properties + .insert("ncol".to_string(), ParameterValue::Number(ncol)); + facet.properties.remove("nrow"); + + Ok(()) } #[cfg(test)] @@ -398,10 +297,7 @@ mod tests { assert!(facet.resolved); // After resolution, free is normalized to boolean array (all false = fixed) assert_eq!(get_free_bools(&facet), Some(vec![false, false])); - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(3.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&3.0.into())); } #[test] @@ -414,19 +310,14 @@ mod tests { crate::plot::ArrayElement::String("y".to_string()), ]), ); - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(2.0)); + facet.properties.insert("ncol".to_string(), 2.0.into()); let context = make_context(10); resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); // free => ['x', 'y'] is normalized to [true, true] assert_eq!(get_free_bools(&facet), Some(vec![true, true])); - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(2.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&2.0.into())); } #[test] @@ -441,28 +332,10 @@ mod tests { assert!(!facet.properties.contains_key("ncol")); } - #[test] - fn test_error_columns_is_unknown_property() { - // "columns" is Vega-Lite's name, we use "ncol" - let mut facet = make_wrap_facet(); - facet - .properties - .insert("columns".to_string(), ParameterValue::Number(4.0)); - - let context = make_context(10); - let result = resolve_properties(&mut facet, &context, CARTESIAN); - - assert!(result.is_err()); - let err = result.unwrap_err(); - assert!(err.contains("not 'columns'")); - } - #[test] fn test_error_ncol_on_grid() { let mut facet = make_grid_facet(); - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(3.0)); + facet.properties = crate::params! { "ncol" => 3.0 }; let context = make_context(10); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -474,27 +347,11 @@ mod tests { } #[test] - fn test_error_unknown_property() { + fn test_error_invalid_free_value() { let mut facet = make_wrap_facet(); facet .properties - .insert("unknown".to_string(), ParameterValue::Number(1.0)); - - let context = make_context(5); - let result = resolve_properties(&mut facet, &context, CARTESIAN); - - assert!(result.is_err()); - let err = result.unwrap_err(); - assert!(err.contains("not 'unknown'")); - } - - #[test] - fn test_error_invalid_free_value() { - let mut facet = make_wrap_facet(); - facet.properties.insert( - "free".to_string(), - ParameterValue::String("invalid".to_string()), - ); + .insert("free".to_string(), "invalid".into()); let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -508,9 +365,7 @@ mod tests { #[test] fn test_error_negative_ncol() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(-1.0)); + facet.properties = crate::params! { "ncol" => -1.0 }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -524,9 +379,7 @@ mod tests { #[test] fn test_error_non_integer_ncol() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(2.5)); + facet.properties = crate::params! { "ncol" => 2.5 }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -592,10 +445,9 @@ mod tests { #[test] fn test_missing_property_repeat_valid() { let mut facet = make_wrap_facet(); - facet.properties.insert( - "missing".to_string(), - ParameterValue::String("repeat".to_string()), - ); + facet + .properties + .insert("missing".to_string(), "repeat".into()); let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -605,10 +457,9 @@ mod tests { #[test] fn test_missing_property_null_valid() { let mut facet = make_wrap_facet(); - facet.properties.insert( - "missing".to_string(), - ParameterValue::String("null".to_string()), - ); + facet + .properties + .insert("missing".to_string(), "null".into()); let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -618,10 +469,9 @@ mod tests { #[test] fn test_error_invalid_missing_value() { let mut facet = make_wrap_facet(); - facet.properties.insert( - "missing".to_string(), - ParameterValue::String("invalid".to_string()), - ); + facet + .properties + .insert("missing".to_string(), "invalid".into()); let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -635,9 +485,7 @@ mod tests { #[test] fn test_error_missing_not_string() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("missing".to_string(), ParameterValue::Number(1.0)); + facet.properties = crate::params! { "missing" => 1.0 }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -651,10 +499,9 @@ mod tests { #[test] fn test_missing_allowed_on_grid_facet() { let mut facet = make_grid_facet(); - facet.properties.insert( - "missing".to_string(), - ParameterValue::String("repeat".to_string()), - ); + facet + .properties + .insert("missing".to_string(), "repeat".into()); let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -668,9 +515,7 @@ mod tests { #[test] fn test_free_property_x_valid() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("free".to_string(), ParameterValue::String("x".to_string())); + facet.properties = crate::params! { "free" => "x" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -682,9 +527,7 @@ mod tests { #[test] fn test_free_property_y_valid() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("free".to_string(), ParameterValue::String("y".to_string())); + facet.properties = crate::params! { "free" => "y" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -782,9 +625,7 @@ mod tests { #[test] fn test_error_free_wrong_type() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("free".to_string(), ParameterValue::Number(1.0)); + facet.properties = crate::params! { "free" => 1.0 }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -820,10 +661,7 @@ mod tests { #[test] fn test_free_property_angle_valid() { let mut facet = make_wrap_facet(); - facet.properties.insert( - "free".to_string(), - ParameterValue::String("angle".to_string()), - ); + facet.properties = crate::params! { "free" => "angle" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, POLAR); @@ -835,10 +673,7 @@ mod tests { #[test] fn test_free_property_radius_valid() { let mut facet = make_wrap_facet(); - facet.properties.insert( - "free".to_string(), - ParameterValue::String("radius".to_string()), - ); + facet.properties = crate::params! { "free" => "radius" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, POLAR); @@ -869,9 +704,7 @@ mod tests { fn test_error_cartesian_names_in_polar() { // x/y should not be valid for polar coords let mut facet = make_wrap_facet(); - facet - .properties - .insert("free".to_string(), ParameterValue::String("x".to_string())); + facet.properties = crate::params! { "free" => "x" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, POLAR); @@ -886,10 +719,7 @@ mod tests { fn test_error_polar_names_in_cartesian() { // angle/radius should not be valid for cartesian coords let mut facet = make_wrap_facet(); - facet.properties.insert( - "free".to_string(), - ParameterValue::String("angle".to_string()), - ); + facet.properties = crate::params! { "free" => "angle" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -908,84 +738,92 @@ mod tests { fn test_nrow_computes_ncol() { // 10 levels, nrow=2 -> ncol=5 let mut facet = make_wrap_facet(); + facet.properties = crate::params! { "nrow" => 2.0 }; + + let context = make_context(10); + resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); + + // nrow should be removed and ncol computed + assert!(!facet.properties.contains_key("nrow")); + assert_eq!(facet.properties.get("ncol"), Some(&5.0.into())); + } + + #[test] + fn test_nrow_null_computes_default_ncol() { + // An explicit null counts as absent, so ncol falls back to the + // computed default rather than erroring + let mut facet = make_wrap_facet(); + facet + .properties + .insert("nrow".to_string(), ParameterValue::Null); + + let context = make_context(5); + resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); + + assert!(!facet.properties.contains_key("nrow")); + assert_eq!(facet.properties.get("ncol"), Some(&3.0.into())); + } + + #[test] + fn test_ncol_null_with_nrow_converts() { + // ncol => null counts as absent, so nrow converts without a + // both-provided error + let mut facet = make_wrap_facet(); facet .properties - .insert("nrow".to_string(), ParameterValue::Number(2.0)); + .insert("ncol".to_string(), ParameterValue::Null); + facet.properties = crate::params! { "nrow" => 2.0 }; let context = make_context(10); resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); - // nrow should be removed and ncol computed assert!(!facet.properties.contains_key("nrow")); - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(5.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&5.0.into())); } #[test] fn test_nrow_with_remainder() { // 10 levels, nrow=3 -> ncol=ceil(10/3)=4 let mut facet = make_wrap_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(3.0)); + facet.properties = crate::params! { "nrow" => 3.0 }; let context = make_context(10); resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); assert!(!facet.properties.contains_key("nrow")); - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(4.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&4.0.into())); } #[test] fn test_nrow_larger_than_num_levels() { // 3 levels, nrow=10 -> ncol=ceil(3/10)=1 let mut facet = make_wrap_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(10.0)); + facet.properties = crate::params! { "nrow" => 10.0 }; let context = make_context(3); resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); assert!(!facet.properties.contains_key("nrow")); - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(1.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&1.0.into())); } #[test] fn test_nrow_equals_num_levels() { // 5 levels, nrow=5 -> ncol=ceil(5/5)=1 let mut facet = make_wrap_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(5.0)); + facet.properties = crate::params! { "nrow" => 5.0 }; let context = make_context(5); resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); assert!(!facet.properties.contains_key("nrow")); - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(1.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&1.0.into())); } #[test] fn test_error_ncol_and_nrow_both_provided() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(3.0)); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(2.0)); + facet.properties = crate::params! { "ncol" => 3.0, "nrow" => 2.0 }; let context = make_context(10); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -1000,9 +838,7 @@ mod tests { #[test] fn test_error_negative_nrow() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(-1.0)); + facet.properties = crate::params! { "nrow" => -1.0 }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -1016,9 +852,7 @@ mod tests { #[test] fn test_error_non_integer_nrow() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(2.5)); + facet.properties = crate::params! { "nrow" => 2.5 }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -1032,9 +866,7 @@ mod tests { #[test] fn test_error_nrow_on_grid() { let mut facet = make_grid_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::Number(2.0)); + facet.properties = crate::params! { "nrow" => 2.0 }; let context = make_context(10); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -1048,9 +880,7 @@ mod tests { #[test] fn test_nrow_not_string() { let mut facet = make_wrap_facet(); - facet - .properties - .insert("nrow".to_string(), ParameterValue::String("2".to_string())); + facet.properties = crate::params! { "nrow" => "2" }; let context = make_context(5); let result = resolve_properties(&mut facet, &context, CARTESIAN); @@ -1065,17 +895,12 @@ mod tests { fn test_user_ncol_preserved() { // Existing behavior: user-provided ncol should be preserved let mut facet = make_wrap_facet(); - facet - .properties - .insert("ncol".to_string(), ParameterValue::Number(2.0)); + facet.properties = crate::params! { "ncol" => 2.0 }; let context = make_context(10); resolve_properties(&mut facet, &context, CARTESIAN).unwrap(); // User's ncol should be preserved, not overwritten - assert_eq!( - facet.properties.get("ncol"), - Some(&ParameterValue::Number(2.0)) - ); + assert_eq!(facet.properties.get("ncol"), Some(&2.0.into())); } } diff --git a/src/plot/facet/types.rs b/src/plot/facet/types.rs index 1fd70bdc1..a2ab1bb1f 100644 --- a/src/plot/facet/types.rs +++ b/src/plot/facet/types.rs @@ -199,7 +199,7 @@ impl FacetLayout { ParamDefinition { name: "free", default: DefaultParamValue::Null, - constraint: ParamConstraint::unconstrained(), // Validated separately due to coord-dependent values + constraint: ParamConstraint::string_or_string_array_unconstrained(), // Membership checked separately: accepted values are coord-dependent }, ParamDefinition { name: "ncol", @@ -213,7 +213,7 @@ impl FacetLayout { }, ParamDefinition { name: "missing", - default: DefaultParamValue::Null, + default: DefaultParamValue::String("repeat"), constraint: ParamConstraint::string_option(MISSING_VALUES), }, ]; @@ -224,11 +224,11 @@ impl FacetLayout { ParamDefinition { name: "free", default: DefaultParamValue::Null, - constraint: ParamConstraint::unconstrained(), // Validated separately due to coord-dependent values + constraint: ParamConstraint::string_or_string_array_unconstrained(), // Membership checked separately: accepted values are coord-dependent }, ParamDefinition { name: "missing", - default: DefaultParamValue::Null, + default: DefaultParamValue::String("repeat"), constraint: ParamConstraint::string_option(MISSING_VALUES), }, ]; diff --git a/src/plot/layer/geom/boxplot.rs b/src/plot/layer/geom/boxplot.rs index cdf36e89e..76849ecd2 100644 --- a/src/plot/layer/geom/boxplot.rs +++ b/src/plot/layer/geom/boxplot.rs @@ -366,7 +366,7 @@ fn boxplot_sql_append_outliers( #[cfg(test)] mod tests { use super::*; - use crate::plot::Parameters; + use crate::reader::AnsiDialect; // ==================== SQL Generation Tests (Compact) ==================== @@ -722,9 +722,7 @@ mod tests { "pos2".to_string(), AestheticValue::standard_column("value".to_string()), ); - let mut parameters = Parameters::new(); - parameters.insert("coef".to_string(), ParameterValue::Number(1.5)); - parameters.insert("outliers".to_string(), ParameterValue::Boolean(true)); + let parameters = crate::params! { "coef" => 1.5, "outliers" => true }; let ctx = crate::plot::aesthetic::AestheticContext::from_static(&["x", "y"], &[]); let result = stat_boxplot( diff --git a/src/plot/layer/geom/density.rs b/src/plot/layer/geom/density.rs index bbd2a485b..a941b77e8 100644 --- a/src/plot/layer/geom/density.rs +++ b/src/plot/layer/geom/density.rs @@ -667,12 +667,7 @@ mod tests { fn test_density_sql_no_groups() { let query = "SELECT x FROM (VALUES (1.0), (2.0), (3.0)) AS t(x)"; let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(0.5)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 0.5, "kernel" => "gaussian" }; let bw_cte = density_sql_bandwidth(query, &groups, "x", ¶meters, &AnsiDialect); let data_cte = build_data_cte("x", None, None, query, &groups, &AnsiDialect); @@ -751,12 +746,7 @@ mod tests { fn test_density_sql_with_two_groups() { let query = "SELECT x, region, category FROM (VALUES (1.0, 'A', 'X'), (2.0, 'B', 'Y')) AS t(x, region, category)"; let groups = vec!["region".to_string(), "category".to_string()]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(0.5)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 0.5, "kernel" => "gaussian" }; let bw_cte = density_sql_bandwidth(query, &groups, "x", ¶meters, &AnsiDialect); let data_cte = build_data_cte("x", None, None, query, &groups, &AnsiDialect); @@ -935,8 +925,7 @@ mod tests { fn test_kernel_integration(kernel_name: &str, tolerance: f64) { let query = "SELECT x FROM (VALUES (1.0), (2.0), (3.0), (4.0), (5.0)) AS t(x)"; let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(1.0)); + let mut parameters = crate::params! { "bandwidth" => 1.0 }; parameters.insert( "kernel".to_string(), ParameterValue::String(kernel_name.to_string()), @@ -1039,11 +1028,7 @@ mod tests { #[test] fn test_kernel_invalid() { - let mut parameters = Parameters::new(); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("invalid_kernel".to_string()), - ); + let parameters = crate::params! { "kernel" => "invalid_kernel" }; let result = choose_kde_kernel(¶meters, None); @@ -1063,12 +1048,7 @@ mod tests { // Compare weighted and unweighted results let query = "SELECT x FROM (VALUES (1.0), (2.0), (3.0)) AS t(x)"; let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(0.5)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 0.5, "kernel" => "gaussian" }; let bw_cte = density_sql_bandwidth(query, &groups, "x", ¶meters, &AnsiDialect); let grid_cte = build_grid_cte(&groups, 100, None, &AnsiDialect); @@ -1238,12 +1218,7 @@ mod tests { let query = "SELECT x FROM bench_data"; let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(5.0)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 5.0, "kernel" => "gaussian" }; let bw_cte = density_sql_bandwidth(query, &groups, "x", ¶meters, &AnsiDialect); let data_cte = build_data_cte("x", None, None, query, &groups, &AnsiDialect); diff --git a/src/plot/layer/geom/histogram.rs b/src/plot/layer/geom/histogram.rs index 02e85498a..19302187c 100644 --- a/src/plot/layer/geom/histogram.rs +++ b/src/plot/layer/geom/histogram.rs @@ -142,10 +142,9 @@ fn stat_histogram( let closed = closed.as_str(); // Get binwidth from parameters (default: None - use bins to calculate) - let explicit_binwidth = parameters.get("binwidth").and_then(|p| match p { - ParameterValue::Number(n) => Some(*n), - _ => None, - }); + let explicit_binwidth = parameters + .get("binwidth") + .and_then(ParameterValue::as_number); // Query min/max to compute bin width let stats_query = crate::sql::select_from( diff --git a/src/plot/layer/geom/line.rs b/src/plot/layer/geom/line.rs index c0ab23532..f5ae33bab 100644 --- a/src/plot/layer/geom/line.rs +++ b/src/plot/layer/geom/line.rs @@ -120,21 +120,19 @@ impl std::fmt::Display for Line { #[cfg(test)] mod tests { use super::*; - use crate::plot::types::ParameterValue; + use crate::reader::AnsiDialect; #[test] fn test_apply_projection_densifies_and_transforms() { let line = Line; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=0 +lon_0=0".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=ortho +lat_0=0 +lon_0=0".into()); let mut mappings = Mappings::new(); mappings.insert_column("pos1", "pos1"); diff --git a/src/plot/layer/geom/mod.rs b/src/plot/layer/geom/mod.rs index 12af10f19..4f70cb68c 100644 --- a/src/plot/layer/geom/mod.rs +++ b/src/plot/layer/geom/mod.rs @@ -332,17 +332,6 @@ pub trait GeomTrait: std::fmt::Debug + std::fmt::Display + Send + Sync { fn setup_layer(&self, _mappings: &mut Mappings, _parameters: &mut Parameters) -> Result<()> { Ok(()) } - - /// Returns valid parameter names for SETTING clause. - /// - /// Combines supported aesthetics with non-aesthetic parameters from default_params. - fn valid_settings(&self) -> Vec<&'static str> { - let mut valid: Vec<&'static str> = self.aesthetics().supported(); - for param in self.default_params() { - valid.push(param.name); - } - valid - } } /// Project pos1/pos2 columns through the map CRS transform. @@ -901,11 +890,6 @@ impl Geom { self.0.setup_layer(mappings, parameters) } - /// Get valid settings - pub fn valid_settings(&self) -> Vec<&'static str> { - self.0.valid_settings() - } - /// Whether this geom accepts the `aggregate` SETTING parameter. pub fn supports_aggregate(&self) -> bool { self.0.supports_aggregate() @@ -1117,52 +1101,45 @@ mod tests { #[test] fn test_needs_projection_false_without_source() { let mut projection = Projection::map(); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho".to_string()), - ); + projection + .properties + .insert("target".to_string(), "+proj=ortho".into()); assert!(!needs_projection(&projection)); } #[test] fn test_needs_projection_false_when_same_crs() { let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "EPSG:4326".into()); assert!(!needs_projection(&projection)); } #[test] fn test_needs_projection_true_when_different_crs() { let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=ortho".into()); assert!(needs_projection(&projection)); } #[test] fn test_apply_projection_default_errors_for_unsupported_geom() { let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=ortho".into()); let geom = Geom::bar(); let result = geom.apply_projection( diff --git a/src/plot/layer/geom/ribbon.rs b/src/plot/layer/geom/ribbon.rs index 33bed6523..28a2ef603 100644 --- a/src/plot/layer/geom/ribbon.rs +++ b/src/plot/layer/geom/ribbon.rs @@ -7,7 +7,7 @@ use super::{ DefaultAesthetics, GeomTrait, GeomType, StatResult, }; use crate::plot::projection::Projection; -use crate::plot::types::{DefaultAestheticValue, ParameterValue, Parameters}; +use crate::plot::types::{DefaultAestheticValue, Parameters}; use crate::plot::{DefaultParamValue, ParamConstraint, ParamDefinition}; use crate::reader::SqlDialect; use crate::{naming, Mappings, Result}; @@ -72,7 +72,7 @@ impl GeomTrait for Ribbon { expand_ribbon_to_polygon(query, &columns, partition_by, dialect); partition_by.push(naming::DENSIFY_ID_COLUMN.to_string()); - parameters.insert("densified".to_string(), ParameterValue::Boolean(true)); + parameters.insert("densified".to_string(), true.into()); let expanded_columns = crate::util::set_union(expanded_columns, partition_by); @@ -247,7 +247,7 @@ mod tests { use super::Ribbon; use crate::plot::layer::geom::GeomTrait; use crate::plot::projection::Projection; - use crate::plot::types::ParameterValue; + use crate::{naming, Mappings}; fn create_ribbon_mappings() -> Mappings { @@ -284,14 +284,12 @@ mod tests { fn test_apply_projection_expands_to_polygon() { let ribbon = Ribbon; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=merc".into()); let mut mappings = create_ribbon_mappings(); let mut partition_by = vec![]; @@ -337,13 +335,12 @@ mod tests { let ribbon = Ribbon; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); projection.properties.insert( "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=45 +lon_0=-60".to_string()), + "+proj=ortho +lat_0=45 +lon_0=-60".into(), ); let mut mappings = create_ribbon_mappings(); diff --git a/src/plot/layer/geom/rule.rs b/src/plot/layer/geom/rule.rs index fd011b370..e48b3be5b 100644 --- a/src/plot/layer/geom/rule.rs +++ b/src/plot/layer/geom/rule.rs @@ -79,7 +79,7 @@ impl GeomTrait for Rule { expand_rule_to_segment(query, &columns, has_pos1, &bbox_expr, dialect); partition_by.push(naming::DENSIFY_ID_COLUMN.to_string()); - parameters.insert("densified".to_string(), ParameterValue::Boolean(true)); + parameters.insert("densified".to_string(), true.into()); let expanded_columns = crate::util::set_union(expanded_columns, partition_by); @@ -124,10 +124,7 @@ impl GeomTrait for Rule { // After densification both axes are explicit — disable the orientation flip // that would otherwise swap the DataFrame columns. - parameters.insert( - "orientation".to_string(), - ParameterValue::String("aligned".to_string()), - ); + parameters.insert("orientation".to_string(), "aligned".into()); Ok(projected) } @@ -187,7 +184,7 @@ impl GeomTrait for Rule { if !has_diagonal_slope { return Ok(()); } - parameters.insert("diagonal".to_string(), ParameterValue::Boolean(true)); + parameters.insert("diagonal".to_string(), true.into()); // Determine orientation from which intercept is present. // We override the bidirectionality algorithm here since it uses @@ -334,7 +331,7 @@ mod tests { use super::{expand_rule_to_segment, Rule}; use crate::plot::layer::geom::{densify_edges, GeomTrait}; use crate::plot::projection::Projection; - use crate::plot::types::ParameterValue; + use crate::plot::{AestheticContext, AestheticValue, Geom, Layer}; use crate::{naming, Mappings}; @@ -412,17 +409,15 @@ mod tests { fn test_apply_projection_without_clip_only_projects() { let rule = Rule; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(false)); + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=merc".into()); + projection + .properties + .insert("clip".to_string(), false.into()); let mut mappings = Mappings::new(); mappings.insert_column("pos1", "pos1"); @@ -448,17 +443,15 @@ mod tests { fn test_apply_projection_with_clip_expands_and_densifies() { let rule = Rule; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(true)); + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=merc".into()); + projection + .properties + .insert("clip".to_string(), true.into()); let mut mappings = Mappings::new(); mappings.insert_column("pos1", "pos1"); @@ -512,17 +505,15 @@ mod tests { let rule = Rule; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=0 +lon_0=0".to_string()), - ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(true)); + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=ortho +lat_0=0 +lon_0=0".into()); + projection + .properties + .insert("clip".to_string(), true.into()); let mut mappings = Mappings::new(); mappings.insert_column("pos1", "pos1"); @@ -593,17 +584,15 @@ mod tests { let rule = Rule; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=0 +lon_0=0".to_string()), - ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(true)); + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=ortho +lat_0=0 +lon_0=0".into()); + projection + .properties + .insert("clip".to_string(), true.into()); // Horizontal rule: pos2 is mapped (latitude is the fixed axis) let mut mappings = Mappings::new(); diff --git a/src/plot/layer/geom/segment.rs b/src/plot/layer/geom/segment.rs index d0d987cbb..4435e908a 100644 --- a/src/plot/layer/geom/segment.rs +++ b/src/plot/layer/geom/segment.rs @@ -6,7 +6,7 @@ use super::{ DefaultParamValue, GeomTrait, GeomType, ParamConstraint, ParamDefinition, }; use crate::plot::projection::Projection; -use crate::plot::types::{DefaultAestheticValue, ParameterValue}; +use crate::plot::types::DefaultAestheticValue; use crate::reader::SqlDialect; use crate::{naming, Mappings, Result}; @@ -68,7 +68,7 @@ impl GeomTrait for Segment { let (expanded, expanded_columns) = expand_segment_to_vertices(query, &columns, dialect); partition_by.push(naming::DENSIFY_ID_COLUMN.to_string()); - parameters.insert("densified".to_string(), ParameterValue::Boolean(true)); + parameters.insert("densified".to_string(), true.into()); let expanded_columns = crate::util::set_union(expanded_columns, partition_by); @@ -172,7 +172,7 @@ mod tests { use super::Segment; use crate::plot::layer::geom::GeomTrait; use crate::plot::projection::Projection; - use crate::plot::types::ParameterValue; + use crate::plot::{AestheticContext, AestheticValue, Geom, Layer}; use crate::{naming, Mappings}; @@ -249,14 +249,12 @@ mod tests { fn test_apply_projection_expands_and_densifies() { let segment = Segment; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=merc".into()); let mut mappings = create_segment_mappings(); let mut partition_by = vec![]; @@ -302,13 +300,12 @@ mod tests { let segment = Segment; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); projection.properties.insert( "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=45 +lon_0=-60".to_string()), + "+proj=ortho +lat_0=45 +lon_0=-60".into(), ); let mut mappings = create_segment_mappings(); diff --git a/src/plot/layer/geom/smooth.rs b/src/plot/layer/geom/smooth.rs index 50148a5a7..68574dbee 100644 --- a/src/plot/layer/geom/smooth.rs +++ b/src/plot/layer/geom/smooth.rs @@ -109,7 +109,7 @@ impl GeomTrait for Smooth { "nw" | "nadaraya-watson" => { // Smooth geom: hardcode tails=0.0 (trim exactly to data range, no extrapolation) let mut params = parameters.clone(); - params.insert("tails".to_string(), ParameterValue::Number(0.0)); + params.insert("tails".to_string(), 0.0.into()); super::density::stat_density( query, diff --git a/src/plot/layer/geom/spatial.rs b/src/plot/layer/geom/spatial.rs index b26fa8ad7..e75329c28 100644 --- a/src/plot/layer/geom/spatial.rs +++ b/src/plot/layer/geom/spatial.rs @@ -193,10 +193,9 @@ mod tests { fn test_apply_projection_map_with_crs_no_clip() { let spatial = Spatial; let mut projection = Projection::map(); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); + projection + .properties + .insert("target".to_string(), "+proj=merc".into()); let result = spatial .apply_projection( "SELECT * FROM t", @@ -219,13 +218,12 @@ mod tests { fn test_apply_projection_mercator_with_clip() { let spatial = Spatial; let mut projection = Projection::map(); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(true)); + .insert("target".to_string(), "+proj=merc".into()); + projection + .properties + .insert("clip".to_string(), true.into()); let result = spatial .apply_projection( "SELECT * FROM t", @@ -248,11 +246,11 @@ mod tests { let mut projection = Projection::map(); projection.properties.insert( "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=45 +lon_0=10".to_string()), + "+proj=ortho +lat_0=45 +lon_0=10".into(), ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(true)); + .insert("clip".to_string(), true.into()); let result = spatial .apply_projection( "SELECT * FROM t", @@ -275,13 +273,12 @@ mod tests { fn test_gnomonic_with_clip() { let spatial = Spatial; let mut projection = Projection::map(); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=gnom +lat_0=90 +lon_0=0".to_string()), - ); projection .properties - .insert("clip".to_string(), ParameterValue::Boolean(true)); + .insert("target".to_string(), "+proj=gnom +lat_0=90 +lon_0=0".into()); + projection + .properties + .insert("clip".to_string(), true.into()); let result = spatial .apply_projection( "SELECT * FROM t", diff --git a/src/plot/layer/geom/stat_aggregate.rs b/src/plot/layer/geom/stat_aggregate.rs index 765b68443..a989563d6 100644 --- a/src/plot/layer/geom/stat_aggregate.rs +++ b/src/plot/layer/geom/stat_aggregate.rs @@ -621,7 +621,7 @@ pub fn targeted_aesthetics( aesthetic_ctx: &AestheticContext, ) -> HashSet { let raw = match parameters.get("aggregate") { - Some(v) if !matches!(v, ParameterValue::Null) => v, + Some(v) if !v.is_null() => v, _ => return HashSet::new(), }; let spec = match parse_aggregate_param(raw).ok().flatten() { @@ -659,7 +659,7 @@ pub fn aggregated_aesthetics( domain_aesthetics: &[&'static str], ) -> Option<(HashSet, HashSet)> { let raw = parameters.get("aggregate")?; - if matches!(raw, ParameterValue::Null) { + if raw.is_null() { return None; } let spec = parse_aggregate_param(raw).ok()??; @@ -1142,8 +1142,7 @@ mod tests { dialect: &dyn SqlDialect, domain: &[&'static str], ) -> Result { - let mut p = Parameters::new(); - p.insert("aggregate".to_string(), params); + let p = crate::params! { "aggregate" => params }; let ctx = cartesian_ctx(); apply( "SELECT * FROM t", @@ -1176,9 +1175,7 @@ mod tests { #[test] fn parses_single_default() { - let s = parse_aggregate_param(&ParameterValue::String("mean".to_string())) - .unwrap() - .unwrap(); + let s = parse_aggregate_param(&"mean".into()).unwrap().unwrap(); assert_eq!(s.default_lower.as_ref().map(|a| a.offset), Some("mean")); assert!(s.default_upper.is_none()); assert!(s.targets.is_empty()); @@ -1275,9 +1272,7 @@ mod tests { fn single_row_returns_no_labels() { // The aggregate column only makes sense as a row-differentiator, and a // single-row aggregation has nothing to differentiate, so no labels. - let s = parse_aggregate_param(&ParameterValue::String("mean".to_string())) - .unwrap() - .unwrap(); + let s = parse_aggregate_param(&"mean".into()).unwrap().unwrap(); assert_eq!(s.explosion_labels(), None); let s = parse_aggregate_param(&arr(&["mean", "color:median"])) @@ -1311,13 +1306,13 @@ mod tests { #[test] fn empty_prefix_is_error() { - let err = parse_aggregate_param(&ParameterValue::String(":mean".to_string())).unwrap_err(); + let err = parse_aggregate_param(&":mean".into()).unwrap_err(); assert!(err.contains("could not parse"), "got: {}", err); } #[test] fn unknown_function_is_error() { - let err = parse_aggregate_param(&ParameterValue::String("nope".to_string())).unwrap_err(); + let err = parse_aggregate_param(&"nope".into()).unwrap_err(); assert!(err.contains("unknown aggregate"), "got: {}", err); } @@ -1403,14 +1398,7 @@ mod tests { aes.insert("pos1", col("__ggsql_aes_pos1__")); aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); - let result = run( - ParameterValue::String("mean".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("mean".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, @@ -1444,14 +1432,7 @@ mod tests { let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); // sdev must not emit STDDEV_POP (SQLite has no such function). - let result = run( - ParameterValue::String("sdev".to_string()), - &aes, - &schema, - &[], - &SqliteDialect, - ) - .unwrap(); + let result = run("sdev".into(), &aes, &schema, &[], &SqliteDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -1465,14 +1446,7 @@ mod tests { // first now uses the portable ROW_NUMBER + MAX(CASE) form. It must run // on SQLite without `FIRST` ever appearing as an aggregate call. - let result = run( - ParameterValue::String("first".to_string()), - &aes, - &schema, - &[], - &SqliteDialect, - ) - .unwrap(); + let result = run("first".into(), &aes, &schema, &[], &SqliteDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -1581,14 +1555,7 @@ mod tests { aes.insert("pos1", col("__ggsql_aes_pos1__")); aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); - let err = run( - ParameterValue::String("first".to_string()), - &aes, - &schema, - &[], - &OptOutDialect, - ) - .unwrap_err(); + let err = run("first".into(), &aes, &schema, &[], &OptOutDialect).unwrap_err(); let msg = format!("{}", err); assert!( msg.contains("first") && msg.contains("not supported"), @@ -1602,14 +1569,7 @@ mod tests { aes.insert("pos1", col("__ggsql_aes_pos1__")); aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); - let result = run( - ParameterValue::String("mid".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("mid".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -1634,14 +1594,7 @@ mod tests { // AnsiDialect path: portable rn-based form for last - first. struct AnsiTestDialect; impl SqlDialect for AnsiTestDialect {} - let result = run( - ParameterValue::String("diff".to_string()), - &aes, - &schema, - &[], - &AnsiTestDialect, - ) - .unwrap(); + let result = run("diff".into(), &aes, &schema, &[], &AnsiTestDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!(query.contains("ROW_NUMBER()"), "{query}"); @@ -1656,14 +1609,7 @@ mod tests { } // Native-FIRST/LAST path: no rn CTE. - let result = run( - ParameterValue::String("diff".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("diff".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -1688,14 +1634,7 @@ mod tests { aes.insert("pos1", col("__ggsql_aes_pos1__")); aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); - let result = run( - ParameterValue::String("first".to_string()), - &aes, - &schema, - &[], - &DuckDbDialect, - ) - .unwrap(); + let result = run("first".into(), &aes, &schema, &[], &DuckDbDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -1727,14 +1666,7 @@ mod tests { ]); // Native-FIRST/LAST dialect: no rn CTE, GROUP BY uses the discrete key. - let result = run( - ParameterValue::String("last".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("last".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -1750,14 +1682,7 @@ mod tests { // Default dialect: rn CTE must partition by the discrete group key. struct AnsiTestDialect; impl SqlDialect for AnsiTestDialect {} - let result = run( - ParameterValue::String("last".to_string()), - &aes, - &schema, - &[], - &AnsiTestDialect, - ) - .unwrap(); + let result = run("last".into(), &aes, &schema, &[], &AnsiTestDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!( @@ -2178,14 +2103,7 @@ mod tests { ("__ggsql_aes_pos2__", false), ("__ggsql_aes_color__", true), // discrete! ]); - let result = run( - ParameterValue::String("mean".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("mean".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, @@ -2210,19 +2128,9 @@ mod tests { let mut aes = Mappings::new(); aes.insert("pos1", col("__ggsql_aes_pos1__")); aes.insert("pos2", col("__ggsql_aes_pos2__")); - aes.insert( - "fill", - AestheticValue::Literal(ParameterValue::String("steelblue".to_string())), - ); + aes.insert("fill", AestheticValue::Literal("steelblue".into())); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); - let result = run( - ParameterValue::String("mean".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("mean".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!(!query.contains("AVG(\"__ggsql_aes_fill__\")")); @@ -2240,14 +2148,7 @@ mod tests { aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); // Only `y` targeted, no default → x is dropped. - let result = run( - ParameterValue::String("y:mean".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("y:mean".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, @@ -2267,14 +2168,7 @@ mod tests { let mut aes = Mappings::new(); aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos2__", false)]); - let result = run( - ParameterValue::String("p25".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("p25".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!(query.contains("QUANTILE_CONT")); @@ -2289,14 +2183,7 @@ mod tests { let mut aes = Mappings::new(); aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos2__", false)]); - let result = run( - ParameterValue::String("p25".to_string()), - &aes, - &schema, - &[], - &NoInlineQuantileDialect, - ) - .unwrap(); + let result = run("p25".into(), &aes, &schema, &[], &NoInlineQuantileDialect).unwrap(); match result { StatResult::Transformed { query, .. } => { assert!(query.contains("ROW_NUMBER()")); @@ -2314,8 +2201,7 @@ mod tests { group_by: &[String], dialect: &dyn SqlDialect, ) -> Result { - let mut p = Parameters::new(); - p.insert("aggregate".to_string(), params); + let mut p = crate::params! { "aggregate" => params }; p.insert( "orientation".to_string(), ParameterValue::String(crate::plot::layer::orientation::TRANSPOSED.to_string()), @@ -2440,14 +2326,7 @@ mod tests { aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); // Only `y` targeted, no default → x (pos1) is dropped. - let result = run( - ParameterValue::String("y:mean".to_string()), - &aes, - &schema, - &[], - &InlineQuantileDialect, - ) - .unwrap(); + let result = run("y:mean".into(), &aes, &schema, &[], &InlineQuantileDialect).unwrap(); match result { StatResult::Transformed { consumed_aesthetics, @@ -2471,7 +2350,7 @@ mod tests { aes.insert("pos2", col("__ggsql_aes_pos2__")); let schema = schema_for(&[("__ggsql_aes_pos1__", false), ("__ggsql_aes_pos2__", false)]); let err = run( - ParameterValue::String("size:mean".to_string()), + "size:mean".into(), &aes, &schema, &[], diff --git a/src/plot/layer/geom/text.rs b/src/plot/layer/geom/text.rs index 4db464606..b0ee8949e 100644 --- a/src/plot/layer/geom/text.rs +++ b/src/plot/layer/geom/text.rs @@ -131,7 +131,7 @@ impl std::fmt::Display for Text { #[cfg(test)] mod tests { - use crate::plot::types::ParameterValue; + use crate::plot::{Geom, Layer}; /// `parse` is on unless the user says otherwise, so a label carrying markdown @@ -140,24 +140,16 @@ mod tests { fn test_parse_defaults_to_true() { let mut layer = Layer::new(Geom::text()); layer.apply_default_params(); - assert_eq!( - layer.parameters.get("parse"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(layer.parameters.get("parse"), Some(&true.into())); } /// An explicit `SETTING parse => false` survives default application. #[test] fn test_parse_setting_is_kept() { let mut layer = Layer::new(Geom::text()); - layer - .parameters - .insert("parse".to_string(), ParameterValue::Boolean(false)); + layer.parameters.insert("parse".to_string(), false.into()); layer.apply_default_params(); - assert_eq!( - layer.parameters.get("parse"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(layer.parameters.get("parse"), Some(&false.into())); } /// `parse` is a boolean; anything else is a validation error rather than a @@ -165,10 +157,7 @@ mod tests { #[test] fn test_parse_rejects_non_boolean() { let mut layer = Layer::new(Geom::text()); - layer.parameters.insert( - "parse".to_string(), - ParameterValue::String("yes".to_string()), - ); + layer.parameters.insert("parse".to_string(), "yes".into()); assert!(layer.validate_settings().is_err()); } } diff --git a/src/plot/layer/geom/tile.rs b/src/plot/layer/geom/tile.rs index 39cbed24a..1c3139159 100644 --- a/src/plot/layer/geom/tile.rs +++ b/src/plot/layer/geom/tile.rs @@ -9,7 +9,7 @@ use super::{ }; use crate::naming; use crate::plot::projection::Projection; -use crate::plot::types::{ColumnInfo, DefaultAestheticValue, ParameterValue, Parameters}; +use crate::plot::types::{ColumnInfo, DefaultAestheticValue, Parameters}; use crate::plot::{DefaultParamValue, ParamDefinition}; use crate::reader::SqlDialect; use crate::{DataFrame, GgsqlError, Mappings, Result}; @@ -241,7 +241,7 @@ impl GeomTrait for Tile { let (expanded, expanded_columns) = expand_rect_to_polygon(query, &columns, dialect); partition_by.push(naming::DENSIFY_ID_COLUMN.to_string()); - parameters.insert("densified".to_string(), ParameterValue::Boolean(true)); + parameters.insert("densified".to_string(), true.into()); let expanded_columns = crate::util::set_union(expanded_columns, partition_by); @@ -1259,11 +1259,7 @@ mod tests { max: None, }); let ctx = AestheticContext::from_static(&["x", "y"], &[]); - let mut parameters = Parameters::new(); - parameters.insert( - "aggregate".to_string(), - ParameterValue::String("mean".to_string()), - ); + let parameters = crate::params! { "aggregate" => "mean" }; let result = Tile .apply_stat_transform( @@ -1382,9 +1378,7 @@ mod tests { let aesthetics = create_aesthetics(&["pos1", "pos2"]); let schema = create_schema(&["pos1", "pos2"]); let group_by = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("width".to_string(), ParameterValue::Number(0.7)); - parameters.insert("height".to_string(), ParameterValue::Number(0.9)); + let parameters = crate::params! { "width" => 0.7, "height" => 0.9 }; let ctx = crate::plot::aesthetic::AestheticContext::from_static(&["x", "y"], &[]); let result = stat_tile( @@ -1463,14 +1457,12 @@ mod tests { fn test_apply_projection_densifies_continuous_tiles() { let tile = Tile; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=0 +lon_0=0".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=ortho +lat_0=0 +lon_0=0".into()); let mut mappings = create_bound_mappings(&["pos1min", "pos1max", "pos2min", "pos2max", "fill"]); @@ -1520,13 +1512,12 @@ mod tests { let tile = Tile; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); projection.properties.insert( "target".to_string(), - ParameterValue::String("+proj=ortho +lat_0=40 +lon_0=-70".to_string()), + "+proj=ortho +lat_0=40 +lon_0=-70".into(), ); for stmt in dialect.sql_spatial_setup() { @@ -1588,14 +1579,12 @@ mod tests { fn test_apply_projection_discrete_tiles_only_project() { let tile = Tile; let mut projection = Projection::map(); - projection.properties.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); - projection.properties.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); + projection + .properties + .insert("source".to_string(), "EPSG:4326".into()); + projection + .properties + .insert("target".to_string(), "+proj=merc".into()); // Discrete tiles only have pos1/pos2 let mut mappings = create_bound_mappings(&["pos1", "pos2"]); diff --git a/src/plot/layer/geom/violin.rs b/src/plot/layer/geom/violin.rs index 37578d58e..ffc756f52 100644 --- a/src/plot/layer/geom/violin.rs +++ b/src/plot/layer/geom/violin.rs @@ -144,10 +144,7 @@ impl GeomTrait for Violin { // Get width parameter (default 0.9) let width = parameters .get("width") - .and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }) + .and_then(ParameterValue::as_number) .unwrap_or(0.9); let half_width = 0.5 * width; @@ -343,12 +340,7 @@ mod tests { let query = "SELECT species, flipper_length FROM penguins"; let aesthetics = create_basic_aesthetics(); let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(5.0)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 5.0, "kernel" => "gaussian" }; let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap(); @@ -408,12 +400,7 @@ mod tests { let query = "SELECT species, flipper_length, island FROM penguins"; let aesthetics = create_aesthetics_with_color(); let groups = vec!["island".to_string()]; // Additional grouping via color aesthetic - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(5.0)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 5.0, "kernel" => "gaussian" }; let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap(); @@ -529,13 +516,8 @@ mod tests { let query = "SELECT species, flipper_length FROM penguins"; let aesthetics = create_basic_aesthetics(); let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(5.0)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); - parameters.insert("tails".to_string(), ParameterValue::Number(1.5)); // Custom tails + let mut parameters = crate::params! { "bandwidth" => 5.0, "kernel" => "gaussian" }; + parameters.insert("tails".to_string(), 1.5.into()); // Custom tails let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap(); @@ -623,8 +605,7 @@ mod tests { .unwrap(); // With width 0.6, half_width = 0.3 - let mut parameters = Parameters::new(); - parameters.insert("width".to_string(), ParameterValue::Number(0.6)); + let parameters = crate::params! { "width" => 0.6 }; let result = violin.post_process(df, ¶meters).unwrap(); @@ -651,12 +632,7 @@ mod tests { AestheticValue::standard_column("flipper_length".to_string()), ); let groups: Vec = vec![]; - let mut parameters = Parameters::new(); - parameters.insert("bandwidth".to_string(), ParameterValue::Number(5.0)); - parameters.insert( - "kernel".to_string(), - ParameterValue::String("gaussian".to_string()), - ); + let parameters = crate::params! { "bandwidth" => 5.0, "kernel" => "gaussian" }; let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap(); let setup_sql = "CREATE TABLE penguins AS SELECT * FROM (VALUES diff --git a/src/plot/layer/mod.rs b/src/plot/layer/mod.rs index 807b91345..162d973a4 100644 --- a/src/plot/layer/mod.rs +++ b/src/plot/layer/mod.rs @@ -28,11 +28,8 @@ pub use position::{Position, PositionTrait, PositionType}; use crate::{ plot::{ - is_facet_aesthetic, is_user_facet_aesthetic, parse_position, - types::{ - validate_parameter, AestheticValue, DataSource, Mappings, ParameterValue, Parameters, - SqlExpression, - }, + is_facet_aesthetic, parse_position, + types::{AestheticValue, DataSource, Mappings, ParameterValue, Parameters, SqlExpression}, }, AestheticContext, }; @@ -319,29 +316,17 @@ impl Layer { /// precedence. For example, if a geom defines width => 0.8 and the position (dodge) /// defines width => 0.9, the geom's 0.8 is used. pub fn apply_default_params(&mut self) { - // Apply geom defaults first (higher priority) - for param in self.geom.default_params() { - if !self.parameters.contains_key(param.name) { - let value = match ¶m.default { - DefaultParamValue::String(s) => ParameterValue::String(s.to_string()), - DefaultParamValue::Number(n) => ParameterValue::Number(*n), - DefaultParamValue::Boolean(b) => ParameterValue::Boolean(*b), - DefaultParamValue::Null => continue, // Don't insert null defaults - }; - self.parameters.insert(param.name.to_string(), value); - } - } - - // Apply position defaults second (lower priority, won't override geom defaults) - for param in self.position.default_params() { - if !self.parameters.contains_key(param.name) { - let value = match ¶m.default { - DefaultParamValue::String(s) => ParameterValue::String(s.to_string()), - DefaultParamValue::Number(n) => ParameterValue::Number(*n), - DefaultParamValue::Boolean(b) => ParameterValue::Boolean(*b), - DefaultParamValue::Null => continue, - }; - self.parameters.insert(param.name.to_string(), value); + // Geom defaults first: or_insert keeps them over position defaults + for param in self + .geom + .default_params() + .iter() + .chain(self.position.default_params()) + { + if let Some(value) = param.to_parameter_value() { + self.parameters + .entry(param.name.to_string()) + .or_insert(value); } } } @@ -391,61 +376,46 @@ impl Layer { /// Validate that all SETTING parameters are valid for this layer's geom and position pub fn validate_settings(&self) -> std::result::Result<(), String> { - // Combine valid settings from both geom and position (includes aesthetics) - let mut valid = self.geom.valid_settings(); - valid.extend(self.position.valid_settings()); + // Valid settings are the geom's supported aesthetics plus the + // geom's and position's parameter definitions. `aggregate`'s shape + // is checked here but its vocabulary is checked in + // `stat_aggregate::parse_aggregate_param`. + let definitions: Vec<&ParamDefinition> = self + .geom + .default_params() + .iter() + .chain(self.position.default_params()) + .collect(); + let aesthetics = self.geom.aesthetics().supported(); + let mut valid: Vec<&'static str> = aesthetics.clone(); + valid.extend(definitions.iter().map(|p| p.name)); + let mut unknown: Vec<&str> = Vec::new(); for (param_name, value) in self.parameters.iter() { - // Facet aesthetics (panel/row/column, or internal facet1/facet2) - // are valid constant settings regardless of geom: they become - // literal facet mappings during aesthetic transformation, mirroring - // MAPPING 'value' AS panel. - if is_user_facet_aesthetic(param_name) || is_facet_aesthetic(param_name) { + // Aesthetic settings have no parameter definition to validate + // against. Facet SETTING keys have already been moved to + // mappings by `transform_aesthetics_to_internal`. + if aesthetics.contains(¶m_name.as_str()) { continue; } - // Check if this is a valid setting at all - if !valid.contains(¶m_name.as_str()) { - return Err(format!( - "{} layer setting should be {}, not '{}'", - self.geom, - crate::or_list_quoted(&valid, '\''), - param_name - )); - } - - // Validate against constraints if this is a geom param - if let Some(param) = self - .geom - .default_params() - .iter() - .find(|p| p.name == param_name) - { - validate_parameter(param_name, value, ¶m.constraint)?; - } - // Or a position param - else if let Some(param) = self - .position - .default_params() - .iter() - .find(|p| p.name == param_name) - { - validate_parameter(param_name, value, ¶m.constraint)?; - } - // Otherwise it's a valid aesthetic setting (no constraint validation needed). - // - // `aggregate` is registered in each supporting geom's `default_params` - // so its structural shape (string / array of strings / null) is - // checked through the standard `validate_parameter` path above. The - // per-entry vocabulary check (function names exist in `AGG_NAMES`, - // band syntax, recycling rules) lives in - // `stat_aggregate::parse_aggregate_param` and runs at execute time - // (`apply`) and at validate time via - // [`validate_aggregate_setting`] (called from `validate.rs::validate` - // so `ggsql validate` surfaces vocab errors without executing). + let Some(param) = definitions.iter().find(|p| p.name == param_name) else { + unknown.push(param_name.as_str()); + continue; + }; + param.validate(Some(value))?; } - Ok(()) + if unknown.is_empty() { + Ok(()) + } else { + Err(format!( + "{} layer setting should be {}, not {}", + self.geom, + crate::or_list_quoted(&valid, '\''), + crate::and_list_quoted(&unknown, '\'') + )) + } } /// Validate the `aggregate` SETTING in isolation: per-entry vocabulary @@ -603,12 +573,8 @@ mod tests { fn test_resolve_aesthetics_from_settings() { // Test that resolve_aesthetics() moves aesthetic values from parameters to mappings let mut layer = Layer::new(Geom::point()); - layer - .parameters - .insert("size".to_string(), ParameterValue::Number(5.0)); - layer - .parameters - .insert("opacity".to_string(), ParameterValue::Number(0.8)); + layer.parameters.insert("size".to_string(), 5.0.into()); + layer.parameters.insert("opacity".to_string(), 0.8.into()); layer.resolve_aesthetics(); @@ -617,11 +583,11 @@ mod tests { assert!(!layer.parameters.contains_key("opacity")); assert_eq!( layer.mappings.get("size"), - Some(&AestheticValue::Literal(ParameterValue::Number(5.0))) + Some(&AestheticValue::Literal(5.0.into())) ); assert_eq!( layer.mappings.get("opacity"), - Some(&AestheticValue::Literal(ParameterValue::Number(0.8))) + Some(&AestheticValue::Literal(0.8.into())) ); } @@ -649,9 +615,7 @@ mod tests { "size", AestheticValue::standard_column("my_size".to_string()), ); - layer - .parameters - .insert("size".to_string(), ParameterValue::Number(5.0)); + layer.parameters.insert("size".to_string(), 5.0.into()); layer.resolve_aesthetics(); @@ -668,10 +632,9 @@ mod tests { fn test_resolve_aesthetics_precedence() { // Test that SETTING takes precedence over geom defaults let mut layer = Layer::new(Geom::point()); - layer.parameters.insert( - "shape".to_string(), - ParameterValue::String("square".to_string()), - ); + layer + .parameters + .insert("shape".to_string(), "square".into()); layer.resolve_aesthetics(); @@ -789,4 +752,50 @@ mod tests { let result = layer.validate_mapping(&Some(ctx), false); assert!(result.is_ok()); } + + #[test] + fn test_validate_settings_accepts_geom_and_position_params() { + // "position" is a point geom param, "width" a jitter position param + let mut layer = Layer::new(Geom::point()); + layer.position = Position::jitter(); + layer + .parameters + .insert("position".to_string(), "jitter".into()); + layer.parameters.insert("width".to_string(), 0.5.into()); + + assert!(layer.validate_settings().is_ok()); + } + + #[test] + fn test_validate_settings_rejects_an_invalid_value() { + let mut layer = Layer::new(Geom::point()); + layer + .parameters + .insert("position".to_string(), "bogus".into()); + + let err = layer.validate_settings().unwrap_err(); + assert!(err.contains("position")); + } + + #[test] + fn test_validate_settings_skips_aesthetics() { + // Aesthetic settings have no definition to validate against: any + // value passes, even one that would fail a parameter constraint + let mut layer = Layer::new(Geom::point()); + layer.parameters.insert("size".to_string(), "huge".into()); + + assert!(layer.validate_settings().is_ok()); + } + + #[test] + fn test_validate_settings_reports_all_unknown_settings() { + let mut layer = Layer::new(Geom::point()); + layer.parameters.insert("bogus1".to_string(), 1.0.into()); + layer.parameters.insert("bogus2".to_string(), 2.0.into()); + + let err = layer.validate_settings().unwrap_err(); + assert!(err.contains("layer setting should be")); + assert!(err.contains("'bogus1'")); + assert!(err.contains("'bogus2'")); + } } diff --git a/src/plot/layer/orientation.rs b/src/plot/layer/orientation.rs index 79308837b..7e3ec705d 100644 --- a/src/plot/layer/orientation.rs +++ b/src/plot/layer/orientation.rs @@ -632,7 +632,7 @@ mod tests { ); layer.mappings.insert( "pos1min".to_string(), - AestheticValue::Literal(crate::plot::ParameterValue::Number(0.0)), + AestheticValue::Literal((-0.0).into()), ); layer.mappings.insert( "pos1max".to_string(), @@ -661,7 +661,7 @@ mod tests { ); layer.mappings.insert( "pos2min".to_string(), - AestheticValue::Literal(crate::plot::ParameterValue::Number(0.0)), + AestheticValue::Literal((-0.0).into()), ); layer.mappings.insert( "pos2max".to_string(), diff --git a/src/plot/layer/position/dodge.rs b/src/plot/layer/position/dodge.rs index 9736fd751..d0c91f8f8 100644 --- a/src/plot/layer/position/dodge.rs +++ b/src/plot/layer/position/dodge.rs @@ -184,10 +184,7 @@ fn apply_dodge_with_width( let bar_width = layer .parameters .get("width") - .and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }) + .and_then(ParameterValue::as_number) .unwrap_or(0.9); // Check if layer has an existing offset column (e.g., violin density offset) @@ -634,9 +631,7 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); - layer - .parameters - .insert("width".to_string(), ParameterValue::Number(0.6)); + layer.parameters.insert("width".to_string(), 0.6.into()); // Mark pos1 as discrete and pos2 as continuous so only pos1offset is created let mut spec = Plot::new(); diff --git a/src/plot/layer/position/jitter.rs b/src/plot/layer/position/jitter.rs index a1e71aae8..e91ae2adc 100644 --- a/src/plot/layer/position/jitter.rs +++ b/src/plot/layer/position/jitter.rs @@ -488,20 +488,14 @@ fn apply_jitter(df: DataFrame, layer: &Layer, spec: &Plot) -> Result let width = layer .parameters .get("width") - .and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }) + .and_then(ParameterValue::as_number) .unwrap_or(0.9); // Get dodge parameter (default true) let dodge = layer .parameters .get("dodge") - .and_then(|v| match v { - ParameterValue::Boolean(b) => Some(*b), - _ => None, - }) + .and_then(ParameterValue::as_bool) .unwrap_or(true); // Get distribution parameter (default "uniform") @@ -575,18 +569,15 @@ fn apply_jitter(df: DataFrame, layer: &Layer, spec: &Plot) -> Result }; // Get density-specific parameters (match violin/density geoms) - let explicit_bandwidth = layer.parameters.get("bandwidth").and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }); + let explicit_bandwidth = layer + .parameters + .get("bandwidth") + .and_then(ParameterValue::as_number); let adjust = layer .parameters .get("adjust") - .and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }) + .and_then(ParameterValue::as_number) .unwrap_or(1.0); // Compute density scales if using density/intensity distribution @@ -804,9 +795,7 @@ mod tests { let jitter = Jitter; let df = make_test_df(); let mut layer = make_test_layer(); - layer - .parameters - .insert("dodge".to_string(), ParameterValue::Boolean(false)); + layer.parameters.insert("dodge".to_string(), false.into()); // Mark pos1 as discrete and pos2 as continuous via scales let mut spec = Plot::new(); @@ -924,9 +913,7 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); - layer - .parameters - .insert("width".to_string(), ParameterValue::Number(0.6)); + layer.parameters.insert("width".to_string(), 0.6.into()); // Mark pos1 as discrete and pos2 as continuous so only pos1offset is created let mut spec = Plot::new(); @@ -1076,10 +1063,9 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); layer.partition_by = vec![]; // No grouping for pure jitter - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("normal".to_string()), - ); + layer + .parameters + .insert("distribution".to_string(), "normal".into()); // Mark pos1 as discrete and pos2 as continuous so only pos1offset is created let mut spec = Plot::new(); @@ -1152,10 +1138,9 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); layer.partition_by = vec![]; // No grouping - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("density".to_string()), - ); + layer + .parameters + .insert("distribution".to_string(), "density".into()); // Test 1: Both axes discrete - should fail let mut spec = Plot::new(); @@ -1220,10 +1205,9 @@ mod tests { m }; layer.partition_by = vec![]; - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("density".to_string()), - ); + layer + .parameters + .insert("distribution".to_string(), "density".into()); // Mark pos1 as discrete and pos2 as continuous (density computed along pos2) let mut spec = Plot::new(); @@ -1279,10 +1263,9 @@ mod tests { m }; layer.partition_by = vec!["__ggsql_aes_fill__".to_string()]; - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("density".to_string()), - ); + layer + .parameters + .insert("distribution".to_string(), "density".into()); // Mark pos1 as discrete and pos2 as continuous let mut spec = Plot::new(); @@ -1395,10 +1378,9 @@ mod tests { let df = make_test_df(); let mut layer = make_test_layer(); layer.partition_by = vec![]; // No grouping - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("intensity".to_string()), - ); + layer + .parameters + .insert("distribution".to_string(), "intensity".into()); // Both axes discrete - should fail let mut spec = Plot::new(); @@ -1449,10 +1431,9 @@ mod tests { m }; layer.partition_by = vec![]; - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("intensity".to_string()), - ); + layer + .parameters + .insert("distribution".to_string(), "intensity".into()); // Mark pos1 as discrete and pos2 as continuous (density computed along pos2) let mut spec = Plot::new(); @@ -1502,14 +1483,11 @@ mod tests { m }; layer.partition_by = vec![]; - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("intensity".to_string()), - ); - // Use dodge=false to avoid group separation layer .parameters - .insert("dodge".to_string(), ParameterValue::Boolean(false)); + .insert("distribution".to_string(), "intensity".into()); + // Use dodge=false to avoid group separation + layer.parameters.insert("dodge".to_string(), false.into()); let mut spec = Plot::new(); spec.scales.push(make_discrete_scale("pos1")); @@ -1554,14 +1532,11 @@ mod tests { m }; layer.partition_by = vec![]; - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("density".to_string()), - ); - // Set explicit bandwidth matching what violin might use layer .parameters - .insert("bandwidth".to_string(), ParameterValue::Number(0.5)); + .insert("distribution".to_string(), "density".into()); + // Set explicit bandwidth matching what violin might use + layer.parameters.insert("bandwidth".to_string(), 0.5.into()); let mut spec = Plot::new(); spec.scales.push(make_discrete_scale("pos1")); @@ -1601,14 +1576,11 @@ mod tests { m }; layer.partition_by = vec![]; - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("density".to_string()), - ); - // Set adjust parameter (scales auto-computed bandwidth) layer .parameters - .insert("adjust".to_string(), ParameterValue::Number(2.0)); + .insert("distribution".to_string(), "density".into()); + // Set adjust parameter (scales auto-computed bandwidth) + layer.parameters.insert("adjust".to_string(), 2.0.into()); let mut spec = Plot::new(); spec.scales.push(make_discrete_scale("pos1")); @@ -1678,9 +1650,7 @@ mod tests { ] { let mut layer = make_test_layer(); layer.partition_by = vec![]; // disable groups so dodge is a no-op - layer - .parameters - .insert("dodge".to_string(), ParameterValue::Boolean(false)); + layer.parameters.insert("dodge".to_string(), false.into()); layer .parameters .insert("side".to_string(), ParameterValue::String(side.to_string())); @@ -1732,9 +1702,7 @@ mod tests { ] { let mut layer = make_test_layer(); layer.partition_by = vec![]; - layer - .parameters - .insert("dodge".to_string(), ParameterValue::Boolean(false)); + layer.parameters.insert("dodge".to_string(), false.into()); layer .parameters .insert("side".to_string(), ParameterValue::String(side.to_string())); @@ -1771,10 +1739,7 @@ mod tests { spec.scales.push(make_continuous_scale("pos2")); let mut layer = make_test_layer(); // partition_by = ["fill"] => 2 dodge groups - layer.parameters.insert( - "side".to_string(), - ParameterValue::String("right".to_string()), - ); + layer.parameters.insert("side".to_string(), "right".into()); let (result, _) = jitter.apply_adjustment(df, &layer, &spec).unwrap(); let offsets = as_f64(result.column("__ggsql_aes_pos1offset__").unwrap()).unwrap(); @@ -1819,17 +1784,11 @@ mod tests { let mut layer = make_test_layer(); layer.partition_by = vec![]; + layer.parameters.insert("dodge".to_string(), false.into()); layer .parameters - .insert("dodge".to_string(), ParameterValue::Boolean(false)); - layer.parameters.insert( - "distribution".to_string(), - ParameterValue::String("normal".to_string()), - ); - layer.parameters.insert( - "side".to_string(), - ParameterValue::String("right".to_string()), - ); + .insert("distribution".to_string(), "normal".into()); + layer.parameters.insert("side".to_string(), "right".into()); let (result, _) = jitter .apply_adjustment(make_test_df(), &layer, &spec) diff --git a/src/plot/layer/position/mod.rs b/src/plot/layer/position/mod.rs index 4330b3f89..55c0e62fd 100644 --- a/src/plot/layer/position/mod.rs +++ b/src/plot/layer/position/mod.rs @@ -14,7 +14,7 @@ mod identity; mod jitter; mod stack; -use crate::plot::types::{DefaultParamValue, ParamDefinition, ParameterValue}; +use crate::plot::types::ParamDefinition; use crate::plot::ScaleTypeKind; use crate::{DataFrame, Plot, Result}; use serde::{Deserialize, Serialize}; @@ -233,11 +233,6 @@ pub trait PositionTrait: std::fmt::Debug + std::fmt::Display + Send + Sync { &[] } - /// Returns valid parameter names for SETTING validation - fn valid_settings(&self) -> Vec<&'static str> { - self.default_params().iter().map(|p| p.name).collect() - } - /// Whether this position creates a pos1offset column fn creates_pos1offset(&self) -> bool { false @@ -314,11 +309,6 @@ impl Position { self.0.default_params() } - /// Get valid settings for SETTING validation - pub fn valid_settings(&self) -> Vec<&'static str> { - self.0.valid_settings() - } - /// Check if this position creates a pos1offset column pub fn creates_pos1offset(&self) -> bool { self.0.creates_pos1offset() @@ -338,24 +328,6 @@ impl Position { ) -> Result<(DataFrame, Option)> { self.0.apply_adjustment(df, layer, spec) } - - /// Apply default position parameter values to a layer - /// - /// For each parameter defined in default_params(), if the layer doesn't - /// already have that parameter set, insert the default value. - pub fn apply_defaults_to_layer(&self, layer: &mut Layer) { - for param in self.default_params() { - if !layer.parameters.contains_key(param.name) { - let value = match ¶m.default { - DefaultParamValue::String(s) => ParameterValue::String(s.to_string()), - DefaultParamValue::Number(n) => ParameterValue::Number(*n), - DefaultParamValue::Boolean(b) => ParameterValue::Boolean(*b), - DefaultParamValue::Null => continue, - }; - layer.parameters.insert(param.name.to_string(), value); - } - } - } } impl Default for Position { diff --git a/src/plot/layer/position/stack.rs b/src/plot/layer/position/stack.rs index 431f719c9..6bacedcbf 100644 --- a/src/plot/layer/position/stack.rs +++ b/src/plot/layer/position/stack.rs @@ -65,16 +65,13 @@ impl PositionTrait for Stack { let center = layer .parameters .get("center") - .and_then(|v| match v { - ParameterValue::Boolean(b) => Some(*b), - _ => None, - }) + .and_then(ParameterValue::as_bool) .unwrap_or(false); - let total = layer.parameters.get("total").and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }); + let total = layer + .parameters + .get("total") + .and_then(ParameterValue::as_number); let mode = match (center, total) { (true, _) => StackMode::Center, @@ -419,7 +416,7 @@ mod tests { let mut layer_centered = make_test_layer(); layer_centered .parameters - .insert("center".to_string(), ParameterValue::Boolean(true)); + .insert("center".to_string(), true.into()); let (result_centered, _) = stack.apply_adjustment(df, &layer_centered, &spec).unwrap(); // Normal stacking should have pos2end starting at 0 @@ -544,9 +541,7 @@ mod tests { // Test with total = 100 (percentage stacking) let mut layer = make_test_layer(); - layer - .parameters - .insert("total".to_string(), ParameterValue::Number(100.0)); + layer.parameters.insert("total".to_string(), 100.0.into()); let (result, _) = stack.apply_adjustment(df, &layer, &spec).unwrap(); @@ -577,9 +572,7 @@ mod tests { // Test with total = 1 (normalized to 1, like old stack_fill behavior) let mut layer = make_test_layer(); - layer - .parameters - .insert("total".to_string(), ParameterValue::Number(1.0)); + layer.parameters.insert("total".to_string(), 1.0.into()); let (result, _) = stack.apply_adjustment(df, &layer, &spec).unwrap(); diff --git a/src/plot/main.rs b/src/plot/main.rs index 190c7956c..c48eedae1 100644 --- a/src/plot/main.rs +++ b/src/plot/main.rs @@ -340,10 +340,7 @@ mod tests { let layer = Layer::new(Geom::point()) .with_aesthetic("x".to_string(), AestheticValue::standard_column("date")) .with_aesthetic("y".to_string(), AestheticValue::standard_column("revenue")) - .with_aesthetic( - "color".to_string(), - AestheticValue::Literal(ParameterValue::String("blue".to_string())), - ); + .with_aesthetic("color".to_string(), AestheticValue::Literal("blue".into())); assert_eq!(layer.geom, Geom::point()); assert_eq!(layer.get_column("x"), Some("date")); @@ -410,9 +407,9 @@ mod tests { #[test] fn test_aesthetic_value_display() { let column = AestheticValue::standard_column("sales"); - let string_lit = AestheticValue::Literal(ParameterValue::String("blue".to_string())); - let number_lit = AestheticValue::Literal(ParameterValue::Number(3.53)); - let bool_lit = AestheticValue::Literal(ParameterValue::Boolean(true)); + let string_lit = AestheticValue::Literal("blue".into()); + let number_lit = AestheticValue::Literal(3.53.into()); + let bool_lit = AestheticValue::Literal(true.into()); assert_eq!(format!("{}", column), "sales"); assert_eq!(format!("{}", string_lit), "'blue'"); @@ -475,7 +472,7 @@ mod tests { #[test] fn test_aesthetic_value_literal() { - let lit = AestheticValue::Literal(ParameterValue::String("red".to_string())); + let lit = AestheticValue::Literal("red".into()); assert!(!lit.is_dummy()); assert_eq!(lit.column_name(), None); } diff --git a/src/plot/projection/coord/cartesian.rs b/src/plot/projection/coord/cartesian.rs index 472d96df8..e1e732e90 100644 --- a/src/plot/projection/coord/cartesian.rs +++ b/src/plot/projection/coord/cartesian.rs @@ -40,7 +40,6 @@ impl CoordTrait for Cartesian { #[cfg(test)] mod tests { use super::*; - use crate::plot::{ParameterValue, Parameters}; #[test] fn test_cartesian_properties() { @@ -57,28 +56,4 @@ mod tests { assert!(names.contains(&"ratio")); assert!(names.contains(&"clip")); } - - #[test] - fn test_cartesian_resolve_valid_properties() { - let cartesian = Cartesian; - let props = Parameters::new(); - // Empty properties should resolve successfully - let resolved = cartesian.resolve_properties(None, &props); - assert!(resolved.is_ok()); - } - - #[test] - fn test_cartesian_rejects_unknown_property() { - let cartesian = Cartesian; - let mut props = Parameters::new(); - props.insert( - "unknown".to_string(), - ParameterValue::String("value".to_string()), - ); - - let resolved = cartesian.resolve_properties(None, &props); - assert!(resolved.is_err()); - let err = resolved.unwrap_err(); - assert!(err.contains("not 'unknown'")); - } } diff --git a/src/plot/projection/coord/map.rs b/src/plot/projection/coord/map.rs index 439c1c7be..e46c93c1b 100644 --- a/src/plot/projection/coord/map.rs +++ b/src/plot/projection/coord/map.rs @@ -1038,47 +1038,9 @@ mod tests { assert_eq!(defaults.len(), 6); } - #[test] - fn test_map_accepts_target_string() { - let mut props = Parameters::new(); - props.insert( - "target".to_string(), - ParameterValue::String("+proj=merc".to_string()), - ); - let coord = Coord::map("crs", &props); - - let resolved = coord.resolve_properties(Some("crs"), &props); - assert!(resolved.is_ok()); - let resolved = resolved.unwrap(); - assert_eq!( - resolved.get("target").unwrap(), - &ParameterValue::String("+proj=merc".to_string()) - ); - } - - #[test] - fn test_map_rejects_unknown_property() { - let coord = Coord::map("crs", &Parameters::new()); - let mut props = Parameters::new(); - props.insert( - "unknown".to_string(), - ParameterValue::String("value".to_string()), - ); - - let resolved = coord.resolve_properties(Some("crs"), &props); - assert!(resolved.is_err()); - let err = resolved.unwrap_err(); - assert!(err.contains("not 'unknown'")); - } - #[test] fn test_target_rejects_origin_and_parallel() { - let mut props = Parameters::new(); - props.insert( - "target".to_string(), - ParameterValue::String("+proj=ortho".to_string()), - ); - props.insert("origin".to_string(), ParameterValue::Number(30.0)); + let props = crate::params! { "target" => "+proj=ortho", "origin" => 30.0 }; let coord = Coord::map("crs", &props); let resolved = coord.resolve_properties(Some("crs"), &props); @@ -1464,8 +1426,7 @@ mod tests { let mut s = Scale::new("pos1"); s.scale_type = Some(ScaleType::continuous()); s.transform = Some(Transform::geographic()); - s.properties - .insert("breaks".to_string(), ParameterValue::Number(5.0)); + s.properties = crate::params! { "breaks" => 5.0 }; resolve_map_scale(&mut s, (-180.0, 180.0)); @@ -1495,11 +1456,7 @@ mod tests { #[test] fn resolve_epsg_property_from_existing() { - let mut props = Parameters::new(); - props.insert( - "source".to_string(), - ParameterValue::String("EPSG:4326".to_string()), - ); + let props = crate::params! { "source" => "EPSG:4326" }; let result = resolve_epsg_property("source", &props, "EPSG:4326", &AnsiDialect, &noop_execute); assert!(result.contains("+proj=longlat"), "got: {result}"); diff --git a/src/plot/projection/coord/map_projections.rs b/src/plot/projection/coord/map_projections.rs index 7489a0cdc..4a74d662f 100644 --- a/src/plot/projection/coord/map_projections.rs +++ b/src/plot/projection/coord/map_projections.rs @@ -4,8 +4,7 @@ use std::sync::Arc; use super::CoordKind; use crate::plot::scale::Scale; use crate::plot::types::{ - validate_parameter, ArrayElement, DefaultParamValue, ParamConstraint, ParamDefinition, - Parameters, TypeConstraint, + ArrayElement, DefaultParamValue, ParamConstraint, ParamDefinition, Parameters, TypeConstraint, }; use crate::plot::{Layer, ParameterValue}; use crate::reader::SqlDialect; @@ -202,20 +201,6 @@ impl super::CoordTrait for T { .to_string(), ); } - let defaults = self.default_properties(); - for (key, value) in properties.iter() { - if let Some(param) = defaults.iter().find(|p| p.name == key) { - validate_parameter(key, value, ¶m.constraint)?; - } else { - let allowed: Vec<&str> = defaults.iter().map(|p| p.name).collect(); - return Err(format!( - "{} projection property should be {}, not '{}'", - self.name(), - crate::or_list_quoted(&allowed, '\''), - key - )); - } - } if let Some(ParameterValue::Array(arr)) = properties.get("origin") { if let Some(crate::plot::types::ArrayElement::Number(lat)) = arr.get(1) { if *lat < -90.0 || *lat > 90.0 { @@ -226,15 +211,11 @@ impl super::CoordTrait for T { } } } - let mut resolved = properties.clone(); - for param in defaults { - if !resolved.contains_key(param.name) { - if let Some(default) = param.to_parameter_value() { - resolved.insert(param.name.to_string(), default); - } - } - } - Ok(resolved) + crate::params::resolve_parameters( + properties, + self.default_properties(), + &format!("{} projection property", self.name()), + ) } fn apply_projection_transforms( @@ -1383,7 +1364,7 @@ mod tests { let mut props = Parameters::new(); props.insert( "target".to_string(), - ParameterValue::String("+proj=aea +lon_0=5 +lat_0=10 +lat_1=30 +lat_2=50".to_string()), + "+proj=aea +lon_0=5 +lat_0=10 +lat_1=30 +lat_2=50".into(), ); let proj = build_map_projection_trait(Some("crs"), &props).unwrap(); assert_eq!(proj.proj_code(), "aea"); @@ -1472,8 +1453,7 @@ mod tests { #[test] fn equal_earth_from_name_and_proj_str() { - let mut props = Parameters::new(); - props.insert("origin".to_string(), ParameterValue::Number(11.0)); + let props = crate::params! { "origin" => 11.0 }; let proj = build_map_projection_trait(Some("equal_earth"), &props).unwrap(); assert_eq!(proj.proj_code(), "eqearth"); assert_eq!(proj.origin(), (11.0, 0.0)); diff --git a/src/plot/projection/coord/mod.rs b/src/plot/projection/coord/mod.rs index 6ec45246d..b9f64d0e4 100644 --- a/src/plot/projection/coord/mod.rs +++ b/src/plot/projection/coord/mod.rs @@ -24,7 +24,7 @@ use serde::{Deserialize, Serialize}; use std::sync::Arc; use crate::plot::scale::Scale; -use crate::plot::types::{validate_parameter, ParamDefinition, Parameters}; +use crate::plot::types::{ParamDefinition, Parameters}; use crate::plot::Layer; use crate::reader::SqlDialect; use crate::DataFrame; @@ -95,42 +95,11 @@ pub trait CoordTrait: std::fmt::Debug + Send + Sync { _coord_type_name: Option<&str>, properties: &Parameters, ) -> Result { - let defaults = self.default_properties(); - - // Validate values against constraints - for (key, value) in properties.iter() { - if let Some(param) = defaults.iter().find(|p| p.name == key) { - validate_parameter(key, value, ¶m.constraint)?; - } else { - let allowed: Vec<&str> = defaults.iter().map(|p| p.name).collect(); - return Err(if allowed.is_empty() { - format!( - "{} projection does not accept any properties, but got '{}'", - self.name(), - key - ) - } else { - format!( - "{} projection property should be {}, not '{}'", - self.name(), - crate::or_list_quoted(&allowed, '\''), - key - ) - }); - } - } - - // Start with user properties, add defaults for missing ones - let mut resolved = properties.clone(); - for param in defaults { - if !resolved.contains_key(param.name) { - if let Some(default) = param.to_parameter_value() { - resolved.insert(param.name.to_string(), default); - } - } - } - - Ok(resolved) + crate::params::resolve_parameters( + properties, + self.default_properties(), + &format!("{} projection property", self.name()), + ) } /// Downcast to `MapProjectionTrait` if this coord is a map projection. diff --git a/src/plot/projection/coord/polar.rs b/src/plot/projection/coord/polar.rs index 16b0ee54f..352a4ca80 100644 --- a/src/plot/projection/coord/polar.rs +++ b/src/plot/projection/coord/polar.rs @@ -55,7 +55,6 @@ impl CoordTrait for Polar { #[cfg(test)] mod tests { use super::*; - use crate::plot::{ParameterValue, Parameters}; #[test] fn test_polar_properties() { @@ -87,89 +86,4 @@ mod tests { DefaultParamValue::Number(0.0) )); } - - #[test] - fn test_polar_rejects_unknown_property() { - let polar = Polar; - let mut props = Parameters::new(); - props.insert( - "unknown".to_string(), - ParameterValue::String("value".to_string()), - ); - - let resolved = polar.resolve_properties(None, &props); - assert!(resolved.is_err()); - let err = resolved.unwrap_err(); - assert!(err.contains("not 'unknown'")); - } - - #[test] - fn test_polar_resolve_with_explicit_start() { - let polar = Polar; - let mut props = Parameters::new(); - props.insert("start".to_string(), ParameterValue::Number(90.0)); - - let resolved = polar.resolve_properties(None, &props); - assert!(resolved.is_ok()); - let resolved = resolved.unwrap(); - assert_eq!( - resolved.get("start").unwrap(), - &ParameterValue::Number(90.0) - ); - } - - #[test] - fn test_polar_resolve_adds_start_default() { - let polar = Polar; - let props = Parameters::new(); - - let resolved = polar.resolve_properties(None, &props); - assert!(resolved.is_ok()); - let resolved = resolved.unwrap(); - assert!(resolved.contains_key("start")); - assert_eq!(resolved.get("start").unwrap(), &ParameterValue::Number(0.0)); - } - - #[test] - fn test_polar_resolve_with_explicit_end() { - let polar = Polar; - let mut props = Parameters::new(); - props.insert("end".to_string(), ParameterValue::Number(180.0)); - - let resolved = polar.resolve_properties(None, &props); - assert!(resolved.is_ok()); - let resolved = resolved.unwrap(); - assert_eq!(resolved.get("end").unwrap(), &ParameterValue::Number(180.0)); - // start should still get its default - assert_eq!(resolved.get("start").unwrap(), &ParameterValue::Number(0.0)); - } - - #[test] - fn test_polar_resolve_with_start_and_end() { - let polar = Polar; - let mut props = Parameters::new(); - props.insert("start".to_string(), ParameterValue::Number(-90.0)); - props.insert("end".to_string(), ParameterValue::Number(90.0)); - - let resolved = polar.resolve_properties(None, &props); - assert!(resolved.is_ok()); - let resolved = resolved.unwrap(); - assert_eq!( - resolved.get("start").unwrap(), - &ParameterValue::Number(-90.0) - ); - assert_eq!(resolved.get("end").unwrap(), &ParameterValue::Number(90.0)); - } - - #[test] - fn test_polar_resolve_with_inner() { - let polar = Polar; - let mut props = Parameters::new(); - props.insert("inner".to_string(), ParameterValue::Number(0.5)); - - let resolved = polar.resolve_properties(None, &props); - assert!(resolved.is_ok()); - let resolved = resolved.unwrap(); - assert_eq!(resolved.get("inner").unwrap(), &ParameterValue::Number(0.5)); - } } diff --git a/src/plot/projection/resolve.rs b/src/plot/projection/resolve.rs index edc03b397..9283737d5 100644 --- a/src/plot/projection/resolve.rs +++ b/src/plot/projection/resolve.rs @@ -600,10 +600,7 @@ mod tests { let mut proj = Projection::polar(); let scales = vec![discrete_scale_with_n("pos2", 5)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(proj.properties.get("radar"), Some(&true.into())); } #[test] @@ -611,10 +608,7 @@ mod tests { let mut proj = Projection::polar(); let scales = vec![scale_with_type("pos2", false)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(proj.properties.get("radar"), Some(&false.into())); } #[test] @@ -622,10 +616,7 @@ mod tests { let mut proj = Projection::polar(); let scales = vec![scale_with_type("pos2", true)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(proj.properties.get("radar"), Some(&true.into())); } #[test] @@ -633,10 +624,7 @@ mod tests { let mut proj = Projection::polar(); let scales = vec![discrete_scale_with_n("pos2", 2)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(proj.properties.get("radar"), Some(&false.into())); } #[test] @@ -644,10 +632,7 @@ mod tests { let mut proj = Projection::polar(); let scales = vec![discrete_scale_with_n("pos2", 1)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(proj.properties.get("radar"), Some(&false.into())); } #[test] @@ -655,30 +640,22 @@ mod tests { let mut proj = Projection::polar(); let scales = vec![discrete_scale_with_n("pos2", 3)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(proj.properties.get("radar"), Some(&true.into())); } #[test] fn test_radar_explicit_true_with_discrete_ok() { let mut proj = Projection::polar(); - proj.properties - .insert("radar".to_string(), ParameterValue::Boolean(true)); + proj.properties = crate::params! { "radar" => true }; let scales = vec![discrete_scale_with_n("pos2", 4)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(proj.properties.get("radar"), Some(&true.into())); } #[test] fn test_radar_explicit_true_with_2_categories_errors() { let mut proj = Projection::polar(); - proj.properties - .insert("radar".to_string(), ParameterValue::Boolean(true)); + proj.properties = crate::params! { "radar" => true }; let scales = vec![discrete_scale_with_n("pos2", 2)]; let result = resolve_projection_properties(&mut proj, &scales); assert!(result.is_err()); @@ -692,8 +669,7 @@ mod tests { #[test] fn test_radar_explicit_true_with_continuous_errors() { let mut proj = Projection::polar(); - proj.properties - .insert("radar".to_string(), ParameterValue::Boolean(true)); + proj.properties = crate::params! { "radar" => true }; let scales = vec![scale_with_type("pos2", false)]; let result = resolve_projection_properties(&mut proj, &scales); assert!(result.is_err()); @@ -707,14 +683,10 @@ mod tests { #[test] fn test_radar_explicit_false_with_discrete_preserved() { let mut proj = Projection::polar(); - proj.properties - .insert("radar".to_string(), ParameterValue::Boolean(false)); + proj.properties = crate::params! { "radar" => false }; let scales = vec![scale_with_type("pos2", true)]; resolve_projection_properties(&mut proj, &scales).unwrap(); - assert_eq!( - proj.properties.get("radar"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(proj.properties.get("radar"), Some(&false.into())); } #[test] diff --git a/src/plot/scale/scale_type/binned.rs b/src/plot/scale/scale_type/binned.rs index 732219341..11c170661 100644 --- a/src/plot/scale/scale_type/binned.rs +++ b/src/plot/scale/scale_type/binned.rs @@ -999,10 +999,9 @@ mod tests { ArrayElement::Number(20.0), ]), ); - scale.properties.insert( - "closed".to_string(), - ParameterValue::String("right".to_string()), - ); + scale + .properties + .insert("closed".to_string(), "right".into()); let sql = binned .pre_stat_transform_sql("col", &DataType::Float64, &scale, &AnsiDialect) @@ -1045,9 +1044,7 @@ mod tests { let binned = Binned; let mut scale = Scale::new("x"); // breaks is still a Number (count), not resolved to Array yet - scale - .properties - .insert("breaks".to_string(), ParameterValue::Number(5.0)); + scale.properties = crate::params! { "breaks" => 5.0 }; // Should return None because breaks hasn't been resolved to Array assert!(binned @@ -1613,15 +1610,11 @@ mod tests { "breaks".to_string(), ParameterValue::Array(breaks.iter().map(|&v| ArrayElement::Number(v)).collect()), ); - scale.properties.insert( - "oob".to_string(), - ParameterValue::String("squish".to_string()), - ); + scale.properties.insert("oob".to_string(), "squish".into()); if closed == "right" { - scale.properties.insert( - "closed".to_string(), - ParameterValue::String("right".to_string()), - ); + scale + .properties + .insert("closed".to_string(), "right".into()); } let sql = binned @@ -1654,10 +1647,7 @@ mod tests { ArrayElement::Number(100.0), ]), ); - scale.properties.insert( - "oob".to_string(), - ParameterValue::String("squish".to_string()), - ); + scale.properties.insert("oob".to_string(), "squish".into()); let sql = binned .pre_stat_transform_sql("x", &DataType::Float64, &scale, &AnsiDialect) .unwrap(); @@ -1678,10 +1668,7 @@ mod tests { "breaks".to_string(), ParameterValue::Array(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]), ); - scale.properties.insert( - "oob".to_string(), - ParameterValue::String("squish".to_string()), - ); + scale.properties.insert("oob".to_string(), "squish".into()); let sql = binned .pre_stat_transform_sql("x", &DataType::Float64, &scale, &AnsiDialect) .unwrap(); diff --git a/src/plot/scale/scale_type/continuous.rs b/src/plot/scale/scale_type/continuous.rs index 1f02eff7c..4a829157c 100644 --- a/src/plot/scale/scale_type/continuous.rs +++ b/src/plot/scale/scale_type/continuous.rs @@ -221,10 +221,7 @@ impl ScaleTypeTrait for Continuous { let oob = scale .properties .get("oob") - .and_then(|p| match p { - ParameterValue::String(s) => Some(s.as_str()), - _ => None, - }) + .and_then(ParameterValue::as_str) .unwrap_or(super::default_oob(&scale.aesthetic)); match oob { @@ -265,10 +262,7 @@ mod tests { let mut scale = Scale::new("y"); scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); scale.explicit_input_range = true; - scale.properties.insert( - "oob".to_string(), - ParameterValue::String("censor".to_string()), - ); + scale.properties = crate::params! { "oob" => "censor" }; let sql = continuous.pre_stat_transform_sql("value", &DataType::Float64, &scale, &AnsiDialect); @@ -288,10 +282,7 @@ mod tests { let mut scale = Scale::new("y"); scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); scale.explicit_input_range = true; - scale.properties.insert( - "oob".to_string(), - ParameterValue::String("squish".to_string()), - ); + scale.properties = crate::params! { "oob" => "squish" }; let sql = continuous.pre_stat_transform_sql("value", &DataType::Float64, &scale, &AnsiDialect); @@ -308,10 +299,7 @@ mod tests { let mut scale = Scale::new("x"); // position aesthetic defaults to keep scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); scale.explicit_input_range = true; - scale.properties.insert( - "oob".to_string(), - ParameterValue::String("keep".to_string()), - ); + scale.properties = crate::params! { "oob" => "keep" }; let sql = continuous.pre_stat_transform_sql("value", &DataType::Float64, &scale, &AnsiDialect); diff --git a/src/plot/scale/scale_type/mod.rs b/src/plot/scale/scale_type/mod.rs index 4dd87ba52..58592469b 100644 --- a/src/plot/scale/scale_type/mod.rs +++ b/src/plot/scale/scale_type/mod.rs @@ -27,9 +27,7 @@ use std::sync::Arc; use super::transform::{Transform, TransformKind}; use crate::plot::aesthetic::{is_facet_aesthetic, is_position_aesthetic}; -use crate::plot::types::{ - format_number, validate_parameter, DefaultParamValue, ParamDefinition, Parameters, -}; +use crate::plot::types::{format_number, DefaultParamValue, ParamDefinition, Parameters}; use crate::plot::{ArrayElement, ColumnInfo, ParameterValue}; // Scale type implementations @@ -644,66 +642,35 @@ pub trait ScaleTypeTrait: std::fmt::Debug + std::fmt::Display + Send + Sync { aesthetic: &str, properties: &Parameters, ) -> Result { - let defaults = self.default_properties(); let is_position = is_position_aesthetic(aesthetic); - // Validate values against constraints - for (key, value) in properties.iter() { - // Check if property is allowed for this aesthetic type - let is_expand_on_non_position = key == "expand" && !is_position; - - // Find the parameter definition and validate if allowed - let param = defaults.iter().find(|p| p.name == key); - if let Some(param) = param { - if !is_expand_on_non_position { - validate_parameter(key, value, ¶m.constraint)?; - continue; - } + // expand only applies to position aesthetics + let mut defaults: Vec = self + .default_properties() + .iter() + .filter(|p| is_position || p.name != "expand") + .cloned() + .collect(); + // oob's real default is aesthetic-dependent; its Null definition + // default is a marker for that. + for p in &mut defaults { + if p.name == "oob" && matches!(p.default, DefaultParamValue::Null) { + p.default = DefaultParamValue::String(default_oob(aesthetic)); } - - // Property not found or not allowed for this aesthetic type - let allowed: Vec<&str> = defaults - .iter() - .filter(|p| p.name != "expand" || is_position) - .map(|p| p.name) - .collect(); - return Err(if allowed.is_empty() { - format!( - "{} scale does not accept any properties, but got '{}'", - self.name(), - key - ) - } else { - format!( - "{} scale property should be {}, not '{}'", - self.name(), - crate::or_list_quoted(&allowed, '\''), - key - ) - }); } - - // Start with user properties, add defaults for missing ones - let mut resolved = properties.clone(); - for param in defaults { - // Skip expand for material aesthetics - if param.name == "expand" && !is_position { - continue; - } - - if !resolved.contains_key(param.name) { - // Special case: oob default varies by aesthetic when marked as Null - if param.name == "oob" && matches!(param.default, DefaultParamValue::Null) { - resolved.insert( - "oob".to_string(), - ParameterValue::String(default_oob(aesthetic).to_string()), - ); - } else if let Some(default) = param.to_parameter_value() { - resolved.insert(param.name.to_string(), default); - } - } + if !is_position && properties.contains_key("expand") { + return Err(format!( + "expand is only valid for position aesthetics, not '{}'", + aesthetic + )); } + let resolved = crate::params::resolve_parameters( + properties, + &defaults, + &format!("{} scale property", self.name()), + )?; + // Additional semantic validation for oob (scale-specific restrictions beyond the constraint) if let Some(ParameterValue::String(oob)) = resolved.get("oob") { // Discrete and Ordinal scales only support "censor" - no way to map unmapped values to output @@ -2531,7 +2498,7 @@ mod tests { #[test] fn test_parse_expand_value_number() { - let val = ParameterValue::Number(0.1); + let val = 0.1.into(); let (mult, add) = parse_expand_value(&val).unwrap(); assert!((mult - 0.1).abs() < 1e-10); assert!((add - 0.0).abs() < 1e-10); @@ -2548,7 +2515,7 @@ mod tests { #[test] fn test_parse_expand_value_invalid() { - let val = ParameterValue::String("invalid".to_string()); + let val = "invalid".into(); assert!(parse_expand_value(&val).is_none()); let val = ParameterValue::Array(vec![ArrayElement::Number(0.05)]); @@ -2668,30 +2635,18 @@ mod tests { #[test] fn test_resolve_properties_rejection_cases() { - // Unknown property rejected - let mut props = Parameters::new(); - props.insert("unknown".to_string(), ParameterValue::Number(1.0)); - let result = ScaleType::continuous().resolve_properties("x", &props); - assert!(result.is_err()); - assert!(result.unwrap_err().contains("unknown")); - - // Discrete rejects expand - let mut expand_props = Parameters::new(); - expand_props.insert("expand".to_string(), ParameterValue::Number(0.1)); + // expand on a non-position aesthetic rejected + let expand_props = crate::params! { "expand" => 0.1 }; let result = ScaleType::discrete().resolve_properties("color", &expand_props); assert!(result.is_err()); - assert!(result.unwrap_err().contains("not 'expand'")); + assert!(result.unwrap_err().contains("position aesthetics")); - // Identity rejects any property + // Identity on a position aesthetic rejects any other property let result = ScaleType::identity().resolve_properties("x", &expand_props); assert!(result.is_err()); // Binned rejects oob='keep' - let mut keep_props = Parameters::new(); - keep_props.insert( - "oob".to_string(), - ParameterValue::String("keep".to_string()), - ); + let keep_props = crate::params! { "oob" => "keep" }; let result = ScaleType::binned().resolve_properties("x", &keep_props); assert!(result.is_err()); let err = result.unwrap_err(); @@ -2741,18 +2696,8 @@ mod tests { #[test] fn test_resolve_properties_user_values_preserved() { - let mut props = Parameters::new(); - props.insert("expand".to_string(), ParameterValue::Number(0.1)); - let resolved = ScaleType::continuous() - .resolve_properties("pos1", &props) - .unwrap(); - match resolved.get("expand") { - Some(ParameterValue::Number(n)) => assert!((n - 0.1).abs() < 1e-10), - _ => panic!("Expected Number"), - } - // Binned supports expand - props.insert("expand".to_string(), ParameterValue::Number(0.2)); + let props = crate::params! { "expand" => 0.2 }; let resolved = ScaleType::binned() .resolve_properties("pos1", &props) .unwrap(); @@ -2762,11 +2707,7 @@ mod tests { } // Binned allows squish oob - let mut oob_props = Parameters::new(); - oob_props.insert( - "oob".to_string(), - ParameterValue::String("squish".to_string()), - ); + let oob_props = crate::params! { "oob" => "squish" }; assert!(ScaleType::binned() .resolve_properties("x", &oob_props) .is_ok()); @@ -2779,8 +2720,7 @@ mod tests { "pos1", "pos1min", "pos1max", "pos1end", "pos2", "pos2min", "pos2max", "pos2end", ]; - let mut props = Parameters::new(); - props.insert("expand".to_string(), ParameterValue::Number(0.1)); + let props = crate::params! { "expand" => 0.1 }; // Position aesthetics should allow expand for aes in internal_position.iter() { @@ -2859,8 +2799,7 @@ mod tests { } // Invalid value rejected with helpful message - let mut props = Parameters::new(); - props.insert("oob".to_string(), ParameterValue::String("invalid".into())); + let props = crate::params! { "oob" => "invalid" }; let result = ScaleType::continuous().resolve_properties("x", &props); assert!(result.is_err()); let err = result.unwrap_err(); @@ -2873,8 +2812,7 @@ mod tests { #[test] fn test_oob_user_value_preserved() { - let mut props = Parameters::new(); - props.insert("oob".to_string(), ParameterValue::String("squish".into())); + let props = crate::params! { "oob" => "squish" }; let resolved = ScaleType::continuous() .resolve_properties("x", &props) .unwrap(); @@ -2899,8 +2837,7 @@ mod tests { } // Identity and discrete reject oob - let mut oob_props = Parameters::new(); - oob_props.insert("oob".to_string(), ParameterValue::String("censor".into())); + let oob_props = crate::params! { "oob" => "censor" }; assert!(ScaleType::identity() .resolve_properties("color", &oob_props) .is_err()); @@ -3117,39 +3054,28 @@ mod tests { let resolved = ScaleType::continuous() .resolve_properties("x", &props) .unwrap(); - assert_eq!( - resolved.get("reverse"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(resolved.get("reverse"), Some(&false.into())); // Same for material aesthetics let resolved = ScaleType::continuous() .resolve_properties("color", &props) .unwrap(); - assert_eq!( - resolved.get("reverse"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(resolved.get("reverse"), Some(&false.into())); } #[test] fn test_reverse_property_accepts_true() { - let mut props = Parameters::new(); - props.insert("reverse".to_string(), ParameterValue::Boolean(true)); + let props = crate::params! { "reverse" => true }; let resolved = ScaleType::continuous() .resolve_properties("x", &props) .unwrap(); - assert_eq!( - resolved.get("reverse"), - Some(&ParameterValue::Boolean(true)) - ); + assert_eq!(resolved.get("reverse"), Some(&true.into())); } #[test] fn test_reverse_property_supported_by_all_scales() { - let mut props = Parameters::new(); - props.insert("reverse".to_string(), ParameterValue::Boolean(true)); + let props = crate::params! { "reverse" => true }; // All scale types should support reverse property for scale_type in &[ @@ -3166,7 +3092,7 @@ mod tests { let resolved = result.unwrap(); assert_eq!( resolved.get("reverse"), - Some(&ParameterValue::Boolean(true)), + Some(&true.into()), "Scale {:?} should preserve reverse=true", scale_type.scale_type_kind() ); @@ -3176,8 +3102,7 @@ mod tests { #[test] fn test_identity_scale_rejects_reverse_property() { // Identity scale should not support reverse (no properties at all) - let mut props = Parameters::new(); - props.insert("reverse".to_string(), ParameterValue::Boolean(true)); + let props = crate::params! { "reverse" => true }; let result = ScaleType::identity().resolve_properties("x", &props); assert!(result.is_err()); @@ -3193,7 +3118,7 @@ mod tests { let resolved = ScaleType::continuous() .resolve_properties("x", &props) .unwrap(); - assert_eq!(resolved.get("breaks"), Some(&ParameterValue::Number(7.0))); + assert_eq!(resolved.get("breaks"), Some(&7.0.into())); } #[test] @@ -3202,18 +3127,17 @@ mod tests { let resolved = ScaleType::continuous() .resolve_properties("x", &props) .unwrap(); - assert_eq!(resolved.get("pretty"), Some(&ParameterValue::Boolean(true))); + assert_eq!(resolved.get("pretty"), Some(&true.into())); } #[test] fn test_breaks_property_accepts_number() { - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(10.0)); + let props = crate::params! { "breaks" => 10.0 }; let result = ScaleType::continuous().resolve_properties("x", &props); assert!(result.is_ok()); let resolved = result.unwrap(); - assert_eq!(resolved.get("breaks"), Some(&ParameterValue::Number(10.0))); + assert_eq!(resolved.get("breaks"), Some(&10.0.into())); } #[test] @@ -3236,22 +3160,17 @@ mod tests { #[test] fn test_pretty_property_accepts_false() { - let mut props = Parameters::new(); - props.insert("pretty".to_string(), ParameterValue::Boolean(false)); + let props = crate::params! { "pretty" => false }; let result = ScaleType::continuous().resolve_properties("x", &props); assert!(result.is_ok()); let resolved = result.unwrap(); - assert_eq!( - resolved.get("pretty"), - Some(&ParameterValue::Boolean(false)) - ); + assert_eq!(resolved.get("pretty"), Some(&false.into())); } #[test] fn test_breaks_supported_by_continuous_scales() { - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(5.0)); + let props = crate::params! { "breaks" => 5.0 }; for scale_type in &[ScaleType::continuous(), ScaleType::binned()] { let result = scale_type.resolve_properties("x", &props); @@ -3265,8 +3184,7 @@ mod tests { #[test] fn test_discrete_does_not_support_breaks() { - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(5.0)); + let props = crate::params! { "breaks" => 5.0 }; let result = ScaleType::discrete().resolve_properties("x", &props); assert!(result.is_err()); @@ -3275,8 +3193,7 @@ mod tests { #[test] fn test_identity_does_not_support_breaks() { - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(5.0)); + let props = crate::params! { "breaks" => 5.0 }; let result = ScaleType::identity().resolve_properties("x", &props); assert!(result.is_err()); @@ -3285,8 +3202,7 @@ mod tests { #[test] fn test_breaks_available_for_material_aesthetics() { // breaks should work for color legends too - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(4.0)); + let props = crate::params! { "breaks" => 4.0 }; let result = ScaleType::continuous().resolve_properties("color", &props); assert!(result.is_ok()); @@ -3299,9 +3215,7 @@ mod tests { #[test] fn test_resolve_breaks_continuous_identity() { let input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(5.0)); - props.insert("pretty".to_string(), ParameterValue::Boolean(true)); + let props = crate::params! { "breaks" => 5.0, "pretty" => true }; let identity = Transform::identity(); let breaks = @@ -3318,8 +3232,7 @@ mod tests { // Break generators iterate the domain in step-sized increments; a // non-finite bound would make that iteration effectively unbounded // (observed as an OOM when a map projection produced inf coordinates). - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(7.0)); + let props = crate::params! { "breaks" => 7.0 }; let geographic = Transform::geographic(); for (min, max) in [ @@ -3347,9 +3260,7 @@ mod tests { ArrayElement::Number(1.0), ArrayElement::Number(1000.0), ]); - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(10.0)); - props.insert("pretty".to_string(), ParameterValue::Boolean(false)); + let props = crate::params! { "breaks" => 10.0, "pretty" => false }; let log10 = Transform::log(); let breaks = @@ -3367,9 +3278,7 @@ mod tests { #[test] fn test_resolve_breaks_continuous_log10_pretty() { let input_range = Some(vec![ArrayElement::Number(1.0), ArrayElement::Number(100.0)]); - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(10.0)); - props.insert("pretty".to_string(), ParameterValue::Boolean(true)); + let props = crate::params! { "breaks" => 10.0, "pretty" => true }; let log10 = Transform::log(); let breaks = @@ -3386,9 +3295,7 @@ mod tests { #[test] fn test_resolve_breaks_continuous_sqrt() { let input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); - let mut props = Parameters::new(); - props.insert("breaks".to_string(), ParameterValue::Number(5.0)); - props.insert("pretty".to_string(), ParameterValue::Boolean(false)); + let props = crate::params! { "breaks" => 5.0, "pretty" => false }; let sqrt = Transform::sqrt(); let breaks = @@ -3484,10 +3391,9 @@ mod tests { ArrayElement::Date(19738), // 2024-01-15 ArrayElement::Date(19889), // 2024-06-15 ]); - scale.properties.insert( - "breaks".to_string(), - ParameterValue::String("2 months".to_string()), - ); + scale + .properties + .insert("breaks".to_string(), "2 months".into()); let context = ScaleDataContext::new(); ScaleType::continuous() @@ -3517,9 +3423,7 @@ mod tests { let mut scale = Scale::new("x"); scale.scale_type = Some(ScaleType::continuous()); scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); - scale - .properties - .insert("breaks".to_string(), ParameterValue::Number(5.0)); + scale.properties = crate::params! { "breaks" => 5.0 }; let context = ScaleDataContext::new(); ScaleType::continuous() @@ -3559,10 +3463,9 @@ mod tests { ArrayElement::Date(19738), // 2024-01-15 ArrayElement::Date(19889), // 2024-06-15 ]); - scale.properties.insert( - "breaks".to_string(), - ParameterValue::String("2 months".to_string()), - ); + scale + .properties + .insert("breaks".to_string(), "2 months".into()); let context = ScaleDataContext::new(); ScaleType::continuous() @@ -3613,9 +3516,7 @@ mod tests { let mut scale = Scale::new("x"); scale.scale_type = Some(ScaleType::continuous()); scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); - scale - .properties - .insert("breaks".to_string(), ParameterValue::Number(5.0)); + scale.properties.insert("breaks".to_string(), 5.0.into()); if let Some(value) = setting { scale.properties.insert("minor_breaks".to_string(), value); } @@ -3629,7 +3530,7 @@ mod tests { #[test] fn test_minor_breaks_setting_count_is_per_major_interval() { // Three per interval, unlike `breaks` whose count targets the whole axis. - let scale = resolved_with_minor_setting(Some(ParameterValue::Number(3.0))); + let scale = resolved_with_minor_setting(Some(3.0.into())); let majors = scale.numeric_breaks(); let minors = scale.numeric_minor_breaks().expect("minors resolved"); for w in majors.windows(2) { @@ -3646,7 +3547,7 @@ mod tests { #[test] fn test_minor_breaks_setting_zero_suppresses() { // Resolves to an empty array — "draw none" — not to the default density. - let scale = resolved_with_minor_setting(Some(ParameterValue::Number(0.0))); + let scale = resolved_with_minor_setting(Some(0.0.into())); assert_eq!(scale.numeric_minor_breaks(), Some(Vec::new())); } @@ -3672,14 +3573,12 @@ mod tests { ArrayElement::Date(19738), // 2024-01-15 ArrayElement::Date(19889), // 2024-06-15 ]); - scale.properties.insert( - "breaks".to_string(), - ParameterValue::String("2 months".to_string()), - ); - scale.properties.insert( - "minor_breaks".to_string(), - ParameterValue::String("week".to_string()), - ); + scale + .properties + .insert("breaks".to_string(), "2 months".into()); + scale + .properties + .insert("minor_breaks".to_string(), "week".into()); let context = ScaleDataContext::new(); ScaleType::continuous() @@ -3712,7 +3611,7 @@ mod tests { scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); scale .properties - .insert("minor_breaks".to_string(), ParameterValue::Number(-1.0)); + .insert("minor_breaks".to_string(), (-1.0).into()); let context = ScaleDataContext::new(); let err = ScaleType::continuous() @@ -3737,10 +3636,9 @@ mod tests { ArrayElement::DateTime(jan1_2024_us), ArrayElement::DateTime(apr1_2024_us), ]); - scale.properties.insert( - "breaks".to_string(), - ParameterValue::String("month".to_string()), - ); + scale + .properties + .insert("breaks".to_string(), "month".into()); let context = ScaleDataContext::new(); ScaleType::continuous() @@ -3772,10 +3670,9 @@ mod tests { scale.scale_type = Some(ScaleType::continuous()); scale.transform = Some(Transform::date()); scale.input_range = Some(vec![ArrayElement::Date(19738), ArrayElement::Date(19889)]); - scale.properties.insert( - "breaks".to_string(), - ParameterValue::String("invalid_interval".to_string()), - ); + scale + .properties + .insert("breaks".to_string(), "invalid_interval".into()); let context = ScaleDataContext::new(); // Should not error, just leave breaks as-is @@ -3801,10 +3698,9 @@ mod tests { scale.scale_type = Some(ScaleType::continuous()); scale.transform = Some(Transform::identity()); // Not temporal scale.input_range = Some(vec![ArrayElement::Number(0.0), ArrayElement::Number(100.0)]); - scale.properties.insert( - "breaks".to_string(), - ParameterValue::String("2 months".to_string()), - ); + scale + .properties + .insert("breaks".to_string(), "2 months".into()); let context = ScaleDataContext::new(); ScaleType::continuous() diff --git a/src/plot/scale/types.rs b/src/plot/scale/types.rs index fe19bedef..01fcdc392 100644 --- a/src/plot/scale/types.rs +++ b/src/plot/scale/types.rs @@ -592,8 +592,7 @@ mod tests { // value that resolution hasn't converted yet reads the same way. let mut s = continuous_scale((0.0, 100.0), vec![0.0, 50.0, 100.0]); assert_eq!(s.numeric_minor_breaks(), None); - s.properties - .insert("minor_breaks".to_string(), ParameterValue::Number(3.0)); + s.properties = crate::params! { "minor_breaks" => 3.0 }; assert_eq!(s.numeric_minor_breaks(), None); } @@ -630,8 +629,7 @@ mod tests { fn test_expand_range_honours_the_setting() { // Multiplier only, then the [mult, add] pair resolution writes back. let mut s = continuous_scale((0.0, 100.0), vec![]); - s.properties - .insert("expand".to_string(), ParameterValue::Number(0.1)); + s.properties.insert("expand".to_string(), 0.1.into()); assert_eq!(s.expand_range(0.0, 100.0), (-10.0, 110.0)); s.properties.insert( diff --git a/src/table/layout.rs b/src/table/layout.rs index e7926d61a..62f196179 100644 --- a/src/table/layout.rs +++ b/src/table/layout.rs @@ -485,8 +485,7 @@ mod tests { #[test] fn discretise_hjust_folds_hjust_into_a_class() { let discretised = |n: f64| { - let mut properties = Parameters::new(); - properties.insert("hjust".to_string(), ParameterValue::Number(n)); + let properties = crate::params! { "hjust" => ParameterValue::Number(n) }; TableCell::new(TableCellKind::Body, 0, 0, 0, 0, String::new()) .with_properties(properties) .discretise_hjust() @@ -501,8 +500,7 @@ mod tests { // The keyword spellings classify identically to their numbers. let discretised_str = |s: &str| { - let mut properties = Parameters::new(); - properties.insert("hjust".to_string(), ParameterValue::String(s.to_string())); + let properties = crate::params! { "hjust" => ParameterValue::String(s.to_string()) }; TableCell::new(TableCellKind::Body, 0, 0, 0, 0, String::new()) .with_properties(properties) .discretise_hjust() diff --git a/src/table/mod.rs b/src/table/mod.rs index 0674b6a25..e0f078a8f 100644 --- a/src/table/mod.rs +++ b/src/table/mod.rs @@ -23,8 +23,7 @@ use std::collections::{HashMap, HashSet}; use crate::labels::Labels; use crate::params::{ - validate_parameter, DefaultParamValue, NumberConstraint, ParamConstraint, ParamDefinition, - Parameters, + DefaultParamValue, NumberConstraint, ParamConstraint, ParamDefinition, Parameters, }; use crate::DataSource; @@ -184,19 +183,14 @@ impl Table { } /// Fully resolve this table's spanners for execution: settings - /// validated, `OVER` ids folded, STUB boundary checked, columns - /// checked against the real schema, and each `label` overlaid with any - /// `LABEL => ...` entry. + /// validated and defaults filled, `OVER` ids folded, STUB boundary + /// checked, columns checked against the real schema, and each `label` + /// overlaid with any `LABEL => ...` entry. pub fn resolve_spanners( &self, labels: &Labels, column_names: Option<&[String]>, ) -> Result, String> { - for (idx, spanner) in self.spans.iter().enumerate() { - spanner - .validate_settings() - .map_err(|e| format!("SPAN {}: {}", idx + 1, e))?; - } let spans = self.resolve_spanner_ids()?; self.validate_span_stub_boundary(&spans)?; // None (validate()'s case) skips this: no real schema to check. @@ -206,13 +200,17 @@ impl Table { } } - Ok(spans + spans .into_iter() - .map(|mut span| { + .enumerate() + .map(|(idx, mut span)| { + span.settings = span + .resolve_settings() + .map_err(|e| format!("SPAN {}: {}", idx + 1, e))?; span.apply_labels(labels); - span + Ok(span) }) - .collect()) + .collect() } } @@ -314,29 +312,17 @@ impl Format { } } - /// Validate `settings` against `FORMAT_PARAMS`. - pub fn validate_settings(&self) -> Result<(), String> { - let valid: Vec<&str> = FORMAT_PARAMS.iter().map(|p| p.name).collect(); - - for (name, value) in &self.settings { - let Some(param) = FORMAT_PARAMS.iter().find(|p| p.name == name.as_str()) else { - return Err(format!( - "FORMAT setting should be {}, not '{}'", - crate::or_list_quoted(&valid, '\''), - name - )); - }; - validate_parameter(name, value, ¶m.constraint)?; - } - - Ok(()) + /// Validate `settings` against `FORMAT_PARAMS` and resolve each to its + /// effective value: the user's value if present, otherwise the + /// definition's default. + pub fn resolve_settings(&self) -> Result { + crate::params::resolve_parameters(&self.settings, FORMAT_PARAMS, "FORMAT setting") } } #[cfg(test)] mod tests { use super::*; - use crate::plot::ParameterValue; fn format_with_settings(settings: Parameters) -> Format { Format { @@ -398,49 +384,32 @@ mod tests { #[test] fn format_validate_settings_accepts_a_string_hjust() { - let mut settings = Parameters::new(); - settings.insert( - "hjust".to_string(), - ParameterValue::String("right".to_string()), - ); + let settings = crate::params! { "hjust" => "right" }; - assert!(format_with_settings(settings).validate_settings().is_ok()); + assert!(format_with_settings(settings).resolve_settings().is_ok()); } #[test] fn format_validate_settings_accepts_a_numeric_hjust() { - let mut settings = Parameters::new(); - settings.insert("hjust".to_string(), ParameterValue::Number(0.25)); + let settings = crate::params! { "hjust" => 0.25 }; - assert!(format_with_settings(settings).validate_settings().is_ok()); + assert!(format_with_settings(settings).resolve_settings().is_ok()); } #[test] fn format_validate_settings_rejects_an_unrecognized_string() { - let mut settings = Parameters::new(); - settings.insert( - "hjust".to_string(), - ParameterValue::String("up".to_string()), - ); + let settings = crate::params! { "hjust" => "up" }; - assert!(format_with_settings(settings).validate_settings().is_err()); + assert!(format_with_settings(settings).resolve_settings().is_err()); } #[test] fn format_validate_settings_accepts_a_percent_or_pixel_width() { - let mut settings = Parameters::new(); - settings.insert( - "width".to_string(), - ParameterValue::String("20%".to_string()), - ); - assert!(format_with_settings(settings).validate_settings().is_ok()); - - let mut settings = Parameters::new(); - settings.insert( - "width".to_string(), - ParameterValue::String("240px".to_string()), - ); - assert!(format_with_settings(settings).validate_settings().is_ok()); + let settings = crate::params! { "width" => "20%" }; + assert!(format_with_settings(settings).resolve_settings().is_ok()); + + let settings = crate::params! { "width" => "240px" }; + assert!(format_with_settings(settings).resolve_settings().is_ok()); } #[test] diff --git a/src/table/spanner.rs b/src/table/spanner.rs index 6b0cb3bbe..4cf85e426 100644 --- a/src/table/spanner.rs +++ b/src/table/spanner.rs @@ -8,8 +8,7 @@ use std::collections::HashSet; use super::layout::{TableCell, TableClass, TableColumn, TableLayout, TableRow}; use crate::labels::Labels; use crate::params::{ - validate_parameter, DefaultParamValue, ParamConstraint, ParamDefinition, ParameterValue, - Parameters, + DefaultParamValue, ParamConstraint, ParamDefinition, ParameterValue, Parameters, }; /// One `SPAN` clause: a named group of columns rendered as one spanner cell @@ -32,7 +31,7 @@ pub struct Spanner { /// `SETTING` parameters `SPAN` accepts — one static name/default/constraint /// list, mirroring how a `GeomTrait` declares `default_params()`, so -/// `Spanner::validate_settings` doesn't hand-roll its own type checks per key. +/// `Spanner::resolve_settings` doesn't hand-roll its own type checks per key. const SPAN_PARAMS: &[ParamDefinition] = &[ ParamDefinition { name: "gather", @@ -49,25 +48,11 @@ const SPAN_PARAMS: &[ParamDefinition] = &[ ]; impl Spanner { - /// Validate `settings` against `SPAN_PARAMS`, mirroring - /// `Layer::validate_settings`. - pub fn validate_settings(&self) -> Result<(), String> { - let valid: Vec<&str> = SPAN_PARAMS.iter().map(|p| p.name).collect(); - - for (name, value) in &self.settings { - // Key isn't in SPAN_PARAMS at all. - let Some(param) = SPAN_PARAMS.iter().find(|p| p.name == name.as_str()) else { - return Err(format!( - "SPAN setting should be {}, not '{}'", - crate::or_list_quoted(&valid, '\''), - name - )); - }; - // Known key, but wrong shape (e.g. `gather` not a boolean). - validate_parameter(name, value, ¶m.constraint)?; - } - - Ok(()) + /// Validate `settings` against `SPAN_PARAMS` and resolve each to its + /// effective value: the user's value if present, otherwise the + /// definition's default. + pub fn resolve_settings(&self) -> Result { + crate::params::resolve_parameters(&self.settings, SPAN_PARAMS, "SPAN setting") } /// Check this spanner's columns against the table's STUB columns. @@ -181,7 +166,7 @@ fn gather_columns(columns: Vec, members: &[String]) -> Vec Vec { let mut levels: Vec = Vec::with_capacity(spans.len()); @@ -420,11 +405,7 @@ mod tests { column("b", "b"), column("y", "y"), ]; - let spans = vec![spanner_with_setting( - &["a", "b"], - "gather", - ParameterValue::Boolean(false), - )]; + let spans = vec![spanner_with_setting(&["a", "b"], "gather", false.into())]; let result = reorder_table_columns(columns, &spans); @@ -484,7 +465,7 @@ mod tests { // error on that, TableLayout::validate does once real cells exist. let spans = vec![ spanner(&["a", "b"]), - spanner_with_setting(&["b", "c"], "level", ParameterValue::Number(1.0)), + spanner_with_setting(&["b", "c"], "level", 1.0.into()), ]; let levels = assign_spanner_levels(&spans); @@ -507,9 +488,9 @@ mod tests { #[test] fn assign_spanner_levels_compacts_gaps_left_by_explicit_levels() { let spans = vec![ - spanner_with_setting(&["a"], "level", ParameterValue::Number(1.0)), - spanner_with_setting(&["b"], "level", ParameterValue::Number(3.0)), - spanner_with_setting(&["c"], "level", ParameterValue::Number(4.0)), + spanner_with_setting(&["a"], "level", 1.0.into()), + spanner_with_setting(&["b"], "level", 3.0.into()), + spanner_with_setting(&["c"], "level", 4.0.into()), ]; let levels = assign_spanner_levels(&spans); @@ -695,23 +676,10 @@ mod tests { } #[test] - fn validate_settings_accepts_valid_gather_and_level() { - let mut settings = Parameters::new(); - settings.insert("gather".to_string(), ParameterValue::Boolean(false)); - settings.insert("level".to_string(), ParameterValue::Number(2.0)); - - assert!(spanner_with_settings(settings).validate_settings().is_ok()); - } - - #[test] - fn validate_settings_rejects_an_unknown_key() { - let mut settings = Parameters::new(); - settings.insert( - "width".to_string(), - ParameterValue::String("40%".to_string()), - ); + fn resolve_settings_accepts_valid_gather_and_level() { + let settings = crate::params! { "gather" => false, "level" => 2.0 }; - assert!(spanner_with_settings(settings).validate_settings().is_err()); + assert!(spanner_with_settings(settings).resolve_settings().is_ok()); } #[test] diff --git a/src/validate.rs b/src/validate.rs index 5f639f4cc..6a407008a 100644 --- a/src/validate.rs +++ b/src/validate.rs @@ -317,7 +317,7 @@ pub fn validate(query: &str) -> Result { // above. if let Some(table) = first_table { for (idx, spanner) in table.spans.iter().enumerate() { - if let Err(e) = spanner.validate_settings() { + if let Err(e) = spanner.resolve_settings() { errors.push(ValidationError { message: format!("SPAN {}: {}", idx + 1, e), location: None, @@ -342,7 +342,7 @@ pub fn validate(query: &str) -> Result { // Validate each FORMAT's SETTING parameters the same way. for (idx, format) in table.formats.iter().enumerate() { - if let Err(e) = format.validate_settings() { + if let Err(e) = format.resolve_settings() { errors.push(ValidationError { message: format!("FORMAT {}: {}", idx + 1, e), location: None, diff --git a/src/writer/hephaestus/scales.rs b/src/writer/hephaestus/scales.rs index 559512fab..6796f7c49 100644 --- a/src/writer/hephaestus/scales.rs +++ b/src/writer/hephaestus/scales.rs @@ -697,10 +697,9 @@ mod tests { mapping.insert("20".to_string(), None); assert_eq!(labels(&binned_bins(&scale)), vec!["< 10", "≥ 10"]); - scale.properties.insert( - "closed".to_string(), - ParameterValue::String("right".to_string()), - ); + scale + .properties + .insert("closed".to_string(), "right".into()); assert_eq!(labels(&binned_bins(&scale)), vec!["≤ 10", "> 10"]); } diff --git a/src/writer/hephaestus/wiring.rs b/src/writer/hephaestus/wiring.rs index 9880268c3..848052fce 100644 --- a/src/writer/hephaestus/wiring.rs +++ b/src/writer/hephaestus/wiring.rs @@ -658,10 +658,7 @@ pub fn band_half_width(layer: &Layer, default: f64) -> f64 { let width = layer .parameters .get("width") - .and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }) + .and_then(ParameterValue::as_number) .unwrap_or(default); layer.adjusted_width.unwrap_or(width).abs() / 2.0 } diff --git a/src/writer/html.rs b/src/writer/html.rs index caeb30411..f6dd92879 100644 --- a/src/writer/html.rs +++ b/src/writer/html.rs @@ -668,8 +668,7 @@ mod render_tests { // Declaration content is inline_style's tests' job — this just checks // render_cell routes `hjust` through it as a `style="..."` attribute. let mut c = cell(TableCellKind::Body, 0, 0, 0, 0); - c.properties - .insert("hjust".to_string(), ParameterValue::Number(1.0)); + c.properties = crate::params! { "hjust" => 1.0 }; let html = render_cell(&c, CssMode::Inline); assert!(html.starts_with("")); @@ -678,8 +677,7 @@ mod render_tests { #[test] fn render_cell_emits_classes_in_class_mode() { let mut body = cell(TableCellKind::Body, 0, 0, 0, 0).with_classes(vec![TableClass::Row]); - body.properties - .insert("hjust".to_string(), ParameterValue::Number(1.0)); + body.properties = crate::params! { "hjust" => 1.0 }; assert_eq!( render_cell(&body, CssMode::Class), "" @@ -734,11 +732,7 @@ mod render_tests { #[test] fn column_style_reads_a_string_width_as_a_css_width() { - let mut properties = Parameters::new(); - properties.insert( - "width".to_string(), - ParameterValue::String("20%".to_string()), - ); + let properties = crate::params! { "width" => "20%" }; assert_eq!(column_style(&properties), Some("width: 20%".to_string())); assert_eq!(column_style(&Parameters::new()), None); @@ -766,11 +760,7 @@ mod render_tests { #[test] fn render_colgroup_emits_a_bare_col_for_a_column_with_no_width() { - let mut widened = Parameters::new(); - widened.insert( - "width".to_string(), - ParameterValue::String("20%".to_string()), - ); + let widened = crate::params! { "width" => "20%" }; let columns = vec![column(widened), column(Parameters::new())]; assert_eq!( diff --git a/src/writer/vegalite/encoding.rs b/src/writer/vegalite/encoding.rs index 77710d3a7..6ff387622 100644 --- a/src/writer/vegalite/encoding.rs +++ b/src/writer/vegalite/encoding.rs @@ -1337,7 +1337,7 @@ mod tests { #[test] fn test_literal_shape_converts_to_svg_path() { - let lit = ParameterValue::String("square".to_string()); + let lit = "square".into(); let result = build_literal_encoding("shape", &lit).unwrap(); let val = &result["value"]; assert!(val.is_string(), "expected SVG path string, got: {val}"); @@ -1350,7 +1350,7 @@ mod tests { #[test] fn test_literal_shape_unknown_passes_through() { - let lit = ParameterValue::String("nonexistent".to_string()); + let lit = "nonexistent".into(); let result = build_literal_encoding("shape", &lit).unwrap(); assert_eq!(result, json!({"value": "nonexistent"})); } diff --git a/src/writer/vegalite/layer.rs b/src/writer/vegalite/layer.rs index 047ba8508..b83ace427 100644 --- a/src/writer/vegalite/layer.rs +++ b/src/writer/vegalite/layer.rs @@ -2132,10 +2132,7 @@ impl BoxplotRenderer { let side = layer .parameters .get("side") - .and_then(|v| match v { - ParameterValue::String(s) => Some(s.as_str()), - _ => None, - }) + .and_then(ParameterValue::as_str) .unwrap_or("both"); let half_side = side != "both"; let side_positive = half_side && side_is_positive(side); @@ -3920,10 +3917,9 @@ mod tests { // Set orientation parameter for horizontal case if is_horizontal { - layer.parameters.insert( - "orientation".to_string(), - ParameterValue::String("transposed".to_string()), - ); + layer + .parameters + .insert("orientation".to_string(), "transposed".into()); } let mut layer_spec = if is_horizontal { @@ -4056,10 +4052,9 @@ mod tests { .insert("side".to_string(), ParameterValue::String(s.to_string())); } if is_horizontal { - layer.parameters.insert( - "orientation".to_string(), - ParameterValue::String("transposed".to_string()), - ); + layer + .parameters + .insert("orientation".to_string(), "transposed".into()); } // Build a minimal prototype with encoding fields the renderer reads. diff --git a/src/writer/vegalite/mod.rs b/src/writer/vegalite/mod.rs index d6d7f3028..312ec9e84 100644 --- a/src/writer/vegalite/mod.rs +++ b/src/writer/vegalite/mod.rs @@ -1877,10 +1877,9 @@ mod tests { "pos2".to_string(), AestheticValue::standard_column("y".to_string()), ); - layer.mappings.insert( - "size".to_string(), - AestheticValue::Literal(crate::plot::ParameterValue::Number(3.0)), - ); + layer + .mappings + .insert("size".to_string(), AestheticValue::Literal(3.0.into())); spec.layers.push(layer); let df = df! { @@ -1909,10 +1908,7 @@ mod tests { "y".to_string(), AestheticValue::standard_column("y".to_string()), ) - .with_aesthetic( - "stroke".to_string(), - AestheticValue::Literal(ParameterValue::String("red".to_string())), - ); + .with_aesthetic("stroke".to_string(), AestheticValue::Literal("red".into())); spec.layers.push(layer); let df = df! { @@ -2287,8 +2283,8 @@ mod tests { // Point with SETTING opacity => 0.5 should override default (1.0) let mut spec = Plot::new(); - let mut layer = build_layer(Geom::point()) - .with_parameter("opacity".to_string(), ParameterValue::Number(0.5)); + let mut layer = + build_layer(Geom::point()).with_parameter("opacity".to_string(), 0.5.into()); // Resolve aesthetics (normally done in execution pipeline) layer.resolve_aesthetics(); @@ -2396,7 +2392,7 @@ mod tests { let mut spec = Plot::new(); let mut layer = build_layer(Geom::line()).with_aesthetic( "linetype".to_string(), - AestheticValue::Literal(ParameterValue::String("dashed".to_string())), + AestheticValue::Literal("dashed".into()), ); // Resolve aesthetics (normally done in execution pipeline) @@ -2505,15 +2501,13 @@ mod tests { #[test] fn test_binned_facet_reverse_sets_descending_sort() { use crate::plot::scale::Scale; - use crate::plot::{ParameterValue, ScaleType}; + use crate::plot::ScaleType; let mut facet_def = json!({"field": "__ggsql_aes_facet1__", "type": "nominal"}); let mut scale = Scale::new("facet1"); scale.scale_type = Some(ScaleType::binned()); - scale - .properties - .insert("reverse".to_string(), ParameterValue::Boolean(true)); + scale.properties = crate::params! { "reverse" => true }; apply_binned_facet_reverse(&mut facet_def, Some(&scale)); @@ -2542,9 +2536,7 @@ mod tests { let mut facet_def = json!({"field": "__ggsql_aes_facet1__", "type": "nominal"}); let mut scale = Scale::new("facet1"); - scale - .properties - .insert("reverse".to_string(), ParameterValue::Boolean(true)); + scale.properties = crate::params! { "reverse" => true }; apply_binned_facet_reverse(&mut facet_def, Some(&scale)); diff --git a/src/writer/vegalite/projection/map.rs b/src/writer/vegalite/projection/map.rs index e84064b8e..ac8813da1 100644 --- a/src/writer/vegalite/projection/map.rs +++ b/src/writer/vegalite/projection/map.rs @@ -25,10 +25,7 @@ impl MapProjection { let get_string = |key: &str| -> Option { project .and_then(|p| p.computed.get(key)) - .and_then(|v| match v { - ParameterValue::String(s) => Some(s.clone()), - _ => None, - }) + .and_then(|v| v.as_str().map(str::to_string)) }; let panel_boundary_wkt = get_string("panel_boundary"); let graticule_lon_wkt = get_string("graticule_lon"); @@ -254,7 +251,7 @@ mod tests { let mut proj = Projection::map(); proj.computed.insert( "panel_boundary".to_string(), - ParameterValue::String("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))".to_string()), + "POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))".into(), ); let renderer = MapProjection::new(Some(&proj), None); let mut theme = json!({"view": {"fill": "white", "stroke": "gray"}}); @@ -308,7 +305,7 @@ mod tests { let mut proj = Projection::map(); proj.computed.insert( "graticule_lon".to_string(), - ParameterValue::String("MULTILINESTRING ((0 -90, 0 90), (30 -90, 30 90))".to_string()), + "MULTILINESTRING ((0 -90, 0 90), (30 -90, 30 90))".into(), ); proj.computed.insert( "graticule_lat".to_string(), @@ -339,11 +336,11 @@ mod tests { let mut proj = Projection::map(); proj.computed.insert( "panel_boundary".to_string(), - ParameterValue::String("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))".to_string()), + "POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))".into(), ); proj.computed.insert( "graticule_lon".to_string(), - ParameterValue::String("MULTILINESTRING ((0.5 0, 0.5 1))".to_string()), + "MULTILINESTRING ((0.5 0, 0.5 1))".into(), ); let renderer = MapProjection::new(Some(&proj), None); let mut theme = json!({"view": {"fill": "white", "stroke": "gray"}}); diff --git a/src/writer/vegalite/projection/polar.rs b/src/writer/vegalite/projection/polar.rs index 328202b88..d22b61862 100644 --- a/src/writer/vegalite/projection/polar.rs +++ b/src/writer/vegalite/projection/polar.rs @@ -59,10 +59,7 @@ impl PolarContext { let prop = |name| { project .and_then(|p| p.properties.get(name)) - .and_then(|v| match v { - ParameterValue::Number(n) => Some(*n), - _ => None, - }) + .and_then(ParameterValue::as_number) }; let start_degrees = prop("start").unwrap_or(0.0); let end_degrees = prop("end").unwrap_or(start_degrees + 360.0); @@ -1339,8 +1336,7 @@ mod tests { }); let mut proj = Projection::polar(); - proj.properties - .insert("inner".to_string(), ParameterValue::Number(0.5)); + proj.properties = crate::params! { "inner" => 0.5 }; let panel = PolarContext::new(Some(&proj), None, &[]); apply_polar_radius_range(&mut encoding, &panel).unwrap(); @@ -1367,10 +1363,7 @@ mod tests { }); let mut proj = Projection::polar(); - proj.properties - .insert("inner".to_string(), ParameterValue::Number(0.5)); - proj.properties - .insert("size".to_string(), ParameterValue::Number(350.0)); + proj.properties = crate::params! { "inner" => 0.5, "size" => 350.0 }; let f = faceted(); let panel = PolarContext::new(Some(&proj), Some(&f), &[]); apply_polar_radius_range(&mut encoding, &panel).unwrap(); @@ -1392,8 +1385,7 @@ mod tests { }); let mut proj = Projection::polar(); - proj.properties - .insert("size".to_string(), ParameterValue::Number(350.0)); + proj.properties = crate::params! { "size" => 350.0 }; let f = faceted(); let panel = PolarContext::new(Some(&proj), Some(&f), &[]); apply_polar_radius_range(&mut encoding, &panel).unwrap(); @@ -2298,8 +2290,7 @@ mod tests { #[test] fn test_faceted_polar_discrete_uses_pixel_size() { let mut proj = Projection::polar(); - proj.properties - .insert("size".to_string(), ParameterValue::Number(300.0)); + proj.properties = crate::params! { "size" => 300.0 }; let f = faceted(); let panel = PolarContext::new(Some(&proj), Some(&f), &[]); @@ -2314,7 +2305,7 @@ mod tests { let mut proj_spec = Projection::polar(); proj_spec .properties - .insert("size".to_string(), ParameterValue::Number(300.0)); + .insert("size".to_string(), 300.0.into()); let f = faceted(); let proj = PolarProjection { panel: PolarContext::new(Some(&proj_spec), Some(&f), &scales), @@ -2383,10 +2374,7 @@ mod tests { #[test] fn test_polygon_ring_closed_for_partial_arc() { let mut proj = Projection::polar(); - proj.properties - .insert("start".to_string(), ParameterValue::Number(0.0)); - proj.properties - .insert("end".to_string(), ParameterValue::Number(180.0)); + proj.properties = crate::params! { "start" => 0.0, "end" => 180.0 }; let mut panel = PolarContext::new(Some(&proj), None, &[]); panel.angle_breaks_radians = vec![0.5, 1.0, 1.5]; let layer = polygon_ring(&panel, POLAR_OUTER, None, Value::Null, json!("red")); @@ -2400,10 +2388,7 @@ mod tests { fn test_polygon_ring_partial_arc_corrects_boundary_radii() { use std::f64::consts::PI; let mut proj = Projection::polar(); - proj.properties - .insert("start".to_string(), ParameterValue::Number(0.0)); - proj.properties - .insert("end".to_string(), ParameterValue::Number(180.0)); + proj.properties = crate::params! { "start" => 0.0, "end" => 180.0 }; let mut panel = PolarContext::new(Some(&proj), None, &[]); panel.angle_breaks_radians = vec![PI / 2.0]; let layer = polygon_ring(&panel, POLAR_OUTER, None, Value::Null, json!("red")); @@ -2455,7 +2440,7 @@ mod tests { let mut proj_spec = Projection::polar(); proj_spec .properties - .insert("radar".to_string(), ParameterValue::Boolean(true)); + .insert("radar".to_string(), true.into()); let proj = PolarProjection { panel: PolarContext::new(Some(&proj_spec), None, &scales), }; @@ -2471,7 +2456,7 @@ mod tests { let mut proj_spec = Projection::polar(); proj_spec .properties - .insert("radar".to_string(), ParameterValue::Boolean(true)); + .insert("radar".to_string(), true.into()); let proj = PolarProjection { panel: PolarContext::new(Some(&proj_spec), None, &scales), }; @@ -2488,7 +2473,7 @@ mod tests { let mut proj_spec = Projection::polar(); proj_spec .properties - .insert("radar".to_string(), ParameterValue::Boolean(true)); + .insert("radar".to_string(), true.into()); let proj = PolarProjection { panel: PolarContext::new(Some(&proj_spec), None, &scales), };