feat: implement extend for polygon

Author: manhunto

src/utils/grid.rs

@@ -46,7 +46,7 @@ where
         Self::new(cells)
     }
 
-    #[expect(dead_code)]
+    #[allow(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;
     }
 
-    #[expect(dead_code)]
+    #[allow(dead_code)]
     pub fn modify_many(&mut self, points: Vec<Point>, new_value: T)
     where
         T: Clone,

src/utils/grid_line.rs

@@ -54,7 +54,7 @@ impl GridLine {
         matches!(self, Self::Vertical { .. })
     }
 
-    #[expect(dead_code)]
+    #[allow(dead_code)]
     pub fn is_horizontal(&self) -> bool {
         matches!(self, Self::Horizontal { .. })
     }
@@ -90,7 +90,6 @@ 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 {
@@ -119,21 +118,19 @@ impl GridLine {
     }
 
     /// Move line in direction by 1
-    #[expect(dead_code)]
-    pub fn moved(&self, direction: Direction) -> Option<Self> {
+    pub fn moved(&self, direction: Direction) -> 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()),
+            Direction::North => Self::new(start.north(), end.north()).unwrap(),
+            Direction::East => Self::new(start.east(), end.east()).unwrap(),
+            Direction::South => Self::new(start.south(), end.south()).unwrap(),
+            Direction::West => Self::new(start.west(), end.west()).unwrap(),
             _ => unimplemented!("Direction {} unimplemented to move grid line", direction),
         }
     }
 
-    #[expect(dead_code)]
     pub fn direction(&self) -> Direction {
         self.start().direction(&self.end())
     }
@@ -274,20 +271,17 @@ mod tests {
     #[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());
+        let east = line.moved(Direction::East);
         assert_eq!(
             GridLine::new(Point::new(4, 8), Point::new(4, 2)).unwrap(),
-            east.unwrap()
+            east
         );
 
         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()
+            west
         );
     }
 
@@ -296,18 +290,15 @@ mod tests {
         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()
+            north
         );
 
         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()
+            south
         );
     }
 

src/utils/line.rs

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

src/utils/point.rs

@@ -129,7 +129,7 @@ impl Point {
         unimplemented!("Diagonal directions are not implemented");
     }
 
-    #[expect(dead_code)]
+    #[allow(dead_code)]
     fn is_neighbour(&self, other: &Self) -> bool {
         let distance = self.distance(other);
 

src/utils/polygon.rs

@@ -1,6 +1,7 @@
 use crate::utils::grid_line::GridLine;
 use crate::utils::point::Point;
 use crate::utils::traits::IsInside;
+use itertools::Itertools;
 
 #[derive(PartialEq, Clone)]
 pub struct Polygon {
@@ -26,13 +27,28 @@ impl Polygon {
     pub fn rectangle(first_corner: Point, second_corner: Point) -> Self {
         let points = [
             Point::new(first_corner.x, first_corner.y),
-            Point::new(first_corner.x, second_corner.y),
-            Point::new(second_corner.x, second_corner.y),
             Point::new(second_corner.x, first_corner.y),
+            Point::new(second_corner.x, second_corner.y),
+            Point::new(first_corner.x, second_corner.y),
         ];
 
         Self::from_iter(points)
     }
+
+    #[allow(dead_code)]
+    pub fn extend(&self) -> Self {
+        let lines = self
+            .lines
+            .iter()
+            .map(|line| {
+                let direction = line.direction().ccw();
+
+                line.extend().moved(direction)
+            })
+            .collect_vec();
+
+        Self { lines }
+    }
 }
 
 impl FromIterator<Point> for Polygon {
@@ -188,4 +204,78 @@ mod tests {
 
         assert_eq!(24, polygon.points().len());
     }
+
+    #[test]
+    fn extend_rectangle() {
+        let rectangle = Polygon::rectangle(Point::new(2, 2), Point::new(5, 5));
+        let extended = rectangle.extend();
+
+        let mut lines = extended.lines.iter();
+
+        assert_eq!(
+            &GridLine::new(Point::new(1, 1), Point::new(6, 1)).unwrap(),
+            lines.next().unwrap()
+        );
+        assert_eq!(
+            &GridLine::new(Point::new(6, 1), Point::new(6, 6)).unwrap(),
+            lines.next().unwrap()
+        );
+        assert_eq!(
+            &GridLine::new(Point::new(6, 6), Point::new(1, 6)).unwrap(),
+            lines.next().unwrap()
+        );
+        assert_eq!(
+            &GridLine::new(Point::new(1, 6), Point::new(1, 1)).unwrap(),
+            lines.next().unwrap()
+        );
+    }
+
+    #[test]
+    fn extend_complex_l_shape() {
+        // Create an L-shaped polygon
+        let points = [
+            Point::new(2, 2),
+            Point::new(5, 2),
+            Point::new(5, 4),
+            Point::new(4, 4),
+            Point::new(4, 6),
+            Point::new(2, 6),
+        ];
+
+        let polygon: Polygon = points.into_iter().collect();
+        let extended = polygon.extend();
+
+        let mut lines = extended.lines.iter();
+
+        // Bottom edge: (2,2)->(5,2) extends and moves north
+        assert_eq!(
+            &GridLine::new(Point::new(1, 1), Point::new(6, 1)).unwrap(),
+            lines.next().unwrap()
+        );
+        // Right edge (lower): (5,2)->(5,4) extends and moves east
+        assert_eq!(
+            &GridLine::new(Point::new(6, 1), Point::new(6, 5)).unwrap(),
+            lines.next().unwrap()
+        );
+        // Inner horizontal: (5,4)->(4,4) extends and moves south
+        assert_eq!(
+            &GridLine::new(Point::new(6, 5), Point::new(3, 5)).unwrap(),
+            lines.next().unwrap()
+        );
+        // Right edge (upper): (4,4)->(4,6) extends and moves east
+        assert_eq!(
+            &GridLine::new(Point::new(5, 3), Point::new(5, 7)).unwrap(),
+            lines.next().unwrap()
+        );
+        // Top edge: (4,6)->(2,6) extends and moves south
+        assert_eq!(
+            &GridLine::new(Point::new(5, 7), Point::new(1, 7)).unwrap(),
+            lines.next().unwrap()
+        );
+        // Left edge: (2,6)->(2,2) extends and moves west
+        assert_eq!(
+            &GridLine::new(Point::new(1, 7), Point::new(1, 1)).unwrap(),
+            lines.next().unwrap()
+        );
+    }
 }