lex-core 0.8.2

Parser library for the lex format
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Reference classification for inline elements.
//!
//! Handles detection and classification of different reference types:
//! - TK placeholders (`[TK]`, `[TK-identifier]`)
//! - Citations (`[@key]`)
//! - Session references (`[#42]`)
//! - URLs (`[https://example.com]`)
//! - File paths (`[./file.txt]`)
//! - Annotation references (`[::note]`)
//! - Footnotes (`[42]`)
//! - General references (`[Section Title]`)

use super::citations::parse_citation_data;
use crate::lex::ast::elements::inlines::{InlineNode, ReferenceType};

/// Post-processor callback for reference nodes that classifies their type.
pub(super) fn classify_reference_node(node: InlineNode) -> InlineNode {
    match node {
        InlineNode::Reference {
            mut data,
            annotations,
        } => {
            data.reference_type = determine_reference_type(&data.raw);
            InlineNode::Reference { data, annotations }
        }
        other => other,
    }
}

/// Determine the reference type from raw content.
fn determine_reference_type(raw: &str) -> ReferenceType {
    let trimmed = raw.trim();
    if trimmed.is_empty() || !trimmed.chars().any(|ch| ch.is_alphanumeric()) {
        return ReferenceType::NotSure;
    }

    if let Some(identifier) = detect_tk_reference(trimmed) {
        return ReferenceType::ToCome { identifier };
    }

    if let Some(rest) = trimmed.strip_prefix('@') {
        if let Some(citation) = parse_citation_data(rest) {
            return ReferenceType::Citation(citation);
        }
    }

    if let Some(rest) = trimmed.strip_prefix("::") {
        let label = rest.trim();
        if !label.is_empty() {
            return ReferenceType::AnnotationReference {
                label: label.to_string(),
            };
        }
    }

    if let Some(session_target) = parse_session_reference(trimmed) {
        return ReferenceType::Session {
            target: session_target,
        };
    }

    if is_url_reference(trimmed) {
        return ReferenceType::Url {
            target: trimmed.to_string(),
        };
    }

    if is_file_reference(trimmed) {
        return ReferenceType::File {
            target: trimmed.to_string(),
        };
    }

    if let Some(number) = parse_footnote_number(trimmed) {
        return ReferenceType::FootnoteNumber { number };
    }

    ReferenceType::General {
        target: trimmed.to_string(),
    }
}

/// Detect TK placeholder references.
///
/// - `[TK]` → ToCome with no identifier
/// - `[TK-feature]` → ToCome with identifier "feature"
fn detect_tk_reference(trimmed: &str) -> Option<Option<String>> {
    if trimmed.eq_ignore_ascii_case("TK") {
        return Some(None);
    }

    // Check for "TK-" prefix case-insensitively using strip_prefix variants
    // We need to check both cases since strip_prefix is case-sensitive
    let identifier = trimmed
        .strip_prefix("TK-")
        .or_else(|| trimmed.strip_prefix("tk-"))
        .or_else(|| trimmed.strip_prefix("Tk-"))
        .or_else(|| trimmed.strip_prefix("tK-"));

    if let Some(identifier) = identifier {
        if !identifier.is_empty()
            && identifier.len() <= 20
            && identifier
                .chars()
                .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit())
        {
            return Some(Some(identifier.to_string()));
        }
    }
    None
}

/// Parse session reference from content starting with `#`.
///
/// Example: `[#2.1]` → Session reference to "2.1"
fn parse_session_reference(trimmed: &str) -> Option<String> {
    let rest = trimmed.strip_prefix('#')?;
    if rest.is_empty() {
        return None;
    }
    if rest
        .chars()
        .all(|c| c.is_ascii_digit() || c == '.' || c == '-')
    {
        Some(rest.to_string())
    } else {
        None
    }
}

/// Check if the reference is a URL.
fn is_url_reference(trimmed: &str) -> bool {
    trimmed.starts_with("http://")
        || trimmed.starts_with("https://")
        || trimmed.starts_with("mailto:")
}

/// Check if the reference is a file path.
fn is_file_reference(trimmed: &str) -> bool {
    trimmed.starts_with('.') || trimmed.starts_with('/')
}

/// Parse numeric footnote reference.
///
/// Example: `[42]` → FootnoteNumber { number: 42 }
fn parse_footnote_number(trimmed: &str) -> Option<u32> {
    if trimmed.chars().all(|c| c.is_ascii_digit()) {
        trimmed.parse::<u32>().ok()
    } else {
        None
    }
}