Remove Builder abstractions for gradients

core/src/gradient.rs

@@ -1,8 +1,8 @@
-//! For creating a Gradient.
-pub use linear::Linear;
-
+//! Colors that transition progressively.
 use crate::{Color, Radians};
 
+use std::cmp::Ordering;
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 /// A fill which transitions colors progressively along a direction, either linearly, radially (TBD),
 /// or conically (TBD).
@@ -14,19 +14,11 @@ pub enum Gradient {
 }
 
 impl Gradient {
-    /// Creates a new linear [`linear::Builder`].
-    ///
-    /// This must be defined by an angle (in [`Degrees`] or [`Radians`])
-    /// which will use the bounds of the widget as a guide.
-    pub fn linear(angle: impl Into<Radians>) -> linear::Builder {
-        linear::Builder::new(angle.into())
-    }
-
     /// Adjust the opacity of the gradient by a multiplier applied to each color stop.
     pub fn mul_alpha(mut self, alpha_multiplier: f32) -> Self {
         match &mut self {
             Gradient::Linear(linear) => {
-                for stop in linear.color_stops.iter_mut().flatten() {
+                for stop in linear.stops.iter_mut().flatten() {
                     stop.color.a *= alpha_multiplier;
                 }
             }
@@ -36,6 +28,12 @@ impl Gradient {
     }
 }
 
+impl From<Linear> for Gradient {
+    fn from(gradient: Linear) -> Self {
+        Self::Linear(gradient)
+    }
+}
+
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 /// A point along the gradient vector where the specified [`color`] is unmixed.
 ///
@@ -50,84 +48,58 @@ pub struct ColorStop {
     pub color: Color,
 }
 
-pub mod linear {
-    //! Linear gradient builder & definition.
-    use crate::gradient::{ColorStop, Gradient};
-    use crate::{Color, Radians};
-    use std::cmp::Ordering;
+/// A linear gradient.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Linear {
+    /// How the [`Gradient`] is angled within its bounds.
+    pub angle: Radians,
+    /// [`ColorStop`]s along the linear gradient path.
+    pub stops: [Option<ColorStop>; 8],
+}
 
-    /// A linear gradient that can be used as a [`Background`].
-    #[derive(Debug, Clone, Copy, PartialEq)]
-    pub struct Linear {
-        /// How the [`Gradient`] is angled within its bounds.
-        pub angle: Radians,
-        /// [`ColorStop`]s along the linear gradient path.
-        pub color_stops: [Option<ColorStop>; 8],
+impl Linear {
+    /// Creates a new [`Linear`] gradient with the given angle in [`Radians`].
+    pub fn new(angle: impl Into<Radians>) -> Self {
+        Self {
+            angle: angle.into(),
+            stops: [None; 8],
+        }
     }
 
-    /// A [`Linear`] builder.
-    #[derive(Debug)]
-    pub struct Builder {
-        angle: Radians,
-        stops: [Option<ColorStop>; 8],
+    /// Adds a new [`ColorStop`], defined by an offset and a color, to the gradient.
+    ///
+    /// Any `offset` that is not within `0.0..=1.0` will be silently ignored.
+    ///
+    /// Any stop added after the 8th will be silently ignored.
+    pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
+        if offset.is_finite() && (0.0..=1.0).contains(&offset) {
+            let (Ok(index) | Err(index)) =
+                self.stops.binary_search_by(|stop| match stop {
+                    None => Ordering::Greater,
+                    Some(stop) => stop.offset.partial_cmp(&offset).unwrap(),
+                });
+
+            if index < 8 {
+                self.stops[index] = Some(ColorStop { offset, color });
+            }
+        } else {
+            log::warn!("Gradient color stop must be within 0.0..=1.0 range.");
+        };
+
+        self
     }
 
-    impl Builder {
-        /// Creates a new [`Builder`].
-        pub fn new(angle: Radians) -> Self {
-            Self {
-                angle,
-                stops: [None; 8],
-            }
+    /// Adds multiple [`ColorStop`]s to the gradient.
+    ///
+    /// Any stop added after the 8th will be silently ignored.
+    pub fn add_stops(
+        mut self,
+        stops: impl IntoIterator<Item = ColorStop>,
+    ) -> Self {
+        for stop in stops.into_iter() {
+            self = self.add_stop(stop.offset, stop.color)
         }
 
-        /// Adds a new [`ColorStop`], defined by an offset and a color, to the gradient.
-        ///
-        /// Any `offset` that is not within `0.0..=1.0` will be silently ignored.
-        ///
-        /// Any stop added after the 8th will be silently ignored.
-        pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
-            if offset.is_finite() && (0.0..=1.0).contains(&offset) {
-                let (Ok(index) | Err(index)) =
-                    self.stops.binary_search_by(|stop| match stop {
-                        None => Ordering::Greater,
-                        Some(stop) => stop.offset.partial_cmp(&offset).unwrap(),
-                    });
-
-                if index < 8 {
-                    self.stops[index] = Some(ColorStop { offset, color });
-                }
-            } else {
-                log::warn!(
-                    "Gradient color stop must be within 0.0..=1.0 range."
-                );
-            };
-
-            self
-        }
-
-        /// Adds multiple [`ColorStop`]s to the gradient.
-        ///
-        /// Any stop added after the 8th will be silently ignored.
-        pub fn add_stops(
-            mut self,
-            stops: impl IntoIterator<Item = ColorStop>,
-        ) -> Self {
-            for stop in stops.into_iter() {
-                self = self.add_stop(stop.offset, stop.color)
-            }
-
-            self
-        }
-
-        /// Builds the linear [`Gradient`] of this [`Builder`].
-        ///
-        /// Returns `BuilderError` if gradient in invalid.
-        pub fn build(self) -> Gradient {
-            Gradient::Linear(Linear {
-                angle: self.angle,
-                color_stops: self.stops,
-            })
-        }
+        self
     }
 }