parsm 0.8.3

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.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Centralized operator definitions for the parsm DSL.
//!
//! This module provides a single source of truth for all comparison operators
//! supported by parsm, eliminating duplication across the codebase.

use crate::filter::ComparisonOp;

/// Operator definition with string representation and enum variant.
#[derive(Debug, Clone, PartialEq)]
pub struct OperatorDef {
    /// The string representation used in the DSL
    pub symbol: &'static str,
    /// The corresponding enum variant
    pub op: ComparisonOp,
}

/// All supported comparison operators in order of precedence.
///
/// Longer operators (like ">=") should come before shorter ones ("<")
/// to ensure proper parsing precedence.
pub const OPERATORS: &[OperatorDef] = &[
    // Multi-character operators first (for proper parsing)
    OperatorDef {
        symbol: "==",
        op: ComparisonOp::Equal,
    },
    OperatorDef {
        symbol: "!=",
        op: ComparisonOp::NotEqual,
    },
    OperatorDef {
        symbol: "<=",
        op: ComparisonOp::LessThanOrEqual,
    },
    OperatorDef {
        symbol: ">=",
        op: ComparisonOp::GreaterThanOrEqual,
    },
    OperatorDef {
        symbol: "^=",
        op: ComparisonOp::StartsWith,
    },
    OperatorDef {
        symbol: "$=",
        op: ComparisonOp::EndsWith,
    },
    OperatorDef {
        symbol: "*=",
        op: ComparisonOp::Contains,
    },
    OperatorDef {
        symbol: "~=",
        op: ComparisonOp::Regex,
    },
    // Single-character operators
    OperatorDef {
        symbol: "<",
        op: ComparisonOp::LessThan,
    },
    OperatorDef {
        symbol: ">",
        op: ComparisonOp::GreaterThan,
    },
    OperatorDef {
        symbol: "~",
        op: ComparisonOp::Contains,
    },
];

/// Parse a comparison operator from its string representation.
///
/// Returns the corresponding `ComparisonOp` variant, or `ComparisonOp::Equal`
/// as a default fallback for unknown operators.
pub fn parse_comparison_op(op_str: &str) -> ComparisonOp {
    OPERATORS
        .iter()
        .find(|op| op.symbol == op_str)
        .map(|op| op.op.clone())
        .unwrap_or(ComparisonOp::Equal)
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Get all operator symbols for use in grammar generation or documentation.
    fn get_all_operator_symbols() -> Vec<&'static str> {
        OPERATORS.iter().map(|op| op.symbol).collect()
    }

    #[test]
    fn test_parse_comparison_op() {
        // Symbol-based operators from the grammar
        assert_eq!(parse_comparison_op("=="), ComparisonOp::Equal);
        assert_eq!(parse_comparison_op("!="), ComparisonOp::NotEqual);
        assert_eq!(parse_comparison_op("<"), ComparisonOp::LessThan);
        assert_eq!(parse_comparison_op("<="), ComparisonOp::LessThanOrEqual);
        assert_eq!(parse_comparison_op(">"), ComparisonOp::GreaterThan);
        assert_eq!(parse_comparison_op(">="), ComparisonOp::GreaterThanOrEqual);
        assert_eq!(parse_comparison_op("*="), ComparisonOp::Contains);
        assert_eq!(parse_comparison_op("^="), ComparisonOp::StartsWith);
        assert_eq!(parse_comparison_op("$="), ComparisonOp::EndsWith);

        // Test fallback
        assert_eq!(parse_comparison_op("unknown"), ComparisonOp::Equal);
    }

    #[test]
    fn test_get_operator_symbols() {
        let symbols = get_all_operator_symbols();
        assert!(symbols.contains(&"=="));
        assert!(symbols.contains(&"*="));
        assert!(symbols.contains(&">="));
        assert_eq!(symbols.len(), OPERATORS.len());
    }
}