From 638a4493435dcd12d804f6ed40fdbe34dc4b091f Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 9 Mar 2024 13:49:29 +0100
Subject: [PATCH] Make naming scheme more consistent

Constructor functions that set/overwrite a value are called with_*,
functions that add a value are called and_*.
---
 Cargo.lock                             |   7 +
 showbits-common/Cargo.toml             |   1 +
 showbits-common/src/node.rs            | 272 +++++++++++--------------
 showbits-common/src/widget.rs          |   2 +-
 showbits-common/src/widgets/block.rs   |   4 +-
 showbits-common/src/widgets/text.rs    |   6 +-
 showbits-thermal-printer/src/drawer.rs |  22 +-
 7 files changed, 144 insertions(+), 170 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 37d7399..21f8bf1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -864,6 +864,12 @@ dependencies = [
  "windows-targets 0.48.5",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
@@ -1167,6 +1173,7 @@ dependencies = [
  "cosmic-text",
  "image",
  "palette",
+ "paste",
  "showbits-assets",
  "taffy",
 ]
diff --git a/showbits-common/Cargo.toml b/showbits-common/Cargo.toml
index 32e85f3..de68233 100644
--- a/showbits-common/Cargo.toml
+++ b/showbits-common/Cargo.toml
@@ -8,6 +8,7 @@ anyhow.workspace = true
 cosmic-text.workspace = true
 image.workspace = true
 palette.workspace = true
+paste = "1.0.14"
 showbits-assets.workspace = true
 taffy.workspace = true
 
diff --git a/showbits-common/src/node.rs b/showbits-common/src/node.rs
index ce54bf3..645ff2f 100644
--- a/showbits-common/src/node.rs
+++ b/showbits-common/src/node.rs
@@ -1,3 +1,4 @@
+use paste::paste;
 use taffy::{
     AlignContent, AlignItems, AlignSelf, Dimension, Display, FlexDirection, FlexWrap, GridAutoFlow,
     GridPlacement, JustifyContent, LengthPercentage, LengthPercentageAuto, Line, NodeId,
@@ -22,12 +23,12 @@ impl<C> Node<C> {
         }
     }
 
-    pub fn child(mut self, node: NodeId) -> Self {
+    pub fn and_child(mut self, node: NodeId) -> Self {
         self.children.push(node);
         self
     }
 
-    pub fn widget<W: Widget<C> + 'static>(mut self, widget: W) -> Self {
+    pub fn with_widget<W: Widget<C> + 'static>(mut self, widget: W) -> Self {
         self.widget = Some(Box::new(widget));
         self
     }
@@ -44,212 +45,177 @@ impl<C> Node<C> {
 
 macro_rules! layout_setter {
     ( $name:ident : $type:ty ) => {
-        pub fn $name(mut self, $name: $type) -> Self {
-            self.layout.$name = $name;
-            self
+        paste! {
+            pub fn [<with_ $name>](mut self, $name: $type) -> Self {
+                self.layout.$name = $name;
+                self
+            }
         }
     };
 }
 
 macro_rules! layout_setter_point {
-    (
-        $name:ident : Point<$type:ty>
-        as $name_x:ident, $name_y:ident
-        as $name_all:ident
-    ) => {
-        pub fn $name_x(mut self, x: $type) -> Self {
-            self.layout.$name.x = x;
-            self
-        }
+    ( $name:ident : Point<$type:ty> ) => {
+        paste! {
+            pub fn [<with_ $name>](mut self, $name: Point<$type>) -> Self {
+                self.layout.$name = $name;
+                self
+            }
 
-        pub fn $name_y(mut self, y: $type) -> Self {
-            self.layout.$name.y = y;
-            self
-        }
+            pub fn [<with_ $name _x>](mut self, x: $type) -> Self {
+                self.layout.$name.x = x;
+                self
+            }
 
-        pub fn $name_all(mut self, all: $type) -> Self {
-            self.layout.$name.x = all;
-            self.layout.$name.y = all;
-            self
+            pub fn [<with_ $name _y>](mut self, y: $type) -> Self {
+                self.layout.$name.y = y;
+                self
+            }
+
+            pub fn [<with_ $name _all>](mut self, all: $type) -> Self {
+                self.layout.$name.x = all;
+                self.layout.$name.y = all;
+                self
+            }
         }
     };
 }
 
 macro_rules! layout_setter_size {
-    (
-        $name:ident : Size<$type:ty>
-        as $name_width:ident, $name_height:ident
-        as $name_all:ident
-    ) => {
-        pub fn $name_width(mut self, width: $type) -> Self {
-            self.layout.$name.width = width;
-            self
-        }
+    ( $name:ident : Size<$type:ty> ) => {
+        paste! {
+            pub fn [<with_ $name>](mut self, $name: Size<$type>) -> Self {
+                self.layout.$name = $name;
+                self
+            }
 
-        pub fn $name_height(mut self, height: $type) -> Self {
-            self.layout.$name.height = height;
-            self
-        }
+            pub fn [<with_ $name _width>](mut self, width: $type) -> Self {
+                self.layout.$name.width = width;
+                self
+            }
 
-        pub fn $name_all(mut self, all: $type) -> Self {
-            self.layout.$name.width = all;
-            self.layout.$name.height = all;
-            self
+            pub fn [<with_ $name _height>](mut self, height: $type) -> Self {
+                self.layout.$name.height = height;
+                self
+            }
+
+            pub fn [<with_ $name _all>](mut self, all: $type) -> Self {
+                self.layout.$name.width = all;
+                self.layout.$name.height = all;
+                self
+            }
         }
     };
 }
 
 macro_rules! layout_setter_line {
-    (
-        $name:ident : Line<$type:ty>
-        as $name_start:ident, $name_end:ident
-        as $name_all:ident
-    ) => {
-        pub fn $name_start(mut self, start: $type) -> Self {
-            self.layout.$name.start = start;
-            self
-        }
+    ( $name:ident : Line<$type:ty> ) => {
+        paste! {
+            pub fn [<with_ $name>](mut self, $name: Line<$type>) -> Self {
+                self.layout.$name = $name;
+                self
+            }
 
-        pub fn $name_end(mut self, end: $type) -> Self {
-            self.layout.$name.end = end;
-            self
-        }
+            pub fn [<with_ $name _start>](mut self, start: $type) -> Self {
+                self.layout.$name.start = start;
+                self
+            }
 
-        pub fn $name_all(mut self, all: $type) -> Self {
-            self.layout.$name.start = all;
-            self.layout.$name.end = all;
-            self
+            pub fn [<with_ $name _end>](mut self, end: $type) -> Self {
+                self.layout.$name.end = end;
+                self
+            }
+
+            pub fn [<with_ $name _all>](mut self, all: $type) -> Self {
+                self.layout.$name.start = all;
+                self.layout.$name.end = all;
+                self
+            }
         }
     };
 }
 
 macro_rules! layout_setter_rect {
-    (
-        $name:ident : Rect<$type:ty>
-        as $name_left:ident, $name_right:ident, $name_top:ident, $name_bottom:ident
-        as $name_horiz:ident, $name_vert:ident, $name_all:ident
-    ) => {
-        pub fn $name_left(mut self, left: $type) -> Self {
-            self.layout.$name.left = left;
-            self
-        }
+    ( $name:ident : Rect<$type:ty> ) => {
+        paste! {
+            pub fn [<with_ $name>](mut self, $name: Rect<$type>) -> Self {
+                self.layout.$name = $name;
+                self
+            }
 
-        pub fn $name_right(mut self, right: $type) -> Self {
-            self.layout.$name.right = right;
-            self
-        }
+            pub fn [<with_ $name _left>](mut self, left: $type) -> Self {
+                self.layout.$name.left = left;
+                self
+            }
 
-        pub fn $name_top(mut self, top: $type) -> Self {
-            self.layout.$name.top = top;
-            self
-        }
+            pub fn [<with_ $name _right>](mut self, right: $type) -> Self {
+                self.layout.$name.right = right;
+                self
+            }
 
-        pub fn $name_bottom(mut self, left: $type) -> Self {
-            self.layout.$name.bottom = left;
-            self
-        }
+            pub fn [<with_ $name _top>](mut self, top: $type) -> Self {
+                self.layout.$name.top = top;
+                self
+            }
 
-        pub fn $name_horiz(mut self, horizontal: $type) -> Self {
-            self.layout.$name.left = horizontal;
-            self.layout.$name.right = horizontal;
-            self
-        }
+            pub fn [<with_ $name _bottom>](mut self, left: $type) -> Self {
+                self.layout.$name.bottom = left;
+                self
+            }
 
-        pub fn $name_vert(mut self, vertical: $type) -> Self {
-            self.layout.$name.top = vertical;
-            self.layout.$name.bottom = vertical;
-            self
-        }
+            pub fn [<with_ $name _horiz>](mut self, horizontal: $type) -> Self {
+                self.layout.$name.left = horizontal;
+                self.layout.$name.right = horizontal;
+                self
+            }
 
-        pub fn $name_all(mut self, all: $type) -> Self {
-            self.layout.$name.left = all;
-            self.layout.$name.right = all;
-            self.layout.$name.top = all;
-            self.layout.$name.bottom = all;
-            self
+            pub fn [<with_ $name _vert>](mut self, vertical: $type) -> Self {
+                self.layout.$name.top = vertical;
+                self.layout.$name.bottom = vertical;
+                self
+            }
+
+            pub fn [<with_ $name _all>](mut self, all: $type) -> Self {
+                self.layout.$name.left = all;
+                self.layout.$name.right = all;
+                self.layout.$name.top = all;
+                self.layout.$name.bottom = all;
+                self
+            }
         }
     };
 }
 
 impl<C> Node<C> {
     layout_setter!(display: Display);
-
-    layout_setter!(overflow: Point<Overflow>);
-    layout_setter_point!(overflow: Point<Overflow>
-        as overflow_x, overflow_y
-        as overflow_all);
-
+    layout_setter_point!(overflow: Point<Overflow>);
     layout_setter!(scrollbar_width: f32);
     layout_setter!(position: Position);
-
-    layout_setter!(inset: Rect<LengthPercentageAuto>);
-    layout_setter_rect!(inset: Rect<LengthPercentageAuto>
-        as inset_left, inset_right, inset_top, inset_bottom
-        as inset_horiz, inset_vert, inset_all);
-
-    layout_setter!(size: Size<Dimension>);
-    layout_setter_size!(size: Size<Dimension>
-        as size_width, size_height
-        as size_all);
-
-    layout_setter!(min_size: Size<Dimension>);
-    layout_setter_size!(min_size: Size<Dimension>
-        as min_size_width, min_size_height
-        as min_size_all);
-
-    layout_setter!(max_size: Size<Dimension>);
-    layout_setter_size!(max_size: Size<Dimension>
-        as max_size_width, max_size_height
-        as max_size_all);
-
+    layout_setter_rect!(inset: Rect<LengthPercentageAuto>);
+    layout_setter_size!(size: Size<Dimension>);
+    layout_setter_size!(min_size: Size<Dimension>);
+    layout_setter_size!(max_size: Size<Dimension>);
     layout_setter!(aspect_ratio: Option<f32>);
-
-    layout_setter!(margin: Rect<LengthPercentageAuto>);
-    layout_setter_rect!(margin: Rect<LengthPercentageAuto>
-        as margin_left, margin_right, margin_top, margin_bottom
-        as margin_horiz, margin_vert, margin_all);
-
-    layout_setter!(padding: Rect<LengthPercentage>);
-    layout_setter_rect!(padding: Rect<LengthPercentage>
-        as padding_left, padding_right, padding_top, padding_bottom
-        as padding_horiz, padding_vert, padding_all);
-
-    layout_setter!(border: Rect<LengthPercentage>);
-    layout_setter_rect!(border: Rect<LengthPercentage>
-        as border_left, border_right, border_top, border_bottom
-        as border_horiz, border_vert, border_all);
-
+    layout_setter_rect!(margin: Rect<LengthPercentageAuto>);
+    layout_setter_rect!(padding: Rect<LengthPercentage>);
+    layout_setter_rect!(border: Rect<LengthPercentage>);
     layout_setter!(align_items: Option<AlignItems>);
     layout_setter!(align_self: Option<AlignSelf>);
     layout_setter!(justify_items: Option<AlignItems>);
     layout_setter!(justify_self: Option<AlignSelf>);
     layout_setter!(align_content: Option<AlignContent>);
     layout_setter!(justify_content: Option<JustifyContent>);
-
-    layout_setter!(gap: Size<LengthPercentage>);
-    layout_setter_size!(gap: Size<LengthPercentage>
-        as gap_width, gap_height
-        as gap_all);
-
+    layout_setter_size!(gap: Size<LengthPercentage>);
     layout_setter!(flex_direction: FlexDirection);
     layout_setter!(flex_wrap: FlexWrap);
     layout_setter!(flex_basis: Dimension);
     layout_setter!(flex_grow: f32);
     layout_setter!(flex_shrink: f32);
-
     layout_setter!(grid_template_rows: Vec<TrackSizingFunction>);
     layout_setter!(grid_template_columns: Vec<TrackSizingFunction>);
     layout_setter!(grid_auto_rows: Vec<NonRepeatedTrackSizingFunction>);
     layout_setter!(grid_auto_columns: Vec<NonRepeatedTrackSizingFunction>);
     layout_setter!(grid_auto_flow: GridAutoFlow);
-
-    layout_setter!(grid_row: Line<GridPlacement>);
-    layout_setter_line!(grid_row: Line<GridPlacement>
-        as grid_row_start, grid_row_end
-        as grid_row_all);
-
-    layout_setter!(grid_column: Line<GridPlacement>);
-    layout_setter_line!(grid_column: Line<GridPlacement>
-        as grid_column_start, grid_column_end
-        as grid_column_all);
+    layout_setter_line!(grid_row: Line<GridPlacement>);
+    layout_setter_line!(grid_column: Line<GridPlacement>);
 }
diff --git a/showbits-common/src/widget.rs b/showbits-common/src/widget.rs
index 67c7ad9..c8988e4 100644
--- a/showbits-common/src/widget.rs
+++ b/showbits-common/src/widget.rs
@@ -48,6 +48,6 @@ pub trait WidgetExt<C> {
 
 impl<C, W: Widget<C> + 'static> WidgetExt<C> for W {
     fn node(self) -> Node<C> {
-        Node::empty().widget(self)
+        Node::empty().with_widget(self)
     }
 }
diff --git a/showbits-common/src/widgets/block.rs b/showbits-common/src/widgets/block.rs
index 55662bb..30f010c 100644
--- a/showbits-common/src/widgets/block.rs
+++ b/showbits-common/src/widgets/block.rs
@@ -16,12 +16,12 @@ impl Block {
         }
     }
 
-    pub fn border(mut self, color: Srgba) -> Self {
+    pub fn with_border(mut self, color: Srgba) -> Self {
         self.border = color;
         self
     }
 
-    pub fn background(mut self, color: Srgba) -> Self {
+    pub fn with_background(mut self, color: Srgba) -> Self {
         self.background = color;
         self
     }
diff --git a/showbits-common/src/widgets/text.rs b/showbits-common/src/widgets/text.rs
index 45615c1..376bbf6 100644
--- a/showbits-common/src/widgets/text.rs
+++ b/showbits-common/src/widgets/text.rs
@@ -96,19 +96,19 @@ impl Text {
         self
     }
 
-    pub fn chunk_plain<S: ToString>(mut self, text: S) -> Self {
+    pub fn and_plain<S: ToString>(mut self, text: S) -> Self {
         let chunk = (self.default_attrs.clone(), text.to_string());
         self.chunks.push(chunk);
         self
     }
 
-    pub fn chunk_rich<S: ToString>(mut self, attrs: Attrs<'_>, text: S) -> Self {
+    pub fn and_rich<S: ToString>(mut self, attrs: Attrs<'_>, text: S) -> Self {
         let chunk = (AttrsOwned::new(attrs), text.to_string());
         self.chunks.push(chunk);
         self
     }
 
-    pub fn chunks<I>(mut self, chunks: I) -> Self
+    pub fn and_chunks<I>(mut self, chunks: I) -> Self
     where
         I: IntoIterator<Item = (AttrsOwned, String)>,
     {
diff --git a/showbits-thermal-printer/src/drawer.rs b/showbits-thermal-printer/src/drawer.rs
index 77e5284..7e60fc5 100644
--- a/showbits-thermal-printer/src/drawer.rs
+++ b/showbits-thermal-printer/src/drawer.rs
@@ -69,28 +69,28 @@ impl Drawer {
         let mut tree = Tree::<Context>::new(Srgba::new(1.0, 1.0, 1.0, 1.0));
 
         let text = Text::new()
-            .chunk_plain("Hello\nworld!")
             .with_metrics(Text::default_metrics().scale(2.0))
+            .and_plain("Hello\nworld!")
             .widget(&mut self.ctx.font_stuff)
             .node()
-            .margin_horiz(length(8.0))
-            .margin_vert(length(2.0))
+            .with_margin_horiz(length(8.0))
+            .with_margin_vert(length(2.0))
             .register(&mut tree)?;
 
         let wrap = Block::new()
-            .border(color::BLACK)
+            .with_border(color::BLACK)
             .node()
-            .border_all(length(2.0))
-            .child(text)
+            .with_border_all(length(2.0))
+            .and_child(text)
             .register(&mut tree)?;
 
         let root = Block::new()
-            .border(color::BLACK)
+            .with_border(color::BLACK)
             .node()
-            .size_width(percent(1.0))
-            .border_all(length(2.0))
-            .padding_all(length(10.0))
-            .child(wrap)
+            .with_size_width(percent(1.0))
+            .with_border_all(length(2.0))
+            .with_padding_all(length(10.0))
+            .and_child(wrap)
             .register(&mut tree)?;
 
         self.printer.print_tree(&mut tree, &mut self.ctx, root)?;