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 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs         |   7 +++
 src/span.rs        |  11 +++++
 src/template.rs    |  25 +++++++++++
 4 files changed, 169 insertions(+)
 create mode 100644 src/highlighter.rs
 create mode 100644 src/lib.rs
 create mode 100644 src/span.rs
 create mode 100644 src/template.rs

(limited to 'src')

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;
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..7a40c94
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,7 @@
+mod span;
+mod template;
+mod highlighter;
+
+pub use span::*;
+pub use template::*;
+pub use highlighter::*;
diff --git a/src/span.rs b/src/span.rs
new file mode 100644
index 0000000..5282cae
--- /dev/null
+++ b/src/span.rs
@@ -0,0 +1,11 @@
+pub struct Span {
+    pub tag: String,
+    pub text: String,
+}
+
+impl std::fmt::Debug for Span {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        let tag = format!("{:?}", self.tag);
+        write!(f, "{tag:>20}: {:?}", self.text)
+    }
+}
diff --git a/src/template.rs b/src/template.rs
new file mode 100644
index 0000000..67eaceb
--- /dev/null
+++ b/src/template.rs
@@ -0,0 +1,25 @@
+use fancy_regex::*;
+
+
+pub struct Template {
+    pub tag: String,
+    pub subtags: Vec<String>,
+    pub expression: Regex,
+}
+
+impl Template {
+    pub fn from_str(pattern: &str, tag: String) -> Self {
+        let pattern = format!("^(?:{pattern})");
+        let expression = Regex::new(&pattern).unwrap();
+
+        if let Some((head, tail)) = tag.split_once('(') {
+            if let Some(tail) = tail.strip_suffix(')') {
+                let tag = head.trim().to_string();
+                let subtags = tail.split(',').map(|t| t.trim().to_string()).collect();
+                return Self { tag, subtags, expression };
+            }
+        }
+        let subtags = Vec::new();
+        return Self { tag, subtags, expression };
+    }
+}
-- 
cgit v1.2.3-70-g09d2