docs: version 0.8.1 and edition 2024

jac18281828 · jac18281828 · commit 3e7ce5889b2f · 2025-07-06T17:48:51.000-05:00
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
@@ -5,7 +5,7 @@
         {
             "label": "Rust: Format",
             "type": "shell",
-            "command": "cargo fmt --all",
+            "command": "cargo fmt --all --check",
             "group": "build",
             "problemMatcher": []
         },
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "parsm"
-version = "0.2.1"
-edition = "2021"
+version = "0.8.1"
+edition = "2024"
 authors = ["John Cairns <john@2ad.com>"]
 description = "Multi-format data processor that understands structured text better than sed or awk. Supports JSON, CSV, YAML, TOML, logfmt, and plain text with powerful filtering and templating."
 license = "MIT"
diff --git a/src/bin/parsm.rs b/src/bin/parsm.rs
@@ -3,8 +3,8 @@ use std::io;
 use tracing::debug;
 
 use parsm::{
-    csv_parser, parse_command, parse_separate_expressions, process_stream, DetectedFormat,
-    FilterEngine, FormatDetector, ParsedDSL, ParsedLine,
+    DetectedFormat, FilterEngine, FormatDetector, ParsedDSL, ParsedLine, csv_parser, parse_command,
+    parse_separate_expressions, process_stream,
 };
 
 /// Main entry point for the parsm command-line tool.
@@ -194,8 +194,13 @@ fn process_stream_with_filter(
 ) -> Result<(), Box<dyn std::error::Error>> {
     use parsm::StreamingParser;
     use std::io::{BufRead, Read, Write};
-    debug!("process_stream_with_filter called with DSL: filter={:?}, template={:?}, field_selector={:?}, forced_format={:?}",
-        dsl.filter.is_some(), dsl.template.is_some(), dsl.field_selector.is_some(), forced_format);
+    debug!(
+        "process_stream_with_filter called with DSL: filter={:?}, template={:?}, field_selector={:?}, forced_format={:?}",
+        dsl.filter.is_some(),
+        dsl.template.is_some(),
+        dsl.field_selector.is_some(),
+        forced_format
+    );
 
     let stdin = io::stdin();
     let stdout = io::stdout();
@@ -622,7 +627,7 @@ mod tests {
 
     use serde_json::json;
 
-    use parsm::{filter::TemplateItem, FilterEngine};
+    use parsm::{FilterEngine, filter::TemplateItem};
 
     /// Test JSON filtering with equality comparison.
     #[test]
diff --git a/src/dsl/fallback.rs b/src/dsl/fallback.rs
@@ -100,7 +100,9 @@ fn try_simple_template_patterns(input: &str) -> Result<ParsedDSL, Box<dyn std::e
                 });
                 return Ok(result);
             } else if field_name.chars().all(|c| c.is_ascii_digit()) {
-                trace!("Dollar sign followed by digits only ($0, $1, $20, etc.), treating as numeric literal");
+                trace!(
+                    "Dollar sign followed by digits only ($0, $1, $20, etc.), treating as numeric literal"
+                );
                 result.template = Some(Template {
                     items: vec![TemplateItem::Literal(input.to_string())],
                 });
@@ -273,8 +275,7 @@ fn try_parse_and_expression(input: &str) -> Result<ParsedDSL, Box<dyn std::error
 
     trace!(
         "try_parse_and_expression: left='{}', right='{}'",
-        parts[0],
-        parts[1]
+        parts[0], parts[1]
     );
 
     // Try to parse each part as either a comparison or a truthy field
@@ -513,8 +514,7 @@ fn parse_field_name_for_truthy(name: &str) -> FieldPath {
     let base_name = name.strip_suffix('?').unwrap_or(name);
     trace!(
         "parse_field_name_for_truthy: '{}' -> base: '{}'",
-        name,
-        base_name
+        name, base_name
     );
     let parts: Vec<String> = base_name.split('.').map(|s| s.to_string()).collect();
     let field_path = FieldPath::new(parts);
diff --git a/src/dsl/filter_parser.rs b/src/dsl/filter_parser.rs
@@ -60,7 +60,7 @@ impl FilterParser {
                         message: "Expected expression in AND".to_string(),
                     },
                     span.start_pos(),
-                )))
+                )));
             }
         };
 
@@ -75,7 +75,7 @@ impl FilterParser {
                                 message: "Expected expression after AND".to_string(),
                             },
                             op_span.end_pos(),
-                        )))
+                        )));
                     }
                 };
                 left = FilterExpr::And(Box::new(left), Box::new(right));
@@ -130,7 +130,7 @@ impl FilterParser {
                         message: "Expected expression in comparison".to_string(),
                     },
                     span.start_pos(),
-                )))
+                )));
             }
         };
 
diff --git a/src/dsl/grammar.rs b/src/dsl/grammar.rs
@@ -1,7 +1,7 @@
 //! Main grammar parser using Pest
 
-use pest::iterators::Pair;
 use pest::Parser;
+use pest::iterators::Pair;
 use pest_derive::Parser;
 use tracing::trace;
 
diff --git a/src/dsl/mod.rs b/src/dsl/mod.rs
@@ -324,29 +324,37 @@ mod tests {
     fn test_existing_template_preserved() {
         // Field selectors
         assert!(parse_command("username").unwrap().field_selector.is_some());
-        assert!(parse_command("user.profile.bio")
-            .unwrap()
-            .field_selector
-            .is_some());
-        assert!(parse_command("\"field with spaces\"")
-            .unwrap()
-            .field_selector
-            .is_some());
+        assert!(
+            parse_command("user.profile.bio")
+                .unwrap()
+                .field_selector
+                .is_some()
+        );
+        assert!(
+            parse_command("\"field with spaces\"")
+                .unwrap()
+                .field_selector
+                .is_some()
+        );
 
         // Templates
         assert!(parse_command("$name").unwrap().template.is_some());
         assert!(parse_command("{${user.name}}").unwrap().template.is_some());
-        assert!(parse_command("[Hello ${name}!]")
-            .unwrap()
-            .template
-            .is_some());
+        assert!(
+            parse_command("[Hello ${name}!]")
+                .unwrap()
+                .template
+                .is_some()
+        );
 
         // Comparisons
         assert!(parse_command("age >= 21").unwrap().filter.is_some());
-        assert!(parse_command("status != \"deleted\"")
-            .unwrap()
-            .filter
-            .is_some());
+        assert!(
+            parse_command("status != \"deleted\"")
+                .unwrap()
+                .filter
+                .is_some()
+        );
         assert!(parse_command("score > 0.5").unwrap().filter.is_some());
 
         // Combined
diff --git a/src/lib.rs b/src/lib.rs
@@ -508,7 +508,7 @@ pub mod format_detector;
 pub mod parse;
 pub mod parser_registry;
 
-pub use dsl::{parse_command, parse_separate_expressions, ParsedDSL};
+pub use dsl::{ParsedDSL, parse_command, parse_separate_expressions};
 pub use filter::{
     ComparisonOp, FieldPath, FilterEngine, FilterExpr, FilterValue, Template, TemplateItem,
 };
diff --git a/src/parse.rs b/src/parse.rs
@@ -1081,10 +1081,12 @@ this,is,csv,but,should,fail
                 // Should gracefully handle malformed input
                 assert_eq!(value["level"], "error");
                 // The parser should treat the rest as the value since no closing \" was found
-                assert!(value["msg"]
-                    .as_str()
-                    .unwrap()
-                    .contains("unclosed quote service=api"));
+                assert!(
+                    value["msg"]
+                        .as_str()
+                        .unwrap()
+                        .contains("unclosed quote service=api")
+                );
             }
             _ => panic!("Expected logfmt parsing result"),
         }
diff --git a/tests/ambiguous_regression_test.rs b/tests/ambiguous_regression_test.rs
@@ -35,8 +35,10 @@ mod ambiguous_regression_tests {
 
             match parse_command(expr) {
                 Ok(parsed) => {
-                    panic!("Expected rejection but got successful parse for '{expr}': filter={:?}, template={:?}, field_selector={:?}", 
-                           parsed.filter, parsed.template, parsed.field_selector);
+                    panic!(
+                        "Expected rejection but got successful parse for '{expr}': filter={:?}, template={:?}, field_selector={:?}",
+                        parsed.filter, parsed.template, parsed.field_selector
+                    );
                 }
                 Err(e) => {
                     println!("✓ Correctly rejected: {e}");
diff --git a/tests/toml_integration_test.rs b/tests/toml_integration_test.rs
@@ -238,7 +238,7 @@ numbers = [1, 2, 3]"#;
 
     // With document-level TOML parsing, we get the fruits array formatted as JSON
     assert!(lines.len() >= 4); // Pretty-printed array takes multiple lines
-                               // Check that we have the pretty-printed array
+    // Check that we have the pretty-printed array
     assert!(lines[0] == "[");
     assert!(lines[1].contains("apple"));
     assert!(lines[2].contains("banana"));
@@ -681,7 +681,7 @@ client = { timeout = 30 }"#;
 
     // With document-level TOML parsing, we get the server object formatted as pretty-printed JSON
     assert!(lines.len() >= 3); // Pretty-printed object takes multiple lines
-                               // First part should contain the server table as pretty-printed JSON
+    // First part should contain the server table as pretty-printed JSON
     assert!(lines[0] == "{");
     assert!(lines[1].contains("host") && lines[1].contains("localhost"));
     assert!(lines[2].contains("port") && lines[2].contains("8080"));

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`{`
`6`	`6`	`"label": "Rust: Format",`
`7`	`7`	`"type": "shell",`
`8`		`- "command": "cargo fmt --all",`
	`8`	`+ "command": "cargo fmt --all --check",`
`9`	`9`	`"group": "build",`
`10`	`10`	`"problemMatcher": []`
`11`	`11`	`},`