Step2 (사다리 생성) : 리뷰 요청드립니다.

src/main/java/ladder/Application.java

@@ -0,0 +1,19 @@
+package ladder;
+
+import ladder.domain.Ladder;
+import ladder.domain.LadderFactory;
+import ladder.domain.PlayersGroup;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+        PlayersGroup playersGroup = PlayersGroup.of(InputView.inputPlayerNames());
+        LadderFactory ladderFactory = new LadderFactory(InputView.inputLadderHeight());
+        Ladder ladder = ladderFactory.buildLadder(playersGroup);
+
+        OutputView.printPlayerNames(playersGroup);
+        OutputView.printLadder(ladder);
+    }
+}

src/main/java/ladder/README.md

@@ -0,0 +1,48 @@
+## 사다리 게임 구현 기능 목록
+
+### Domain
+
+* Player
+    * 게임 참가자 객체
+    * 이름에 대한 예외 처리
+        * 이름이 NULL이거나 빈 문자열이거나 5자를 넘는 경우 예외 발생
+
+* PlayersGroup
+    * 게임 참가지 객체의 리스트(List<Player>) 일급 컬렉션
+    * 참가자 객체의 이름 목록을 파라미터로 받아 객체 생성
+    * Player들의 이름 명단(List<String>) 반환
+    * Player들 수를 반환
+
+* Point
+    * 사다리 한 수평 라인의 한 점을 구성하는 객체
+    * 해당 부분에 값이 존재하는지 아닌지(boolean)를 결정함.
+    * 난수를 받아 객체 생성 시, 해당 부분에 값이 존재하는지 아닌지를 결정함.
+
+* Line
+    * 사다리의 수평 라인 한 줄을 의미하는 객체
+    * 수평 라인이 존재하는 부분과 아닌 부분을 List<Point>으로 가짐
+    * 생성된 Line을 구성하는 각 Point들의 정보를 담은 List<Boolean> 반환
+
+ * DrawingLineStrategy
+    * 선을 그리는 전략 인터페이스
+    * RandomDrawingLineStrategy는 인자로 참가자의 수(사다리의 너비)를 받음.
+
+* LadderFactory
+    * 게임 참가자 수와 Ladder 높이를 파라미터로 받아 적합한 크기의 Ladder 생성
+    * 높이가 1보다 작을 경우 예외 발생
+
+* Ladder
+    * 사다리 2차원 배열의 정보를 List<Line>으로 가지고 있는 일급 컬렉션.
+    * 플레이어 명단과 사다리 높이를 바탕으로 사다리를 생성함.
+    * 사다리의 설계도면을 List<List<Boolean>>으로 반환함
+
+### View
+
+* InputView
+    * 쉼표로 구분되는 게임 참가자(Player) 명단을 입력 받음.
+    * 사다리 높이를 입력 받음.
+
+* OutputView
+    * Ladder 객체를 바탕으로 사다리의 모습을 그림
+
+### Application

src/main/java/ladder/domain/DrawingLineStrategy.java

@@ -0,0 +1,8 @@
+package ladder.domain;
+
+import java.util.List;
+
+public interface DrawingLineStrategy {
+
+    public List<Point> drawLine(int playerCounts);
+}

src/main/java/ladder/domain/ErrorMessages.java

@@ -0,0 +1,11 @@
+package ladder.domain;
+
+public class ErrorMessages {
+
+    public static final String INVALID_PLAYER_NAME = "게임 참가자의 이름은 빈 문자열이 아닌 1 ~ 5자리의 문자만 가능합니다.";
+    public static final String INVALID_PLAYER_COUNTS = "게임 참가자는 1명 이상이어야 합니다.";
+    public static final String INVALID_LADDER_HEIGHT = "사다리 높이는 1 이상이어야 합니다.";
+
+    private ErrorMessages() {
+    }
+}

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

@@ -0,0 +1,32 @@
+package ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Ladder {
+
+    private final List<Line> lines;
+
+    private Ladder(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public static Ladder buildLadder(PlayersGroup playersGroup, int ladderHeight) {
+        int playerCounts = playersGroup.getPlayerCounts();
+        List<Line> ladder = Stream.generate(() -> Line.drawLine(playerCounts))
+                .limit(ladderHeight)
+                .collect(Collectors.toList());
+        return new Ladder(ladder);
+    }
+
+    public List<List<Boolean>> getLadderBluePrint() {
+        return lines.stream()
+                .map(Line::getPointPositions)
+                .collect(Collectors.toList());
+    }
+
+    public int getLadderHeight() {
+        return lines.size();
+    }
+}

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

@@ -0,0 +1,22 @@
+package ladder.domain;
+
+public class LadderFactory {
+
+    private static final int MINIMUM_LADDER_HEIGHT = 1;
+    private final int ladderHeight;
+
+    public LadderFactory(int ladderHeight) {
+        validateLadderHeight(ladderHeight);
+        this.ladderHeight = ladderHeight;
+    }
+
+    private void validateLadderHeight(int ladderHeight) {
+        if (ladderHeight < MINIMUM_LADDER_HEIGHT) {
+            throw new IllegalArgumentException(ErrorMessages.INVALID_LADDER_HEIGHT);
+        }
+    }
+
+    public Ladder buildLadder(PlayersGroup playersGroup) {
+        return Ladder.buildLadder(playersGroup, ladderHeight);
+    }
+}

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

@@ -0,0 +1,37 @@
+package ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Line {
+
+    private static final int MINIMUM_PLAYER_COUNTS = 1;
+    private final List<Point> points;
+
+    private Line(List<Point> points) {
+        this.points = points;
+    }
+
+    public static Line drawLine(int playerCounts) {
+        validatePlayerCounts(playerCounts);
+        List<Point> points = drawLineWithStrategy(playerCounts, new RandomDrawingLineStrategy());
+        return new Line(points);
+    }
+
+    private static void validatePlayerCounts(int playerCounts) {
+        if (playerCounts < MINIMUM_PLAYER_COUNTS) {
+            throw new IllegalArgumentException(ErrorMessages.INVALID_PLAYER_COUNTS);
+        }
+    }
+
+    private static List<Point> drawLineWithStrategy(int playerCounts,
+                                                    DrawingLineStrategy drawingLineStrategy) {
+        return drawingLineStrategy.drawLine(playerCounts);
+    }
+
+    public List<Boolean> getPointPositions() {
+        return points.stream()
+                .map(Point::getIsExisting)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/ladder/domain/Player.java

@@ -0,0 +1,30 @@
+package ladder.domain;
+
+public class Player {
+
+    private static final int MAXIMUM_NAME_LENGTH = 5;
+    private final String name;
+
+    public Player(String name) {
+        validateName(name);
+        this.name = name;
+    }
+
+    private void validateName(String name) {
+        if (isNullOrEmpty(name) || isInvalidLength(name)) {
+            throw new IllegalArgumentException(ErrorMessages.INVALID_PLAYER_NAME);
+        }
+    }
+
+    private boolean isNullOrEmpty(String name) {
+        return name == null || name.isEmpty();
+    }
+
+    private boolean isInvalidLength(String name) {
+        return name.length() > MAXIMUM_NAME_LENGTH;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/ladder/domain/PlayersGroup.java

@@ -0,0 +1,30 @@
+package ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PlayersGroup {
+
+    private final List<Player> players;
+
+    private PlayersGroup(List<Player> players) {
+        this.players = players;
+    }
+
+    public static PlayersGroup of(List<String> playerNames) {
+        List<Player> players = playerNames.stream()
+                .map(Player::new)
+                .collect(Collectors.toList());
+        return new PlayersGroup(players);
+    }
+
+    public List<String> getPlayerNames() {
+        return players.stream()
+                .map(Player::getName)
+                .collect(Collectors.toList());
+    }
+
+    public int getPlayerCounts() {
+        return players.size();
+    }
+}

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

@@ -0,0 +1,22 @@
+package ladder.domain;
+
+public class Point {
+
+    private static final int RANDOM_NUMBER_BOUNDARY = 5;
+    private final boolean isExisting;
+
+    public Point(boolean isExisting) {
+        this.isExisting = isExisting;
+    }
+
+    public static Point drawPoint(int randomNumber) {
+        if (randomNumber < RANDOM_NUMBER_BOUNDARY) {
+            return new Point(false);
+        }
+        return new Point(true);
+    }
+
+    public boolean getIsExisting() {
+        return isExisting;
+    }
+}

src/main/java/ladder/domain/RandomDrawingLineStrategy.java

@@ -0,0 +1,46 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class RandomDrawingLineStrategy implements DrawingLineStrategy {
+
+    private static final int LOOP_ZERO = 0;
+    private static final int LINE_WIDTH_CONSTANT = 1;
+    private static final int INDEX_CONSTANT = 1;
+    private static final int RANDOM_NUMBER_RANGE = 10;
+    private static final Random random = new Random();
+
+    @Override
+    public List<Point> drawLine(int playerCounts) {
+        List<Point> points = new ArrayList<>();
+        int lineWidth = playerCounts - LINE_WIDTH_CONSTANT;
+        for (int i = LOOP_ZERO; i < lineWidth; i++) {
+            Point point = drawPoint(points);
+            points.add(point);
+        }
+        return points;
+    }
+
+    private Point drawPoint(List<Point> points) {
+        int randomNumber = generateRandomNumber();
+        if (points.isEmpty()) {
+            return Point.drawPoint(randomNumber);
+        }
+        if (isLastPointExisting(points)) {
+            return new Point(false);
+        }
+        return Point.drawPoint(randomNumber);
+    }
+
+    private boolean isLastPointExisting(List<Point> points) {
+        int lastPointIndex = points.size() - INDEX_CONSTANT;
+        Point lastPoint = points.get(lastPointIndex);
+        return lastPoint.getIsExisting();
+    }
+
+    private int generateRandomNumber() {
+        return random.nextInt(RANDOM_NUMBER_RANGE);
+    }
+}

src/main/java/ladder/view/InputView.java

@@ -0,0 +1,24 @@
+package ladder.view;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+    private static Scanner scanner = new Scanner(System.in);
+
+    private InputView() {
+    }
+
+    public static List<String> inputPlayerNames() {
+        System.out.println(ViewMessages.INSTRUCTION_PLAYER_NAMES);
+        String[] inputPlayerNames = scanner.nextLine().split(ViewMessages.COMMA);
+        return Arrays.asList(inputPlayerNames);
+    }
+
+    public static int inputLadderHeight() {
+        System.out.println(ViewMessages.INSTRUCTION_LADDER_HEIGHT);
+        return Integer.parseInt(scanner.nextLine());
+    }
+}