use std::ops::Range;
use annotate_snippets::renderer::{AnsiColor, Effects, Style};
use annotate_snippets::{Annotation, AnnotationKind, Group, Level, Origin, Renderer, Snippet};
use jsonvet::{Location, Report, Severity, is_hidden};
use crate::output::printable;
const CONTEXT: usize = 160;
pub(crate) const ERROR: Style = AnsiColor::BrightRed.on_default().effects(Effects::BOLD);
pub(crate) const WARNING: Style = AnsiColor::Yellow.on_default().effects(Effects::BOLD);
const BLUE: Style = AnsiColor::BrightBlue.on_default().effects(Effects::BOLD);
pub(crate) const STYLED: Renderer = Renderer::styled()
.error(ERROR)
.warning(WARNING)
.info(BLUE)
.line_num(BLUE)
.context(BLUE)
.emphasis(Style::new().effects(Effects::BOLD));
#[derive(Clone, Copy)]
pub(crate) struct Mark<'a> {
pub(crate) at: Location,
pub(crate) span: (usize, usize),
pub(crate) label: Option<&'a str>,
}
pub(crate) fn one_char(report: &Report<'_>, offset: usize) -> (usize, usize) {
match report
.text()
.get(offset..)
.and_then(|rest| rest.chars().next())
{
Some(c) if report.ends_line(c) => (offset, offset),
None => (offset, offset),
Some(c) => (offset, offset + c.len_utf8()),
}
}
pub(crate) fn render(
renderer: &Renderer,
file: &str,
severity: Severity,
rule: &str,
message: &str,
primary: Option<(&Report<'_>, Mark<'_>)>,
related: Option<Mark<'_>>,
) -> String {
let level = if severity == Severity::Error {
Level::ERROR
} else {
Level::WARNING
};
let message = printable(message);
let file = printable(file);
let Some((report, primary)) = primary else {
let group = level.primary_title(message).element(Origin::path(file));
return renderer.render(&[group]);
};
let mut group = Group::with_title(level.primary_title(message).id(rule));
let close = related.filter(|related| {
related.at.line == primary.at.line && primary.span.0.abs_diff(related.span.0) <= CONTEXT
});
let mut columns = vec![primary.at.column];
if let Some(related) = close {
let first = if related.span.0 < primary.span.0 {
related
} else {
primary
};
let to = primary.span.1.max(related.span.1);
let excerpt = Excerpt::new(report, first.at, first.span.0, to);
group = group.element(excerpt.snippet(report.text(), &file, &[primary, related], true));
} else {
let excerpt = Excerpt::new(report, primary.at, primary.span.0, primary.span.1);
group = group.element(excerpt.snippet(report.text(), &file, &[primary], true));
if let Some(related) = related {
let other = Excerpt::new(report, related.at, related.span.0, related.span.1);
group = group.element(other.snippet(report.text(), &file, &[related], false));
columns.push(related.at.column);
}
}
let group = group.element(Level::HELP.message(crate::rules::help_uri(rule)));
let frame = renderer.render(&[group]);
let mut columns = columns.into_iter();
let lines: Vec<String> = frame
.split('\n')
.map(|line| match (is_header(line), line.rsplit_once(':')) {
(true, Some((head, _))) => columns
.next()
.map_or_else(|| line.to_owned(), |column| format!("{head}:{column}")),
_ => line.to_owned(),
})
.collect();
lines.join("\n")
}
fn is_header(line: &str) -> bool {
let mut rest = line.trim_start();
while let Some(after) = rest.strip_prefix('\u{1b}') {
rest = after.split_once('m').map_or("", |(_, rest)| rest);
}
rest.starts_with("--> ") || rest.starts_with("::: ")
}
struct Excerpt {
range: Range<usize>,
cut: (bool, bool),
line: usize,
}
impl Excerpt {
fn new(report: &Report<'_>, at: Location, from: usize, to: usize) -> Excerpt {
let text = report.text();
let before = at.column - 1;
let start = text[..from]
.char_indices()
.rev()
.take(before.min(CONTEXT))
.last()
.map_or(from, |(i, _)| i);
let mut end = text.len();
let mut after = 0;
let mut cut_end = false;
for (i, c) in text[from..].char_indices() {
let i = from + i;
if report.ends_line(c) {
end = i;
break;
}
if i >= to {
if after == CONTEXT {
end = i;
cut_end = true;
break;
}
after += 1;
}
}
Excerpt {
range: start..end,
cut: (before > CONTEXT, cut_end),
line: at.line,
}
}
fn snippet<'a>(
&self,
text: &str,
file: &str,
marks: &[Mark<'a>],
problem: bool,
) -> Snippet<'a, Annotation<'a>> {
let mut shown = String::with_capacity(self.range.len() + 6);
if self.cut.0 {
shown.push('…');
}
let mut spans = vec![(usize::MAX, usize::MAX); marks.len()];
let clamp = |offset: usize| offset.clamp(self.range.start, self.range.end);
let place = |spans: &mut [(usize, usize)], offset: usize, len: usize| {
for (span, mark) in spans.iter_mut().zip(marks) {
if clamp(mark.span.0) == offset {
span.0 = len;
}
if clamp(mark.span.1) == offset {
span.1 = len;
}
}
};
for (i, c) in text[self.range.clone()].char_indices() {
place(&mut spans, self.range.start + i, shown.len());
let hides = (c.is_control() && c != '\t') || is_hidden(c);
if hides || (c == '[' && shown.ends_with("##")) {
shown.push('\u{FFFD}');
} else {
shown.push(c);
}
}
place(&mut spans, self.range.end, shown.len());
if self.cut.1 {
shown.push('…');
}
let annotations = spans
.into_iter()
.zip(marks)
.enumerate()
.map(|(n, (span, mark))| {
let kind = if problem && n == 0 {
AnnotationKind::Primary
} else {
AnnotationKind::Context
};
kind.span(span.0..span.1).label(mark.label)
});
Snippet::source(shown)
.path(file.to_owned())
.line_start(self.line)
.annotations(annotations)
}
}
#[cfg(test)]
mod tests {
use annotate_snippets::Renderer;
use jsonvet::{Config, Dialect, Severity, check};
use proptest::prelude::*;
use super::{Mark, one_char, render};
fn frames(text: &str) -> String {
frames_in(text, Dialect::Json5, &Renderer::plain())
}
fn frames_in(text: &str, dialect: Dialect, renderer: &Renderer) -> String {
let report = check(text, &Config::new(dialect));
let mut out = String::new();
for problem in report.problems() {
let primary = Mark {
at: report.location(problem.offset()),
span: (problem.offset(), problem.end()),
label: None,
};
let related = problem.related().map(|related| Mark {
at: report.location(related.offset),
span: one_char(&report, related.offset),
label: Some("here"),
});
let message = problem.to_string();
let rule = problem.rule().id();
let severity = problem.severity();
out += &render(
renderer,
"f",
severity,
rule,
&message,
Some((&report, primary)),
related,
);
out.push('\n');
}
out
}
#[test]
fn a_long_line_is_cut_and_keeps_its_columns() {
let keys: String = (0..60)
.map(|n| format!("k{n}: {n}, "))
.collect::<Vec<_>>()
.concat();
let text = format!("{{k0: 0, {keys}x: True}}");
insta::assert_snapshot!(frames(&text));
let keys = (100..200)
.map(|n| format!("b{n}: 1, "))
.collect::<Vec<_>>()
.concat();
let text = format!("[{}{{a: 1, {keys}a: 2}}]", "1, ".repeat(100));
let frame = frames(&text);
assert!(frame.contains(" --> f:1:1209\n"), "{frame}");
assert!(frame.contains(" ::: f:1:303\n"), "{frame}");
}
#[test]
fn control_characters_and_the_runners_command_form_show_as_replacements() {
insta::assert_snapshot!(frames("[\"##[x\u{202e}\", \u{1b}[2J\u{9b}]"));
}
#[test]
fn a_problem_at_the_end_of_the_file_marks_the_empty_place_there() {
insta::assert_snapshot!(frames("{\"a\": [1,\n"));
}
#[test]
fn headers_name_the_column_jsonvet_counts_past_a_tab_a_crlf_and_multibyte_characters() {
let frame = frames("{\r\n\t\"é中\": 1,\r\n\t\"é中\": 2}\r\n");
assert!(frame.contains(" --> f:3:2\n"), "{frame}");
assert!(frame.contains(" ::: f:2:2\n"), "{frame}");
assert!(!frame.contains('\r'), "{frame}");
insta::assert_snapshot!(frame);
let frame = frames("[\"é中\",\t1 2]");
assert!(frame.contains(" --> f:1:9\n"), "{frame}");
}
#[test]
fn a_line_separator_ends_a_frame_line_only_in_json5() {
let text = "{\"a\": \"x\u{2028}y\", \"a\": 2}\n";
let frame = frames_in(text, Dialect::Jsonc, &Renderer::plain());
assert!(frame.contains(" --> f:1:14\n"), "{frame}");
let line = frame
.lines()
.find(|line| line.starts_with("1 |"))
.expect("the source line");
let caret = frame
.lines()
.skip_while(|l| !l.starts_with("1 |"))
.nth(1)
.expect("the mark");
let start = line.find("\"a\": 2").expect("the second key");
let column = line[..start].chars().count();
assert_eq!(
caret.chars().position(|c| c == '^'),
Some(column),
"{frame}"
);
let frame = frames(text);
assert!(frame.contains(" --> f:2:5\n"), "{frame}");
assert!(frame.contains("2 | y\", \"a\": 2}"), "{frame}");
}
fn soup() -> impl Strategy<Value = String> {
let tokens = prop::sample::select(vec![
"[",
"]",
"{",
"}",
":",
",",
"\"a\"",
"'b'",
"c",
"1",
"True",
"NaN",
"// x\n",
"/*",
"\"",
"\\",
"\n",
"\r\n",
"\r",
"\t",
" ",
"\u{2028}",
"\u{2029}",
"é",
"中",
"😀",
"\u{1b}",
"\u{202e}",
"##[",
"{\"a\":1,\"a\":2}",
]);
let token = prop_oneof![
20 => tokens.prop_map(String::from),
1 => Just("1, ".repeat(100)),
];
prop::collection::vec(token, 0..40).prop_map(|t| t.concat())
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(256))]
#[test]
fn frames_name_each_problem_and_keep_marks_on_their_line(
text in soup(),
dialect in prop::sample::select(Dialect::ALL.to_vec()),
) {
let frame = frames_in(&text, dialect, &Renderer::plain());
let report = check(&text, &Config::new(dialect));
for problem in report.problems() {
let at = report.location(problem.offset());
let header = format!(" --> f:{}:{}\n", at.line, at.column);
prop_assert!(frame.contains(&header), "{header:?} in {frame}");
}
let mut source: Option<&str> = None;
for line in frame.lines() {
let Some((gutter, rest)) = line.split_once("| ").or_else(|| line.split_once('|'))
else {
continue;
};
if gutter.trim().chars().all(|c| c.is_ascii_digit()) && !gutter.trim().is_empty() {
source = Some(rest);
} else if let Some(source) = source {
let marks = rest
.split(|c| !matches!(c, ' ' | '^' | '-'))
.next()
.unwrap_or("")
.trim_end();
let width: usize =
source.chars().map(|c| if matches!(c, '中' | '😀') { 2 } else { 1 }).sum();
prop_assert!(
marks.chars().count() <= width + 1,
"{marks:?} under {source:?} in {frame}"
);
}
}
}
}
#[test]
fn one_char_spans_the_character_at_an_offset_and_nothing_at_a_line_break() {
let at = |text, dialect, offset| one_char(&check(text, &Config::new(dialect)), offset);
assert_eq!(at("aé", Dialect::Jsonc, 0), (0, 1));
assert_eq!(at("aé", Dialect::Jsonc, 1), (1, 3));
assert_eq!(at("aé", Dialect::Jsonc, 3), (3, 3));
assert_eq!(at("a\nb", Dialect::Jsonc, 1), (1, 1));
assert_eq!(at("a\rb", Dialect::Jsonc, 1), (1, 1));
assert_eq!(at("a\u{2028}b", Dialect::Json5, 1), (1, 1));
assert_eq!(at("a\u{2028}b", Dialect::Jsonc, 1), (1, 4));
}
#[test]
fn a_close_related_place_before_the_problem_keeps_its_own_context() {
let text = format!("[{}{{a: 1, a: 2}}]", "1, ".repeat(100));
let frame = frames_in(&text, Dialect::Json5, &Renderer::plain().term_width(1000));
let related = text.find("a: 1").expect("the first key");
let shown = &text[related - super::CONTEXT..];
assert!(frame.contains(&format!("1 | …{shown}\n")), "{frame}");
}
#[test]
fn a_file_name_like_a_position_keeps_its_name() {
let text = format!("[{}True]", "1, ".repeat(100));
let report = check(&text, &Config::new(Dialect::Json5));
let problem = &report.problems()[0];
let mark = Mark {
at: report.location(problem.offset()),
span: (problem.offset(), problem.end()),
label: None,
};
let frame = render(
&Renderer::plain(),
"a:1:162.json",
problem.severity(),
problem.rule().id(),
"m",
Some((&report, mark)),
None,
);
assert!(frame.contains(" --> a:1:162.json:1:302\n"), "{frame}");
}
#[test]
fn a_file_that_cannot_be_read_names_only_the_file() {
let frame = render(
&Renderer::plain(),
"gone.json",
Severity::Error,
"unreadable",
"no such file",
None,
None,
);
assert_eq!(frame, "error: no such file\n--> gone.json");
}
#[test]
fn a_frame_ends_with_a_help_line_naming_the_rules_docs() {
let frame = frames("[1 2]");
assert!(
frame.ends_with(
"\n = help: https://simonvanlierde.com/jsonvet/docs/usage.html#syntax\n"
),
"{frame}"
);
}
}