Tidy up

1 files changed, 44 insertions, 41 deletions

diff --git a/src/library/grid.rs b/src/library/grid.rs
index 0aa1fc9d..cfe46bf4 100644
--- a/src/library/grid.rs
+++ b/src/library/grid.rs
@@ -1,76 +1,79 @@
-use crate::layout::GridNode;
+use crate::layout::{GridNode, TrackSizing, Tracks};
 
 use super::*;
 
-/// `stack`: Stack children along an axis.
+/// `grid`: Arrange children into a grid.
 ///
 /// # Positional parameters
 /// - Children: variadic, of type `template`.
 ///
 /// # Named parameters
-/// - Column widths: `columns`, of type `Array<GridUnit>`.
-/// - Row widths: `rows`, of type `Array<GridUnit>`.
-/// - Gutter: `gutter-vertical` and `gutter-horizontal` for individual track axis or `gutter` for both, of type `Array<GridUnit>` respectively.
-/// - Stacking direction: `dir`, of type `direction`.
+/// - Column sizing: `columns`, of type `tracks`.
+/// - Row sizing: `rows`, of type `tracks`.
+/// - Column direction: `column-dir`, of type `direction`.
+/// - Gutter: `gutter`, shorthand for equal column and row gutter, of type `tracks`.
+/// - Gutter for rows: `gutter-rows`, of type `tracks`.
+/// - Gutter for columns: `gutter-columns`, of type `tracks`.
 ///
 /// # Return value
 /// A template that arranges its children along the specified grid cells.
 ///
 /// # Relevant types and constants
+/// - Type `tracks`
+///   - coerces from `array` of `track-sizing`
+/// - Type `track-sizing`
+///   - `auto`
+//    - coerces from `length`
+//    - coerces from `relative`
+//    - coerces from `linear`
+//    - coerces from `fractional`
 /// - Type `direction`
 ///   - `ltr`
 ///   - `rtl`
 ///   - `ttb`
 ///   - `btt`
 pub fn grid(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
-    let cols = args.eat_named::<GridUnits>(ctx, "columns").unwrap_or_default();
-    let rows = args.eat_named::<GridUnits>(ctx, "rows").unwrap_or_default();
-
-    let gutter = args.eat_named(ctx, "gutter");
-    let gutter_vertical = args
-        .eat_named::<GridUnits>(ctx, "gutter-col")
-        .or_else(|| gutter.clone())
-        .unwrap_or_default();
-    let gutter_horizontal = args
-        .eat_named::<GridUnits>(ctx, "gutter-row")
-        .or(gutter)
-        .unwrap_or_default();
-
-    let dir = args.eat_named(ctx, "dir");
+    let columns = args.eat_named::<Tracks>(ctx, "columns").unwrap_or_default();
+    let rows = args.eat_named::<Tracks>(ctx, "rows").unwrap_or_default();
+    let column_dir = args.eat_named(ctx, "column-dir");
+    let gutter = args.eat_named::<Tracks>(ctx, "gutter").unwrap_or_default();
+    let gutter_columns = args.eat_named::<Tracks>(ctx, "gutter-columns");
+    let gutter_rows = args.eat_named::<Tracks>(ctx, "gutter-rows");
     let children = args.eat_all::<TemplateValue>(ctx);
 
     Value::template("grid", move |ctx| {
-        let children =
-            children.iter().map(|child| ctx.exec_template_stack(child).into()).collect();
+        let children = children
+            .iter()
+            .map(|child| ctx.exec_template_stack(child).into())
+            .collect();
+
         ctx.push(GridNode {
-            dir: dir.unwrap_or_else(|| ctx.state.lang.dir),
+            column_dir: column_dir.unwrap_or(ctx.state.lang.dir),
             children,
-            gutter: Gen::new(gutter_vertical.clone(), gutter_horizontal.clone()),
-            tracks: Gen::new(cols.clone(), rows.clone()),
+            tracks: Gen::new(columns.clone(), rows.clone()),
+            gutter: Gen::new(
+                gutter_columns.as_ref().unwrap_or(&gutter).clone(),
+                gutter_rows.as_ref().unwrap_or(&gutter).clone(),
+            ),
         })
     })
 }
 
-/// A list of [`GridUnit`]s.
-#[derive(Default, Debug, Clone, PartialEq, Hash)]
-pub struct GridUnits(pub Vec<TrackSizing>);
-
-impl GridUnits {
-    pub fn get(&self, index: usize) -> TrackSizing {
-        if self.0.is_empty() {
-            TrackSizing::Auto
-        } else {
-            *self.0.get(index).unwrap_or(self.0.last().unwrap())
-        }
-    }
-}
-
 value! {
-    GridUnits: "array of fractional values, lengths, and the `auto` keyword",
-    Value::TrackSizing(value) => Self(vec![value]),
+    Tracks: "array of `auto`s, linears, and fractionals",
+    Value::Int(count) => Self(vec![TrackSizing::Auto; count.max(0) as usize]),
     Value::Array(values) => Self(values
         .into_iter()
         .filter_map(|v| v.cast().ok())
         .collect()
     ),
 }
+
+value! {
+    TrackSizing: "`auto`, linear, or fractional",
+    Value::Auto => TrackSizing::Auto,
+    Value::Length(v) => TrackSizing::Linear(v.into()),
+    Value::Relative(v) => TrackSizing::Linear(v.into()),
+    Value::Linear(v) => TrackSizing::Linear(v),
+    Value::Fractional(v) => TrackSizing::Fractional(v),
+}