jiq 2.21.1

Interactive JSON query tool with real-time output
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Lexer-aware scanner state for jq queries.
//!
//! This module provides a state machine for tracking whether the scanner
//! is inside a string literal, handling escape sequences correctly.
//! This enables other components to skip syntactic characters inside strings.

/// Scanner state for lexer-aware parsing of jq queries.
///
/// This state machine tracks whether we're inside a string literal,
/// allowing components to correctly ignore syntactic characters
/// (like braces, brackets, operators) that appear inside strings.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ScanState {
    /// Normal code context - syntactic characters are meaningful
    #[default]
    Normal,
    /// Inside a string literal `"..."`
    InString,
    /// After a backslash inside a string (escape sequence)
    InStringEscape,
}

impl ScanState {
    /// Advance the scanner state based on the next character.
    ///
    /// Returns the new state after processing the character.
    ///
    /// # Arguments
    /// * `ch` - The character to process
    ///
    /// # Returns
    /// The new `ScanState` after processing the character
    pub fn advance(self, ch: char) -> Self {
        match self {
            ScanState::Normal => match ch {
                '"' => ScanState::InString,
                _ => ScanState::Normal,
            },
            ScanState::InString => match ch {
                '\\' => ScanState::InStringEscape,
                '"' => ScanState::Normal,
                _ => ScanState::InString,
            },
            ScanState::InStringEscape => {
                // After escape, return to string state regardless of character
                ScanState::InString
            }
        }
    }

    /// Check if currently inside a string literal.
    pub fn is_in_string(self) -> bool {
        matches!(self, ScanState::InString | ScanState::InStringEscape)
    }
}

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

    #[test]
    fn test_default_is_normal() {
        assert_eq!(ScanState::default(), ScanState::Normal);
    }

    #[test]
    fn test_enter_string() {
        let state = ScanState::Normal.advance('"');
        assert_eq!(state, ScanState::InString);
        assert!(state.is_in_string());
    }

    #[test]
    fn test_exit_string() {
        let state = ScanState::InString.advance('"');
        assert_eq!(state, ScanState::Normal);
        assert!(!state.is_in_string());
    }

    #[test]
    fn test_escape_in_string() {
        let state = ScanState::InString.advance('\\');
        assert_eq!(state, ScanState::InStringEscape);
        assert!(state.is_in_string());
    }

    #[test]
    fn test_escaped_quote() {
        let state = ScanState::InStringEscape.advance('"');
        assert_eq!(state, ScanState::InString);
        assert!(state.is_in_string());
    }

    #[test]
    fn test_escaped_backslash() {
        let state = ScanState::InStringEscape.advance('\\');
        assert_eq!(state, ScanState::InString);
    }

    #[test]
    fn test_normal_chars_stay_normal() {
        let state = ScanState::Normal.advance('a');
        assert_eq!(state, ScanState::Normal);
    }

    #[test]
    fn test_string_chars_stay_in_string() {
        let state = ScanState::InString.advance('a');
        assert_eq!(state, ScanState::InString);
    }

    #[test]
    fn test_full_string_scan() {
        // Scan through: "hello"
        let mut state = ScanState::Normal;
        for ch in "\"hello\"".chars() {
            state = state.advance(ch);
        }
        assert_eq!(state, ScanState::Normal);
    }

    #[test]
    fn test_escaped_quote_in_string() {
        // Scan through: "say \"hi\""
        let mut state = ScanState::Normal;
        for ch in "\"say \\\"hi\\\"\"".chars() {
            state = state.advance(ch);
        }
        assert_eq!(state, ScanState::Normal);
    }
}