Complete rewrite of --greppable

Author: IvanIsCoding

Cargo.lock

@@ -35,7 +35,7 @@ path = "src/documentation.rs"
 default = ["mimalloc", "from-toml", "from-yaml", "greppable"]
 from-toml = ["dep:toml"]
 from-yaml = ["dep:serde-saphyr"]
-greppable = ["dep:gron", "dep:ressa", "dep:resast"]
+greppable = ["dep:ressa", "dep:resast"]
 
 [dependencies]
 anyhow = "1"
@@ -48,7 +48,6 @@ mimalloc = { version = ">=0.1.40, <0.2.0", default-features = false, optional =
 json5 = "0.4"
 toml = { version = "=0.9.8", default-features = false, features = ["parse", "serde", "preserve_order"], optional = true }
 serde-saphyr = { version = "=0.0.14", default-features = false, optional = true }
-gron = { version = "=0.4.0", optional = true }
 ressa = { version = "=0.8.2", optional = true}
 resast = { version = "=0.5.0", optional = true }
 

Cargo.toml

@@ -0,0 +1,106 @@
+use resast::prelude::*;
+use ressa::Parser;
+use serde_json::Value as JsonValue;
+use std::fmt::Write;
+
+/// Convert a JSON value to gron format
+pub fn json_to_gron(value: &JsonValue) -> String {
+    let mut output = String::new();
+    gron_recursive(value, "json", &mut output);
+    output
+}
+
+fn gron_recursive(value: &JsonValue, path: &str, output: &mut String) {
+    match value {
+        JsonValue::Null => {
+            writeln!(output, "{} = null;", path).unwrap();
+        }
+        JsonValue::Bool(b) => {
+            writeln!(output, "{} = {};", path, b).unwrap();
+        }
+        JsonValue::Number(n) => {
+            writeln!(output, "{} = {};", path, n).unwrap();
+        }
+        JsonValue::String(s) => {
+            writeln!(output, "{} = {};", path, escape_string(s)).unwrap();
+        }
+        JsonValue::Array(arr) => {
+            writeln!(output, "{} = [];", path).unwrap();
+            for (i, item) in arr.iter().enumerate() {
+                let new_path = format!("{}[{}]", path, i);
+                gron_recursive(item, &new_path, output);
+            }
+        }
+        JsonValue::Object(obj) => {
+            writeln!(output, "{} = {{}};", path).unwrap();
+            for (key, val) in obj.iter() {
+                let new_path = format_path_segment(path, key);
+                gron_recursive(val, &new_path, output);
+            }
+        }
+    }
+}
+
+/// Check if a string is a valid JavaScript identifier
+fn is_valid_identifier(s: &str) -> bool {
+    if s.is_empty() {
+        return false;
+    }
+
+    // 1. Quick check: identifiers cannot contain whitespace or newlines
+    if s.chars().any(|c| c.is_whitespace() || c.is_control()) {
+        return false;
+    }
+
+    let test_code = format!("json.{}", s);
+
+    // If the parser errors, we should escape in quotes
+    if let Ok(mut parser) = Parser::new(&test_code) {
+        // This is a good sign, but we need to ensure the entire input was consumed
+        if let Some(Ok(ProgramPart::Stmt(Stmt::Expr(Expr::Member(_))))) = parser.next() {
+            // Guard against tokens such as newline
+            return parser.next().is_none();
+        }
+    }
+
+    false
+}
+
+/// Format a path segment, using dot notation for valid identifiers,
+/// bracket notation with quotes for everything else
+fn format_path_segment(current_path: &str, key: &str) -> String {
+    if is_valid_identifier(key) {
+        format!("{}.{}", current_path, key)
+    } else {
+        format!("{}[{}]", current_path, escape_string(key))
+    }
+}
+
+/// Escape a string for use in gron output (both for keys and values)
+fn escape_string(s: &str) -> String {
+    let mut result = String::with_capacity(s.len() + 2);
+    result.push('"');
+
+    for ch in s.chars() {
+        match ch {
+            '"' => result.push_str(r#"\""#),
+            '\\' => result.push_str(r"\\"),
+            '\n' => result.push_str(r"\n"),
+            '\r' => result.push_str(r"\r"),
+            '\t' => result.push_str(r"\t"),
+            '\x08' => result.push_str(r"\b"),
+            '\x0C' => result.push_str(r"\f"),
+            c if c.is_control() => {
+                write!(result, "\\u{:04x}", c as u32).unwrap();
+            }
+            c => result.push(c),
+        }
+    }
+
+    result.push('"');
+    result
+}
+
+#[cfg(test)]
+#[path = "gron_test.rs"]
+mod tests;

src/gron.rs

@@ -0,0 +1,192 @@
+use super::*;
+use serde_json::json;
+
+#[test]
+fn test_simple_object() {
+    let value = json!({
+        "name": "Get Celq",
+        "email": "get-celq@proton.me"
+    });
+
+    let result = json_to_gron(&value);
+    assert!(result.contains(r#"json = {};"#));
+    assert!(result.contains(r#"json.name = "Get Celq";"#));
+    assert!(result.contains(r#"json.email = "get-celq@proton.me";"#));
+}
+
+#[test]
+fn test_nested_object() {
+    let value = json!({
+        "commit": {
+            "author": {
+                "name": "Get Celq",
+                "email": "get-celq@proton.me",
+                "date": "2026-01-01T06:00:00Z"
+            }
+        }
+    });
+
+    let result = json_to_gron(&value);
+    assert!(result.contains(r#"json.commit.author = {};"#));
+    assert!(result.contains(r#"json.commit.author.name = "Get Celq";"#));
+    assert!(result.contains(r#"json.commit.author.email = "get-celq@proton.me";"#));
+    assert!(result.contains(r#"json.commit.author.date = "2026-01-01T06:00:00Z";"#));
+}
+
+#[test]
+fn test_array() {
+    let value = json!([
+        {
+            "commit": {
+                "author": {
+                    "name": "Get Celq"
+                }
+            }
+        }
+    ]);
+
+    let result = json_to_gron(&value);
+    assert!(result.contains("json = [];"));
+    assert!(result.contains(r#"json[0].commit.author.name = "Get Celq";"#));
+}
+
+#[test]
+fn test_special_keys() {
+    let value = json!({
+        "x86_64-unknown-linux-musl": {
+            "pkg-url": "some-value"
+        }
+    });
+
+    let result = json_to_gron(&value);
+    // Keys with hyphens are not valid identifiers, so they need bracket notation
+    assert!(result.contains(r#"json["x86_64-unknown-linux-musl"]["pkg-url"] = "some-value";"#));
+}
+
+#[test]
+fn test_primitives() {
+    let value = json!({
+        "null_val": null,
+        "bool_val": true,
+        "num_val": 42,
+        "float_val": 3.14
+    });
+
+    let result = json_to_gron(&value);
+    assert!(result.contains(r#"json.null_val = null;"#));
+    assert!(result.contains(r#"json.bool_val = true;"#));
+    assert!(result.contains(r#"json.num_val = 42;"#));
+    assert!(result.contains(r#"json.float_val = 3.14;"#));
+}
+
+#[test]
+fn test_string_escaping() {
+    let value = json!({
+        "with\"quote": "value with \"quote\"",
+        "with\nnewline": "value\nwith\nnewline"
+    });
+
+    let result = json_to_gron(&value);
+    println!("DEBUG: {}", result);
+    assert!(result.contains(r#"json["with\"quote"] = "value with \"quote\"";"#));
+    assert!(result.contains(r#"json["with\nnewline"] = "value\nwith\nnewline";"#));
+}
+
+#[test]
+fn test_your_example() {
+    let value = json!({
+        "package": {
+            "metadata": {
+                "binstall": {
+                    "overrides": {
+                        "x86_64-unknown-linux-musl": {
+                            "pkg-url": "{ repo }/releases/download/v{ version }/{ name }-linux-x86_64-musl{ archive-suffix }"
+                        }
+                    }
+                }
+            }
+        }
+    });
+
+    let result = json_to_gron(&value);
+    // "pkg-url" and "x86_64-unknown-linux-musl" have hyphens, so they need brackets
+    // but package, metadata, binstall, overrides are valid identifiers
+    assert!(result.contains(
+            r#"json.package.metadata.binstall.overrides["x86_64-unknown-linux-musl"]["pkg-url"] = "{ repo }/releases/download/v{ version }/{ name }-linux-x86_64-musl{ archive-suffix }";"#
+        ));
+}
+
+#[test]
+fn test_mixed_notation() {
+    let value = json!({
+        "valid_id": {
+            "also-valid": "value",
+            "nested": {
+                "deep-key": "deep-value"
+            }
+        },
+        "123start": "invalid"
+    });
+
+    let result = json_to_gron(&value);
+    // valid_id is a valid identifier, uses dot
+    assert!(result.contains(r#"json.valid_id = {};"#));
+    // also-valid has hyphen, needs brackets
+    assert!(result.contains(r#"json.valid_id["also-valid"] = "value";"#));
+    // nested is valid, uses dot
+    assert!(result.contains(r#"json.valid_id.nested = {};"#));
+    // deep-key has hyphen, needs brackets
+    assert!(result.contains(r#"json.valid_id.nested["deep-key"] = "deep-value";"#));
+    // 123start starts with number but has letters, needs quoted brackets
+    assert!(result.contains(r#"json["123start"] = "invalid";"#));
+}
+
+#[test]
+fn test_array_with_objects() {
+    let value = json!([
+        {
+            "123": "starts with number",
+            "validKey": "valid"
+        }
+    ]);
+
+    let result = json_to_gron(&value);
+    // Array index is unquoted
+    assert!(result.contains(r#"json[0] = {};"#));
+    // Numeric string object key uses quoted bracket notation
+    assert!(result.contains(r#"json[0]["123"] = "starts with number";"#));
+    // Valid identifier after array index uses dot
+    assert!(result.contains(r#"json[0].validKey = "valid";"#));
+}
+
+#[test]
+fn test_serde_saphyr_example() {
+    let value = json!({
+        "dependencies": {
+            "serde-saphyr": {
+                "version": "=0.0.14"
+            }
+        }
+    });
+
+    let result = json_to_gron(&value);
+    // Should produce: json.dependencies["serde-saphyr"].version = "=0.0.14";
+    assert!(result.contains(r#"json.dependencies["serde-saphyr"].version = "=0.0.14";"#));
+}
+
+#[test]
+fn test_features_array_example() {
+    let value = json!({
+        "features": {
+            "default": [
+                "from-yaml",
+                "from-toml"
+            ]
+        }
+    });
+
+    let result = json_to_gron(&value);
+    // Array indices are unquoted
+    assert!(result.contains(r#"json.features.default[0] = "from-yaml";"#));
+    assert!(result.contains(r#"json.features.default[1] = "from-toml";"#));
+}

src/gron_test.rs

@@ -228,19 +228,8 @@ fn handle_json_output(result: &CelValue, input_params: &InputParameters) -> Resu
     if input_params.greppable {
         #[cfg(feature = "greppable")]
         {
-            let mut output = Vec::new();
-            gron::json_to_gron(&mut output, "json", &json_value)
-                .context("Failed to convert to greppable format")?;
-            let gron_output = String::from_utf8(output)
-                .context("Failed to convert greppable output to string")?;
-            // Add semicolons to each line.
-            // For some reason gron crate does not add semicolons, but the original gron CLI does.
-            let with_semicolons = gron_output
-                .lines()
-                .map(|line| format!("{};", line))
-                .collect::<Vec<_>>()
-                .join("\n");
-            return Ok(with_semicolons + "\n");
+            let gron_output = crate::gron::json_to_gron(&json_value);
+            return Ok(gron_output);
         }
 
         #[cfg(not(feature = "greppable"))]

src/input_handler.rs

@@ -27,6 +27,11 @@ mod ungron;
 #[cfg(feature = "greppable")]
 pub use ungron::gron_to_json;
 
+#[cfg(feature = "greppable")]
+mod gron;
+#[cfg(feature = "greppable")]
+pub use gron::json_to_gron;
+
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;