scraps 3.7.0

Scraps is a portable CLI knowledge hub for managing interconnected Markdown documentation with Wiki-link notation.
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
120
121
122
123
124

use scraps_libs::model::{scrap::Scrap, tags::Tags};

use crate::usecase::build::model::backlinks_map::BacklinksMap;
use crate::usecase::lint::rule::{LintRule, LintRuleName, LintWarning, scrap_relative_path};

pub struct SelfLinkRule;

impl LintRule for SelfLinkRule {
    fn name(&self) -> LintRuleName {
        LintRuleName::SelfLink
    }

    fn check(
        &self,
        scraps: &[Scrap],
        _backlinks_map: &BacklinksMap,
        _tags: &Tags,
    ) -> Vec<LintWarning> {
        scraps
            .iter()
            .filter(|scrap| scrap.links().contains(&scrap.self_key()))
            .map(|scrap| LintWarning {
                rule_name: self.name(),
                scrap_path: scrap_relative_path(scrap),
                message: "scrap links to itself".to_string(),
                source: Some(scrap.md_text().to_string()),
                span: find_self_link_span(scrap),
            })
            .collect()
    }
}

fn find_self_link_span(scrap: &Scrap) -> Option<(usize, usize)> {
    let self_key_str = scrap.self_key().to_string();
    let pattern = format!("[[{}]]", self_key_str);
    let text = scrap.md_text();
    let self_key = scrap.self_key();
    let markdown = || {
        scrap
            .link_occurrences()
            .filter(|link| link.target.as_ref() == Some(&self_key))
            .find_map(|link| link.markdown)
    };
    text.find(&pattern)
        .map(|start| (start, start + pattern.len()))
        .or_else(|| {
            let written = markdown()?;
            text.find(&written)
                .map(|start| (start, start + written.len()))
        })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn detect_self_link() {
        let scrap = Scrap::new("myself", &None, "text [[myself]] more");
        let scraps = vec![scrap];
        let backlinks_map = BacklinksMap::new(&scraps);
        let tags = Tags::new(&scraps);

        let warnings = SelfLinkRule.check(&scraps, &backlinks_map, &tags);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].rule_name, LintRuleName::SelfLink);
        assert_eq!(warnings[0].scrap_path, "myself.md");
        assert!(warnings[0].span.is_some());
    }

    #[test]
    fn detect_self_link_with_context() {
        let scrap = Scrap::new(
            "title",
            &Some("Context".into()),
            "text [[Context/title]] more",
        );
        let scraps = vec![scrap];
        let backlinks_map = BacklinksMap::new(&scraps);
        let tags = Tags::new(&scraps);

        let warnings = SelfLinkRule.check(&scraps, &backlinks_map, &tags);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].scrap_path, "Context/title.md");
    }

    #[test]
    fn detect_self_link_written_as_a_markdown_link() {
        let scrap = Scrap::new(
            "title",
            &Some("Context".into()),
            "text [me](./title.md) more",
        );
        let scraps = vec![scrap];
        let backlinks_map = BacklinksMap::new(&scraps);
        let tags = Tags::new(&scraps);

        let warnings = SelfLinkRule.check(&scraps, &backlinks_map, &tags);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].span, Some((5, 21)));
    }

    #[test]
    fn skip_links_to_other_scraps() {
        let scrap = Scrap::new("a", &None, "[[b]] [[c]]");
        let scraps = vec![scrap];
        let backlinks_map = BacklinksMap::new(&scraps);
        let tags = Tags::new(&scraps);

        let warnings = SelfLinkRule.check(&scraps, &backlinks_map, &tags);
        assert!(warnings.is_empty());
    }

    #[test]
    fn self_link_mixed_with_other_links() {
        let scrap = Scrap::new("me", &None, "[[other]] [[me]] [[another]]");
        let scraps = vec![scrap];
        let backlinks_map = BacklinksMap::new(&scraps);
        let tags = Tags::new(&scraps);

        let warnings = SelfLinkRule.check(&scraps, &backlinks_map, &tags);
        assert_eq!(warnings.len(), 1);
    }
}