jiq 3.21.0

Interactive JSON query tool with real-time output
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

use super::super::*;
use crate::test_utils::test_helpers::test_app;
use proptest::prelude::*;

#[test]
fn test_scroll_to_match_with_margin_when_below_viewport() {
    let mut app = test_app(r#"{"name": "test"}"#);
    app.results_scroll.viewport_height = 20;
    app.results_scroll.max_offset = 100;
    app.results_scroll.offset = 0;

    // Set up a match at line 50 (below viewport 0-20)
    app.search.open();
    app.search.search_textarea_mut().insert_str("test");
    // Manually set matches to control the test
    let content = (0..120)
        .map(|i| if i == 50 { "test\n" } else { "line\n" })
        .collect::<String>();
    app.search.update_matches(&content);

    // Navigate to the match at line 50
    while app.search.current_match().map(|m| m.line) != Some(50) {
        app.search.next_match();
    }

    scroll::scroll_to_match(&mut app);

    // Neovim-style: position match near bottom with margin
    // new_offset = target_line + margin + 1 - viewport_height = 50 + 5 + 1 - 20 = 36
    assert_eq!(app.results_scroll.offset, 36);
}

#[test]
fn test_scroll_to_match_with_margin_when_above_viewport() {
    let mut app = test_app(r#"{"name": "test"}"#);
    app.results_scroll.viewport_height = 20;
    app.results_scroll.max_offset = 100;
    app.results_scroll.offset = 50;

    // Set up a match at line 10 (above viewport 50-70)
    app.search.open();
    app.search.search_textarea_mut().insert_str("test");
    let content = (0..120)
        .map(|i| if i == 10 { "test\n" } else { "line\n" })
        .collect::<String>();
    app.search.update_matches(&content);

    scroll::scroll_to_match(&mut app);

    // Neovim-style: position match near top with margin
    // new_offset = target_line - margin = 10 - 5 = 5
    assert_eq!(app.results_scroll.offset, 5);
}

#[test]
fn test_scroll_to_match_no_scroll_if_visible_with_margin() {
    let mut app = test_app(r#"{"name": "test"}"#);
    app.results_scroll.viewport_height = 20;
    app.results_scroll.max_offset = 100;
    app.results_scroll.offset = 10;

    // Set up a match at line 20 (within viewport 10-30, and outside margin zones)
    // Margin zone at top: 10-15, margin zone at bottom: 25-30
    // Line 20 is safely in the middle
    app.search.open();
    app.search.search_textarea_mut().insert_str("test");
    let content = (0..120)
        .map(|i| if i == 20 { "test\n" } else { "line\n" })
        .collect::<String>();
    app.search.update_matches(&content);

    scroll::scroll_to_match(&mut app);

    // Should not change offset since line 20 is visible and outside margin zones
    assert_eq!(app.results_scroll.offset, 10);
}

#[test]
fn test_scroll_to_match_clamps_to_max() {
    let mut app = test_app(r#"{"name": "test"}"#);
    app.results_scroll.viewport_height = 20;
    app.results_scroll.max_offset = 50;
    app.results_scroll.offset = 0;

    // Set up a match at line 100
    app.search.open();
    app.search.search_textarea_mut().insert_str("test");
    let content = (0..120)
        .map(|i| if i == 100 { "test\n" } else { "line\n" })
        .collect::<String>();
    app.search.update_matches(&content);

    // Navigate to the match at line 100
    while app.search.current_match().map(|m| m.line) != Some(100) {
        app.search.next_match();
    }

    scroll::scroll_to_match(&mut app);

    // Should clamp to max_offset (50)
    assert_eq!(app.results_scroll.offset, 50);
}

#[test]
fn test_scroll_to_match_horizontal() {
    let mut app = test_app(r#"{"name": "test"}"#);
    app.results_scroll.viewport_height = 20;
    app.results_scroll.max_offset = 100;
    app.results_scroll.max_h_offset = 200;
    app.results_scroll.offset = 0;
    app.results_scroll.h_offset = 0;

    // Set up a match at column 150 (beyond typical viewport)
    app.search.open();
    app.search.search_textarea_mut().insert_str("test");
    // Create content with match far to the right
    let content = format!("{}test\n", " ".repeat(150));
    app.search.update_matches(&content);

    scroll::scroll_to_match(&mut app);

    // Should scroll horizontally to show the match (150 - 10 margin = 140)
    assert_eq!(app.results_scroll.h_offset, 140);
}

// Feature: search-in-results, Property 8: Auto-scroll positions match in viewport
// *For any* match navigation, the resulting scroll offset should position the
// match line within the visible viewport.
// **Validates: Requirements 3.3**
proptest! {
    #![proptest_config(ProptestConfig::with_cases(100))]

    #[test]
    fn prop_auto_scroll_positions_match_in_viewport(
        // Generate viewport and scroll parameters
        viewport_height in 5u16..50,
        max_offset in 10u16..200,
        initial_offset in 0u16..100,
        // Constrain target_line to be within the scrollable content
        // (max_offset + viewport_height represents the total content height)
        target_line_factor in 0.0f64..1.0,
    ) {
        let mut app = test_app(r#"{"name": "test"}"#);

        // Set up scroll state
        app.results_scroll.viewport_height = viewport_height;
        app.results_scroll.max_offset = max_offset;
        app.results_scroll.offset = initial_offset.min(max_offset);

        // Calculate target line within valid content range
        // Content height = max_offset + viewport_height (the last visible line when scrolled to max)
        let content_height = max_offset as u32 + viewport_height as u32;
        let target_line = ((target_line_factor * content_height as f64) as u32).min(content_height.saturating_sub(1));

        // Set up a match at the target line so scroll_to_match works
        app.search.open();
        app.search.search_textarea_mut().insert_str("test");
        // Create content with a match at the target line
        let content: String = (0..content_height)
            .map(|i| if i == target_line { "test\n" } else { "line\n" })
            .collect();
        app.search.update_matches(&content);

        // Navigate to the match at target_line (there should be exactly one match)
        prop_assert_eq!(app.search.matches().len(), 1, "Should have exactly one match");
        prop_assert_eq!(app.search.current_match().map(|m| m.line), Some(target_line), "Match should be at target line");

        // Call scroll_to_match
        scroll::scroll_to_match(&mut app);

        // Get the resulting offset
        let result_offset = app.results_scroll.offset;

        // Calculate visible range after scroll
        let visible_start = result_offset as u32;
        let visible_end = visible_start + viewport_height as u32;

        // The target line should be within the visible viewport
        prop_assert!(
            target_line >= visible_start && target_line < visible_end,
            "Target line {} should be within visible range [{}, {}), offset={}, viewport_height={}, max_offset={}",
            target_line, visible_start, visible_end, result_offset, viewport_height, max_offset
        );

        // Verify offset is within valid bounds
        prop_assert!(
            result_offset <= max_offset,
            "Scroll offset {} should not exceed max_offset {}",
            result_offset, max_offset
        );
    }
}