convert into_ methods to impl From

4 files changed, 82 insertions, 64 deletions

diff --git a/packages/svgbob/src/buffer/cell_buffer/span.rs b/packages/svgbob/src/buffer/cell_buffer/span.rs
index ec04ebd..a6eef00 100644
--- a/packages/svgbob/src/buffer/cell_buffer/span.rs
+++ b/packages/svgbob/src/buffer/cell_buffer/span.rs
@@ -138,7 +138,7 @@ impl Span {
     /// belong on the same group
     ///
     pub(crate) fn get_contacts(&self) -> Vec<Contacts> {
-        let fb: FragmentBuffer = self.clone().into_fragment_buffer();
+        let fb: FragmentBuffer = self.clone().into();
 
         let mut groups: Vec<Contacts> = vec![];
         let merged_fragments = fb.merge_fragment_spans();
@@ -301,11 +301,11 @@ impl<'p> From<Span> for PropertyBuffer<'p> {
 ///
 /// If a character has no property, try to see if has equivalent fragments from unicode_map
 /// otherwise add it to the fragment_buffer as a text fragment
-impl Span {
-    fn into_fragment_buffer(self) -> FragmentBuffer {
-        let pb: PropertyBuffer = self.clone().into();
-        let mut fb: FragmentBuffer = pb.clone().into_fragment_buffer();
-        for (cell, ch) in self.iter() {
+impl From<Span> for FragmentBuffer {
+    fn from(span: Span) -> FragmentBuffer {
+        let pb = PropertyBuffer::from(span.clone());
+        let mut fb = FragmentBuffer::from(pb.clone());
+        for (cell, ch) in span.iter() {
             if pb.as_ref().get(cell).is_none() {
                 if let Some(fragments) = UNICODE_FRAGMENTS.get(ch) {
                     fb.add_fragments_to_cell(*cell, *ch, fragments.clone());
diff --git a/packages/svgbob/src/buffer/fragment_buffer.rs b/packages/svgbob/src/buffer/fragment_buffer.rs
index b945d26..fa2e983 100644
--- a/packages/svgbob/src/buffer/fragment_buffer.rs
+++ b/packages/svgbob/src/buffer/fragment_buffer.rs
@@ -41,10 +41,10 @@ mod fragment_tree;
 ///     8└─┴─┴─┴─┘        U└─┴─┴─┴─┘Y
 /// ```                      V W X
 #[derive(Debug, Default)]
-pub struct FragmentBuffer(BTreeMap<Cell, (char, Vec<Fragment>)>);
+pub struct FragmentBuffer(BTreeMap<Cell, Vec<FragmentSpan>>);
 
 impl Deref for FragmentBuffer {
-    type Target = BTreeMap<Cell, (char, Vec<Fragment>)>;
+    type Target = BTreeMap<Cell, Vec<FragmentSpan>>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -66,10 +66,10 @@ impl FragmentBuffer {
     /// printling the fragments on this fragment buffer
     pub fn dump(&self) -> String {
         let mut buff = String::new();
-        for (cell, (_ch, shapes)) in self.iter() {
+        for (cell, shapes) in self.iter() {
             write!(buff, "\ncell: {} ", cell);
             for shape in shapes {
-                write!(buff, "\n    {}", shape);
+                write!(buff, "\n    {}", shape.fragment);
             }
         }
         buff
@@ -77,7 +77,7 @@ impl FragmentBuffer {
 
     /// sort the fragments content in this cell
     fn sort_fragments_in_cell(&mut self, cell: Cell) {
-        if let Some((_ch, fragments)) = &mut self.get_mut(&cell) {
+        if let Some(fragments) = &mut self.get_mut(&cell) {
             (*fragments).sort();
         }
     }
@@ -103,6 +103,19 @@ impl FragmentBuffer {
         (w, h)
     }
 
+    fn add_fragment_span_to_cell(
+        &mut self,
+        cell: Cell,
+        fragment_span: FragmentSpan,
+    ) {
+        if let Some(existing) = self.get_mut(&cell) {
+            existing.push(fragment_span)
+        } else {
+            self.insert(cell, vec![fragment_span]);
+        }
+        self.sort_fragments_in_cell(cell);
+    }
+
     /// Add a single fragment to this cell
     pub fn add_fragment_to_cell(
         &mut self,
@@ -110,13 +123,8 @@ impl FragmentBuffer {
         ch: char,
         fragment: Fragment,
     ) {
-        if let Some((ex_ch, existing)) = self.get_mut(&cell) {
-            assert_eq!(*ex_ch, ch);
-            existing.push(fragment);
-        } else {
-            self.insert(cell, (ch, vec![fragment]));
-        }
-        self.sort_fragments_in_cell(cell);
+        let fragment_span = FragmentSpan::new(Span::new(cell, ch), fragment);
+        self.add_fragment_span_to_cell(cell, fragment_span);
     }
 
     /// add multiple fragments to cell
@@ -126,43 +134,25 @@ impl FragmentBuffer {
         ch: char,
         fragments: Vec<Fragment>,
     ) {
-        if let Some((ex_ch, existing)) = self.get_mut(&cell) {
-            assert_eq!(*ex_ch, ch);
-            existing.extend(fragments);
-        } else {
-            self.insert(cell, (ch, fragments));
+        for fragment in fragments {
+            self.add_fragment_to_cell(cell, ch, fragment);
         }
-        self.sort_fragments_in_cell(cell);
     }
 
-    pub fn merge_fragment_spans(self) -> Vec<FragmentSpan> {
-        let fragment_spans = self.into_fragment_spans();
+    pub fn merge_fragment_spans(&self) -> Vec<FragmentSpan> {
+        let fragment_spans = self.abs_fragment_spans();
         FragmentSpan::merge_recursive(fragment_spans)
     }
 
-    /// create a merged of fragments while preserving their cells
-    fn into_fragment_spans(self) -> Vec<FragmentSpan> {
-        let mut fragment_spans: Vec<FragmentSpan> = vec![];
-        for (cell, (ch, fragments)) in self.iter() {
-            for frag in fragments.iter() {
-                let abs_frag = frag.absolute_position(*cell);
-                let span = Span::new(*cell, *ch);
-                let abs_frag = FragmentSpan::new(span, abs_frag);
-                let had_merged =
-                    fragment_spans.iter_mut().rev().any(|frag_span| {
-                        if let Some(new_merge) = frag_span.merge(&abs_frag) {
-                            *frag_span = new_merge;
-                            true
-                        } else {
-                            false
-                        }
-                    });
-
-                if !had_merged {
-                    fragment_spans.push(abs_frag);
-                }
-            }
-        }
-        fragment_spans
+    /// Collect all the fragment span where all fragment spans of each cell
+    /// are converted to their absolute position
+    fn abs_fragment_spans(&self) -> Vec<FragmentSpan> {
+        self.iter()
+            .flat_map(|(cell, fragment_spans)| {
+                fragment_spans
+                    .iter()
+                    .map(|frag_span| frag_span.absolute_position(*cell))
+            })
+            .collect()
     }
 }
diff --git a/packages/svgbob/src/buffer/fragment_buffer/fragment_span.rs b/packages/svgbob/src/buffer/fragment_buffer/fragment_span.rs
index 4efeae9..f3ca678 100644
--- a/packages/svgbob/src/buffer/fragment_buffer/fragment_span.rs
+++ b/packages/svgbob/src/buffer/fragment_buffer/fragment_span.rs
@@ -3,6 +3,7 @@ use crate::Cell;
 use crate::Fragment;
 use crate::Merge;
 use crate::Settings;
+use std::cmp::Ordering;
 use std::fmt;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -17,6 +18,18 @@ impl fmt::Display for FragmentSpan {
     }
 }
 
+impl Ord for FragmentSpan {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.fragment.cmp(&other.fragment)
+    }
+}
+
+impl PartialOrd for FragmentSpan {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 impl FragmentSpan {
     pub fn new(span: Span, fragment: Fragment) -> Self {
         Self { span, fragment }
diff --git a/packages/svgbob/src/buffer/property_buffer.rs b/packages/svgbob/src/buffer/property_buffer.rs
index e9f24ad..43d9bfd 100644
--- a/packages/svgbob/src/buffer/property_buffer.rs
+++ b/packages/svgbob/src/buffer/property_buffer.rs
@@ -136,22 +136,37 @@ impl<'p> AsMut<HashMap<Cell, &'p Property>> for PropertyBuffer<'p> {
 }
 
 /// convert property buffer to fragment buffer
-impl<'p> PropertyBuffer<'p> {
-    pub(crate) fn into_fragment_buffer(self) -> FragmentBuffer {
+impl<'p> From<PropertyBuffer<'p>> for FragmentBuffer {
+    fn from(property_buffer: PropertyBuffer<'p>) -> FragmentBuffer {
         let mut fb = FragmentBuffer::new();
-        for (cell, property) in self.as_ref() {
+        for (cell, property) in property_buffer.as_ref() {
             let empty = &&Property::empty();
-            let top_left = self.as_ref().get(&cell.top_left()).unwrap_or(empty);
-            let top = self.as_ref().get(&cell.top()).unwrap_or(empty);
-            let top_right =
-                self.as_ref().get(&cell.top_right()).unwrap_or(empty);
-            let left = self.as_ref().get(&cell.left()).unwrap_or(empty);
-            let right = self.as_ref().get(&cell.right()).unwrap_or(empty);
-            let bottom_left =
-                self.as_ref().get(&cell.bottom_left()).unwrap_or(empty);
-            let bottom = self.as_ref().get(&cell.bottom()).unwrap_or(empty);
-            let bottom_right =
-                self.as_ref().get(&cell.bottom_right()).unwrap_or(empty);
+            let top_left = property_buffer
+                .as_ref()
+                .get(&cell.top_left())
+                .unwrap_or(empty);
+            let top =
+                property_buffer.as_ref().get(&cell.top()).unwrap_or(empty);
+            let top_right = property_buffer
+                .as_ref()
+                .get(&cell.top_right())
+                .unwrap_or(empty);
+            let left =
+                property_buffer.as_ref().get(&cell.left()).unwrap_or(empty);
+            let right =
+                property_buffer.as_ref().get(&cell.right()).unwrap_or(empty);
+            let bottom_left = property_buffer
+                .as_ref()
+                .get(&cell.bottom_left())
+                .unwrap_or(empty);
+            let bottom = property_buffer
+                .as_ref()
+                .get(&cell.bottom())
+                .unwrap_or(empty);
+            let bottom_right = property_buffer
+                .as_ref()
+                .get(&cell.bottom_right())
+                .unwrap_or(empty);
             let cell_fragments = property.fragments(
                 top_left,
                 top,