use std::cmp::Ordering;
use outlint_core::{
BlockKind, BlockMatcher, ContentMatcher, Diagnostic, DiagnosticReference, DiagnosticTarget,
FrontmatterScalar, InvalidSchema, ListKind, LoadedSchema, Matcher, RefAnchor, SchemaError,
SchemaLocations, SchemaNode, SchemaSources, SourceRange,
};
use serde_json::Number;
#[derive(Debug)]
pub(crate) struct InvocationOutput {
pub(crate) results: Vec<ValidationResult>,
pub(crate) operational_errors: Vec<String>,
}
#[derive(Debug)]
pub(crate) struct ValidationResult {
pub(crate) kind: ResultKind,
pub(crate) path: String,
pub(crate) schema: String,
pub(crate) diagnostics: Vec<RenderedDiagnostic>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ResultKind {
Document,
Schema,
}
#[derive(Debug)]
pub(crate) struct RenderedDiagnostic {
pub(crate) id: String,
pub(crate) message: String,
pub(crate) source_path: String,
pub(crate) line: u64,
pub(crate) column: u64,
pub(crate) target: Option<RenderedTarget>,
pub(crate) schema_node: Option<RenderedSchemaNode>,
pub(crate) schema_location: Option<RenderedLocation>,
pub(crate) involved_headers: Vec<RenderedInvolvedHeader>,
pub(crate) references: Vec<RenderedReference>,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedTarget {
Header {
path: Vec<String>,
},
MissingHeader {
parent: Vec<String>,
matcher: String,
},
Document,
Frontmatter {
line_range: Option<RenderedLineRange>,
pointer: Option<String>,
},
Block {
parent: Vec<String>,
block: String,
index: usize,
},
MissingBlock {
parent: Vec<String>,
matcher: RenderedContentMatcher,
},
Item {
list: RenderedListAddress,
index: usize,
},
MissingItem {
list: RenderedListAddress,
matcher: String,
},
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RenderedListAddress {
pub(crate) parent: Vec<String>,
pub(crate) index: usize,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedContentMatcher {
Block(RenderedBlockMatcher),
OneOf(Vec<RenderedBlockMatcher>),
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RenderedBlockMatcher {
pub(crate) block: String,
pub(crate) list_kind: Option<String>,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RenderedLineRange {
pub(crate) start_line: u64,
pub(crate) end_line: u64,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RenderedLocation {
pub(crate) path: String,
pub(crate) line: u64,
pub(crate) column: u64,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedSchemaNode {
Title,
Frontmatter,
FrontmatterSchemaDeclaration,
FrontmatterSchemaDocument,
Rule {
scope: Vec<usize>,
index: usize,
},
Guard {
scope: Vec<usize>,
index: usize,
},
Capture {
scope: Vec<usize>,
index: usize,
name: String,
},
FrontmatterCapture {
name: String,
},
OrderEntry {
scope: Vec<usize>,
index: usize,
order_index: usize,
},
Constraint {
scope: Vec<usize>,
index: usize,
},
ContentRule {
owner: RenderedContentOwner,
index: usize,
},
ItemRule {
content: RenderedContentRulePath,
index: usize,
},
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedContentOwner {
Document,
Title,
Rule { scope: Vec<usize>, index: usize },
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RenderedContentRulePath {
pub(crate) owner: RenderedContentOwner,
pub(crate) index: usize,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RenderedInvolvedHeader {
pub(crate) header_path: Vec<String>,
pub(crate) line: u64,
pub(crate) column: u64,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedReference {
Rule {
locator: String,
anchor: &'static str,
path: Vec<String>,
positions: Option<Vec<Option<RenderedPosition>>>,
matcher: RenderedMatcher,
},
FrontmatterQuery {
locator: String,
query: String,
equals: Option<RenderedScalar>,
},
FrontmatterCapture {
locator: String,
name: String,
value_type: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct RenderedPosition(Number);
impl RenderedPosition {
pub(crate) fn from_canonical_digits(digits: String) -> Self {
Self(Number::from_string_unchecked(digits))
}
pub(crate) fn as_number(&self) -> &Number {
&self.0
}
fn digits(&self) -> &str {
self.0.as_str()
}
}
impl Ord for RenderedPosition {
fn cmp(&self, other: &Self) -> Ordering {
let (left, right) = (self.digits(), other.digits());
left.len()
.cmp(&right.len())
.then_with(|| left.as_bytes().cmp(right.as_bytes()))
}
}
impl PartialOrd for RenderedPosition {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedMatcher {
Exact(String),
Glob(String),
Regex(String),
Any,
Unknown,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum RenderedScalar {
Null,
Boolean(bool),
Integer(String),
Float(String),
String(String),
}
pub(crate) fn render_schema_errors(
invalid: &InvalidSchema,
fallback_path: &str,
) -> Vec<RenderedDiagnostic> {
invalid
.errors
.iter()
.map(|error| render_schema_error(error, &invalid.sources, fallback_path))
.collect()
}
fn render_schema_error(
error: &SchemaError,
sources: &SchemaSources,
fallback_path: &str,
) -> RenderedDiagnostic {
let location = source_location(sources, error.range, fallback_path);
RenderedDiagnostic {
id: error.kind.as_str().to_owned(),
message: error.message.clone(),
source_path: location.path.clone(),
line: location.line,
column: location.column,
target: None,
schema_node: None,
schema_location: Some(location),
involved_headers: Vec::new(),
references: Vec::new(),
}
}
pub(crate) fn render_document_diagnostic(
document_path: &str,
diagnostic: &Diagnostic,
loaded: &LoadedSchema,
) -> RenderedDiagnostic {
let schema_location = diagnostic.schema_node.as_ref().and_then(|node| {
schema_node_location(node, &loaded.locations)
.map(|range| source_location(&loaded.sources, range, "<schema>"))
});
RenderedDiagnostic {
id: diagnostic.id.as_str().to_owned(),
message: diagnostic.message.clone(),
source_path: document_path.to_owned(),
line: diagnostic.location.line,
column: diagnostic.location.column,
target: Some(render_target(&diagnostic.target)),
schema_node: diagnostic.schema_node.as_ref().map(render_schema_node),
schema_location,
involved_headers: diagnostic
.involved_headers
.iter()
.map(|header| RenderedInvolvedHeader {
header_path: header.path.0.clone(),
line: header.location.line,
column: header.location.column,
})
.collect(),
references: diagnostic.references.iter().map(render_reference).collect(),
}
}
fn render_target(target: &DiagnosticTarget) -> RenderedTarget {
match target {
DiagnosticTarget::Header(path) => RenderedTarget::Header {
path: path.0.clone(),
},
DiagnosticTarget::MissingHeader { parent, matcher } => RenderedTarget::MissingHeader {
parent: parent.0.clone(),
matcher: matcher.clone(),
},
DiagnosticTarget::Document => RenderedTarget::Document,
DiagnosticTarget::Frontmatter { block } => RenderedTarget::Frontmatter {
line_range: block.as_ref().map(|block| RenderedLineRange {
start_line: block.line_range.start_line,
end_line: block.line_range.end_line,
}),
pointer: block.as_ref().and_then(|block| block.json_pointer.clone()),
},
DiagnosticTarget::Block {
parent,
block,
index,
} => RenderedTarget::Block {
parent: parent.0.clone(),
block: render_block_kind(*block).to_owned(),
index: *index,
},
DiagnosticTarget::MissingBlock { parent, matcher } => RenderedTarget::MissingBlock {
parent: parent.0.clone(),
matcher: render_content_matcher(matcher),
},
DiagnosticTarget::Item { list, index } => RenderedTarget::Item {
list: RenderedListAddress {
parent: list.parent.0.clone(),
index: list.index,
},
index: *index,
},
DiagnosticTarget::MissingItem { list, matcher } => RenderedTarget::MissingItem {
list: RenderedListAddress {
parent: list.parent.0.clone(),
index: list.index,
},
matcher: matcher.clone(),
},
}
}
fn render_content_matcher(matcher: &ContentMatcher) -> RenderedContentMatcher {
match matcher {
ContentMatcher::Block(matcher) => {
RenderedContentMatcher::Block(render_block_matcher(matcher))
}
ContentMatcher::OneOf(alternatives) => {
RenderedContentMatcher::OneOf(alternatives.iter().map(render_block_matcher).collect())
}
}
}
fn render_block_matcher(matcher: &BlockMatcher) -> RenderedBlockMatcher {
match matcher {
BlockMatcher::Paragraph => RenderedBlockMatcher {
block: "p".to_owned(),
list_kind: None,
},
BlockMatcher::List { list_kind } => RenderedBlockMatcher {
block: "list".to_owned(),
list_kind: list_kind.map(render_list_kind).map(ToOwned::to_owned),
},
BlockMatcher::Any => RenderedBlockMatcher {
block: "any".to_owned(),
list_kind: None,
},
}
}
fn render_block_kind(kind: BlockKind) -> &'static str {
match kind {
BlockKind::Paragraph => "p",
BlockKind::List => "list",
BlockKind::Quote => "quote",
BlockKind::Code => "code",
BlockKind::Html => "html",
BlockKind::Break => "break",
}
}
fn render_list_kind(kind: ListKind) -> &'static str {
match kind {
ListKind::Bullet => "bullet",
ListKind::Ordered => "ordered",
}
}
fn render_schema_node(node: &SchemaNode) -> RenderedSchemaNode {
match node {
SchemaNode::Title => RenderedSchemaNode::Title,
SchemaNode::Frontmatter => RenderedSchemaNode::Frontmatter,
SchemaNode::FrontmatterSchemaDeclaration => {
RenderedSchemaNode::FrontmatterSchemaDeclaration
}
SchemaNode::FrontmatterSchemaDocument => RenderedSchemaNode::FrontmatterSchemaDocument,
SchemaNode::Rule(path) => RenderedSchemaNode::Rule {
scope: path.scope.0.iter().map(|index| index.0).collect(),
index: path.index.0,
},
SchemaNode::Guard(path) => RenderedSchemaNode::Guard {
scope: path.scope.0.iter().map(|index| index.0).collect(),
index: path.index.0,
},
SchemaNode::Capture(path) => RenderedSchemaNode::Capture {
scope: path.rule.scope.0.iter().map(|index| index.0).collect(),
index: path.rule.index.0,
name: path.name.as_str().to_owned(),
},
SchemaNode::FrontmatterCapture(name) => RenderedSchemaNode::FrontmatterCapture {
name: name.as_str().to_owned(),
},
SchemaNode::OrderEntry(path) => RenderedSchemaNode::OrderEntry {
scope: path.rule.scope.0.iter().map(|index| index.0).collect(),
index: path.rule.index.0,
order_index: path.order_index.0,
},
SchemaNode::Constraint(path) => RenderedSchemaNode::Constraint {
scope: path.scope.0.iter().map(|index| index.0).collect(),
index: path.index.0,
},
SchemaNode::ContentRule(path) => RenderedSchemaNode::ContentRule {
owner: render_content_owner(&path.owner),
index: path.index.0,
},
SchemaNode::ItemRule(path) => RenderedSchemaNode::ItemRule {
content: RenderedContentRulePath {
owner: render_content_owner(&path.content.owner),
index: path.content.index.0,
},
index: path.index.0,
},
}
}
fn render_content_owner(owner: &outlint_core::ContentOwner) -> RenderedContentOwner {
match owner {
outlint_core::ContentOwner::Document => RenderedContentOwner::Document,
outlint_core::ContentOwner::Title => RenderedContentOwner::Title,
outlint_core::ContentOwner::Rule(path) => RenderedContentOwner::Rule {
scope: path.scope.0.iter().map(|index| index.0).collect(),
index: path.index.0,
},
}
}
fn render_reference(reference: &DiagnosticReference) -> RenderedReference {
match reference {
DiagnosticReference::Rule { locator, matcher } => {
let steps = locator.steps().iter().collect::<Vec<_>>();
let positions = steps
.iter()
.map(|step| {
step.position_digits()
.map(RenderedPosition::from_canonical_digits)
})
.collect::<Vec<_>>();
RenderedReference::Rule {
locator: locator.locator().to_owned(),
anchor: render_anchor(locator.anchor()),
path: steps
.iter()
.map(|step| step.id().as_str().to_owned())
.collect(),
positions: positions.iter().any(Option::is_some).then_some(positions),
matcher: render_matcher(matcher),
}
}
DiagnosticReference::FrontmatterQuery(reference) => RenderedReference::FrontmatterQuery {
locator: reference.locator().to_owned(),
query: reference.query().to_owned(),
equals: reference.equals().map(render_scalar),
},
DiagnosticReference::FrontmatterCapture(reference) => {
RenderedReference::FrontmatterCapture {
locator: reference.locator().to_owned(),
name: reference.name().as_str().to_owned(),
value_type: reference.type_name().to_owned(),
}
}
}
}
fn render_anchor(anchor: RefAnchor) -> &'static str {
match anchor {
RefAnchor::CurrentScope => "current_scope",
RefAnchor::SchemaRoot => "schema_root",
}
}
fn render_matcher(matcher: &Matcher) -> RenderedMatcher {
match matcher {
Matcher::Exact(value) => RenderedMatcher::Exact(value.0.clone()),
Matcher::Glob(value) => RenderedMatcher::Glob(value.as_str().to_owned()),
Matcher::Regex(value) => RenderedMatcher::Regex(value.as_str().to_owned()),
Matcher::Any => RenderedMatcher::Any,
_ => RenderedMatcher::Unknown,
}
}
fn render_scalar(scalar: &FrontmatterScalar) -> RenderedScalar {
match scalar {
FrontmatterScalar::Null => RenderedScalar::Null,
FrontmatterScalar::Boolean(value) => RenderedScalar::Boolean(*value),
FrontmatterScalar::Integer(value) => RenderedScalar::Integer(value.as_str().to_owned()),
FrontmatterScalar::Float(value) => RenderedScalar::Float(value.as_str().to_owned()),
FrontmatterScalar::String(value) => RenderedScalar::String(value.clone()),
}
}
fn schema_node_location(node: &SchemaNode, locations: &SchemaLocations) -> Option<SourceRange> {
locations.nodes.get(node).copied()
}
fn source_location(
sources: &SchemaSources,
range: SourceRange,
fallback_path: &str,
) -> RenderedLocation {
let Some(source) = sources.documents.get(&range.source) else {
return RenderedLocation {
path: fallback_path.to_owned(),
line: 1,
column: 1,
};
};
let path = source
.label
.as_ref()
.map_or_else(|| fallback_path.to_owned(), |label| label.0.clone());
let (line, column) = line_column(&source.text, range.range.start.0);
RenderedLocation { path, line, column }
}
fn line_column(source: &str, byte_offset: usize) -> (u64, u64) {
let offset = byte_offset.min(source.len());
let bytes = source.as_bytes();
let mut index = 0;
let mut line = 1_u64;
let mut line_start = 0;
while index < offset {
match bytes.get(index).copied() {
Some(b'\r') => {
let next = index.saturating_add(1);
let terminator_width =
usize::from(next < offset && bytes.get(next).copied() == Some(b'\n')) + 1;
index = index.saturating_add(terminator_width).min(offset);
line = line.saturating_add(1);
line_start = index;
}
Some(b'\n') => {
index = index.saturating_add(1);
line = line.saturating_add(1);
line_start = index;
}
Some(_) => index = index.saturating_add(1),
None => break,
}
}
let column =
u64::try_from(offset.saturating_sub(line_start).saturating_add(1)).unwrap_or(u64::MAX);
(line, column)
}
type DiagnosticSortKey<'a> = (
u64,
u64,
&'a str,
Option<&'a RenderedLocation>,
Option<&'a RenderedTarget>,
&'a str,
Option<&'a RenderedSchemaNode>,
&'a [RenderedInvolvedHeader],
&'a [RenderedReference],
&'a str,
);
fn diagnostic_sort_key(diagnostic: &RenderedDiagnostic) -> DiagnosticSortKey<'_> {
(
diagnostic.line,
diagnostic.column,
diagnostic.id.as_str(),
diagnostic.schema_location.as_ref(),
diagnostic.target.as_ref(),
diagnostic.message.as_str(),
diagnostic.schema_node.as_ref(),
&diagnostic.involved_headers,
&diagnostic.references,
diagnostic.source_path.as_str(),
)
}
pub(crate) fn sort_diagnostics(diagnostics: &mut [RenderedDiagnostic]) {
diagnostics.sort_by(|left, right| diagnostic_sort_key(left).cmp(&diagnostic_sort_key(right)));
}
#[cfg(test)]
mod tests {
use std::fmt::Debug;
use super::{
diagnostic_sort_key, line_column, sort_diagnostics, RenderedBlockMatcher,
RenderedContentMatcher, RenderedContentOwner, RenderedContentRulePath, RenderedDiagnostic,
RenderedInvolvedHeader, RenderedLineRange, RenderedListAddress, RenderedLocation,
RenderedMatcher, RenderedPosition, RenderedReference, RenderedScalar, RenderedSchemaNode,
RenderedTarget,
};
fn assert_ascending<T: Ord + Debug>(what: &str, chain: &[T]) {
for pair in chain.windows(2) {
assert!(pair[0] < pair[1], "{what} out of §11.4 order: {pair:#?}");
}
}
fn position(digits: &str) -> RenderedPosition {
RenderedPosition::from_canonical_digits(digits.to_owned())
}
#[test]
fn positions_compare_as_integers_and_not_as_decimal_text() {
assert_ascending(
"positions",
&[
position("0"),
position("2"),
position("9"),
position("10"),
position("11"),
position("100"),
position("18446744073709551615"),
position("18446744073709551616"),
position("340282366920938463463374607431768211456"),
],
);
assert!(position("2") < position("10"));
assert!(position("10") < position("340282366920938463463374607431768211456"));
}
#[test]
fn target_variants_and_members_follow_the_section_6_1_order() {
let frontmatter = |line_range, pointer: Option<&str>| RenderedTarget::Frontmatter {
line_range,
pointer: pointer.map(ToOwned::to_owned),
};
let range = |start_line, end_line| {
Some(RenderedLineRange {
start_line,
end_line,
})
};
assert_ascending(
"target kinds and members",
&[
RenderedTarget::Header {
path: vec!["Alpha".into()],
},
RenderedTarget::Header {
path: vec!["Alpha".into(), "Beta".into()],
},
RenderedTarget::Header {
path: vec!["Beta".into()],
},
RenderedTarget::MissingHeader {
parent: Vec::new(),
matcher: "Zeta".into(),
},
RenderedTarget::MissingHeader {
parent: vec!["Alpha".into()],
matcher: "Alpha".into(),
},
RenderedTarget::MissingHeader {
parent: vec!["Alpha".into()],
matcher: "Beta".into(),
},
RenderedTarget::Document,
frontmatter(None, None),
frontmatter(range(1, 3), None),
frontmatter(range(1, 3), Some("")),
frontmatter(range(1, 3), Some("/a")),
frontmatter(range(1, 4), Some("/a")),
frontmatter(range(2, 3), Some("/a")),
RenderedTarget::Block {
parent: Vec::new(),
block: "p".into(),
index: 0,
},
RenderedTarget::MissingBlock {
parent: Vec::new(),
matcher: RenderedContentMatcher::Block(RenderedBlockMatcher {
block: "p".into(),
list_kind: None,
}),
},
RenderedTarget::Item {
list: RenderedListAddress {
parent: Vec::new(),
index: 0,
},
index: 0,
},
RenderedTarget::MissingItem {
list: RenderedListAddress {
parent: Vec::new(),
index: 0,
},
matcher: "A".into(),
},
],
);
}
#[test]
fn preamble_items_total_order_covers_every_new_variant() {
let block = |value: &str, list_kind: Option<&str>| RenderedBlockMatcher {
block: value.into(),
list_kind: list_kind.map(ToOwned::to_owned),
};
assert_ascending(
"structured content matchers",
&[
RenderedContentMatcher::Block(block("list", None)),
RenderedContentMatcher::Block(block("list", Some("bullet"))),
RenderedContentMatcher::Block(block("list", Some("ordered"))),
RenderedContentMatcher::Block(block("p", None)),
RenderedContentMatcher::OneOf(vec![block("list", None), block("p", None)]),
RenderedContentMatcher::OneOf(vec![block("list", None), block("quote", None)]),
],
);
assert_ascending(
"list addresses and item indices",
&[
RenderedTarget::Item {
list: RenderedListAddress {
parent: vec!["A".into()],
index: 9,
},
index: 99,
},
RenderedTarget::Item {
list: RenderedListAddress {
parent: vec!["B".into()],
index: 1,
},
index: 0,
},
RenderedTarget::Item {
list: RenderedListAddress {
parent: vec!["B".into()],
index: 2,
},
index: 0,
},
RenderedTarget::Item {
list: RenderedListAddress {
parent: vec!["B".into()],
index: 2,
},
index: 1,
},
],
);
assert_ascending(
"content owner and appended schema nodes",
&[
RenderedSchemaNode::ContentRule {
owner: RenderedContentOwner::Document,
index: 9,
},
RenderedSchemaNode::ContentRule {
owner: RenderedContentOwner::Title,
index: 0,
},
RenderedSchemaNode::ContentRule {
owner: RenderedContentOwner::Rule {
scope: vec![0],
index: 1,
},
index: 0,
},
RenderedSchemaNode::ItemRule {
content: RenderedContentRulePath {
owner: RenderedContentOwner::Document,
index: 0,
},
index: 0,
},
],
);
assert!("z".as_bytes() < "Ã¥".as_bytes());
assert!(
RenderedTarget::Block {
parent: vec!["z".into()],
block: "p".into(),
index: usize::MAX,
} < RenderedTarget::Block {
parent: vec!["Ã¥".into()],
block: "a".into(),
index: 0,
}
);
}
#[test]
fn schema_node_variants_are_ordered_as_the_json_contract_lists_them() {
let scope = || vec![1_usize];
assert_ascending(
"schema node kinds",
&[
RenderedSchemaNode::Title,
RenderedSchemaNode::Frontmatter,
RenderedSchemaNode::FrontmatterSchemaDeclaration,
RenderedSchemaNode::FrontmatterSchemaDocument,
RenderedSchemaNode::Rule {
scope: scope(),
index: 1,
},
RenderedSchemaNode::Guard {
scope: scope(),
index: 1,
},
RenderedSchemaNode::Capture {
scope: scope(),
index: 1,
name: "version".into(),
},
RenderedSchemaNode::FrontmatterCapture {
name: "version".into(),
},
RenderedSchemaNode::OrderEntry {
scope: scope(),
index: 1,
order_index: 0,
},
RenderedSchemaNode::Constraint {
scope: scope(),
index: 1,
},
RenderedSchemaNode::ContentRule {
owner: RenderedContentOwner::Document,
index: 0,
},
RenderedSchemaNode::ItemRule {
content: RenderedContentRulePath {
owner: RenderedContentOwner::Document,
index: 0,
},
index: 0,
},
],
);
assert_ascending(
"rule coordinates",
&[
RenderedSchemaNode::Rule {
scope: vec![0],
index: 9,
},
RenderedSchemaNode::Rule {
scope: vec![1],
index: 0,
},
RenderedSchemaNode::Rule {
scope: vec![1],
index: 1,
},
RenderedSchemaNode::Rule {
scope: vec![1, 0],
index: 0,
},
],
);
assert_ascending(
"guard coordinates",
&[
RenderedSchemaNode::Guard {
scope: vec![0],
index: 9,
},
RenderedSchemaNode::Guard {
scope: vec![1],
index: 0,
},
RenderedSchemaNode::Guard {
scope: vec![1],
index: 1,
},
],
);
assert_ascending(
"capture coordinates then name",
&[
RenderedSchemaNode::Capture {
scope: scope(),
index: 0,
name: "zeta".into(),
},
RenderedSchemaNode::Capture {
scope: scope(),
index: 1,
name: "alpha".into(),
},
RenderedSchemaNode::Capture {
scope: scope(),
index: 1,
name: "beta".into(),
},
],
);
assert_ascending(
"order-entry coordinates then order index",
&[
RenderedSchemaNode::OrderEntry {
scope: scope(),
index: 0,
order_index: 9,
},
RenderedSchemaNode::OrderEntry {
scope: scope(),
index: 1,
order_index: 0,
},
RenderedSchemaNode::OrderEntry {
scope: scope(),
index: 1,
order_index: 1,
},
],
);
}
#[test]
fn reference_variants_follow_the_declaration_order_of_section_11_3() {
let rule =
|locator: &str, anchor, path: &[&str], positions, matcher| RenderedReference::Rule {
locator: locator.to_owned(),
anchor,
path: path.iter().map(|step| (*step).to_owned()).collect(),
positions,
matcher,
};
assert_ascending(
"reference kinds",
&[
rule("a", "current_scope", &["a"], None, RenderedMatcher::Any),
RenderedReference::FrontmatterQuery {
locator: "fm[$.a]".into(),
query: "$.a".into(),
equals: None,
},
RenderedReference::FrontmatterCapture {
locator: "fm.a".into(),
name: "a".into(),
value_type: "text".into(),
},
],
);
assert_ascending(
"rule members in declaration order",
&[
rule("a", "schema_root", &["z"], None, RenderedMatcher::Any),
rule("b", "current_scope", &["a"], None, RenderedMatcher::Any),
rule("b", "schema_root", &["a"], None, RenderedMatcher::Any),
rule("b", "schema_root", &["b"], None, RenderedMatcher::Any),
rule(
"b",
"schema_root",
&["b"],
Some(vec![None]),
RenderedMatcher::Any,
),
rule(
"b",
"schema_root",
&["b"],
Some(vec![Some(position("2"))]),
RenderedMatcher::Any,
),
rule(
"b",
"schema_root",
&["b"],
Some(vec![Some(position("10"))]),
RenderedMatcher::Exact("A".into()),
),
rule(
"b",
"schema_root",
&["b"],
Some(vec![Some(position("10"))]),
RenderedMatcher::Any,
),
],
);
assert_ascending(
"frontmatter query members in declaration order",
&[
RenderedReference::FrontmatterQuery {
locator: "fm[$.a]".into(),
query: "$.z".into(),
equals: None,
},
RenderedReference::FrontmatterQuery {
locator: "fm[$.b]".into(),
query: "$.a".into(),
equals: None,
},
RenderedReference::FrontmatterQuery {
locator: "fm[$.b]".into(),
query: "$.b".into(),
equals: None,
},
RenderedReference::FrontmatterQuery {
locator: "fm[$.b]".into(),
query: "$.b".into(),
equals: Some(RenderedScalar::Null),
},
],
);
assert_ascending(
"frontmatter capture members in declaration order",
&[
RenderedReference::FrontmatterCapture {
locator: "fm.a".into(),
name: "z".into(),
value_type: "text".into(),
},
RenderedReference::FrontmatterCapture {
locator: "fm.b".into(),
name: "a".into(),
value_type: "text".into(),
},
RenderedReference::FrontmatterCapture {
locator: "fm.b".into(),
name: "b".into(),
value_type: "date".into(),
},
RenderedReference::FrontmatterCapture {
locator: "fm.b".into(),
name: "b".into(),
value_type: "int".into(),
},
],
);
}
#[test]
fn matcher_and_equality_variants_compare_by_kind_before_value() {
assert_ascending(
"matcher kinds then values",
&[
RenderedMatcher::Exact("A".into()),
RenderedMatcher::Exact("B".into()),
RenderedMatcher::Glob("A *".into()),
RenderedMatcher::Regex("A.+".into()),
RenderedMatcher::Any,
],
);
assert_ascending(
"equality types then values",
&[
RenderedScalar::Null,
RenderedScalar::Boolean(false),
RenderedScalar::Boolean(true),
RenderedScalar::Integer("16".into()),
RenderedScalar::Integer("2".into()),
RenderedScalar::Float("15e-1".into()),
RenderedScalar::String("release".into()),
],
);
}
type Tier = (&'static str, fn(&mut RenderedDiagnostic, bool));
const TIERS: [Tier; 10] = [
("source line", |d, low| d.line = if low { 1 } else { 2 }),
("byte column", |d, low| d.column = if low { 1 } else { 2 }),
("diagnostic id", |d, low| {
d.id = if low { "a" } else { "z" }.into();
}),
("schema location", |d, low| {
d.schema_location = (!low).then(|| RenderedLocation {
path: "schema.yml".into(),
line: 1,
column: 1,
});
}),
("target", |d, low| {
d.target = (!low).then_some(RenderedTarget::Document);
}),
("message", |d, low| {
d.message = if low { "a" } else { "z" }.into();
}),
("schema node", |d, low| {
d.schema_node = (!low).then_some(RenderedSchemaNode::Title);
}),
("involved headers", |d, low| {
d.involved_headers = if low {
Vec::new()
} else {
vec![RenderedInvolvedHeader {
header_path: vec!["Alpha".into()],
line: 1,
column: 1,
}]
};
}),
("references", |d, low| {
d.references = if low {
Vec::new()
} else {
vec![RenderedReference::FrontmatterCapture {
locator: "fm.a".into(),
name: "a".into(),
value_type: "text".into(),
}]
};
}),
("source path", |d, low| {
d.source_path = if low { "a.md" } else { "z.md" }.into();
}),
];
fn unset_diagnostic() -> RenderedDiagnostic {
RenderedDiagnostic {
id: String::new(),
message: String::new(),
source_path: String::new(),
line: 0,
column: 0,
target: None,
schema_node: None,
schema_location: None,
involved_headers: Vec::new(),
references: Vec::new(),
}
}
#[test]
fn an_earlier_tier_always_outranks_every_later_one() {
for (index, (name, tier)) in TIERS.iter().enumerate() {
let (mut left, mut right) = (unset_diagnostic(), unset_diagnostic());
for (_, earlier) in &TIERS[..index] {
earlier(&mut left, false);
earlier(&mut right, false);
}
tier(&mut left, true);
tier(&mut right, false);
for (_, later) in &TIERS[index + 1..] {
later(&mut left, false);
later(&mut right, true);
}
assert!(
diagnostic_sort_key(&left) < diagnostic_sort_key(&right),
"the `{name}` tier was overruled by a less significant member"
);
let expected = vec![
format!("{:?}", diagnostic_sort_key(&left)),
format!("{:?}", diagnostic_sort_key(&right)),
];
let mut reversed = vec![right, left];
sort_diagnostics(&mut reversed);
assert_eq!(key_strings(&reversed), expected, "`{name}` did not sort");
}
}
#[test]
fn source_positions_are_one_based_byte_columns() {
assert_eq!(line_column("one\nåx", 6), (2, 3));
assert_eq!(line_column("one\råx", 6), (2, 3));
assert_eq!(line_column("one\r\n😀x", 9), (2, 5));
}
fn key_tied_diagnostic(
target: Option<RenderedTarget>,
message: &str,
references: Vec<RenderedReference>,
) -> RenderedDiagnostic {
RenderedDiagnostic {
id: "too-few-sections".into(),
message: message.into(),
source_path: "document.md".into(),
line: 3,
column: 1,
target,
schema_node: None,
schema_location: Some(RenderedLocation {
path: "schema.outlint.yml".into(),
line: 2,
column: 5,
}),
involved_headers: Vec::new(),
references,
}
}
fn key_tied_fixture() -> Vec<RenderedDiagnostic> {
let frontmatter = |pointer: &str| RenderedTarget::Frontmatter {
line_range: Some(RenderedLineRange {
start_line: 1,
end_line: 3,
}),
pointer: Some(pointer.into()),
};
vec![
key_tied_diagnostic(
Some(RenderedTarget::Header {
path: vec!["Alpha".into()],
}),
"m",
Vec::new(),
),
key_tied_diagnostic(
Some(RenderedTarget::Header {
path: vec!["Alpha".into(), "Beta".into()],
}),
"m",
Vec::new(),
),
key_tied_diagnostic(
Some(RenderedTarget::MissingHeader {
parent: Vec::new(),
matcher: "Step *".into(),
}),
"m",
Vec::new(),
),
key_tied_diagnostic(Some(RenderedTarget::Document), "matched 0", Vec::new()),
key_tied_diagnostic(Some(RenderedTarget::Document), "matched 1", Vec::new()),
key_tied_diagnostic(Some(frontmatter("/a")), "m", Vec::new()),
key_tied_diagnostic(Some(frontmatter("/b")), "m", Vec::new()),
key_tied_diagnostic(
Some(frontmatter("/b")),
"m",
vec![RenderedReference::Rule {
locator: "a".into(),
anchor: "current_scope",
path: vec!["a".into()],
positions: None,
matcher: RenderedMatcher::Exact("A".into()),
}],
),
]
}
fn key_strings(diagnostics: &[RenderedDiagnostic]) -> Vec<String> {
diagnostics
.iter()
.map(|diagnostic| format!("{:?}", diagnostic_sort_key(diagnostic)))
.collect()
}
#[test]
fn diagnostics_tied_on_the_old_key_sort_into_the_json_total_order() {
let canonical = key_tied_fixture();
for pair in canonical.windows(2) {
assert!(
diagnostic_sort_key(&pair[0]) < diagnostic_sort_key(&pair[1]),
"fixture entries compare equal or reversed: {pair:#?}"
);
}
let mut reversed = key_tied_fixture();
reversed.reverse();
sort_diagnostics(&mut reversed);
assert_eq!(key_strings(&reversed), key_strings(&canonical));
}
#[test]
fn every_emission_order_sorts_to_the_same_sequence() {
let size = key_tied_fixture().len();
let mut indices = (0..size).collect::<Vec<_>>();
let mut permutations = Vec::new();
heap_permutations(&mut indices, size, &mut permutations);
for permutation in permutations {
let mut slots = key_tied_fixture().into_iter().map(Some).collect::<Vec<_>>();
let mut shuffled = permutation
.iter()
.map(|&index| slots[index].take().expect("each index appears once"))
.collect::<Vec<_>>();
sort_diagnostics(&mut shuffled);
for pair in shuffled.windows(2) {
assert!(
diagnostic_sort_key(&pair[0]) < diagnostic_sort_key(&pair[1]),
"permutation {permutation:?} did not sort strictly"
);
}
}
}
fn heap_permutations(indices: &mut Vec<usize>, size: usize, output: &mut Vec<Vec<usize>>) {
if size <= 1 {
output.push(indices.clone());
return;
}
for step in 0..size {
heap_permutations(indices, size - 1, output);
let last = size - 1;
if size.is_multiple_of(2) {
indices.swap(step, last);
} else {
indices.swap(0, last);
}
}
}
}