bc-envelope-pattern 0.14.0

Pattern matcher for Gordian Envelope
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221

mod common;

use bc_envelope::prelude::*;
use bc_envelope_pattern::{Matcher, Pattern, format_paths};
use dcbor_parse::parse_dcbor_item;
use indoc::indoc;

#[test]
fn test_dcbor_pattern_extended_paths() {
    // Create a complex nested `cbor` structure
    let nested_cbor =
        parse_dcbor_item(r#"{"numbers": [1, 2, 3], "nested": {"value": 42}}"#)
            .unwrap();
    let envelope = Envelope::new(nested_cbor);

    // Test `search(number)` - should find all numbers in the structure
    let pattern = Pattern::parse("cbor(/search(number)/)").unwrap();
    let paths = pattern.paths(&envelope);

    // Should find 4 numbers: 1, 2, 3, and 42
    assert_eq!(
        paths.len(),
        4,
        "Should find 4 numbers in the nested structure"
    );

    // Format the paths for comparison
    let actual = format_paths(&paths);
    // expected-text-output-rubric:
    #[rustfmt::skip]
    let expected = indoc! {r#"
        4bd40828 LEAF {"nested": {"value": 42}, "numbers": [1, 2, 3]}
            563fb650 LEAF {"value": 42}
                7f83f7bd LEAF 42
        4bd40828 LEAF {"nested": {"value": 42}, "numbers": [1, 2, 3]}
            4abc3113 LEAF [1, 2, 3]
                4bf5122f LEAF 1
        4bd40828 LEAF {"nested": {"value": 42}, "numbers": [1, 2, 3]}
            4abc3113 LEAF [1, 2, 3]
                dbc1b4c9 LEAF 2
        4bd40828 LEAF {"nested": {"value": 42}, "numbers": [1, 2, 3]}
            4abc3113 LEAF [1, 2, 3]
                084fed08 LEAF 3
    "#}
    .trim();

    assert_actual_expected!(
        actual,
        expected,
        "`cbor` pattern should return extended paths for all numbers in nested structure"
    );
}

#[test]
fn test_dcbor_pattern_simple_leaf_paths() {
    // Test with a simple number - should have minimal path extension
    let envelope = Envelope::new(42);
    let pattern = Pattern::parse("cbor(/number/)").unwrap();
    let paths = pattern.paths(&envelope);

    assert_eq!(paths.len(), 1, "Should find 1 number");

    // Format the paths for comparison - single value should not extend
    let actual = format_paths(&paths);
    let expected = "7f83f7bd LEAF 42";

    assert_actual_expected!(
        actual,
        expected,
        "Single value `cbor` pattern should return just the root envelope"
    );
}

#[test]
fn test_dcbor_pattern_array_paths() {
    // Test array access with specific element patterns
    let array_cbor = parse_dcbor_item("[1, \"hello\", true]").unwrap();
    let envelope = Envelope::new(array_cbor);

    // Find all text values in the array
    let pattern = Pattern::parse("cbor(/search(text)/)").unwrap();
    let paths = pattern.paths(&envelope);

    assert_eq!(paths.len(), 1, "Should find 1 text element"); // Should find "hello"

    // Format the paths for comparison
    let actual = format_paths(&paths);
    // expected-text-output-rubric:
    #[rustfmt::skip]
    let expected = indoc! {r#"
        4cd61f73 LEAF [1, "hello", true]
            cb835593 LEAF "hello"
    "#}
    .trim();

    assert_actual_expected!(
        actual,
        expected,
        "Text search should find hello with proper path extension"
    );
}

#[test]
fn test_dcbor_pattern_array_elements() {
    // Test what dcbor-pattern returns for array structure
    let array_cbor = parse_dcbor_item("[1, 2, 3]").unwrap();
    let envelope = Envelope::new(array_cbor);

    let pattern = Pattern::parse("cbor(/search(number)/)").unwrap();
    let paths = pattern.paths(&envelope);

    // Should find 3 numbers: 1, 2, 3
    assert_eq!(paths.len(), 3, "Should find 3 numbers in the array");

    // Format the paths for comparison
    let actual = format_paths(&paths);
    // expected-text-output-rubric:
    #[rustfmt::skip]
    let expected = indoc! {r#"
        4abc3113 LEAF [1, 2, 3]
            4bf5122f LEAF 1
        4abc3113 LEAF [1, 2, 3]
            dbc1b4c9 LEAF 2
        4abc3113 LEAF [1, 2, 3]
            084fed08 LEAF 3
    "#}
    .trim();

    assert_actual_expected!(
        actual,
        expected,
        "Array numbers should be found with proper path extension"
    );
}

#[test]
fn test_cbor_pattern_multiple_paths() {
    // Create a `cbor` structure with nested numbers
    let cbor_data = dcbor_parse::parse_dcbor_item(
        r#"
        {
            "numbers": [1, 2, 3],
            "value": 42
        }
    "#,
    )
    .unwrap();

    let envelope = Envelope::new(cbor_data);

    // Test `search(number)` pattern to find all numbers in the structure
    let pattern = Pattern::parse("cbor(/search(number)/)").unwrap();
    let paths = pattern.paths(&envelope);

    // We should find 4 numbers: 1, 2, 3, 42
    // Each should have its own path showing the route through the `cbor`
    // structure
    assert_eq!(
        paths.len(),
        4,
        "Should find 4 numbers in the `cbor` structure"
    );

    // Format the paths for comparison
    let actual = format_paths(&paths);
    // expected-text-output-rubric:
    #[rustfmt::skip]
    let expected = indoc! {r#"
        832e44f1 LEAF {"value": 42, "numbers": [1, 2, 3]}
            7f83f7bd LEAF 42
        832e44f1 LEAF {"value": 42, "numbers": [1, 2, 3]}
            4abc3113 LEAF [1, 2, 3]
                4bf5122f LEAF 1
        832e44f1 LEAF {"value": 42, "numbers": [1, 2, 3]}
            4abc3113 LEAF [1, 2, 3]
                dbc1b4c9 LEAF 2
        832e44f1 LEAF {"value": 42, "numbers": [1, 2, 3]}
            4abc3113 LEAF [1, 2, 3]
                084fed08 LEAF 3
    "#}
    .trim();

    assert_actual_expected!(
        actual,
        expected,
        "Complex structure should show proper path extension to all numbers"
    );
}

#[test]
fn test_array_element_access() {
    // Test with a simple array to understand path extension behavior
    let array_data = vec![1, 2, 3];
    let envelope = Envelope::new(array_data.clone());

    // Test our pattern
    let pattern = Pattern::parse("cbor(/search(number)/)").unwrap();
    let paths = pattern.paths(&envelope);

    assert_eq!(paths.len(), 3, "Should find 3 numbers in the array");

    // Format the paths for comparison
    let actual = format_paths(&paths);
    // expected-text-output-rubric:
    #[rustfmt::skip]
    let expected = indoc! {r#"
        4abc3113 LEAF [1, 2, 3]
            4bf5122f LEAF 1
        4abc3113 LEAF [1, 2, 3]
            dbc1b4c9 LEAF 2
        4abc3113 LEAF [1, 2, 3]
            084fed08 LEAF 3
    "#}
    .trim();

    assert_actual_expected!(
        actual,
        expected,
        "Array search should return extended paths to each element"
    );
}