badness 0.11.0

A language server, formatter, and linter for LaTeX
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! `undefined-string`: an `@string` *use* that matches no definition in the file
//! (nor a predefined month macro `jan`..`dec`).
//!
//! Built on [`Model::undefined_string_uses`](crate::bib::semantic::Model::undefined_string_uses),
//! which the resolve pass already computes against in-file `@string` defs plus the
//! twelve month macros. A [`Severity::Warning`]; report-only (the fix is to define
//! the macro or correct the name, a meaning-level edit left to the author).
//!
//! **Single-file caveat:** in a multi-file bibliography the macro may be defined in
//! another `.bib`, so this can false-positive across files — the same trade-off
//! [`unused-string`](super::unused_string) carries. It is sound for the common
//! self-contained `.bib`, which is where a typo'd or undefined macro is worth
//! surfacing. A cross-file `@string` resolver is out of scope for this slice.

use std::path::PathBuf;

use crate::linter::diagnostic::{Diagnostic, Severity};

use super::{BibRule, BibRuleContext, Example};

const EXAMPLES: &[Example] = &[Example {
    caption: "A typo'd macro name (`cpu` for `cup`):",
    source: "@string{cup = {Cambridge University Press}}\n\
             @book{turing50, title = {Draft}, publisher = cpu}\n",
}];

pub struct UndefinedString;

impl BibRule for UndefinedString {
    fn id(&self) -> &'static str {
        "undefined-string"
    }

    fn default_severity(&self) -> Severity {
        Severity::Warning
    }

    fn description(&self) -> &'static str {
        "Flag an `@string` macro used in a field value but defined nowhere in \
         the file (the twelve month macros `jan`..`dec` are predefined). \
         Usually a typo'd macro name or a missing `@string` definition; BibTeX \
         errors on it at build time. In a multi-file bibliography the \
         definition may live in another `.bib`, so a use resolved there is a \
         false positive -- cross-file `@string` resolution is not modeled yet. \
         Report-only: the fix (define the macro or correct the name) is a \
         meaning-level edit left to the author."
    }

    fn examples(&self) -> &'static [Example] {
        EXAMPLES
    }

    fn check_file(&self, ctx: &BibRuleContext<'_>, sink: &mut Vec<Diagnostic>) {
        for use_ in ctx.model.undefined_string_uses() {
            sink.push(Diagnostic {
                rule: self.id(),
                severity: self.default_severity(),
                path: PathBuf::new(),
                start: usize::from(use_.range.start()),
                end: usize::from(use_.range.end()),
                message: format!("`@string` macro `{}` is used but never defined", use_.name),
                fix: None,
                related: Vec::new(),
            });
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::bib::parse;
    use crate::bib::semantic::Model;

    fn findings(src: &str) -> Vec<Diagnostic> {
        let root = parse(src).syntax();
        let model = Model::build(&root);
        let ctx = BibRuleContext {
            path: std::path::Path::new("x.bib"),
            root: &root,
            model: &model,
            db: crate::bib::semantic::builtin(),
        };
        let mut out = Vec::new();
        UndefinedString.check_file(&ctx, &mut out);
        out
    }

    #[test]
    fn flags_undefined_use() {
        let out = findings("@book{k, publisher = nope}\n");
        assert_eq!(out.len(), 1);
        assert_eq!(out[0].rule, "undefined-string");
        assert!(out[0].message.contains("nope"));
    }

    #[test]
    fn in_file_def_is_fine() {
        assert!(findings("@string{cup = {C}}\n@book{k, publisher = cup}\n").is_empty());
    }

    #[test]
    fn month_macro_is_fine() {
        assert!(findings("@article{k, month = jan}\n").is_empty());
    }

    #[test]
    fn number_value_is_not_a_use() {
        assert!(findings("@article{k, year = 2020}\n").is_empty());
    }

    #[test]
    fn underlines_the_use() {
        let src = "@book{k, publisher = nope}\n";
        let out = findings(src);
        assert_eq!(out.len(), 1);
        assert_eq!(&src[out[0].start..out[0].end], "nope");
    }
}