refactor: use descriptive names, extensive use of Endorse struct

4 files changed, 100 insertions, 67 deletions

diff --git a/packages/svgbob/src/buffer/cell_buffer.rs b/packages/svgbob/src/buffer/cell_buffer.rs
index 7c182b6..3b0b89b 100644
--- a/packages/svgbob/src/buffer/cell_buffer.rs
+++ b/packages/svgbob/src/buffer/cell_buffer.rs
@@ -8,6 +8,7 @@ use crate::{
 };
 pub use cell::{Cell, CellGrid};
 pub use contacts::Contacts;
+pub use endorse::Endorse;
 use itertools::Itertools;
 use sauron::{
     html,
@@ -133,31 +134,30 @@ impl CellBuffer {
         self,
     ) -> (Vec<FragmentSpan>, Vec<Vec<FragmentSpan>>) {
         let escaped_text = self.escaped_text_nodes();
-        let (single_member_fragments, vec_group_fragments, vec_fragments) =
-            self.group_single_members_from_other_fragments();
+        let Endorse {
+            mut accepted,
+            rejects,
+        } = self.endorse_to_fragment_spans();
 
-        let regulars =
-            [vec_fragments, single_member_fragments, escaped_text].concat();
+        accepted.extend(escaped_text);
 
-        (regulars, vec_group_fragments)
+        (accepted, rejects)
     }
 
     /// return fragments that are Rect, Circle,
-    pub(crate) fn get_shapes_fragment(self) -> Vec<FragmentSpan> {
-        let (single_member, _, endorsed_fragments) =
-            self.group_single_members_from_other_fragments();
-        endorsed_fragments
+    pub(crate) fn into_shapes_fragment(self) -> Vec<FragmentSpan> {
+        let endorse = self.endorse_to_fragment_spans();
+        endorse
+            .accepted
             .into_iter()
-            .chain(single_member.into_iter().filter(|frag| {
-                frag.fragment.is_rect() || frag.fragment.is_circle()
-            }))
+            .filter(|frag| frag.fragment.is_rect() || frag.fragment.is_circle())
             .collect()
     }
 
     /// returns (single_member, grouped,  rest of the fragments
-    fn group_single_members_from_other_fragments(
+    fn endorse_to_fragment_spans(
         self,
-    ) -> (Vec<FragmentSpan>, Vec<Vec<FragmentSpan>>, Vec<FragmentSpan>) {
+    ) -> Endorse<FragmentSpan, Vec<FragmentSpan>> {
         // endorsed_fragments are the fragment result of successful endorsement
         //
         // vec_groups are not endorsed, but are still touching, these will be grouped together in
@@ -169,6 +169,7 @@ impl CellBuffer {
         ) = group_adjacents
             .into_iter()
             .map(|span| span.endorse())
+            .map(|endorse| (endorse.accepted, endorse.rejects))
             .unzip();
 
         // partition the vec_groups into groups that is alone and the group
@@ -184,15 +185,34 @@ impl CellBuffer {
             .flat_map(|contact| contact.as_ref().to_vec())
             .collect();
 
-        let vec_groups: Vec<Vec<FragmentSpan>> = vec_groups
+        let rejects: Vec<Vec<FragmentSpan>> = vec_groups
             .into_iter()
             .map(|contact| contact.as_ref().to_vec())
             .collect();
 
-        let endorsed_fragments: Vec<FragmentSpan> =
-            endorsed_fragments.into_iter().flatten().collect();
+        log::info!("rejects: {:#?}", rejects);
+        let re_endorsed = Span::re_endorse(rejects);
+        log::info!("re_endorsed: {:#?}", re_endorsed);
+        log::info!(
+            "got some accepted re_endorsed: {}",
+            re_endorsed.accepted.len()
+        );
+
+        let accepted: Vec<FragmentSpan> = endorsed_fragments
+            .into_iter()
+            .flatten()
+            .chain(single_member_fragments.into_iter())
+            .chain(re_endorsed.accepted.into_iter())
+            .collect();
 
-        (single_member_fragments, vec_groups, endorsed_fragments)
+        Endorse {
+            accepted,
+            rejects: re_endorsed
+                .rejects
+                .into_iter()
+                .map(|contacts| contacts.0)
+                .collect(),
+        }
     }
 
     /// group nodes that can be group and the rest will be fragments
@@ -202,11 +222,10 @@ impl CellBuffer {
         settings: &Settings,
     ) -> (Vec<Node<MSG>>, Vec<FragmentSpan>) {
         let escaped_text_nodes = self.escaped_text_nodes();
-        let (single_member_fragments, vec_group_fragments, vec_fragments) =
-            self.group_single_members_from_other_fragments();
+        let Endorse { accepted, rejects } = self.endorse_to_fragment_spans();
 
         // grouped fragments will be rendered as svg groups
-        let group_nodes: Vec<Node<MSG>> = vec_group_fragments
+        let group_nodes: Vec<Node<MSG>> = rejects
             .into_iter()
             .map(move |fragments| {
                 let group_members = fragments
@@ -221,9 +240,8 @@ impl CellBuffer {
             })
             .collect();
 
-        let mut fragments: Vec<FragmentSpan> = vec_fragments;
+        let mut fragments: Vec<FragmentSpan> = accepted;
 
-        fragments.extend(single_member_fragments);
         fragments.extend(escaped_text_nodes);
 
         (group_nodes, fragments)
@@ -694,7 +712,7 @@ This is a text
 
     "#;
         let buffer = CellBuffer::from(art);
-        let shapes = buffer.get_shapes_fragment();
+        let shapes = buffer.into_shapes_fragment();
         println!("shapes: {:#?}", shapes);
         assert_eq!(2, shapes.len());
     }
@@ -708,7 +726,7 @@ This is a text
 
     "#;
         let buffer = CellBuffer::from(art);
-        let shapes = buffer.get_shapes_fragment();
+        let shapes = buffer.into_shapes_fragment();
         println!("shapes: {:#?}", shapes);
         assert_eq!(1, shapes.len());
         assert!(shapes[0]
diff --git a/packages/svgbob/src/buffer/cell_buffer/contacts.rs b/packages/svgbob/src/buffer/cell_buffer/contacts.rs
index b9345de..1c3cf49 100644
--- a/packages/svgbob/src/buffer/cell_buffer/contacts.rs
+++ b/packages/svgbob/src/buffer/cell_buffer/contacts.rs
@@ -1,4 +1,5 @@
 use super::endorse;
+use super::endorse::Endorse;
 use crate::buffer::fragment_buffer::FragmentSpan;
 use crate::buffer::Span;
 use crate::buffer::{fragment::Fragment, Cell};
@@ -80,19 +81,19 @@ impl Contacts {
     /// These includes: rect, roundedrect,
     pub(crate) fn endorse_rects(
         groups: Vec<Contacts>,
-    ) -> (Vec<FragmentSpan>, Vec<Contacts>) {
-        let mut fragments = vec![];
-        let mut un_endorsed_rect: Vec<Contacts> = vec![];
+    ) -> Endorse<FragmentSpan, Contacts> {
+        let mut accepted = vec![];
+        let mut rejects: Vec<Contacts> = vec![];
         for group in groups {
             if let Some(fragment) = group.endorse_rect() {
                 let span = group.span();
                 let fragment_span = FragmentSpan::new(span, fragment);
-                fragments.push(fragment_span);
+                accepted.push(fragment_span);
             } else {
-                un_endorsed_rect.push(group);
+                rejects.push(group);
             }
         }
-        (fragments, un_endorsed_rect)
+        Endorse { accepted, rejects }
     }
 
     pub(crate) fn absolute_position(&self, cell: Cell) -> Self {
diff --git a/packages/svgbob/src/buffer/cell_buffer/endorse.rs b/packages/svgbob/src/buffer/cell_buffer/endorse.rs
index ad8a5d9..5f1808a 100644
--- a/packages/svgbob/src/buffer/cell_buffer/endorse.rs
+++ b/packages/svgbob/src/buffer/cell_buffer/endorse.rs
@@ -3,6 +3,22 @@ use crate::{
     Fragment,
 };
 
+/// Result of endorsing processes
+#[derive(Debug)]
+pub struct Endorse<T, E> {
+    /// The result that passed the endorsed
+    pub accepted: Vec<T>,
+    /// The objects that didn't pass the endorsement
+    pub rejects: Vec<E>,
+}
+
+impl<T, E> Endorse<T, E> {
+    pub fn extend(&mut self, other: Self) {
+        self.accepted.extend(other.accepted);
+        self.rejects.extend(other.rejects);
+    }
+}
+
 /// if a group of fragment can be endorse as rect, return the bounds point for the
 /// rectangle
 pub fn endorse_rect(fragments: &[&Fragment]) -> Option<Rect> {
@@ -181,21 +197,12 @@ mod tests {
         let line_uy = line(u, y);
         let line_au = line(a, u);
         let line_ey = line(e, y);
-        let group = parallel_aabb_group(&[
-            &line_ae,
-            &line_au,
-            &line_uy,
-            &line_ey,
-        ]);
+        let group =
+            parallel_aabb_group(&[&line_ae, &line_au, &line_uy, &line_ey]);
         println!("group: {:#?}", group);
         assert_eq!(group, vec![(0, 2), (1, 3)]);
 
-        let rect = endorse_rect(&[
-            &line_ae,
-            &line_au,
-            &line_uy,
-            &line_ey,
-        ]);
+        let rect = endorse_rect(&[&line_ae, &line_au, &line_uy, &line_ey]);
         assert!(rect.is_some());
         assert_eq!(rect, Some(Rect::new(a, y, false, false)));
         assert!(is_rect(&[&line_ae, &line_au, &line_uy, &line_ey]));
diff --git a/packages/svgbob/src/buffer/cell_buffer/span.rs b/packages/svgbob/src/buffer/cell_buffer/span.rs
index 3415abc..e3c106a 100644
--- a/packages/svgbob/src/buffer/cell_buffer/span.rs
+++ b/packages/svgbob/src/buffer/cell_buffer/span.rs
@@ -1,3 +1,4 @@
+use crate::buffer::cell_buffer::Endorse;
 use crate::buffer::fragment_buffer::FragmentSpan;
 use crate::{
     buffer::{
@@ -126,34 +127,37 @@ impl Span {
     /// The second element of the tuple: `contacts` are fragments that are touching together
     /// but can not form a fragment shape. These will be grouped in the svg nodes
     /// to keep them go together, when dragged (editing)
-    pub(crate) fn endorse(self) -> (Vec<FragmentSpan>, Vec<Contacts>) {
-        let mut fragments = vec![];
+    pub(crate) fn endorse(self) -> Endorse<FragmentSpan, Contacts> {
+        let mut accepted = vec![];
         let (top_left, _) = self.bounds().expect("must have bounds");
-        let un_endorsed_span = if let Some((circle, un_endorsed_span)) =
+        let un_endorsed_span: Span = if let Some((circle, un_endorsed_span)) =
             circle_map::endorse_circle_span(&self)
         {
             let circle = circle.absolute_position(top_left);
             let circle_frag_span =
                 FragmentSpan::new(self.clone(), circle.into());
-            fragments.push(circle_frag_span);
+            accepted.push(circle_frag_span);
             un_endorsed_span
         } else if let Some((arc, un_endorsed_span)) =
             circle_map::endorse_quarter_arc_span(&self)
         {
             let arc = arc.absolute_position(top_left);
             let arc_frag_span = FragmentSpan::new(self.clone(), arc.into());
-            fragments.push(arc_frag_span);
+            accepted.push(arc_frag_span);
             un_endorsed_span
         } else {
             self
         };
 
         let groups: Vec<Contacts> = un_endorsed_span.into();
-        let (rect_fragments, un_endorsed) = Contacts::endorse_rects(groups);
+        let rect_endorse = Contacts::endorse_rects(groups);
 
-        fragments.extend(rect_fragments);
-
-        (fragments, un_endorsed)
+        let mut endorse = Endorse {
+            accepted,
+            rejects: vec![],
+        };
+        endorse.extend(rect_endorse);
+        endorse
     }
 
     /// create a span of the cells that is inside of the start and end bound cells
@@ -180,23 +184,26 @@ impl Span {
     /// Convert a group of fragment span
     /// that didn't make it into an endorsed single shape fragment
     /// We try it again for endorsing to circle
-    fn re_endorsed(
+    pub fn re_endorse(
         grouped: Vec<Vec<FragmentSpan>>,
-    ) -> (Vec<FragmentSpan>, Vec<Contacts>) {
-        let spans = Self::extract_spans(grouped);
-        let merged_spans: Vec<Span> = Self::merge_recursive(spans);
-
-        let (endorsed_frag_spans, endorsed_contacts): (
-            Vec<Vec<FragmentSpan>>,
-            Vec<Vec<Contacts>>,
-        ) = merged_spans.into_iter().map(|span| span.endorse()).unzip();
-
-        (
-            endorsed_frag_spans.into_iter().flatten().collect(),
-            endorsed_contacts.into_iter().flatten().collect(),
-        )
+    ) -> Endorse<FragmentSpan, Contacts> {
+        let spans: Vec<Span> = Self::extract_spans(grouped);
+        let merge_spans = Span::merge_recursive(spans);
+
+        let (accepted, rejects): (Vec<Vec<FragmentSpan>>, Vec<Vec<Contacts>>) =
+            merge_spans
+                .into_iter()
+                .map(|span| span.endorse())
+                .map(|endorse| (endorse.accepted, endorse.rejects))
+                .unzip();
+
+        Endorse {
+            accepted: accepted.into_iter().flatten().collect(),
+            rejects: rejects.into_iter().flatten().collect(),
+        }
     }
-    fn extract_spans(grouped: Vec<Vec<FragmentSpan>>) -> Vec<Self> {
+
+    fn extract_spans(grouped: Vec<Vec<FragmentSpan>>) -> Vec<Span> {
         grouped
             .into_iter()
             .flat_map(|group| group.into_iter().map(|frag_span| frag_span.span))