panache 2.41.1

An LSP, formatter, and linter for Markdown, Quarto, and R Markdown
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

use std::collections::HashMap;
use std::path::PathBuf;

use rowan::TextRange;
use serde::{Deserialize, Serialize};

use crate::bib::BibEntry;

#[derive(Debug, Clone)]
pub struct InlineReference {
    pub id: String,
    pub range: TextRange,
    pub path: PathBuf,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ReferenceEntry {
    pub id: Option<String>,
}

#[derive(Debug, Clone)]
pub struct InlineReferenceDuplicate {
    pub key: String,
    pub first: InlineReference,
    pub duplicate: InlineReference,
}

#[derive(Debug, Clone)]
pub struct InlineBibConflict {
    pub key: String,
    pub inline: InlineReference,
    pub bib: BibEntry,
}

pub fn inline_reference_map(inline: &[InlineReference]) -> HashMap<String, Vec<InlineReference>> {
    let mut map: HashMap<String, Vec<InlineReference>> = HashMap::new();
    for entry in inline {
        map.entry(entry.id.to_lowercase())
            .or_default()
            .push(entry.clone());
    }
    map
}

pub fn inline_reference_duplicates(inline: &[InlineReference]) -> Vec<InlineReferenceDuplicate> {
    let mut duplicates = Vec::new();
    let map = inline_reference_map(inline);
    for (key, entries) in map {
        if entries.len() <= 1 {
            continue;
        }
        let first = entries[0].clone();
        for duplicate in entries.iter().skip(1).cloned() {
            duplicates.push(InlineReferenceDuplicate {
                key: key.clone(),
                first: first.clone(),
                duplicate,
            });
        }
    }
    duplicates
}

pub fn inline_bib_conflicts(
    inline: &[InlineReference],
    index: &crate::bib::BibIndex,
) -> Vec<InlineBibConflict> {
    let mut conflicts = Vec::new();
    for entry in inline {
        if let Some(bib) = index.get(&entry.id) {
            conflicts.push(InlineBibConflict {
                key: entry.id.clone(),
                inline: entry.clone(),
                bib: bib.clone(),
            });
        }
    }
    conflicts
}

pub fn inline_reference_contains(inline: &[InlineReference], key: &str) -> bool {
    let needle = key.to_lowercase();
    inline.iter().any(|entry| entry.id.to_lowercase() == needle)
}