feat: 사람 명단, 높이 입력받기 완료

- refactoring 사항
  - validation은 generator에서 객체로 이동
  - 생성자에서 필드를 초기화하는 것이 아닌, 컨트롤러에서 필드 값들을
    만들고 넘겨주는 것으로 변경

Author: yumble

README.md

@@ -26,9 +26,9 @@
 * [X] Optional 실습 3 : Optional에서 exception 처리
 
 # STEP 2
-* [ ] 참여할 사람 명단 입력받기
-  * [ ] 쉼표 구분자를 파싱하기
-* [ ] 최대 사다리 높이 입력받기
+* [X] 참여할 사람 명단 입력받기
+  * [X] 쉼표 구분자를 파싱하기
+* [X] 최대 사다리 높이 입력받기
 * [ ] 실행결과 출력하기
 * [X] 사다리 만들기
   * [X] 사다리 한 줄(Line) 만들기

src/main/java/nextstep/ladder/controller/LadderController.java

@@ -0,0 +1,20 @@
+package nextstep.ladder.controller;
+
+import nextstep.ladder.model.Ladder;
+import nextstep.ladder.model.Lines;
+import nextstep.ladder.model.LinesGenerator;
+import nextstep.ladder.model.Participants;
+import nextstep.ladder.view.InputView;
+
+public class LadderController {
+
+    private final LinesGenerator linesGenerator = new LinesGenerator();
+
+    public void game() {
+        Participants participants = new Participants(InputView.inputGameParticipants());
+        int height = InputView.inputLadderHeight();
+        Lines lines = new Lines(linesGenerator.generatorLines(participants.getNumbersOfParticipants(), height));
+
+        Ladder ladder = new Ladder(participants, lines, height);
+    }
+}

src/main/java/nextstep/ladder/model/Ladder.java

@@ -1,14 +1,25 @@
 package nextstep.ladder.model;
 
-import java.util.List;
-
 public class Ladder {
 
-    private final List<Line> lines;
+    private static final int MIN_HEIGHT = 1;
+
+    private final Participants participants;
+    private final Lines lines;
     private final Integer height;
 
-    public Ladder(List<Line> lines, Integer height) {
+    public Ladder(Participants participants, Lines lines, Integer height) {
+        validateHeight(height);
+        this.participants = participants;
         this.lines = lines;
         this.height = height;
     }
+
+    private void validateHeight(Integer height) {
+        if (height < MIN_HEIGHT) {
+            throw new IllegalArgumentException("높이는 최소 1 이상이어야 합니다.");
+        }
+    }
+
+
 }

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

@@ -4,6 +4,8 @@
 
 public class Line {
 
+    private static final Integer MIN_NUMBERS_OF_PEOPLE = 2;
+
     private final List<Bridge> bridges;
 
     public Line(Integer numbersOfPeople, List<Bridge> bridges) {
@@ -14,6 +16,7 @@ public Line(Integer numbersOfPeople, List<Bridge> bridges) {
     private void validateLine(Integer numbersOfPeople, List<Bridge> bridges) {
         validateBridgeCount(numbersOfPeople, bridges);
         validateContinuousTrueBridge(bridges);
+        validateNumbersOfPeople(numbersOfPeople);
     }
 
     private void validateBridgeCount(Integer numbersOfPeople, List<Bridge> bridges) {
@@ -29,4 +32,10 @@ private void validateContinuousTrueBridge(List<Bridge> bridges) {
                     return currentBridge;
                 });
     }
+
+    private void validateNumbersOfPeople(Integer numbersOfPeople) {
+        if (numbersOfPeople < MIN_NUMBERS_OF_PEOPLE) {
+            throw new IllegalArgumentException("사람은 최소 2명 이상이어야 합니다.");
+        }
+    }
 }

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

@@ -0,0 +1,12 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+
+public class Lines {
+
+    private final List<Line> lines;
+
+    public Lines(List<Line> lines) {
+        this.lines = lines;
+    }
+}

src/main/java/nextstep/ladder/model/LinesGenerator.java

@@ -6,20 +6,11 @@
 
 public class LinesGenerator {
 
-    private static final Integer MIN_HEIGHT = 1;
-
     private final BridgesGenerator bridgesGenerator = new SequentialRandomBridgesGenerator();
 
     public List<Line> generatorLines(Integer numbersOfPeople, Integer height) {
-        validateHeight(height);
         return IntStream.range(0, height)
                 .mapToObj(index -> new Line(numbersOfPeople, bridgesGenerator.generateBridges(numbersOfPeople)))
                 .collect(Collectors.toList());
     }
-
-    private void validateHeight(Integer height) {
-        if (height < MIN_HEIGHT) {
-            throw new IllegalArgumentException("높이는 최소 1 이상이어야 합니다.");
-        }
-    }
 }

src/main/java/nextstep/ladder/model/Participant.java

@@ -0,0 +1,20 @@
+package nextstep.ladder.model;
+
+public class Participant {
+
+    private static final Integer MIN_NAME_LENGTH = 1;
+    private static final Integer MAX_NAME_LENGTH = 5;
+
+    private final String name;
+
+    public Participant(String name) {
+        validateNameLength(name);
+        this.name = name;
+    }
+
+    private void validateNameLength(String name) {
+        if (name.length() < MIN_NAME_LENGTH || name.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("0글자 이하이거나 5글자를 초과하는 참가자 이름이 포함되어 있습니다.");
+        }
+    }
+}

src/main/java/nextstep/ladder/model/Participants.java

@@ -0,0 +1,29 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Participants {
+
+    private static final String DELIMITER = ",";
+
+    private final List<Participant> participants;
+
+    public Participants(String inputParticipants) {
+        this.participants = createParticipants(parseInputParticipants(inputParticipants));
+    }
+
+    private List<String> parseInputParticipants(String inputParticipants) {
+        return List.of(inputParticipants.split(DELIMITER));
+    }
+
+    private List<Participant> createParticipants(List<String> inputParticipants) {
+        return inputParticipants.stream()
+                .map(Participant::new)
+                .collect(Collectors.toList());
+    }
+
+    public Integer getNumbersOfParticipants() {
+        return participants.size();
+    }
+}

src/main/java/nextstep/ladder/model/SequentialRandomBridgesGenerator.java

@@ -6,11 +6,8 @@
 
 public class SequentialRandomBridgesGenerator implements BridgesGenerator {
 
-    private static final Integer MIN_NUMBERS_OF_PEOPLE = 2;
-
     @Override
     public List<Bridge> generateBridges(Integer numbersOfPeople) {
-        validateNumbersOfPeople(numbersOfPeople);
         List<Bridge> bridges = new LinkedList<>();
         Bridge currentBridge = Bridge.of(ThreadLocalRandom.current().nextBoolean());
         for (int i = 0; i < numbersOfPeople - 1; i++) {
@@ -19,10 +16,4 @@ public List<Bridge> generateBridges(Integer numbersOfPeople) {
         }
         return bridges;
     }
-
-    private void validateNumbersOfPeople(Integer numbersOfPeople) {
-        if (numbersOfPeople < MIN_NUMBERS_OF_PEOPLE) {
-            throw new IllegalArgumentException("사람은 최소 2명 이상이어야 합니다.");
-        }
-    }
 }

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

@@ -0,0 +1,17 @@
+package nextstep.ladder.view;
+
+import java.util.Scanner;
+
+public class InputView {
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static String inputGameParticipants() {
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+        return scanner.nextLine();
+    }
+
+    public static int inputLadderHeight() {
+        System.out.println("최대 사다리 높이는 몇 개인가요?");
+        return Integer.parseInt(scanner.nextLine());
+    }
+}

src/test/java/nextstep/ladder/model/BridgeTest.java

@@ -1,6 +1,8 @@
 package nextstep.ladder.model;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import org.junit.jupiter.api.Test;
 
@@ -19,4 +21,22 @@ public class BridgeTest {
 
         assertThat(bridge.canCrossBridge()).isFalse();
     }
+
+    @Test
+    public void compareToNextBridge_연속된_두개가_True일시_에러_반환() {
+        Bridge prev = Bridge.of(true);
+        Bridge next = Bridge.of(true);
+
+        assertThatThrownBy(() -> prev.compareToNextBridge(next))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void compareToNextBridge_연속된_두개가_True가_아닐시_정상동작_테스트() {
+        Bridge prev = Bridge.of(false);
+        Bridge next = Bridge.of(true);
+
+        assertThatCode(() -> prev.compareToNextBridge(next))
+                .doesNotThrowAnyException(); // 예외가 발생하지 않아야 함
+    }
 }

src/test/java/nextstep/ladder/model/LadderTest.java

@@ -0,0 +1,28 @@
+package nextstep.ladder.model;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class LadderTest {
+
+    private Participants participants;
+    private Lines lines;
+
+    @BeforeEach
+    public void setup() {
+        List<Bridge> bridges = List.of(Bridge.of(true));
+        List<Line> line = List.of(new Line(2, bridges));
+
+        participants = new Participants("a,b");
+        lines = new Lines(line);
+    }
+
+    @Test
+    public void generatorLines_높이가_0일때_에러_테스트() {
+        assertThatThrownBy( () -> new Ladder(participants, lines, 0))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}

src/test/java/nextstep/ladder/model/LineTest.java

@@ -2,6 +2,7 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import java.util.LinkedList;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 
@@ -20,4 +21,10 @@ public class LineTest {
         assertThatThrownBy(() -> new Line(5, bridges))
                 .isInstanceOf(IllegalArgumentException.class);
     }
+
+    @Test
+    public void 사람수_1명일때_에러_테스트() {
+        assertThatThrownBy(() -> new Line(1, new LinkedList<>()))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
 }

src/test/java/nextstep/ladder/model/LinesGeneratorTest.java

@@ -1,7 +1,6 @@
 package nextstep.ladder.model;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import org.junit.jupiter.api.Test;
 
@@ -13,10 +12,4 @@ public class LinesGeneratorTest {
     public void generatorLines_높이에_맞게_생성하는지_테스트() {
         assertThat(linesGenerator.generatorLines(5, 6)).hasSize(6);
     }
-
-    @Test
-    public void generatorLines_높이가_0일때_에러_테스트() {
-        assertThatThrownBy( () -> linesGenerator.generatorLines(5, 0))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
 }

src/test/java/nextstep/ladder/model/ParticipantTest.java

@@ -0,0 +1,14 @@
+package nextstep.ladder.model;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.jupiter.api.Test;
+
+public class ParticipantTest {
+
+    @Test
+    public void 이름_5글자_이상일때_에러_반환_테스트() {
+        assertThatThrownBy(() -> new Participant("aaaaaa"))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}

src/test/java/nextstep/ladder/model/SequentialRandomBridgesGeneratorTest.java

@@ -14,9 +14,5 @@ public class SequentialRandomBridgesGeneratorTest {
         assertThat(bridgesGenerator.generateBridges(5)).hasSize(4);
     }
 
-    @Test
-    public void generateBridges_사람수_1명일때_에러_테스트() {
-        assertThatThrownBy(() -> bridgesGenerator.generateBridges(1))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
+
 }