use crate::jqlang::{parse_json, render};
#[derive(Default, Clone, Copy)]
struct Scan {
depth: usize,
in_str: bool,
escaped: bool,
}
#[derive(PartialEq)]
enum Step {
Inside,
Closed,
Bad,
}
impl Scan {
fn step(&mut self, b: u8) -> Step {
if self.in_str {
match b {
_ if self.escaped => self.escaped = false,
b'\\' => self.escaped = true,
b'"' => {
self.in_str = false;
if self.depth == 0 {
return Step::Closed;
}
}
_ => {}
}
return Step::Inside;
}
match b {
b'"' => self.in_str = true,
b'[' | b'{' => self.depth += 1,
b']' | b'}' => match self.depth {
0 => return Step::Bad,
1 => {
self.depth = 0;
return Step::Closed;
}
_ => self.depth -= 1,
},
_ => {}
}
Step::Inside
}
}
enum Line {
One,
Values(Vec<(usize, usize)>),
Opens(Scan),
Text,
}
fn classify(line: &str) -> Line {
let b = line.as_bytes();
let mut first = None;
let mut spans = Vec::new();
let mut i = 0;
while i < b.len() {
if b[i].is_ascii_whitespace() {
i += 1;
continue;
}
let start = i;
if matches!(b[i], b'[' | b'{' | b'"') {
let mut scan = Scan::default();
loop {
if i == b.len() {
return if scan.depth > 0 {
Line::Opens(scan)
} else {
Line::Text
};
}
let step = scan.step(b[i]);
i += 1;
match step {
Step::Inside => {}
Step::Closed => break,
Step::Bad => return Line::Text,
}
}
} else {
while i < b.len() && !b[i].is_ascii_whitespace() && !matches!(b[i], b'[' | b'{' | b'"')
{
if matches!(b[i], b']' | b'}') {
return Line::Text;
}
i += 1;
}
}
match first {
None => first = Some((start, i)),
Some(f) => {
if spans.is_empty() {
spans.push(f);
}
spans.push((start, i));
}
}
}
if spans.is_empty() {
Line::One
} else {
Line::Values(spans)
}
}
#[derive(Default)]
pub struct JsonDocs {
pending: Vec<String>,
scan: Scan,
}
impl JsonDocs {
pub fn passes_through(&self, line: &str) -> bool {
self.pending.is_empty() && matches!(classify(line), Line::One)
}
pub fn push(&mut self, line: &str, out: &mut Vec<String>) {
if !self.pending.is_empty() {
self.continue_doc(line, out);
return;
}
match classify(line) {
Line::One => out.push(line.to_string()),
Line::Values(spans) => {
let parts: Vec<&str> = spans.iter().map(|&(a, z)| &line[a..z]).collect();
if parts.iter().all(|p| parse_json(p).is_ok()) {
out.extend(parts.into_iter().map(str::to_string));
} else {
out.push(line.to_string());
}
}
Line::Opens(scan) if starts_with_opener(line) => {
self.scan = scan;
self.pending.push(line.to_string());
}
Line::Opens(_) | Line::Text => out.push(line.to_string()),
}
}
pub fn finish(&mut self, out: &mut Vec<String>) {
out.append(&mut self.pending);
self.scan = Scan::default();
}
fn continue_doc(&mut self, line: &str, out: &mut Vec<String>) {
let mut end = None;
for (i, &b) in line.as_bytes().iter().enumerate() {
match self.scan.step(b) {
Step::Inside => {}
Step::Closed => {
end = Some(i + 1);
break;
}
Step::Bad => {
let lines = std::mem::take(&mut self.pending);
self.scan = Scan::default();
self.replay(lines, line, out);
return;
}
}
}
let Some(end) = end else {
self.pending.push(line.to_string());
return;
};
let mut text = self.pending.join("\n");
text.push('\n');
text.push_str(&line[..end]);
let lines = std::mem::take(&mut self.pending);
self.scan = Scan::default();
match parse_json(&text) {
Ok(v) => {
out.push(render(&v));
let rest = line[end..].trim_start();
if !rest.is_empty() {
self.push(rest, out);
}
}
Err(_) => self.replay(lines, line, out),
}
}
fn replay(&mut self, lines: Vec<String>, last: &str, out: &mut Vec<String>) {
let mut it = lines.into_iter();
if let Some(first) = it.next() {
out.push(first);
}
for l in it {
self.push(&l, out);
}
self.push(last, out);
}
}
fn starts_with_opener(line: &str) -> bool {
matches!(line.trim_start().as_bytes().first(), Some(b'[' | b'{'))
}
pub fn documents(lines: &[String]) -> Vec<String> {
let mut docs = JsonDocs::default();
let mut out = Vec::with_capacity(lines.len());
for l in lines {
docs.push(l, &mut out);
}
docs.finish(&mut out);
out
}
#[cfg(test)]
mod tests {
use super::*;
fn docs(lines: &[&str]) -> Vec<String> {
documents(&lines.iter().map(|s| s.to_string()).collect::<Vec<_>>())
}
#[test]
fn one_value_lines_pass_through_unchanged() {
assert_eq!(
docs(&[r#"{"a": 1.50}"#, "abc", "", r#""x y""#]),
[r#"{"a": 1.50}"#, "abc", "", r#""x y""#]
);
}
#[test]
fn several_values_on_a_line_split() {
assert_eq!(docs(&["1 2 3"]), ["1", "2", "3"]);
assert_eq!(docs(&[r#"{"a":1}{"a":2}"#]), [r#"{"a":1}"#, r#"{"a":2}"#]);
assert_eq!(docs(&[r#""a" [1] "b""#]), [r#""a""#, "[1]", r#""b""#]);
assert_eq!(docs(&["200 OK"]), ["200 OK"]);
assert_eq!(docs(&["[INFO] started"]), ["[INFO] started"]);
}
#[test]
fn a_pretty_document_is_one_compact_item() {
assert_eq!(
docs(&["{", r#" "a": [1,"#, " 2.50],", r#" "s": "}{""#, "}", "7"]),
[r#"{"a":[1,2.50],"s":"}{"}"#, "7"]
);
assert_eq!(docs(&["[1,", "2] [3,", "4]"]), ["[1,2]", "[3,4]"]);
}
#[test]
fn what_never_makes_a_document_stays_text() {
assert_eq!(docs(&["{", "not json", "}"]), ["{", "not json", "}"]);
assert_eq!(docs(&["[INFO", "x"]), ["[INFO", "x"]);
assert_eq!(docs(&["a]", "1 [2,", "3]"]), ["a]", "1 [2,", "3]"]);
assert_eq!(docs(&[r#""open"#, "x"]), [r#""open"#, "x"]);
}
}