feat: add extend, moved and direction methods to grid line

Author: manhunto

src/solutions/year2023/day25.rs

@@ -88,13 +88,12 @@ impl Graph {
             .push(to.to_string());
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     fn remove_unidirectional_connection(&mut self, from: &String, to: &String) {
         self.remove_directional_connection(from, to);
         self.remove_directional_connection(to, from);
     }
 
-    #[allow(dead_code)]
     fn remove_directional_connection(&mut self, from: &String, to: &String) {
         let from_connections = self.connections.entry(from.to_string()).or_default();
         if let Some(index) = from_connections.iter().position(|f| f == to) {

src/solutions/year2024/day05.rs

@@ -58,7 +58,6 @@ impl From<&str> for Rule {
 
 #[derive(Debug)]
 struct Update {
-    #[allow(dead_code)]
     pages: Vec<usize>,
 }
 

src/solutions/year2024/day21.rs

@@ -105,7 +105,7 @@ impl Day21 {
                     .iter()
                     .collect_vec()
                     .windows(2)
-                    .map(|pair| Dir(pair[0].direction(pair[1]).unwrap()))
+                    .map(|pair| Dir(pair[0].direction(pair[1])))
                     .collect();
                 directions.push(Activate);
 

src/solutions/year2025/day07.rs

@@ -87,7 +87,7 @@ impl Day07 {
     }
 }
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 fn print(grid: &Grid<char>, beams: &[Beam]) {
     let mut new = grid.clone();
     new.print(beams);

src/utils/deltoid_surface.rs

@@ -1,9 +1,7 @@
 use crate::utils::point::Point;
 
 pub struct DeltoidSurface {
-    #[allow(dead_code)]
     point: Point,
-    #[allow(dead_code)]
     distance: usize,
 }
 

src/utils/grid.rs

@@ -46,7 +46,7 @@ where
         Self::new(cells)
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn filled(surface_range: SurfaceRange, element: T) -> Self
     where
         T: Clone,
@@ -178,7 +178,7 @@ where
         *self.cells.get_mut(&point).unwrap() = new_value;
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn modify_many(&mut self, points: Vec<Point>, new_value: T)
     where
         T: Clone,
@@ -188,7 +188,7 @@ where
         }
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn modify_many_with<F>(&mut self, points: Vec<Point>, mut func: F)
     where
         F: FnMut(&mut T),
@@ -380,7 +380,7 @@ where
         printable.print(self)
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn all(&self) -> HashMap<Point, T>
     where
         T: Clone,

src/utils/grid_line.rs

@@ -1,3 +1,4 @@
+use crate::utils::direction::Direction;
 use crate::utils::point::Point;
 use crate::utils::range::Range;
 
@@ -53,7 +54,7 @@ impl GridLine {
         matches!(self, Self::Vertical { .. })
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn is_horizontal(&self) -> bool {
         matches!(self, Self::Horizontal { .. })
     }
@@ -87,10 +88,60 @@ impl GridLine {
             }
         }
     }
+
+    /// It extends its size by 1 in the direction of orientation
+    #[expect(dead_code)]
+    pub fn extend(&self) -> Self {
+        match self {
+            GridLine::Horizontal {
+                y: _,
+                x_start,
+                x_end,
+            } => {
+                if x_start < x_end {
+                    GridLine::new(self.start().west(), self.end().east()).unwrap()
+                } else {
+                    GridLine::new(self.start().east(), self.end().west()).unwrap()
+                }
+            }
+            GridLine::Vertical {
+                x: _,
+                y_start,
+                y_end,
+            } => {
+                if y_start < y_end {
+                    GridLine::new(self.start().north(), self.end().south()).unwrap()
+                } else {
+                    GridLine::new(self.start().south(), self.end().north()).unwrap()
+                }
+            }
+        }
+    }
+
+    /// Move line in direction by 1
+    #[expect(dead_code)]
+    pub fn moved(&self, direction: Direction) -> Option<Self> {
+        let start = self.start();
+        let end = self.end();
+
+        match direction {
+            Direction::North => Self::new(start.north(), end.north()),
+            Direction::East => Self::new(start.east(), end.east()),
+            Direction::South => Self::new(start.south(), end.south()),
+            Direction::West => Self::new(start.west(), end.west()),
+            _ => unimplemented!("Direction {} unimplemented to move grid line", direction),
+        }
+    }
+
+    #[expect(dead_code)]
+    pub fn direction(&self) -> Direction {
+        self.start().direction(&self.end())
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::utils::direction::Direction;
     use crate::utils::grid_line::GridLine;
     use crate::utils::point::Point;
 
@@ -183,4 +234,104 @@ mod tests {
         assert!(!line.is_on(&Point::new(2, 5)));
         assert!(!line.is_on(&Point::new(3, 2)));
     }
+
+    #[test]
+    fn extend_vertical() {
+        let line = GridLine::new(Point::new(1, 1), Point::new(4, 1)).unwrap();
+        let extended = line.extend();
+
+        assert_eq!(Point::new(0, 1), extended.start());
+        assert_eq!(Point::new(5, 1), extended.end());
+    }
+
+    #[test]
+    fn extend_vertical_reversed() {
+        let line = GridLine::new(Point::new(5, 1), Point::new(0, 1)).unwrap();
+        let extended = line.extend();
+
+        assert_eq!(Point::new(6, 1), extended.start());
+        assert_eq!(Point::new(-1, 1), extended.end());
+    }
+
+    #[test]
+    fn extend_horizontal() {
+        let line = GridLine::new(Point::new(5, 4), Point::new(5, 11)).unwrap();
+        let extended = line.extend();
+
+        assert_eq!(Point::new(5, 3), extended.start());
+        assert_eq!(Point::new(5, 12), extended.end());
+    }
+
+    #[test]
+    fn extend_horizontal_reversed() {
+        let line = GridLine::new(Point::new(3, 8), Point::new(3, 2)).unwrap();
+        let extended = line.extend();
+
+        assert_eq!(Point::new(3, 9), extended.start());
+        assert_eq!(Point::new(3, 1), extended.end());
+    }
+
+    #[test]
+    fn moved_horizontal() {
+        let line = GridLine::new(Point::new(3, 8), Point::new(3, 2)).unwrap();
+        let east = line.moved(Direction::East);
+
+        assert!(east.is_some());
+        assert_eq!(
+            GridLine::new(Point::new(4, 8), Point::new(4, 2)).unwrap(),
+            east.unwrap()
+        );
+
+        let west = line.moved(Direction::West);
+
+        assert!(west.is_some());
+        assert_eq!(
+            GridLine::new(Point::new(2, 8), Point::new(2, 2)).unwrap(),
+            west.unwrap()
+        );
+    }
+
+    #[test]
+    fn moved_vertical() {
+        let line = GridLine::new(Point::new(2, 7), Point::new(7, 7)).unwrap();
+        let north = line.moved(Direction::North);
+
+        assert!(north.is_some());
+        assert_eq!(
+            GridLine::new(Point::new(2, 6), Point::new(7, 6)).unwrap(),
+            north.unwrap()
+        );
+
+        let south = line.moved(Direction::South);
+
+        assert!(south.is_some());
+        assert_eq!(
+            GridLine::new(Point::new(2, 8), Point::new(7, 8)).unwrap(),
+            south.unwrap()
+        );
+    }
+
+    #[test]
+    fn direction_horizontal_east() {
+        let line = GridLine::new(Point::new(1, 3), Point::new(4, 3)).unwrap();
+        assert_eq!(Direction::East, line.direction());
+    }
+
+    #[test]
+    fn direction_horizontal_west() {
+        let line = GridLine::new(Point::new(4, 3), Point::new(1, 3)).unwrap();
+        assert_eq!(Direction::West, line.direction());
+    }
+
+    #[test]
+    fn direction_vertical_south() {
+        let line = GridLine::new(Point::new(2, 1), Point::new(2, 4)).unwrap();
+        assert_eq!(Direction::South, line.direction());
+    }
+
+    #[test]
+    fn direction_vertical_north() {
+        let line = GridLine::new(Point::new(2, 4), Point::new(2, 1)).unwrap();
+        assert_eq!(Direction::North, line.direction());
+    }
 }

src/utils/line.rs

@@ -46,7 +46,7 @@ impl Line {
         Some(Point::new(x as isize, y as isize))
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn is_on(&self, point: &Point) -> bool {
         let a = self.start;
         let b = self.end;

src/utils/point.rs

@@ -115,25 +115,21 @@ impl Point {
         self.move_in(SouthWest)
     }
 
-    pub fn direction(&self, other: &Self) -> Result<Direction, String> {
-        if !self.is_neighbour(other) {
-            return Err(format!(
-                "Point {} is not neighbour for point {}",
-                self, other
-            ));
+    pub fn direction(&self, other: &Self) -> Direction {
+        let diff = *other - *self;
+
+        if diff.x == 0 {
+            return if diff.y > 0 { South } else { North };
         }
 
-        let diff = *other - *self;
+        if diff.y == 0 {
+            return if diff.x > 0 { East } else { West };
+        }
 
-        Ok(match (diff.x, diff.y) {
-            (0, 1) => South,
-            (0, -1) => North,
-            (1, 0) => East,
-            (-1, 0) => West,
-            _ => todo!("Implement diagonal directions"),
-        })
+        unimplemented!("Diagonal directions are not implemented");
     }
 
+    #[expect(dead_code)]
     fn is_neighbour(&self, other: &Self) -> bool {
         let distance = self.distance(other);
 
@@ -146,12 +142,12 @@ impl Point {
         ((diff.x.abs().pow(2) + diff.y.abs().pow(2)) as f64).sqrt()
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn with_y(self, y: isize) -> Self {
         Self::new(self.x, y)
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn with_x(self, x: isize) -> Self {
         Self::new(x, self.y)
     }
@@ -279,17 +275,16 @@ mod tests {
     fn direction() {
         let point = Point::new(2, 2);
 
-        assert_eq!(
-            Direction::South,
-            point.direction(&Point::new(2, 3)).unwrap()
-        );
-        assert_eq!(
-            Direction::North,
-            point.direction(&Point::new(2, 1)).unwrap()
-        );
-        assert_eq!(Direction::West, point.direction(&Point::new(1, 2)).unwrap());
-        assert_eq!(Direction::East, point.direction(&Point::new(3, 2)).unwrap());
-
-        assert!(point.direction(&Point::new(4, 3)).is_err());
+        // adjacent
+        assert_eq!(Direction::South, point.direction(&Point::new(2, 3)));
+        assert_eq!(Direction::North, point.direction(&Point::new(2, 1)));
+        assert_eq!(Direction::West, point.direction(&Point::new(1, 2)));
+        assert_eq!(Direction::East, point.direction(&Point::new(3, 2)));
+
+        // further
+        assert_eq!(Direction::South, point.direction(&Point::new(2, 5)));
+        assert_eq!(Direction::North, point.direction(&Point::new(2, -1)));
+        assert_eq!(Direction::West, point.direction(&Point::new(-5, 2)));
+        assert_eq!(Direction::East, point.direction(&Point::new(7, 2)));
     }
 }

src/utils/range.rs

@@ -136,12 +136,12 @@ impl Range {
         self.iter().collect::<Vec<isize>>().into_iter().rev()
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn is_before(&self, value: isize) -> bool {
         self.start > value
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn is_after(&self, value: isize) -> bool {
         self.end < value
     }