liwe 0.14.0

IWE core library
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
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 crate::model::node::Node;
use crate::model::tree::Tree;
use crate::model::{Key, NodeId};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SectionRef {
    pub number: usize,
    pub title: String,
    pub id: NodeId,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InclusionRef {
    pub number: usize,
    pub title: String,
    pub key: Key,
    pub id: NodeId,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SelectError<T> {
    NoSelector,
    NotFound(String),
    Ambiguous(String, Vec<T>),
    OutOfRange(usize, usize),
}

pub fn sections(tree: &Tree) -> Vec<SectionRef> {
    let mut out = Vec::new();
    collect_sections(tree, &mut out);
    out
}

fn collect_sections(tree: &Tree, out: &mut Vec<SectionRef>) {
    if let Node::Section(inlines) = &tree.node {
        out.push(SectionRef {
            number: out.len() + 1,
            title: inlines.iter().map(|i| i.plain_text()).collect(),
            id: tree.id,
        });
    }
    for child in &tree.children {
        collect_sections(child, out);
    }
}

pub fn select_section(
    tree: &Tree,
    title: Option<&str>,
    block: Option<usize>,
) -> Result<SectionRef, SelectError<SectionRef>> {
    let sections = sections(tree);
    if let Some(title) = title {
        let needle = title.to_lowercase();
        let matches: Vec<SectionRef> = sections
            .into_iter()
            .filter(|section| section.title.to_lowercase().contains(&needle))
            .collect();
        match matches.len() {
            0 => Err(SelectError::NotFound(title.to_string())),
            1 => Ok(matches.into_iter().next().unwrap()),
            _ => Err(SelectError::Ambiguous(title.to_string(), matches)),
        }
    } else if let Some(block) = block {
        if block == 0 || block > sections.len() {
            Err(SelectError::OutOfRange(block, sections.len()))
        } else {
            Ok(sections.into_iter().nth(block - 1).unwrap())
        }
    } else {
        Err(SelectError::NoSelector)
    }
}

pub fn references(tree: &Tree) -> Vec<InclusionRef> {
    let mut out = Vec::new();
    collect_references(tree, &mut out);
    out
}

fn collect_references(tree: &Tree, out: &mut Vec<InclusionRef>) {
    if let Node::Reference(reference) = &tree.node {
        out.push(InclusionRef {
            number: out.len() + 1,
            title: reference.text.clone(),
            key: reference.key.clone(),
            id: tree.id,
        });
    }
    for child in &tree.children {
        collect_references(child, out);
    }
}

pub fn select_reference(
    tree: &Tree,
    reference: Option<&str>,
    block: Option<usize>,
) -> Result<InclusionRef, SelectError<InclusionRef>> {
    let references = references(tree);
    if let Some(reference) = reference {
        let needle = reference.to_lowercase();
        let matches: Vec<InclusionRef> = references
            .into_iter()
            .filter(|inclusion| {
                inclusion.title.to_lowercase().contains(&needle)
                    || inclusion.key.to_string().to_lowercase().contains(&needle)
            })
            .collect();
        match matches.len() {
            0 => Err(SelectError::NotFound(reference.to_string())),
            1 => Ok(matches.into_iter().next().unwrap()),
            _ => Err(SelectError::Ambiguous(reference.to_string(), matches)),
        }
    } else if let Some(block) = block {
        if block == 0 || block > references.len() {
            Err(SelectError::OutOfRange(block, references.len()))
        } else {
            Ok(references.into_iter().nth(block - 1).unwrap())
        }
    } else {
        Err(SelectError::NoSelector)
    }
}