brief-core 0.3.0

Compiler library for the Brief markup language: lexer, parser, AST, HTML/LLM emitters, formatter, and Markdown-to-Brief converter.
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

use crate::ast::{Block, Document};
use crate::diag::{Code, Diagnostic};
use crate::span::{SourceMap, Span};
use std::collections::BTreeMap;

pub struct ValidateOpts {
    pub strict_heading_levels: bool,
}

impl Default for ValidateOpts {
    fn default() -> Self {
        ValidateOpts {
            strict_heading_levels: false,
        }
    }
}

pub fn validate(doc: &Document, opts: &ValidateOpts, src: &SourceMap) -> Vec<Diagnostic> {
    let mut diags = Vec::new();
    if opts.strict_heading_levels {
        check_heading_monotonic(doc, &mut diags);
    }
    check_duplicate_anchors(doc, src, &mut diags);
    diags
}

fn check_heading_monotonic(doc: &Document, diags: &mut Vec<Diagnostic>) {
    let mut last: u8 = 0;
    for b in &doc.blocks {
        if let Block::Heading { level, span, .. } = b {
            if last > 0 && *level > last + 1 {
                diags.push(
                    Diagnostic::new(Code::HeadingMonotonic, *span)
                        .label(format!("heading level jumps from {} to {}", last, level))
                        .help("increment heading levels by at most one"),
                );
            }
            last = *level;
        }
    }
}

fn check_duplicate_anchors(doc: &Document, src: &SourceMap, diags: &mut Vec<Diagnostic>) {
    let mut seen: BTreeMap<String, Span> = BTreeMap::new();
    for b in &doc.blocks {
        collect_anchor(b, src, &mut seen, diags);
    }
}

fn collect_anchor(
    block: &Block,
    src: &SourceMap,
    seen: &mut BTreeMap<String, Span>,
    diags: &mut Vec<Diagnostic>,
) {
    match block {
        Block::Heading { anchor, span, .. } => {
            if let Some(name) = anchor {
                if let Some(first_span) = seen.get(name) {
                    let (first_line, _) = src.line_col(first_span.start);
                    diags.push(Diagnostic::new(Code::DuplicateHeadingAnchor, *span).label(
                        format!("anchor `{}` already used at line {}", name, first_line),
                    ));
                } else {
                    seen.insert(name.clone(), *span);
                }
            }
        }
        Block::Blockquote { children, .. } | Block::BlockShortcode { children, .. } => {
            for c in children {
                collect_anchor(c, src, seen, diags);
            }
        }
        Block::List { items, .. } => {
            for it in items {
                for c in &it.children {
                    collect_anchor(c, src, seen, diags);
                }
            }
        }
        Block::DefinitionList { .. } => {}
        Block::Paragraph { .. }
        | Block::CodeBlock { .. }
        | Block::Table { .. }
        | Block::HorizontalRule { .. } => {}
    }
}