refactor: LineBuilder를 Line 내부로 이동

Author: sang5c

src/main/java/nextstep/ladder/domain/Line.java

@@ -1,13 +1,14 @@
 package nextstep.ladder.domain;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class Line {
     private static final int MIN_POINT_SIZE = 2;
 
     private final List<Point> points;
 
-    Line(List<Point> points) {
+    private Line(List<Point> points) {
         validate(points);
         this.points = points;
     }
@@ -61,4 +62,35 @@ public Point getPoint(int index) {
                 .findFirst()
                 .orElseThrow(() -> new IllegalArgumentException("포인트가 없습니다. index: " + index));
     }
+
+    static class LineBuilder {
+        private final List<Point> points;
+
+        public LineBuilder() {
+            this.points = new ArrayList<>();
+        }
+
+        public LineBuilder point(boolean canMoveRight) {
+            if (points.isEmpty()) {
+                points.add(Point.createLeftmost(canMoveRight));
+                return this;
+            }
+            points.add(lastPoint().createNext(canMoveRight));
+            return this;
+        }
+
+        public Line build() {
+            if (points.isEmpty()) {
+                throw new IllegalStateException("점이 없습니다.");
+            }
+
+            points.add(lastPoint().createRightmost());
+
+            return new Line(points);
+        }
+
+        private Point lastPoint() {
+            return points.get(points.size() - 1);
+        }
+    }
 }

src/main/java/nextstep/ladder/domain/LineBuilder.java

@@ -1,12 +1,14 @@
 package nextstep.ladder.domain;
 
 import java.util.List;
+import java.util.Random;
 import java.util.stream.IntStream;
 
 import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.toList;
 
 public class Lines {
+    private static final Random RANDOM = new Random();
 
     private final List<Line> lines;
 
@@ -23,10 +25,19 @@ private void validate(List<Line> lines) {
 
     public static Lines of(int numberOfPlayers, int height) {
         return IntStream.range(0, height)
-                .mapToObj(i -> LineBuilder.buildWithRandomPoints(numberOfPlayers))
+                .mapToObj(i -> getBuildWithRandomPoints(numberOfPlayers))
                 .collect(collectingAndThen(toList(), Lines::new));
     }
 
+    private static Line getBuildWithRandomPoints(int numberOfPlayers) {
+        Line.LineBuilder builder = new Line.LineBuilder();
+        builder.point(RANDOM.nextBoolean());
+        for (int i = 0; i < numberOfPlayers - 2; i++) {
+            builder.point(RANDOM.nextBoolean());
+        }
+        return builder.build();
+    }
+
     public int getHeight() {
         return lines.size();
     }

src/main/java/nextstep/ladder/domain/Lines.java

@@ -1,5 +1,7 @@
 package nextstep.ladder.domain;
 
+import java.util.Objects;
+
 public class Point {
     private static final int MIN_INDEX = 0;
 
@@ -50,4 +52,17 @@ public boolean canMoveRight() {
     public boolean sameIndex(int index) {
         return this.index == index;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Point point = (Point) o;
+        return index == point.index && left == point.left && right == point.right;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(index, left, right);
+    }
 }

src/main/java/nextstep/ladder/domain/Point.java

@@ -3,8 +3,6 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-import java.util.List;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
@@ -13,77 +11,27 @@ class LineTest {
     @DisplayName("포인트를 받아 라인을 생성한다")
     @Test
     void create() {
-        Point leftmostPoint = Point.createLeftmost(true);
-        List<Point> points = List.of(
-                leftmostPoint,
-                leftmostPoint.createRightmost()
-        );
-        Line line = new Line(points);
+        Line line = new Line.LineBuilder()
+                .point(true)
+                .build();
 
         assertThat(line.width()).isEqualTo(2);
     }
 
-    @DisplayName("포인트가 null이면 예외가 발생한다")
-    @Test
-    void nullPoints() {
-        assertThatThrownBy(() -> new Line(null))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
-
     @DisplayName("포인트가 비어있으면 예외가 발생한다")
     @Test
     void emptyPoints() {
-        assertThatThrownBy(() -> new Line(List.of()))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
-
-    @DisplayName("시작 포인트가 왼쪽으로 이동 가능하면 예외가 발생한다")
-    @Test
-    void firstPointCannotMoveLeft() {
-        List<Point> points = List.of(
-                new Point(0, true, false),
-                new Point(1, false, false)
-        );
-
-        assertThatThrownBy(() -> new Line(points))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
-
-    @DisplayName("마지막 포인트가 오른쪽으로 이동 가능하면 예외가 발생한다")
-    @Test
-    void lastPointCannotMoveRight() {
-        List<Point> points = List.of(
-                new Point(0, false, false),
-                new Point(1, false, true)
-        );
-
-        assertThatThrownBy(() -> new Line(points))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
-
-    @DisplayName("이동 가능한 포인트간에 서로 이동 가능하지 않으면 예외가 발생한다")
-    @Test
-    void hasMovableConnectionToNext() {
-        List<Point> points = List.of(
-                new Point(0, false, true),
-                new Point(1, false, false)
-        );
-
-        assertThatThrownBy(() -> new Line(points))
-                .isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> new Line.LineBuilder().build())
+                .isInstanceOf(IllegalStateException.class);
     }
 
     @DisplayName("인덱스를 받아 포인트를 반환한다")
     @Test
     void getPoint() {
-        Point leftmostPoint = Point.createLeftmost(true);
-        List<Point> points = List.of(
-                leftmostPoint,
-                leftmostPoint.createRightmost()
-        );
-        Line line = new Line(points);
+        Line line = new Line.LineBuilder()
+                .point(true)
+                .build();
 
-        assertThat(line.getPoint(0)).isEqualTo(leftmostPoint);
+        assertThat(line.getPoint(0)).isEqualTo(Point.createLeftmost(true));
     }
-
 }