feat: Use chumsky for expression parsing

Implement a new expression parser using chumsky crate to produce better
error messages on parsing failure.

Author: Maximkaaa

Cargo.toml

@@ -44,6 +44,7 @@ bitcode = "0.6"
 bytemuck = "1.14"
 bytes = "1.4"
 cfg-if = "1"
+chumsky = "0.12"
 console_log = "1"
 console_error_panic_hook = "0.1"
 csv = "1.3"
@@ -68,13 +69,13 @@ geo-types = "0.7"
 getrandom = "0.3"
 image = { version = "0.24", default-features = false }
 insta = "1.41"
+itertools = "0.14"
 js-sys = "0.3"
 las = "0.8"
 log = "0.4"
 lyon = "1"
 maybe-sync = "0.1"
 nalgebra = "0.32"
-nom = "7"
 num-traits = "0.2"
 ordered-float = "5"
 ordered_hash_map = "0.5"

galileo/Cargo.toml

@@ -30,17 +30,18 @@ base64 = { workspace = true }
 bytemuck = { workspace = true, features = ["derive"] }
 bytes = { workspace = true }
 cfg-if = { workspace = true }
+chumsky = { workspace = true }
 either = { workspace = true }
 futures-intrusive = { workspace = true }
 galileo-mvt = { workspace = true }
 galileo-types = { workspace = true }
 geojson = { workspace = true, optional = true }
 geozero = { workspace = true, features = ["with-geojson", "with-geo"] }
 image = { workspace = true, default-features = false, features = ["png", "jpeg"], optional = true }
+itertools = { workspace = true }
 log = { workspace = true }
 lyon = { workspace = true, features = ["serialization"] }
 nalgebra = { workspace = true }
-nom = { workspace = true }
 num-traits = { workspace = true }
 ordered-float = { workspace = true }
 ordered_hash_map = { workspace = true }

galileo/src/expr/mod.rs

@@ -2,6 +2,7 @@
 
 use std::marker::PhantomData;
 
+use itertools::Itertools;
 use serde::{Deserialize, Deserializer, Serialize};
 
 mod interpolation;
@@ -10,6 +11,7 @@ mod match_expr;
 pub use match_expr::*;
 
 mod value;
+use serde_json::Value;
 pub use value::{ExprGeometryType, ExprValue};
 
 use crate::Color;
@@ -118,20 +120,42 @@ impl From<f64> for Expr {
     }
 }
 
+impl From<String> for Expr {
+    fn from(value: String) -> Self {
+        Expr::Literal(value.into())
+    }
+}
+
+impl From<bool> for Expr {
+    fn from(value: bool) -> Self {
+        Expr::Literal(value.into())
+    }
+}
+
 impl<'de, Out> Deserialize<'de> for TypedExpr<Out> {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         // Buffer into a generic value so we can inspect the shape without consuming the input.
         let value = serde_json::Value::deserialize(deserializer)?;
 
-        if let serde_json::Value::String(ref s) = value {
-            return parser::parse_expr(s)
-                .map(|(_, expr)| expr.into())
-                .map_err(|e| serde::de::Error::custom(format!("expression parse error: {e}")));
-        }
+        let expr = match value {
+            Value::Number(v) => v
+                .as_f64()
+                .ok_or_else(|| serde::de::Error::custom(format!("invalid number value: {v}")))?
+                .into(),
+            Value::Bool(v) => v.into(),
+            Value::Null => ExprValue::Null.into(),
+            Value::String(s) => parser::parse_expr(&s).map_err(|e| {
+                let errors = e.into_iter().map(|v| v.to_string());
+                let errors = Itertools::intersperse(errors, ", ".to_string());
+                serde::de::Error::custom(format!(
+                    "expression parse error: {}",
+                    errors.collect::<String>(),
+                ))
+            })?,
+            v => Expr::deserialize(v).map_err(serde::de::Error::custom)?,
+        };
 
-        Expr::deserialize(value)
-            .map(Into::into)
-            .map_err(serde::de::Error::custom)
+        Ok(expr.into())
     }
 }
 
@@ -236,6 +260,13 @@ mod tests {
         );
     }
 
+    #[test]
+    fn deserialize_expr_from_num() {
+        let json = "42";
+        let expr: NumExpr = serde_json::from_str(json).unwrap();
+        assert_eq!(expr.0, Expr::Literal(ExprValue::Number(42.0)));
+    }
+
     #[test]
     fn deserialize_expr_from_object() {
         let json = r#"{"Get": "kind"}"#;