[사다리 타기] 김이화 미션 제출합니다.

.gitignore

@@ -30,3 +30,4 @@ out/
 
 ### VS Code ###
 .vscode/
+.DS_STORE

README.md

@@ -93,7 +93,7 @@ public class Line {
   - 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만들어라.
 - 배열 대신 컬렉션을 사용한다.
 - Java Enum을 적용한다.
-- 모든 원시 값과 문자열을 포장한다
+- 모든 원시 값과 문자열을 포장한다.
 - 줄여 쓰지 않는다(축약 금지).
 - 일급 컬렉션을 쓴다.
 

docs/README.md

@@ -0,0 +1,15 @@
+1. 참여할 사람 이름 입력 -> 조건 : 사람 최소 2명, 이름은 쉼표(,)로 구분, 이름 최대 5글자, 이름 빈칸 X
+2. 사다리 게임 높이 입력 -> 조건 : 최소 높이 2이상, 높이 숫자만 입력
+3. 사다리 게임 -> 조건 : 사람
+4. 실행 결과: 사람 이름, 사다리 동시 출력, 사람 이름 5글자 맞춰서 출력, 라인 겹치지 않게 출력
+
+- 모든 기능을 TDD로 구현해 단위 테스트가 존재해야 한다. 단, UI(System.out, System.in) 로직은 제외
+    - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다.
+    - UI 로직을 InputView, ResultView와 같은 클래스를 추가해 분리한다.
+- 함수(또는 메서드)의 길이가 10라인을 넘어가지 않도록 구현한다.
+    - 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만들어라.
+- 배열 대신 컬렉션을 사용한다.
+- Java Enum을 적용한다.
+- 모든 원시 값과 문자열을 포장한다.
+- 줄여 쓰지 않는다(축약 금지).
+- 일급 컬렉션을 쓴다.

src/main/java/Application.java

@@ -0,0 +1,12 @@
+import controller.GameController;
+import view.InputView;
+import view.OutPutView;
+
+public class Application {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutPutView outPutView = new OutPutView();
+        GameController gameController = new GameController(inputView,outPutView);
+        gameController.playGame();
+    }
+}

src/main/java/controller/GameController.java

@@ -0,0 +1,37 @@
+package controller;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
+import java.util.List;
+import model.Ladder;
+import model.User;
+import model.Users;
+import view.InputView;
+import view.OutPutView;
+
+public class GameController {
+
+    private final InputView inputView;
+    private final OutPutView outPutView;
+
+    public GameController(InputView inputView, OutPutView outPutView) {
+        this.inputView = inputView;
+        this.outPutView = outPutView;
+    }
+
+    public void playGame() {
+        Users users = createUsers();
+        int ladderHeight = inputView.createLadderHeight();
+        Ladder ladder = new Ladder(users.getUserCount(), ladderHeight);
+        outPutView.gameResult(users, ladder);
+
+    }
+
+    private Users createUsers() {
+        List<String> userNames = inputView.createUser();
+
+        return userNames.stream()
+                .map(i -> new User(i))
+                .collect(collectingAndThen(toList(), i -> new Users(i)));
+    }
+}

src/main/java/model/Direction.java

@@ -0,0 +1,5 @@
+package model;
+
+public enum Direction {
+    RIGHT, NEUTRAL, LEFT
+}

src/main/java/model/Ladder.java

@@ -0,0 +1,29 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Ladder {
+    private static final int MIN_LADDER_HEIGHT = 2;
+    private final List<Line> lines;
+
+    public Ladder(int userCount, int height) {
+        validateHeight(height);
+
+        this.lines = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            lines.add(new Line(userCount));
+        }
+    }
+
+    private void validateHeight(int height) {
+        if (height < MIN_LADDER_HEIGHT) {
+            throw new IllegalArgumentException("사다리 높이는 최소 2이상이어야 합니다.");
+        }
+    }
+
+    public List<Line> getLines(){
+        return this.lines;
+    }
+}

src/main/java/model/Line.java

@@ -0,0 +1,53 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import java.util.Random;
+
+public class Line {
+
+    private final Random random = new Random();
+
+    private final List<Direction> points;
+
+    public Line(int personCount) {
+
+        points = new ArrayList<>();
+        createLine(personCount,points);
+    }
+
+    private void createLine(int personCount, List<Direction> points){
+        Direction previousDirection = Direction.NEUTRAL;
+
+        for (int i = 0; i < personCount - 1; i++) {
+            Direction newDirection = createDirection(previousDirection);
+            points.add(newDirection);
+            previousDirection = updatePreviousDirection(previousDirection, newDirection);
+        }
+        // 마지막 포인트는 항상 NEUTRAL
+        points.add(Direction.NEUTRAL);
+    }
+
+    private Direction createDirection(Direction previousDirection) {
+        if (previousDirection == Direction.LEFT) {
+            return Direction.NEUTRAL;
+        }
+        if (random.nextBoolean()) {
+            return Direction.RIGHT;
+        }
+        return Direction.NEUTRAL;
+    }
+
+    private Direction updatePreviousDirection(Direction previousDirection, Direction newDirection) {
+        // 오른쪽으로 가는 경우 다음 포인트는 왼쪽으로 갈 수 없습니다.
+        if (newDirection == Direction.RIGHT) {
+            return previousDirection = Direction.LEFT;
+        }
+        return previousDirection = Direction.NEUTRAL;
+    }
+
+    public List<Direction> getPoints() {
+        return this.points;
+    }
+}

src/main/java/model/User.java

@@ -0,0 +1,34 @@
+package model;
+
+public class User {
+    private static final int MAX_NAME_LENGTH = 5;
+    private static final String BLANK = " ";
+
+    private final String userName;
+
+    public User(String userName) {
+        validateUserName(userName);
+        this.userName = userName;
+    }
+
+    private void validateUserName(String name) {
+        validateNameLength(name);
+        validateBlankInName(name);
+    }
+
+    private void validateNameLength(String name){
+        if(name.isEmpty() || name.length() > MAX_NAME_LENGTH){
+            throw new IllegalArgumentException("유저 이름은 1~5자리 글자여야 합니다.");
+        }
+    }
+
+    private void validateBlankInName(String name){
+        if(name.contains(BLANK)){
+            throw new IllegalArgumentException("유저 이름은 빈칸이 들어갈 수 없습니다.");
+        }
+    }
+
+    public String getUserName(){
+        return this.userName;
+    }
+}

src/main/java/model/Users.java

@@ -0,0 +1,32 @@
+package model;
+
+import java.util.List;
+
+public class Users {
+    private static final int MIN_USERS = 2;
+
+    private final List<User> users;
+
+    public Users(final List<User> users) {
+        validateUsersSizeValidate(users);
+        this.users = users;
+    }
+
+    private void validateUsersSizeValidate(List<User> users) {
+        validateUsers(users);
+    }
+
+    private void validateUsers(List<User> users) {
+        if (users.size() < MIN_USERS) {
+            throw new IllegalArgumentException("유저는 2명 이상이어야 합니다.");
+        }
+    }
+
+    public int getUserCount() {
+        return users.size();
+    }
+
+    public List<String> getUserName() {
+        return users.stream().map(i -> i.getUserName()).toList();
+    }
+}

src/main/java/view/InputView.java

@@ -0,0 +1,40 @@
+package view;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+    private static final String separation = ",";
+
+    private Scanner sc = new Scanner(System.in);
+
+    public List<String> createUser(){
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+        String name = sc.nextLine();
+        validateCreateUser(name);
+
+        return Arrays.stream(name.split(separation)).toList();
+    }
+
+    public int createLadderHeight(){
+        System.out.println("최대 사다리 높이는 몇 개인가요?");
+        int ladderHeight = sc.nextInt();
+        validateCreateHeight(ladderHeight);
+
+        return ladderHeight;
+    }
+
+    private void validateCreateUser(String name){
+        if(name.isEmpty()||name.endsWith(separation)){
+            throw new IllegalArgumentException("잘못된 입력입니다.");
+        }
+    }
+
+    private void validateCreateHeight(int ladderHeight){
+        if(ladderHeight<2){
+            throw new IllegalArgumentException("2이상의 숫자만 입력하세요");
+        }
+    }
+}

src/main/java/view/OutPutView.java

@@ -0,0 +1,63 @@
+package view;
+
+import java.util.List;
+
+import model.Direction;
+import model.Ladder;
+import model.Line;
+import model.Users;
+
+public class OutPutView {
+
+    private static final int MAX_NAME = 5;
+    private static final String BLANK = " ";
+    private static final String POINT = "-----";
+    private static final String LINE = "|";
+
+    public void gameResult(Users users, Ladder ladder) {
+        System.out.println("실행결과");
+        printUserNames(users);
+        printLadder(ladder);
+    }
+
+    private void printUserNames(Users users) {
+        StringBuilder sb = new StringBuilder();
+        for (String name : users.getUserName()) {
+            remakeNameFormat(sb, name);
+        }
+        System.out.println(sb);
+    }
+
+    private void remakeNameFormat(StringBuilder sb, String name) {
+        int blankNum = MAX_NAME - name.length();
+        if (name.length() < MAX_NAME) {
+            sb.append(BLANK.repeat(blankNum));
+        }
+        sb.append(name).append(BLANK);
+    }
+
+    private void printLadder(Ladder ladder) {
+        List<Line> lineList = ladder.getLines();
+        StringBuilder sb = new StringBuilder();
+        for (Line line : lineList) {
+            printLadderPoint(sb, line.getPoints());
+        }
+        System.out.println(sb);
+    }
+
+    private void printLadderPoint(StringBuilder sb, List<Direction> directions) {
+        sb.append(BLANK.repeat(MAX_NAME));
+        for (int i = 0; i < directions.size() - 1; i++) {
+            sb.append(LINE)
+                    .append(printDirections(directions.get(i)));
+        }
+        sb.append(LINE).append(System.lineSeparator());
+    }
+
+    private String printDirections(Direction direction) {
+        if (direction == Direction.RIGHT) {
+            return POINT;
+        }
+        return BLANK.repeat(MAX_NAME);
+    }
+}

src/test/java/ladder/LadderTest.java

@@ -0,0 +1,35 @@
+package ladder;
+
+import model.Ladder;
+import model.Line;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class LadderTest {
+    @DisplayName("주어진 높이에 맞게 사다리 생성")
+    @Test
+    void newLadderTest() {
+        int userCount = 5;
+        int height = 6;
+
+        Ladder ladder = new Ladder(userCount, height);
+        List<Line> lines = ladder.getLines();
+        assertEquals(height, lines.size());
+    }
+
+    @DisplayName("사다리의 높이가 2개 미만일 경우 예외 발생")
+    @Test
+    void ValidateLadderHeightTest() {
+        int userCount = 5;
+        int height = 1;
+
+        assertThatThrownBy(() -> new Ladder(userCount, height))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("사다리 높이는 최소 2이상이어야 합니다.");
+    }
+}