From a749f3455678848e97208dd13fa2dcf64e4e28e5 Mon Sep 17 00:00:00 2001
From: Ben Bridle <ben@derelict.engineering>
Date: Wed, 21 May 2025 11:57:36 +1200
Subject: Initial commit

---
 src/highlighter.rs | 126 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 src/highlighter.rs

(limited to 'src/highlighter.rs')

diff --git a/src/highlighter.rs b/src/highlighter.rs
new file mode 100644
index 0000000..40e618e
--- /dev/null
+++ b/src/highlighter.rs
@@ -0,0 +1,126 @@
+use crate::*;
+
+use std::collections::{HashMap, VecDeque};
+
+
+pub struct Highlighter {
+    pub templates: Vec<Template>,
+}
+
+impl Highlighter {
+    pub fn from_str(template_set: &str) -> Self {
+        let mut variables = HashMap::new();
+        let mut templates = Vec::new();
+
+        for line in template_set.lines().map(|l| l.trim()) {
+            if line.is_empty() || line.starts_with('#') {
+                continue;
+            }
+            let (left, right) = line.split_once('=').expect("Missing '=' character");
+            let name = left.trim().to_string();
+            let pattern = replace_variables(right.trim(), &variables);
+            if name.starts_with('<') && name.ends_with('>') {
+                variables.insert(name, pattern);
+            } else {
+                templates.push(Template::from_str(&pattern, name));
+            }
+        }
+        Self { templates }
+    }
+
+    pub fn highlight(&self, text: &str) -> Vec<Span> {
+        let mut remaining = &text[..];
+        let mut accumulator = String::new();
+        let mut spans = Vec::new();
+
+        'outer: while !remaining.is_empty() {
+            // Check all templates.
+            for template in &self.templates {
+                if let Some(captures) = template.expression.captures(remaining).unwrap() {
+                    if captures[0].len() > 0 {
+                        // Bank the accumulator as an untagged span.
+                        if !accumulator.is_empty() {
+                            let text = std::mem::take(&mut accumulator);
+                            spans.push(Span { tag: String::new(), text });
+                        }
+                        // Tag each capture group.
+                        let mut i = 0;
+                        let mut groups = captures.iter().filter_map(|c| c);
+                        groups.next();
+                        for (tag_i, group) in groups.enumerate() {
+                            // Tag the text before this capture group.
+                            if group.start() > i {
+                                let text = captures[0][i..group.start()].to_string();
+                                spans.push(Span { tag: template.tag.clone(), text })
+                            }
+                            // Tag the text in this capture group.
+                            let text = captures[0][group.start()..group.end()].to_string();
+                            let tag = match template.subtags.get(tag_i) {
+                                Some(tag) => tag.clone(),
+                                None => template.tag.clone(),
+                            };
+                            spans.push(Span { tag, text });
+                            i = group.end();
+                        }
+                        // Tag the remaining text.
+                        if captures[0].len() > i {
+                            let text = captures[0][i..].to_string();
+                            spans.push(Span { tag: template.tag.clone(), text })
+                        }
+                        // Continue to the next match.
+                        remaining = &remaining[captures[0].len()..];
+                        continue 'outer;
+                    }
+                }
+            }
+            // Pop the first character into accumulator.
+            if let Some(c) = remaining.chars().nth(0) {
+                remaining = &remaining[c.len_utf8()..];
+                accumulator.push(c);
+            }
+        }
+        // Bank the accumulator as an untagged span.
+        if !accumulator.is_empty() {
+            let text = std::mem::take(&mut accumulator);
+            spans.push(Span { tag: String::new(), text });
+        }
+
+        // Merge adjacent spans that have the same tag.
+        let mut spans = VecDeque::from(spans);
+        let mut merged_spans: Vec<Span> = Vec::new();
+        while let Some(span) = spans.pop_front() {
+            if let Some(last) = merged_spans.last_mut() {
+                if span.tag == last.tag {
+                    last.text.push_str(&span.text);
+                    continue;
+                }
+            }
+            merged_spans.push(span);
+        }
+
+        return merged_spans;
+    }
+}
+
+
+fn replace_variables(pattern: &str, variables: &HashMap<String, String>) -> String {
+    let mut output = String::new();
+    let mut chars = pattern.chars();
+    while let Some(c) = chars.next() {
+        if c == '<' {
+            let mut name = String::from('<');
+            loop {
+                match chars.next() {
+                    Some('>') => { name.push('>'); break; }
+                    Some(c)   => name.push(c),
+                    None      => panic!("Missing '>' character"),
+                }
+            }
+            let pattern = variables.get(&name).expect(&format!("Missing definition for {name:?}"));
+            output.push_str(&format!("(?:{pattern})"));
+        } else {
+            output.push(c);
+        }
+    }
+    return output;
+}
-- 
cgit v1.2.3-70-g09d2