[1단계 - 사다리 생성] 허브(방대의) 미션 제출합니다.

README.md

@@ -5,3 +5,52 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+### 다이어그램
+
+```mermaid
+graph TD
+
+    LadderGameController --> LadderGame
+    LadderGame --> Ladder
+    LadderGame --> Players
+
+    Players --> Player
+
+    LadderGameController --> InputView
+    LadderGameController --> OutputView
+
+    Ladder --> Line
+    Line --> LineStatus
+```
+
+### 참가자
+
+- [x] 참가자는 이름을 가진다.
+    - [x] 이름은 1자 이상, 5자 이하의 길이를 가진다.
+    - [x] 이름이 없거나, 5자를 초과하는 경우 예외를 던진다.
+- [x] 참가자는 최소 2명 이어야 한다.
+    - [x] 참가자가 1명 이하인 경우 예외를 던진다.
+- [x] 참가자들의 이름은 중복될 수 없다.
+    - [x] 중복된 이름이 존재하는 경우 예외를 던진다.
+
+### 사다리
+
+- [x] 사다리는 높이를 가진다.
+- [x] 사다리 가로 라인을 가진다.
+    - [x] 사다리 가로 라인의 상태가 연속으로 `연결됨` 상태일 수 없다.
+- [x] 각각의 가로 라인은 상태를 가진다.
+    - [x] 연결됨, 연결되지 않음으로 구분된다.
+
+### 입력
+
+- [x] 사람 이름은 쉼표(,)를 기준으로 구분하여 입력받는다.
+- [x] 이름의 앞뒤 공백을 제거한다.
+- [x] 최대 사다리 높이를 입력받는다.
+    - [x] 1보다 작은 값을 입력하는 경우 예외를 던진다.
+
+### 출력
+
+- [x] 최대 사람이름을 기준으로 사다리 폭이 넓어진다.
+
+

src/main/java/ladder/Application.java

@@ -0,0 +1,33 @@
+package ladder;
+
+import java.util.Scanner;
+import ladder.controller.LadderGameController;
+import ladder.domain.RandomBooleanGenerator;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+        try (Scanner scanner = new Scanner(System.in)) {
+            final LadderGameController ladderGameController = new LadderGameController(
+                    booleanGenerator(),
+                    inputView(scanner),
+                    outputView()
+            );
+            ladderGameController.run();
+        }
+    }
+
+    private static RandomBooleanGenerator booleanGenerator() {
+        return new RandomBooleanGenerator();
+    }
+
+    private static OutputView outputView() {
+        return new OutputView();
+    }
+
+    private static InputView inputView(final Scanner scanner) {
+        return new InputView(scanner);
+    }
+}

src/main/java/ladder/controller/LadderGameController.java

@@ -0,0 +1,60 @@
+package ladder.controller;
+
+import java.util.List;
+import ladder.domain.BooleanGenerator;
+import ladder.domain.LadderGame;
+import ladder.domain.Line;
+import ladder.domain.Players;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class LadderGameController {
+
+    private final BooleanGenerator booleanGenerator;
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderGameController(
+            final BooleanGenerator booleanGenerator,
+            final InputView inputView,
+            final OutputView outputView
+    ) {
+        this.booleanGenerator = booleanGenerator;
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        final LadderGame ladderGame = initialize();
+        final List<String> players = ladderGame.getPlayers();
+        final List<Line> ladder = ladderGame.getLadder();
+
+        outputView.printResult(players, ladder);
+    }
+
+    private LadderGame initialize() {
+        final Players players = readPlayers();
+        final int height = readHeight();
+
+        return new LadderGame(booleanGenerator, players, height);
+    }
+
+    private Players readPlayers() {
+        try {
+            final List<String> names = inputView.readPlayerNames();
+            return new Players(names);
+        } catch (IllegalArgumentException e) {
+            outputView.printError(e.getMessage());
+            return readPlayers();
+        }
+    }
+
+    private int readHeight() {
+        try {
+            return inputView.readLadderHeight();
+        } catch (IllegalArgumentException e) {
+            outputView.printError(e.getMessage());
+            return readHeight();
+        }
+    }
+}

src/main/java/ladder/domain/BooleanGenerator.java

@@ -0,0 +1,5 @@
+package ladder.domain;
+
+public interface BooleanGenerator {
+    boolean generate();
+}

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

@@ -0,0 +1,26 @@
+package ladder.domain;
+
+import static java.util.stream.Collectors.toUnmodifiableList;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+class Ladder {
+
+    private final List<Line> lines;
+
+    public Ladder(final BooleanGenerator booleanGenerator, final int height, final int width) {
+        this.lines = generateLines(booleanGenerator, height, width);
+    }
+
+    private List<Line> generateLines(final BooleanGenerator booleanGenerator, final int height, final int width) {
+        return Stream.generate(() -> new Line(booleanGenerator, width))
+                .limit(height)
+                .collect(toUnmodifiableList());
+    }
+
+    public List<Line> getLines() {
+        return Collections.unmodifiableList(lines);
+    }
+}

src/main/java/ladder/domain/LadderGame.java

@@ -0,0 +1,24 @@
+package ladder.domain;
+
+import java.util.List;
+
+public class LadderGame {
+
+    private static final int SUBTRACT_VALUE_OF_LADDER_WIDTH = 1;
+
+    private final Players players;
+    private final Ladder ladder;
+
+    public LadderGame(final BooleanGenerator booleanGenerator, final Players players, final int height) {
+        this.players = players;
+        this.ladder = new Ladder(booleanGenerator, height, players.count() - SUBTRACT_VALUE_OF_LADDER_WIDTH);
+    }
+
+    public List<String> getPlayers() {
+        return players.getNames();
+    }
+
+    public List<Line> getLadder() {
+        return ladder.getLines();
+    }
+}

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

@@ -0,0 +1,36 @@
+package ladder.domain;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+
+public class Line {
+
+    private final List<LineStatus> statuses;
+
+    public Line(final BooleanGenerator booleanGenerator, final int width) {
+        this.statuses = generateLine(booleanGenerator, width);
+    }
+
+    private List<LineStatus> generateLine(final BooleanGenerator booleanGenerator, final int width) {
+        final Deque<LineStatus> statuses = new ArrayDeque<>();
+        for (int i = 0; i < width; i++) {
+            statuses.add(generateLineStatus(booleanGenerator, statuses));
+        }
+        return new ArrayList<>(statuses);
+    }
+
+    private LineStatus generateLineStatus(final BooleanGenerator booleanGenerator, final Deque<LineStatus> statuses) {
+        final boolean status = booleanGenerator.generate();
+        if (statuses.isEmpty() || statuses.getLast().isDisconnected()) {
+            return LineStatus.from(status);
+        }
+        return LineStatus.DISCONNECTED;
+    }
+
+    public List<LineStatus> getLine() {
+        return Collections.unmodifiableList(statuses);
+    }
+}

src/main/java/ladder/domain/LineStatus.java

@@ -0,0 +1,21 @@
+package ladder.domain;
+
+public enum LineStatus {
+    CONNECTED,
+    DISCONNECTED;
+
+    public static LineStatus from(final boolean status) {
+        if (status) {
+            return CONNECTED;
+        }
+        return DISCONNECTED;
+    }
+
+    public boolean isConnected() {
+        return this == CONNECTED;
+    }
+
+    public boolean isDisconnected() {
+        return this == DISCONNECTED;
+    }
+}

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

@@ -0,0 +1,27 @@
+package ladder.domain;
+
+public class Player {
+    private static final String INVALID_NAME_LENGTH_MESSAGE = "이름은 1자 이상, 5자 이하여야 한다.";
+    private static final int NAME_LENGTH_UPPER_BOUND = 5;
+
+    private final String name;
+
+    public Player(final String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(final String name) {
+        if (isInvalidNameLength(name)) {
+            throw new IllegalArgumentException(INVALID_NAME_LENGTH_MESSAGE);
+        }
+    }
+
+    private boolean isInvalidNameLength(final String name) {
+        return name.isBlank() || NAME_LENGTH_UPPER_BOUND < name.length();
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/ladder/domain/Players.java

@@ -0,0 +1,53 @@
+package ladder.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Players {
+    private static final int PLAYERS_SIZE_LOWER_BOUND = 2;
+    private static final String INVALID_PLAYERS_SIZE_MESSAGE = "참가자는 최소 두명이어야 합니다.";
+    private static final String DUPLICATE_NAMES_MESSAGE = "참가자의 이름은 중복되지 않아야 합니다.";
+
+    private final List<Player> players;
+
+    public Players(final List<String> names) {
+        validate(names);
+        this.players = generatePlayers(names);
+    }
+
+    private void validate(final List<String> names) {
+        validatePlayersSize(names);
+        validateDuplicateNames(names);
+    }
+
+    private void validatePlayersSize(final List<String> names) {
+        if (names.size() < PLAYERS_SIZE_LOWER_BOUND) {
+            throw new IllegalArgumentException(INVALID_PLAYERS_SIZE_MESSAGE);
+        }
+    }
+
+    private void validateDuplicateNames(final List<String> names) {
+        final Set<String> nonDuplicateNames = new HashSet<>(names);
+        if (nonDuplicateNames.size() != names.size()) {
+            throw new IllegalArgumentException(DUPLICATE_NAMES_MESSAGE);
+        }
+    }
+
+    private List<Player> generatePlayers(final List<String> names) {
+        return names.stream()
+                .map(Player::new)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    public List<String> getNames() {
+        return players.stream()
+                .map(Player::getName)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    public int count() {
+        return players.size();
+    }
+}

src/main/java/ladder/domain/RandomBooleanGenerator.java

@@ -0,0 +1,13 @@
+package ladder.domain;
+
+import java.util.Random;
+
+public class RandomBooleanGenerator implements BooleanGenerator {
+
+    private final Random random = new Random();
+
+    @Override
+    public boolean generate() {
+        return random.nextBoolean();
+    }
+}