simplify rectangles

clippy.toml

@@ -0,0 +1 @@
+cognitive-complexity-threshold = 3

src/lib.rs

@@ -1,6 +1,8 @@
 //! # RADN
 //! Rainbow something something Network.
 
+#![warn(clippy::cognitive_complexity)]
+
 pub mod atomic;
 pub mod flow;
 pub mod func;

src/rstd/tracing/rendered.rs

@@ -207,25 +207,44 @@ impl WithLengthAndWidth<RenderedAny> {
         match self.value {
             RenderedAny::Common(common) => common.rectangles(vec, t, c),
             RenderedAny::Wide(rendereds) => {
-                let mut c = c;
+                Self::wide_rectangles(c, rendereds, vec, t);
-                for rendered in rendereds.into_iter().map(|x| x.map(RenderedLong::any)) {
-                    let rw = rendered.width;
-                    rendered.rectangles(vec, t, c);
-                    c += 2 * rw;
-                }
             }
             RenderedAny::Long(rendereds) => {
-                let mut t = t;
+                Self::long_rectangles(t, rendereds, vec, c, self.width);
-                for rendered in rendereds.into_iter().map(|x| x.map(RenderedWide::any)) {
-                    let rl = rendered.length;
-                    let rw = rendered.width;
-                    rendered.rectangles(vec, t, c + (self.width - rw) / 2);
-                    t += rl;
-                }
             }
         }
     }
 
+    fn wide_rectangles(
+        c: usize,
+        rendereds: Vec<WithLengthAndWidth<RenderedLong>>,
+        vec: &mut Vec<(usize, usize)>,
+        t: usize,
+    ) {
+        let mut c = c;
+        for rendered in rendereds.into_iter().map(|x| x.map(RenderedLong::any)) {
+            let rw = rendered.width;
+            rendered.rectangles(vec, t, c);
+            c += 2 * rw;
+        }
+    }
+
+    fn long_rectangles(
+        t: usize,
+        rendereds: Vec<WithLengthAndWidth<RenderedWide>>,
+        vec: &mut Vec<(usize, usize)>,
+        c: usize,
+        width: usize,
+    ) {
+        let mut t = t;
+        for rendered in rendereds.into_iter().map(|x| x.map(RenderedWide::any)) {
+            let rl = rendered.length;
+            let rw = rendered.width;
+            rendered.rectangles(vec, t, c + (width - rw) / 2);
+            t += rl;
+        }
+    }
+
     pub fn to_vec(self) -> Vec<(usize, usize)> {
         let mut vec = Vec::new();
         self.rectangles(&mut vec, 0, 0);