From f2a60a8dccc98dc77e3db678c0c8994cd6200853 Mon Sep 17 00:00:00 2001
From: "Andrew Wheeler(Genusis)" <genusistimelord@gmail.com>
Date: Sat, 29 Oct 2022 19:56:14 -0400
Subject: [PATCH] Rework add_span (#25)

* Rework Ranges to split and change or overwrite based on old ranges to new range

* set array size to 3 instead of 5. added some comments

* Avoid adding ranges that the start and end == each other

* actually remove the start != end requirement since get_span doesnt care and would work for single characters.

* Add 1 to forward map so it cant overlap ranges like 11..11

* optimize the span lookup so if it is outside the search parameters it doesnt keep looping. update get span to iterate normally since there should be no duplicates. Maybe optimize this to a btree now instead?

* make the range changes for front to end have the end -1 so as to not overlap since get span is <=

* Readded block for ranges like 1..1
Moved rework ranges into the first loop.
Removed the -1 and +1 from the range clips.
---
 src/attrs.rs | 46 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/src/attrs.rs b/src/attrs.rs
index 44d6920..fdcef08 100644
--- a/src/attrs.rs
+++ b/src/attrs.rs
@@ -170,27 +170,53 @@ impl<'a> AttrsList<'a> {
 
     /// Add an attribute span, removes any previous matching parts of spans
     pub fn add_span(&mut self, range: Range<usize>, attrs: Attrs<'a>) {
-        self.spans.push((range, attrs));
+        //do not support 1..1 even if by accident.
+        if range.start == range.end {
+            return;
+        }
 
-        // Condense spans
-        //TODO: more advanced merging
+        let mut rework_spans = Vec::with_capacity(3);
         let mut i = 0;
-        while i + 1 < self.spans.len() {
-            if self.spans[i].0.end == self.spans[i + 1].0.start
-            && self.spans[i].1 == self.spans[i + 1].1 {
-                let next = self.spans.remove(i + 1);
-                self.spans[i].0.end = next.0.end;
+
+        //Grab intersecting parts that are not fully intersected. remove those that are.
+        //This clips or splits the parts that are outside of the range.
+        while i < self.spans.len() {
+            if self.spans[i].0.end <= range.end && self.spans[i].0.start >= range.start {
+                let _ = self.spans.remove(i);
+            } else if self.spans[i].0.end > range.end && self.spans[i].0.start >= range.start && self.spans[i].0.start <= range.end {
+                let rework = self.spans.remove(i);
+                rework_spans.push((range.end..rework.0.end, rework.1))
+            } else if self.spans[i].0.end <= range.end && self.spans[i].0.end >= range.start && self.spans[i].0.start < range.start {
+                let rework = self.spans.remove(i);
+                rework_spans.push((rework.0.start..range.start, rework.1))
+            } else if self.spans[i].0.end > range.end && self.spans[i].0.start < range.start {
+                let rework = self.spans.remove(i);
+                rework_spans.push((rework.0.start..range.start, rework.1));
+                rework_spans.push((range.end..rework.0.end, rework.1));
+            } else if self.spans[i].0.start > range.end {
+                break;
             } else {
                 i += 1;
             }
         }
+
+        // Readd reworked arrays back.
+        for reworked in rework_spans {
+            self.spans.push(reworked);
+        }
+
+        //Finally lets add the new span. it should fit now.
+        self.spans.push((range, attrs));
+
+        //sort by start to speed up further additions
+        self.spans.sort_by(|a, b| a.0.start.partial_cmp(&b.0.start).unwrap())
     }
 
     /// Get the highest priority attribute span for a range
     ///
-    /// This returns the latest added span that contains the range
+    /// This returns the first span that contains the range
     pub fn get_span(&self, range: Range<usize>) -> Attrs<'a> {
-        for span in self.spans.iter().rev() {
+        for span in self.spans.iter() {
             if range.start >= span.0.start && range.end <= span.0.end {
                 return span.1;
             }