fmtview 0.4.0

Fast CLI viewer for highlighting, search, and diffs across JSON, JSONL, markup, Markdown, TOML, text, and Jinja
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

use crate::formats::{
    StructureCandidateKind,
    shared::{leading_indent, max_observed_offset},
};

pub(crate) fn candidate_kind(line: &str) -> Option<StructureCandidateKind> {
    let indent = leading_indent(line);
    let trimmed = line.trim_start();
    let first = trimmed.as_bytes().first().copied()?;
    if matches!(first, b'{' | b'[') {
        return Some(if indent == 0 {
            StructureCandidateKind::JsonRecordStart
        } else if first == b'{' {
            StructureCandidateKind::JsonArrayItemStart
        } else {
            StructureCandidateKind::JsonRootStart
        });
    }
    let after_colon = value_after_key(trimmed)?;
    if after_colon.starts_with('{') || after_colon.starts_with('[') {
        Some(StructureCandidateKind::JsonCompositeField)
    } else {
        None
    }
}

pub(crate) fn block_end(
    lines: &[String],
    read_start: usize,
    start_offset: usize,
    viewport_bottom: usize,
) -> Option<usize> {
    let max_offset = max_observed_offset(lines, read_start, viewport_bottom)?;
    let mut depth = 0_usize;
    let mut started = false;
    let mut in_string = false;
    let mut escaped = false;

    for (relative, line) in lines[start_offset..=max_offset].iter().enumerate() {
        let offset = start_offset + relative;
        let start_byte = if offset == start_offset {
            first_open_byte(line)?
        } else {
            0
        };
        for (_, ch) in line[start_byte..].char_indices() {
            if in_string {
                if escaped {
                    escaped = false;
                } else if ch == '\\' {
                    escaped = true;
                } else if ch == '"' {
                    in_string = false;
                }
                continue;
            }

            match ch {
                '"' => in_string = true,
                '{' | '[' => {
                    depth = depth.saturating_add(1);
                    started = true;
                }
                '}' | ']' if started => {
                    depth = depth.saturating_sub(1);
                    if depth == 0 {
                        return Some(read_start + offset);
                    }
                }
                _ => {}
            }
        }
    }

    None
}

fn value_after_key(trimmed: &str) -> Option<&str> {
    if !trimmed.starts_with('"') {
        return None;
    }

    let mut escaped = false;
    for (index, ch) in trimmed.char_indices().skip(1) {
        if escaped {
            escaped = false;
            continue;
        }
        match ch {
            '\\' => escaped = true,
            '"' => {
                return trimmed[index + ch.len_utf8()..]
                    .trim_start()
                    .strip_prefix(':')
                    .map(str::trim_start);
            }
            _ => {}
        }
    }
    None
}

fn first_open_byte(line: &str) -> Option<usize> {
    let mut in_string = false;
    let mut escaped = false;
    for (index, ch) in line.char_indices() {
        if in_string {
            if escaped {
                escaped = false;
            } else if ch == '\\' {
                escaped = true;
            } else if ch == '"' {
                in_string = false;
            }
            continue;
        }

        match ch {
            '"' => in_string = true,
            '{' | '[' => return Some(index),
            _ => {}
        }
    }
    None
}