Colour semantics (#54)

* standardise spelling of the colour aesthetic

* add stroke aesthetic

* forgot renaming aes

* Dance to clippy's puppet strings

* use `.to_string()` instead

* tests expect colour to be split up to stroke/fill

* rework normalisation of aesthetic names

* rework trickle-down defaults

* move splitting to after literal columns have been materialised

* remove leftover debug statement

* Fix quotemarks

Author: teunbrand

CLAUDE.md

@@ -905,7 +905,7 @@ All clauses (MAPPING, SETTING, PARTITION BY, FILTER) are optional.
 Maps data values (columns or literals) to visual aesthetics. Syntax: `value AS aesthetic`
 
 - **Position**: `x`, `y`, `xmin`, `xmax`, `ymin`, `ymax`
-- **Color**: `color`, `fill`, `opacity`
+- **Color**: `color`, `fill`, `stroke`, `opacity`
 - **Size/Shape**: `size`, `shape`, `linetype`, `linewidth`
 - **Text**: `label`, `family`, `fontface`
 

ggsql-vscode/syntaxes/ggsql.tmLanguage.json

@@ -177,7 +177,7 @@
         },
         {
           "name": "variable.parameter.aesthetic.ggsql",
-          "match": "\\b(x|y|xmin|xmax|ymin|ymax|xend|yend|color|colour|fill|opacity|size|shape|linetype|linewidth|width|height|label|family|fontface|hjust|vjust)\\b"
+          "match": "\\b(x|y|xmin|xmax|ymin|ymax|xend|yend|color|colour|fill|stroke|opacity|size|shape|linetype|linewidth|width|height|label|family|fontface|hjust|vjust)\\b"
         }
       ]
     },

src/execute.rs

@@ -728,6 +728,7 @@ where
 /// 3. Expands wildcards by adding mappings only for supported aesthetics that:
 ///    - Are not already mapped (either from global or layer)
 ///    - Have a matching column in the layer's schema
+/// 4. Moreover it propagates 'color' to 'fill' and 'stroke'
 fn merge_global_mappings_into_layers(specs: &mut [Plot], layer_schemas: &[Schema]) {
     for spec in specs {
         for (layer, schema) in spec.layers.iter_mut().zip(layer_schemas.iter()) {
@@ -754,7 +755,7 @@ fn merge_global_mappings_into_layers(specs: &mut [Plot], layer_schemas: &[Schema
                         layer
                             .mappings
                             .aesthetics
-                            .entry(aes.to_string())
+                            .entry(crate::parser::builder::normalise_aes_name(aes))
                             .or_insert(AestheticValue::standard_column(aes));
                     }
                 }
@@ -834,6 +835,27 @@ fn with_has_trailing_select(with_node: &Node) -> bool {
     false
 }
 
+// Let 'color' aesthetics fill defaults for the 'stroke' and 'fill' aesthetics
+fn split_color_aesthetic(layers: &mut Vec<Layer>) {
+    for layer in layers {
+        if !layer.mappings.aesthetics.contains_key("color") {
+            continue;
+        }
+        let supported = layer.geom.aesthetics().supported;
+        for &aes in &["stroke", "fill"] {
+            if !supported.contains(&aes) {
+                continue;
+            }
+            let color = layer.mappings.aesthetics.get("color").unwrap().clone();
+            layer
+                .mappings
+                .aesthetics
+                .entry(aes.to_string())
+                .or_insert(color);
+        }
+    }
+}
+
 /// Result of preparing data for visualization
 pub struct PreparedData {
     /// Data map with global and layer-specific DataFrames
@@ -1089,6 +1111,9 @@ where
         replace_literals_with_columns(spec);
         // Compute aesthetic labels (uses first non-constant column, respects user-specified labels)
         spec.compute_aesthetic_labels();
+        // Divide 'color' over 'stroke' and 'fill'. This needs to happens after
+        // literals have associated columns.
+        split_color_aesthetic(&mut spec.layers);
     }
 
     Ok(PreparedData {
@@ -2682,4 +2707,59 @@ mod tests {
 
         assert!(y_values.contains(&30.0), "Should have sum values");
     }
+
+    #[cfg(feature = "duckdb")]
+    #[test]
+    fn test_expansion_of_color_aesthetic() {
+        let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+
+        // Colors as standard columns
+        let query = r#"
+            VISUALISE bill_len AS x, bill_dep AS y FROM ggsql:penguins
+            DRAW point MAPPING species AS color, island AS fill
+        "#;
+
+        let result = prepare_data(query, &reader).unwrap();
+
+        let aes = &result.specs[0].layers[0].mappings.aesthetics;
+
+        assert!(aes.contains_key("stroke"));
+        assert!(aes.contains_key("fill"));
+
+        let stroke = aes.get("stroke").unwrap().column_name().unwrap();
+        assert_eq!(stroke, "species");
+
+        let fill = aes.get("fill").unwrap().column_name().unwrap();
+        assert_eq!(fill, "island");
+
+        // Colors as global constant
+        let query = r#"
+          VISUALISE bill_len AS x, bill_dep AS y, 'blue' AS color FROM ggsql:penguins
+          DRAW point MAPPING island AS stroke
+        "#;
+
+        let result = prepare_data(query, &reader).unwrap();
+        let aes = &result.specs[0].layers[0].mappings.aesthetics;
+
+        let stroke = aes.get("stroke").unwrap();
+        assert_eq!(stroke.column_name().unwrap(), "island");
+
+        let fill = aes.get("fill").unwrap();
+        assert_eq!(fill.column_name().unwrap(), "__ggsql_const_color_0__");
+
+        // Colors as layer constant
+        let query = r#"
+          VISUALISE bill_len AS x, bill_dep AS y, island AS fill FROM ggsql:penguins
+          DRAW point MAPPING 'blue' AS color
+        "#;
+
+        let result = prepare_data(query, &reader).unwrap();
+        let aes = &result.specs[0].layers[0].mappings.aesthetics;
+
+        let stroke = aes.get("stroke").unwrap();
+        assert_eq!(stroke.column_name().unwrap(), "__ggsql_const_color_0__");
+
+        let fill = aes.get("fill").unwrap();
+        assert_eq!(fill.column_name().unwrap(), "island");
+    }
 }

src/lib.rs

@@ -524,8 +524,8 @@ mod integration_tests {
         let query = r#"
             SELECT 1 as x, 10 as y
             VISUALISE x, y
-            DRAW line MAPPING 'value' AS color
-            DRAW point MAPPING 'value2' AS color
+            DRAW line MAPPING 'value' AS linetype
+            DRAW point MAPPING 'value2' AS shape
         "#;
 
         // Prepare data - this parses, injects constants into global data, and replaces literals with columns
@@ -553,12 +553,12 @@ mod integration_tests {
         let global_df = prepared.data.get(naming::GLOBAL_DATA_KEY).unwrap();
         let col_names = global_df.get_column_names();
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_0__"),
+            col_names.iter().any(|c| *c == "__ggsql_const_linetype_0__"),
             "Global data should have layer 0 color constant: {:?}",
             col_names
         );
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_1__"),
+            col_names.iter().any(|c| *c == "__ggsql_const_shape_1__"),
             "Global data should have layer 1 color constant: {:?}",
             col_names
         );
@@ -572,18 +572,18 @@ mod integration_tests {
         assert_eq!(vl_spec["layer"].as_array().unwrap().len(), 2);
 
         // Verify the color aesthetic is mapped to layer-indexed synthetic columns
-        let layer0_color = &vl_spec["layer"][0]["encoding"]["color"];
-        let layer1_color = &vl_spec["layer"][1]["encoding"]["color"];
+        let layer0_color = &vl_spec["layer"][0]["encoding"]["linetype"];
+        let layer1_color = &vl_spec["layer"][1]["encoding"]["shape"];
 
-        // Color should be field-mapped to layer-indexed columns
+        // Constants should be field-mapped to layer-indexed columns
         assert_eq!(
             layer0_color["field"].as_str().unwrap(),
-            "__ggsql_const_color_0__",
+            "__ggsql_const_linetype_0__",
             "Layer 0 color should map to layer-indexed column"
         );
         assert_eq!(
             layer1_color["field"].as_str().unwrap(),
-            "__ggsql_const_color_1__",
+            "__ggsql_const_shape_1__",
             "Layer 1 color should map to layer-indexed column"
         );
 
@@ -594,18 +594,18 @@ mod integration_tests {
         // Verify constant values appear in the global data with layer-indexed names
         let data_row = &global_data.as_array().unwrap()[0];
         assert_eq!(
-            data_row["__ggsql_const_color_0__"], "value",
+            data_row["__ggsql_const_linetype_0__"], "value",
             "Layer 0 constant should be 'value'"
         );
         assert_eq!(
-            data_row["__ggsql_const_color_1__"], "value2",
+            data_row["__ggsql_const_shape_1__"], "value2",
             "Layer 1 constant should be 'value2'"
         );
     }
 
     #[test]
-    fn test_end_to_end_facet_with_constant_colors() {
-        // Test faceting with multiple layers that have constant color mappings
+    fn test_end_to_end_facet_with_constant_strokes() {
+        // Test faceting with multiple layers that have constant stroke mappings
         // This verifies the fix for faceting compatibility with constants
 
         let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
@@ -629,10 +629,10 @@ mod integration_tests {
             SELECT month, region, category, revenue, quantity * 10 as qty_scaled
             FROM facet_test
             VISUALISE month AS x
-            DRAW line MAPPING revenue AS y, 'value' AS color
-            DRAW point MAPPING revenue AS y, 'value2' AS color SETTING size => 30
-            DRAW line MAPPING qty_scaled AS y, 'value3' AS color
-            DRAW point MAPPING qty_scaled AS y, 'value4' AS color SETTING size => 30
+            DRAW line MAPPING revenue AS y, 'value' AS stroke
+            DRAW point MAPPING revenue AS y, 'value2' AS stroke SETTING size => 30
+            DRAW line MAPPING qty_scaled AS y, 'value3' AS stroke
+            DRAW point MAPPING qty_scaled AS y, 'value4' AS stroke SETTING size => 30
             SCALE x SETTING type => 'date'
             FACET region BY category
         "#;
@@ -667,19 +667,19 @@ mod integration_tests {
         let global_df = prepared.data.get(naming::GLOBAL_DATA_KEY).unwrap();
         let col_names = global_df.get_column_names();
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_0__"),
+            col_names.iter().any(|c| *c == "__ggsql_const_stroke_0__"),
             "Should have layer 0 color constant"
         );
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_1__"),
+            col_names.iter().any(|c| *c == "__ggsql_const_stroke_1__"),
             "Should have layer 1 color constant"
         );
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_2__"),
+            col_names.iter().any(|c| *c == "__ggsql_const_stroke_2__"),
             "Should have layer 2 color constant"
         );
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_3__"),
+            col_names.iter().any(|c| *c == "__ggsql_const_stroke_3__"),
             "Should have layer 3 color constant"
         );
 
@@ -699,7 +699,7 @@ mod integration_tests {
     #[test]
     fn test_end_to_end_global_constant_in_visualise() {
         // Test that global constants in VISUALISE clause work correctly
-        // e.g., VISUALISE date AS x, value AS y, 'value' AS color
+        // e.g., VISUALISE date AS x, value AS y, 'value' AS stroke
 
         let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
 
@@ -716,10 +716,10 @@ mod integration_tests {
             )
             .unwrap();
 
-        // Query with global constant color in VISUALISE clause
+        // Query with global constant stroke in VISUALISE clause
         let query = r#"
             SELECT date, value FROM timeseries
-            VISUALISE date AS x, value AS y, 'value' AS color
+            VISUALISE date AS x, value AS y, 'value' AS stroke
             DRAW line
             DRAW point SETTING size => 50
             SCALE x SETTING type => 'date'
@@ -738,13 +738,13 @@ mod integration_tests {
         let global_df = prepared.data.get(naming::GLOBAL_DATA_KEY).unwrap();
         let col_names = global_df.get_column_names();
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_0__"),
-            "Should have layer 0 color constant: {:?}",
+            col_names.iter().any(|c| *c == "__ggsql_const_stroke_0__"),
+            "Should have layer 0 stroke constant: {:?}",
             col_names
         );
         assert!(
-            col_names.iter().any(|c| *c == "__ggsql_const_color_1__"),
-            "Should have layer 1 color constant: {:?}",
+            col_names.iter().any(|c| *c == "__ggsql_const_stroke_1__"),
+            "Should have layer 1 stroke constant: {:?}",
             col_names
         );
 
@@ -756,23 +756,23 @@ mod integration_tests {
         // Both layers should have color field-mapped to their indexed constant columns
         assert_eq!(vl_spec["layer"].as_array().unwrap().len(), 2);
         assert_eq!(
-            vl_spec["layer"][0]["encoding"]["color"]["field"]
+            vl_spec["layer"][0]["encoding"]["stroke"]["field"]
                 .as_str()
                 .unwrap(),
-            "__ggsql_const_color_0__"
+            "__ggsql_const_stroke_0__"
         );
         assert_eq!(
-            vl_spec["layer"][1]["encoding"]["color"]["field"]
+            vl_spec["layer"][1]["encoding"]["stroke"]["field"]
                 .as_str()
                 .unwrap(),
-            "__ggsql_const_color_1__"
+            "__ggsql_const_stroke_1__"
         );
 
         // Both constants should have the same value "value"
         let data = &vl_spec["datasets"][naming::GLOBAL_DATA_KEY]
             .as_array()
             .unwrap()[0];
-        assert_eq!(data["__ggsql_const_color_0__"], "value");
-        assert_eq!(data["__ggsql_const_color_1__"], "value");
+        assert_eq!(data["__ggsql_const_stroke_0__"], "value");
+        assert_eq!(data["__ggsql_const_stroke_1__"], "value");
     }
 }

src/parser/builder.rs

@@ -387,11 +387,14 @@ fn parse_mapping_element(node: &Node, source: &str, mappings: &mut Mappings) ->
             }
             "explicit_mapping" => {
                 let (aesthetic, value) = parse_explicit_mapping(&child, source)?;
-                mappings.insert(aesthetic, value);
+                mappings.insert(normalise_aes_name(&aesthetic), value);
             }
             "implicit_mapping" | "identifier" => {
                 let name = get_node_text(&child, source);
-                mappings.insert(&name, AestheticValue::standard_column(&name));
+                mappings.insert(
+                    normalise_aes_name(&name),
+                    AestheticValue::standard_column(&name),
+                );
             }
             _ => continue,
         }
@@ -1006,6 +1009,7 @@ fn is_aesthetic_name(name: &str) -> bool {
             | "color"
             | "colour"
             | "fill"
+            | "stroke"
             | "opacity"
             | "size"
             | "shape"
@@ -1356,6 +1360,13 @@ fn with_statement_has_trailing_select(with_node: &Node) -> bool {
     false
 }
 
+pub fn normalise_aes_name(name: &str) -> String {
+    match name {
+        "col" | "colour" => "color".to_string(),
+        _ => name.to_string(),
+    }
+}
+
 fn color_to_hex(value: &str) -> String {
     match csscolorparser::parse(value) {
         Ok(value) => value.to_css_hex(),
@@ -2884,6 +2895,7 @@ mod tests {
         assert_eq!(specs[0].layers[0].mappings.len(), 0);
 
         // Point layer should have color from layer MAPPING
+        // color should expand into stroke and fill
         assert_eq!(specs[0].layers[1].mappings.len(), 1);
         assert!(specs[0].layers[1].mappings.contains_key("color"));
     }

src/plot/layer/geom/abline.rs

@@ -18,6 +18,7 @@ impl GeomTrait for AbLine {
                 "intercept",
                 "color",
                 "colour",
+                "stroke",
                 "linetype",
                 "linewidth",
                 "opacity",

src/plot/layer/geom/area.rs

@@ -13,7 +13,7 @@ impl GeomTrait for Area {
 
     fn aesthetics(&self) -> GeomAesthetics {
         GeomAesthetics {
-            supported: &["x", "y", "color", "colour", "fill", "opacity"],
+            supported: &["x", "y", "color", "colour", "fill", "stroke", "opacity"],
             required: &["x", "y"],
             hidden: &[],
         }

src/plot/layer/geom/arrow.rs

@@ -20,6 +20,7 @@ impl GeomTrait for Arrow {
                 "yend",
                 "color",
                 "colour",
+                "stroke",
                 "linetype",
                 "linewidth",
                 "opacity",

src/plot/layer/geom/bar.rs

@@ -27,7 +27,7 @@ impl GeomTrait for Bar {
             // If y is missing: stat computes COUNT or SUM(weight)
             // weight: optional, if mapped uses SUM(weight) instead of COUNT(*)
             supported: &[
-                "x", "y", "weight", "color", "colour", "fill", "width", "opacity",
+                "x", "y", "weight", "color", "colour", "fill", "stroke", "width", "opacity",
             ],
             required: &[],
             hidden: &[],