episodic 0.1.0

Reusable Observational Memory core models and pure transforms.
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

use super::OmParseMode;
use super::tokens::{TagKind, TagSectionRange, TagToken};

fn normalize_tag_name(tag: &str) -> Option<String> {
    let normalized = tag.trim().to_ascii_lowercase();
    if normalized.is_empty() {
        None
    } else {
        Some(normalized)
    }
}

fn section_content<'a>(text: &'a str, range: &TagSectionRange) -> Option<&'a str> {
    text.get(range.content_start..range.content_end)
}

pub(super) fn section_ranges_for_tag(
    text: &str,
    tokens: &[TagToken],
    tag: &str,
    mode: OmParseMode,
) -> Vec<TagSectionRange> {
    let Some(tag) = normalize_tag_name(tag) else {
        return Vec::new();
    };

    let mut ranges = Vec::<TagSectionRange>::new();
    let mut current_open: Option<&TagToken> = None;
    let mut discard_next_close = false;

    for token in tokens {
        if token.name != tag {
            continue;
        }
        match token.kind {
            TagKind::Open => {
                // Lenient mode prefers latest anchored open for malformed overlap recovery.
                // Strict mode rejects ambiguous overlap instead of recovering.
                if !token.line_anchored {
                    continue;
                }
                if matches!(mode, OmParseMode::Strict) && current_open.is_some() {
                    // Ambiguous overlap in strict mode: discard this malformed block.
                    current_open = None;
                    discard_next_close = true;
                    continue;
                }
                if matches!(mode, OmParseMode::Lenient) || current_open.is_none() {
                    current_open = Some(token);
                }
            }
            TagKind::Close => {
                if discard_next_close {
                    discard_next_close = false;
                    continue;
                }
                let Some(open) = current_open else {
                    continue;
                };
                if token.start < open.end {
                    continue;
                }

                let same_line_close = text
                    .get(open.end..token.start)
                    .map(|segment| !segment.contains('\n'))
                    .unwrap_or(false);
                if !token.line_anchored && !same_line_close {
                    continue;
                }

                ranges.push(TagSectionRange {
                    open_start: open.start,
                    content_start: open.end,
                    content_end: token.start,
                    close_end: token.end,
                });
                current_open = None;
            }
        }
    }

    ranges
}

pub(super) fn extract_tag_sections_from_tokens(
    text: &str,
    tokens: &[TagToken],
    tag: &str,
    mode: OmParseMode,
) -> Vec<String> {
    section_ranges_for_tag(text, tokens, tag, mode)
        .into_iter()
        .filter_map(|range| section_content(text, &range).map(str::trim))
        .filter(|content| !content.is_empty())
        .map(ToString::to_string)
        .collect::<Vec<_>>()
}

pub(super) fn extract_tag_content_from_tokens(
    text: &str,
    tokens: &[TagToken],
    tag: &str,
    mode: OmParseMode,
) -> Option<String> {
    extract_tag_sections_from_tokens(text, tokens, tag, mode)
        .into_iter()
        .rev()
        .find(|content| !content.is_empty())
}

pub(super) fn extract_and_remove_tag_sections_return_last(
    text: &str,
    tokens: &[TagToken],
    tag: &str,
    mode: OmParseMode,
) -> (String, Option<String>) {
    let ranges = section_ranges_for_tag(text, tokens, tag, mode);
    if ranges.is_empty() {
        return (text.trim().to_string(), None);
    }

    let last = ranges
        .iter()
        .rev()
        .filter_map(|range| section_content(text, range))
        .map(str::trim)
        .find(|content| !content.is_empty())
        .map(ToString::to_string);

    let mut stripped = String::with_capacity(text.len());
    let mut cursor = 0usize;
    for range in ranges {
        if range.open_start < cursor {
            continue;
        }
        if let Some(prefix) = text.get(cursor..range.open_start) {
            stripped.push_str(prefix);
        }
        cursor = range.close_end;
    }
    if let Some(suffix) = text.get(cursor..) {
        stripped.push_str(suffix);
    }

    (stripped.trim().to_string(), last)
}