고생하셨습니다.

🎉 PR 머지 완료! 🎉

Author: dd-jiyun

README.md

@@ -9,33 +9,52 @@
 
 ## 요구사항
 
-- 사다리는 4x4 크기 고정
-- 클래스는 3개 이상의 인스턴스 변수 가질 수 없음.
-- 모든 엔티티 작게
+- 사다리의 높이와 넓이를 입력받아 생성한다.
+    - 넓이와 높이는 2 이상 24 이하 여야한다.
+- 클래스는 3개 이상의 인스턴스 변수 가질 수 없다.
+- 모든 엔티티 작게 유지해야 한다.
 
 ## 구현 기능
 
 ### 사다리
 
-- 여러 개의 라인을 가지고 있다.
-- 전체 구조를 나타낸다.
+- 여러 개의 라인을 가진다.
+- 전체 사다리 구조를 나타내며, 사다리가 완성될 때까지 여러 번 라인을 생성해 재시도한다.
+- 완성된 사다리를 반환하며, 유효하지 않으면 예외를 발생시킨다.
+
+### 라인 생성기
+
+- 포인트 생성기를 사용해 한 줄의 포인트들을 생성한다.
+- 인접 포인트 간 연결이 겹치지 않도록 제어한다.
 
 ### 라인
 
-- 한 줄을 나타내는 포인트 들을 가진다.
-- 연결 상태를 관리하고 연결한다.
+- 한 줄을 구성하는 포인트들의 리스트를 가진다.
+- 각 포인트의 오른쪽 연결 상태를 관리한다.
+
+### 포인트 생성기
+
+- 랜덤 방식으로 연결 여부를 생성한다.
 
 ### 포인트
 
-- 연결 여부를 판단한다.
+- 불변 객체로 연결 여부(오른쪽 연결)를 가진다.
+- 새로운 연결 상태를 생성하여 반환한다.
 
 ## 출력 예시
 
 ```text
+사다리의 넓이는 몇 인가요?
+4
+
+사다리의 높이는 몇 인가요?
+5
 실행결과
 
-     |     |-----|     |
+     |-----|     |-----|
      |-----|     |-----|
      |     |-----|     |
-     |-----|     |     |
+     |     |     |     |
+     |     |     |-----|
+
 ```

src/main/java/LadderApplication.java

@@ -1,17 +1,8 @@
-import domain.Ladder;
-import strategy.PointGenerator;
-import strategy.RandomGenerator;
-import view.OutputView;
+import controller.LadderController;
 
 public class LadderApplication {
     public static void main(String[] args) {
-        int width = 4;
-        int height = 4;
-
-        PointGenerator generator = new RandomGenerator();
-        Ladder ladder = Ladder.create(width, height, generator);
-
-        OutputView.printLadderResultTitle();
-        OutputView.paintLadder(ladder);
+        LadderController controller = new LadderController();
+        controller.play();
     }
 }

src/main/java/controller/LadderController.java

@@ -0,0 +1,44 @@
+package controller;
+
+import domain.Height;
+import domain.Width;
+import domain.dto.RequestLadder;
+import domain.ladder.Ladder;
+import domain.ladder.LadderFactory;
+import strategy.LineGenerator;
+import strategy.PointGenerator;
+import strategy.RandomLineGenerator;
+import strategy.RandomPointGenerator;
+import view.InputView;
+import view.OutputView;
+
+public class LadderController {
+
+    public void play() {
+        RequestLadder requestLadder = inputLadderSettings();
+        Width width = requestLadder.toWidth();
+        Height height = requestLadder.toHeight();
+
+        LineGenerator lineGenerator = createLineGenerator();
+        LadderFactory factory = new LadderFactory();
+        Ladder ladder = factory.draw(width, height, lineGenerator);
+
+        drawLadder(ladder);
+    }
+
+    private RequestLadder inputLadderSettings() {
+        String width = InputView.inputLadderWidth();
+        String height = InputView.inputLadderHeight();
+        return new RequestLadder(width, height);
+    }
+
+    private LineGenerator createLineGenerator() {
+        PointGenerator pointGenerator = new RandomPointGenerator();
+        return new RandomLineGenerator(pointGenerator);
+    }
+
+    private void drawLadder(final Ladder ladder) {
+        OutputView.printLadderResultTitle();
+        OutputView.drawLadder(ladder);
+    }
+}

src/main/java/domain/Height.java

@@ -0,0 +1,24 @@
+package domain;
+
+public record Height(
+        int value
+) {
+
+    static final int MIN_LADDER_HEIGHT_SIZE = 2;
+    static final int MAX_LADDER_HEIGHT_SIZE = 24;
+
+    public Height {
+        validateHeightSize(value);
+    }
+
+    public static Height from(final int value) {
+        return new Height(value);
+    }
+
+    private void validateHeightSize(final int value) {
+        if (value < MIN_LADDER_HEIGHT_SIZE || MAX_LADDER_HEIGHT_SIZE < value) {
+            throw new IllegalArgumentException(
+                    "사다리의 높이는 %s 이상 %s 이하여야 합니다.".formatted(MIN_LADDER_HEIGHT_SIZE, MAX_LADDER_HEIGHT_SIZE));
+        }
+    }
+}

src/main/java/domain/Ladder.java

@@ -1,44 +1,21 @@
 package domain;
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
-import strategy.PointGenerator;
 
 public class Line {
 
-    private final List<Point> points;
+    final List<Point> points;
 
     private Line(final List<Point> points) {
-        this.points = Collections.unmodifiableList(points);
+        this.points = List.copyOf(points);
     }
 
-    public static Line create(final int width, final PointGenerator generator) {
-        return new Line(generatePoints(width, generator));
+    public static Line from(final List<Point> points) {
+        return new Line(points);
     }
 
-     /**
-     * 주어진 너비와 PointGenerator를 바탕으로, 왼쪽에서 오른쪽 방향으로 연결된 Point 리스트를 생성한다.
-     * 첫 번째 Point는 {@code Point.first()} 를 통해 생성되며,
-     * 이후 Point는 이전 Point의 연결 상태를 기준으로 오른쪽으로 순차적으로 생성된다.
-     * <p>
-     * * 사다리는 왼쪽에서 오른쪽으로만 연결된다는 전제 하에 동작한다.
-
-     * @param width 사다리의 너비
-     * @param generator 오른쪽 연결 여부를 결정하는 PointGenerator
-     * @return 연결된 Point 리스트
-     */
-    private static List<Point> generatePoints(final int width, final PointGenerator generator) {
-        List<Point> points = new ArrayList<>();
-        Point first = Point.first(generator.generate());
-        points.add(first);
-
-        for (int i = 1; i < width; i++) {
-            first = first.connectNext(generator.generate());
-            points.add(first);
-        }
-
-        return points;
+    public boolean hasConnectionAt(final int index) {
+        return points.get(index).right();
     }
 
     public List<Point> getPoints() {

src/main/java/domain/Line.java

@@ -4,7 +4,7 @@ public record Point(
         boolean right
 ) {
 
-    public static Point first(final boolean right) {
+    public static Point from(final boolean right) {
         return new Point(right);
     }
 

src/main/java/domain/Point.java

@@ -0,0 +1,24 @@
+package domain;
+
+public record Width(
+        int value
+) {
+
+    static final int MIN_LADDER_WIDTH_SIZE = 2;
+    static final int MAX_LADDER_WIDTH_SIZE = 24;
+
+    public Width {
+        validateWidthSize(value);
+    }
+
+    public static Width from(final int value) {
+        return new Width(value);
+    }
+
+    private void validateWidthSize(final int value) {
+        if (value < MIN_LADDER_WIDTH_SIZE || MAX_LADDER_WIDTH_SIZE < value) {
+            throw new IllegalArgumentException(
+                    "사다리의 넓이는 %s 이상 %s 이하여야 합니다.".formatted(MIN_LADDER_WIDTH_SIZE, MAX_LADDER_WIDTH_SIZE));
+        }
+    }
+}

src/main/java/domain/Width.java

@@ -0,0 +1,37 @@
+package domain.dto;
+
+import domain.Height;
+import domain.Width;
+
+public record RequestLadder(
+        String width,
+        String height
+) {
+
+    public RequestLadder {
+        validateEmpty(width, height);
+    }
+
+    private void validateEmpty(final String width, final String height) {
+        if (width == null || width.isBlank() || height == null || height.isBlank()) {
+            throw new IllegalArgumentException("사다리의 넓이와 높이를 입력해야 합니다.");
+        }
+    }
+
+    public Width toWidth() {
+        try {
+            return new Width(Integer.parseInt(width.strip()));
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("사다리의 넓이는 숫자여야 합니다.");
+        }
+    }
+
+    public Height toHeight() {
+        try {
+            return new Height(Integer.parseInt(height.strip()));
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("사다리의 높이는 숫자여야 합니다.");
+        }
+    }
+
+}

src/main/java/domain/dto/RequestLadder.java

@@ -0,0 +1,33 @@
+package domain.ladder;
+
+import domain.Line;
+import domain.Width;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class Ladder {
+
+    private final List<Line> lines;
+
+    private Ladder(final List<Line> lines) {
+        this.lines = List.copyOf(lines);
+    }
+
+    public static Ladder from(final List<Line> lines) {
+        return new Ladder(lines);
+    }
+
+    public boolean isFullyConnected(final Width width) {
+        return IntStream.range(0, width.value() - 1)
+                .allMatch(this::isConnectedBetween);
+    }
+
+    private boolean isConnectedBetween(final int index) {
+        return lines.stream()
+                .anyMatch(line -> line.hasConnectionAt(index));
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}

src/main/java/domain/ladder/Ladder.java

@@ -0,0 +1,35 @@
+package domain.ladder;
+
+import domain.Height;
+import domain.Line;
+import domain.Width;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+import strategy.LineGenerator;
+
+public class LadderFactory {
+
+    private static final int MAX_ATTEMPTS = 50;
+
+    public Ladder draw(final Width width, final Height height, final LineGenerator generator) {
+        return findDrawableLadder(width, height, generator)
+                .orElseThrow(() -> new IllegalArgumentException("유효한 사다리를 생성할 수 없습니다."));
+    }
+
+    private Optional<Ladder> findDrawableLadder(final Width width, final Height height, final LineGenerator generator) {
+        return IntStream.range(0, MAX_ATTEMPTS)
+                .mapToObj(attempt -> drawLadder(width, height, generator))
+                .filter(ladder -> ladder.isFullyConnected(width))
+                .findFirst();
+    }
+
+    private Ladder drawLadder(final Width width, final Height height, final LineGenerator lineGenerator) {
+        List<Line> lines = new ArrayList<>();
+        for (int i = 0; i < height.value(); i++) {
+            lines.add(lineGenerator.generate(width.value()));
+        }
+        return Ladder.from(lines);
+    }
+}

src/main/java/domain/ladder/LadderFactory.java

@@ -0,0 +1,7 @@
+package strategy;
+
+import domain.Line;
+
+public interface LineGenerator {
+    Line generate(int width);
+}