use crate::charset::{CharRange, CharSet};
use crate::lint::{Level, Lint};
#[cfg(test)]
use crate::render::Violation;
use crate::render::escape::string;
use crate::render::group::Fold;
use crate::render::line::{Line, Spelled};
use crate::render::name::{Codepoint, codepoint, level_name, method_name};
use crate::render::order;
use crate::render::total::{self, Total};
use crate::render::value::{
Fields, array, field, list, number, object, optional,
};
use crate::render::{Change, Explanation, FileStats, InForce, Skipped};
use crate::rules::{LevelChoice, Origin, Rule, Sourced};
use crate::scan::{Hit, Unreadable};
use crate::tokens::Count;
use std::borrow::Cow;
use std::path::Path;
const VIOLATION_BYTES: usize = 200;
pub(super) const SCHEMA: u32 = 1;
pub(super) fn error(verb: &str, message: &str) -> String {
let mut out = String::new();
let mut doc = Fields::open(&mut out);
doc.number("schema", SCHEMA);
doc.text("verb", verb);
doc.text("error", message);
doc.close();
out
}
#[cfg(test)]
pub(super) fn check(
items: &[Violation<'_>],
skipped: &[Skipped<'_>],
) -> String {
check_lines(order::lines(items), skipped)
}
pub(super) fn check_lines<'a>(
lines: impl IntoIterator<Item = Line<'a>>,
skipped: &[Skipped<'_>],
) -> String {
let mut out = String::new();
let mut doc = Fields::open(&mut out);
doc.number("schema", SCHEMA);
doc.text("verb", "check");
violations(doc.key("violations"), lines);
doc.raw("skipped", &unread(skipped));
doc.close();
out
}
fn violations<'a>(out: &mut String, lines: impl IntoIterator<Item = Line<'a>>) {
let lines = lines.into_iter();
out.reserve(lines.size_hint().0.saturating_mul(VIOLATION_BYTES));
let mut path = Spelled::new(literal);
list(out, lines, |out, item| {
violation(out, path.of(item.path), item)
});
}
fn literal(path: &str) -> Cow<'_, str> {
Cow::Owned(string(path))
}
fn violation(out: &mut String, path: &str, item: Line<'_>) {
let mut fields = Fields::open(out);
violation_fields(&mut fields, path, item);
fields.close();
}
fn violation_fields(fields: &mut Fields<'_>, path: &str, item: Line<'_>) {
fields.raw("path", path);
hit_fields(fields, item.finding.hit);
let (lint, level) = (item.finding.lint, item.finding.level);
verdict_fields(fields, item.set, lint, level);
let to = item.remedy.and_then(|remedy| remedy.to.as_deref());
let fixable = item.remedy.is_some_and(|remedy| remedy.fixable);
remedy_fields(fields, to, fixable);
}
pub(super) fn summary(groups: &[Fold<'_>], skipped: &[Skipped<'_>]) -> String {
let mut out = String::new();
let mut doc = Fields::open(&mut out);
doc.number("schema", SCHEMA);
doc.text("verb", "check");
let mut path = Spelled::new(literal);
list(doc.key("groups"), groups, |out, group| {
let mut fields = Fields::open(out);
violation_fields(&mut fields, path.of(group.first.path), group.first);
fields.number("count", group.count);
fields.close();
});
doc.raw("skipped", &unread(skipped));
doc.close();
out
}
fn verdict_fields(
fields: &mut Fields<'_>,
set: &str,
lint: Lint,
level: Level,
) {
fields.text("set", set);
fields.text("lint", lint.name);
fields.text("level", level_name(level));
}
fn remedy_fields(fields: &mut Fields<'_>, to: Option<&str>, fixable: bool) {
fields.raw("replacement", &optional(to));
fields.raw("fixable", if fixable { "true" } else { "false" });
}
fn hit_fields(fields: &mut Fields<'_>, hit: Hit) {
fields.number("line", hit.position.line);
fields.number("column", hit.position.column);
fields.number("byte", hit.position.byte);
fields.number(
"codepoint",
format_args!("\"{}\"", Codepoint(hit.character)),
);
let mut buffer = [0_u8; 4];
fields.text("character", hit.character.encode_utf8(&mut buffer));
}
fn unread(items: &[Skipped<'_>]) -> String {
let rendered: Vec<String> =
order::skipped(items).into_iter().map(unread_item).collect();
array(&rendered)
}
fn unread_item(item: &Skipped<'_>) -> String {
let mut fields = vec![field("path", &string(item.path))];
fields.extend(reason_fields(item.reason));
object(&fields)
}
fn reason_fields(reason: Unreadable) -> Vec<String> {
match reason {
Unreadable::NotUtf8 { byte, line, column } => vec![
field("reason", &string("not-utf8")),
field("byte", &number(byte)),
field("line", &number(line)),
field("column", &number(column)),
],
Unreadable::Binary => vec![field("reason", &string("binary"))],
}
}
pub(super) fn fix<'a>(
items: &[Change<'_>],
unmapped: impl IntoIterator<Item = Line<'a>>,
skipped: &[Skipped<'_>],
) -> String {
let mut out = String::new();
let mut doc = Fields::open(&mut out);
doc.number("schema", SCHEMA);
doc.text("verb", "fix");
let mut path = Spelled::new(literal);
let rewrites = order::changes(items);
list(doc.key("rewrites"), rewrites, |out, item| {
change(out, path.of(item.path), item);
});
violations(doc.key("unmapped"), unmapped);
doc.raw("skipped", &unread(skipped));
doc.close();
out
}
fn change(out: &mut String, path: &str, item: &Change<'_>) {
let mut fields = Fields::open(out);
fields.raw("path", path);
hit_fields(&mut fields, item.rewrite.hit);
fields.text("to", &item.rewrite.to);
verdict_fields(&mut fields, item.set, item.lint, item.level);
remedy_fields(&mut fields, Some(&item.rewrite.to), true);
fields.close();
}
pub(super) fn stats(
files: &[FileStats<'_>],
skipped: &[Skipped<'_>],
) -> String {
let rows: Vec<String> = order::stats(files).into_iter().map(row).collect();
object(&[
field("schema", &number(SCHEMA)),
field("verb", &string("stats")),
field("files", &array(&rows)),
field("total", &total::of(files).map_or_else(null, total_row)),
field("skipped", &unread(skipped)),
])
}
fn total_row(sum: Total) -> String {
object(&[
field("files", &number(sum.files)),
field("outside", &number(sum.outside)),
field("bytes", &number(sum.bytes)),
field("tokens_now", &count(sum.now)),
field("tokens_after", &count(sum.after)),
])
}
fn row(item: &FileStats<'_>) -> String {
object(&[
field("path", &string(item.path)),
field("outside", &number(item.outside)),
field("bytes", &number(item.bytes)),
field("tokens_now", &count(item.now)),
field("tokens_after", &count(item.after)),
])
}
fn count(value: Count) -> String {
object(&[
field("tokens", &number(value.tokens)),
field("method", &string(method_name(value.method))),
])
}
pub(super) fn explain(item: &Explanation<'_>) -> String {
object(&[
field("schema", &number(SCHEMA)),
field("verb", &string("explain")),
field("path", &optional(item.path)),
field("set", &char_set(item.set)),
field("rule", &item.rule.map_or_else(null, rule)),
field("effective", &in_force(&item.in_force)),
])
}
fn in_force(item: &InForce<'_>) -> String {
let family = object(&[
field("name", &string(item.family)),
field("origin", &item.family_origin.map_or_else(null, origin)),
]);
let levels: Vec<String> = item.levels.iter().map(sourced_level).collect();
object(&[
field("family", &family),
field(
"default_level",
&item.level.as_ref().map_or_else(null, bare),
),
field("levels", &array(&levels)),
])
}
fn bare(item: &Sourced<'_, Level>) -> String {
object(&[
field("level", &string(level_name(item.value))),
field("origin", &origin(item.origin)),
])
}
fn sourced_level(item: &Sourced<'_, LevelChoice>) -> String {
object(&[
field("target", &string(&item.value.target)),
field("level", &string(level_name(item.value.level))),
field("origin", &origin(item.origin)),
])
}
pub(super) fn sets(items: &[CharSet]) -> String {
let rendered: Vec<String> = items.iter().map(char_set).collect();
object(&[
field("schema", &number(SCHEMA)),
field("verb", &string("sets")),
field("sets", &array(&rendered)),
])
}
fn char_set(item: &CharSet) -> String {
let ranges: Vec<String> = item.ranges.iter().map(range).collect();
object(&[
field("name", &string(&item.name)),
field("ranges", &array(&ranges)),
])
}
fn range(item: &CharRange) -> String {
object(&[
field("start", &string(&codepoint(item.start))),
field("end", &string(&codepoint(item.end))),
])
}
fn null() -> String {
String::from("null")
}
fn rule(item: &Rule) -> String {
let sets: Vec<String> = item.sets.iter().map(|set| string(set)).collect();
let levels: Vec<String> = item.levels.iter().map(level_choice).collect();
let bare = item.default_level;
object(&[
field("pattern", &string(&item.pattern)),
field("sets", &array(&sets)),
field("family", &optional(item.family.as_deref())),
field("levels", &array(&levels)),
field("default_level", &optional(bare.map(level_name))),
field("origin", &origin(&item.origin)),
])
}
fn level_choice(item: &LevelChoice) -> String {
object(&[
field("target", &string(&item.target)),
field("level", &string(level_name(item.level))),
])
}
fn origin(item: &Origin) -> String {
match item {
Origin::File { path, line } => file_origin(path, *line),
Origin::Argument { index } => object(&[
field("kind", &string("argument")),
field("index", &number(*index)),
]),
Origin::Builtin { line } => object(&[
field("kind", &string("builtin")),
field("line", &number(*line)),
]),
}
}
fn file_origin(path: &Path, line: usize) -> String {
object(&[
field("kind", &string("file")),
field("path", &string(&path.to_string_lossy())),
field("line", &number(line)),
])
}
#[cfg(test)]
#[path = "json_test.rs"]
mod tests;