Step2 - 사다리(생성)

README.md

@@ -9,7 +9,7 @@
 * [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/nextstep-step/nextstep-docs/tree/master/codereview)
 
 
-## step1(1단계) - 스트림, 람다, Optional
+## step1 - 스트림, 람다, Optional
 ### 람다 실습
 - [x] 익명 클래스를 람다로 전환
   > `CarTest`
@@ -31,3 +31,19 @@
   > 메소드 인자로 받은 `User`를 `Optional`로 생성하여 메서드 구현
 - [x] `Users` 클래스의 `getUser()` 메서드를 `stream`과 `Optional`을 활용해 리팩토링
 - [x] `Expression`의 `of` 메서드를 `stream` 기반으로 리팩토링
+
+
+## step2 - 사다리(생성)
+### 프로그래밍 요구 사항
+- 자바 8의 스트림과 람다를 적용해 프로그래밍
+- 규칙 6: 모든 엔티티를 작게 유지
+
+### 기능 요구 사항
+- [x] 사다리 게임에 참여하는 사람의 이름을 최대 5글자까지 부여
+  > 참여 최소 인원은 1명
+- [x] 사람 이름은 쉼표(`,`)를 기준으로 구분
+- [x] 사다리 출력 시, 사람 이름을 5자 기준으로 함께 출력
+- [x] 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
+  > 가로 라인이 겹치는 경우(ex. `|-----|-----|`) 어느 방향으로 이동할지 결정할 수 없다.  
+  > 최소 사다리 높이는 1  
+  > 최소 라인 연결수는 0개

src/main/java/nextstep/ladder/LadderApplication.java

@@ -0,0 +1,35 @@
+package nextstep.ladder;
+
+import nextstep.ladder.domain.*;
+import nextstep.ladder.presentation.LadderGameResultView;
+import nextstep.ladder.presentation.util.ConsoleInputUtil;
+
+public class LadderApplication {
+    public static void main(String[] args) {
+        Participants participants = new Participants(participantNames());
+        Ladder ladder = ladderFactory().create(participants, maximumLadderHeight());
+
+        LadderGameResultView ladderGameResultView = new LadderGameResultView(participants, ladder);
+        ladderGameResultView.printExecuteResult();
+    }
+
+    private static LadderFactory ladderFactory() {
+        return new LadderFactory(lineFactory());
+    }
+
+    private static LineFactory lineFactory() {
+        return new LineFactory(randomConnectionsFactory());
+    }
+
+    private static ConnectionsFactory randomConnectionsFactory() {
+        return new RandomConnectionsFactory();
+    }
+
+    private static int maximumLadderHeight() {
+        return ConsoleInputUtil.askMaximumLadderHeight();
+    }
+
+    private static String participantNames() {
+        return ConsoleInputUtil.askParticipantNames();
+    }
+}

src/main/java/nextstep/ladder/domain/Connection.java

@@ -0,0 +1,28 @@
+package nextstep.ladder.domain;
+
+import java.util.Objects;
+
+public class Connection {
+    private final boolean connection;
+
+    public Connection(boolean connection) {
+        this.connection = connection;
+    }
+
+    public boolean isConnected() {
+        return connection;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Connection)) return false;
+        Connection that = (Connection) o;
+        return connection == that.connection;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(connection);
+    }
+}

src/main/java/nextstep/ladder/domain/Connections.java

@@ -0,0 +1,57 @@
+package nextstep.ladder.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.IntStream;
+
+public class Connections {
+    private static final int START_INDEX_OF_CONNECTIONS = 0;
+    private static final int ONE = 1;
+    private final List<Connection> connections;
+
+    public Connections(List<Connection> connections) {
+        validateConnections(connections);
+        this.connections = connections;
+    }
+
+    public List<Connection> connections() {
+        return Collections.unmodifiableList(connections);
+    }
+
+    private void validateConnections(List<Connection> connections) {
+        if(connections == null) {
+            throw new IllegalArgumentException("가로 라인의 연결선은 null이 될 수 없습니다.");
+        }
+
+        if(containsConsecutiveConnections(connections)) {
+            throw new IllegalArgumentException("가로 라인의 연결선은 연속해서 존재할 수 없습니다.");
+        }
+    }
+
+    private boolean containsConsecutiveConnections(List<Connection> connections) {
+        return IntStream.range(START_INDEX_OF_CONNECTIONS, beforeLastIndexOf(connections))
+                .anyMatch(index -> isConsecutiveConnections(connections, index));
+    }
+
+    private int beforeLastIndexOf(List<Connection> connections) {
+        return connections.size() - ONE;
+    }
+
+    private boolean isConsecutiveConnections(List<Connection> connections, int index) {
+        return connections.get(index).isConnected() && connections.get(index + ONE).isConnected();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Connections)) return false;
+        Connections that = (Connections) o;
+        return Objects.equals(connections, that.connections);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(connections);
+    }
+}

src/main/java/nextstep/ladder/domain/ConnectionsFactory.java

@@ -0,0 +1,5 @@
+package nextstep.ladder.domain;
+
+public interface ConnectionsFactory {
+    Connections create(int numberOfConnections);
+}

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

@@ -0,0 +1,35 @@
+package nextstep.ladder.domain;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public class Ladder {
+    private final List<Line> lines;
+
+    public Ladder(Line...lines) {
+        this(Arrays.asList(lines));
+    }
+
+    public Ladder(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public List<Line> lines() {
+        return Collections.unmodifiableList(lines);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Ladder)) return false;
+        Ladder ladder = (Ladder) o;
+        return Objects.equals(lines, ladder.lines);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(lines);
+    }
+}

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

@@ -0,0 +1,40 @@
+package nextstep.ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LadderFactory {
+    private static final int ONE = 1;
+    private static final int ZERO = 0;
+    private final LineFactory lineFactory;
+
+    public LadderFactory(LineFactory lineFactory) {
+        this.lineFactory = lineFactory;
+    }
+
+    public Ladder create(Participants participants, int height) {
+        return create(participants.size(), height);
+    }
+
+    public Ladder create(int numberOfLine, int height) {
+        validateHeight(height);
+        return new Ladder(lines(numberOfLine, height));
+    }
+
+    private List<Line> lines(int numberOfLine, int height) {
+        return IntStream.range(ZERO, height)
+                .mapToObj(index -> lineFactory.create(numberOfConnections(numberOfLine)))
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    private int numberOfConnections(int numberOfLine) {
+        return numberOfLine - ONE;
+    }
+
+    private void validateHeight(int height) {
+        if(height <= ZERO) {
+            throw new IllegalArgumentException("사다리의 높이는 0 이하일 수 없습니다: " + height);
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+package nextstep.ladder.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Line {
+    private final Connections connections;
+
+    public Line(Boolean...connections) {
+        this(Arrays.stream(connections)
+                .map(Connection::new)
+                .collect(Collectors.toUnmodifiableList()));
+    }
+
+    public Line(List<Connection> connections) {
+        this(new Connections(connections));
+    }
+
+    public Line(Connections connections) {
+        this.connections = connections;
+    }
+
+    public List<Connection> connections() {
+        return connections.connections();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Line)) return false;
+        Line line = (Line) o;
+        return Objects.equals(connections, line.connections);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(connections);
+    }
+}

src/main/java/nextstep/ladder/domain/LineFactory.java

@@ -0,0 +1,25 @@
+package nextstep.ladder.domain;
+
+public class LineFactory {
+    private static final int ZERO = 0;
+    private final ConnectionsFactory connectionsFactory;
+
+    public LineFactory(ConnectionsFactory connectionsFactory) {
+        this.connectionsFactory = connectionsFactory;
+    }
+
+    public Line create(int numberOfConnections) {
+        validateNumberOfConnections(numberOfConnections);
+        return new Line(connections(numberOfConnections));
+    }
+
+    private Connections connections(int numberOfConnections) {
+        return connectionsFactory.create(numberOfConnections);
+    }
+
+    private void validateNumberOfConnections(int numberOfConnections) {
+        if(numberOfConnections < ZERO) {
+            throw new IllegalArgumentException("라인 연결수는 0 미만이 될 수 없습니다: " + numberOfConnections);
+        }
+    }
+}

src/main/java/nextstep/ladder/domain/ParticipantName.java

@@ -0,0 +1,40 @@
+package nextstep.ladder.domain;
+
+import java.util.Objects;
+
+public class ParticipantName {
+    private static final int MAX_NAME_LENGTH = 5;
+    private final String name;
+
+    public ParticipantName(String name) {
+        validateName(name);
+        this.name = name;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    private void validateName(String name) {
+        if(name == null || name.isBlank()) {
+            throw new IllegalArgumentException("이름은 null이거나 공백일 수 없습니다: " + name);
+        }
+
+        if(name.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("이름의 길이는 5를 초과할 수 없습니다: " + name);
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof ParticipantName)) return false;
+        ParticipantName that = (ParticipantName) o;
+        return Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}

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

@@ -0,0 +1,53 @@
+package nextstep.ladder.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Participants {
+    private static final String COMMA = ",";
+    private final List<ParticipantName> names;
+
+    public Participants(String csvNames) {
+        this(csvNames.split(COMMA));
+    }
+
+    public Participants(String...names) {
+        this(participantsNames(names));
+    }
+
+    public Participants(List<ParticipantName> names) {
+        this.names = names;
+    }
+
+    public int size() {
+        return names.size();
+    }
+
+    public List<String> names() {
+        return names.stream()
+                .map(ParticipantName::name)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    private static List<ParticipantName> participantsNames(String[] names) {
+        return Arrays.stream(names)
+                .map(String::trim)
+                .map(ParticipantName::new)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Participants)) return false;
+        Participants that = (Participants) o;
+        return Objects.equals(names, that.names);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(names);
+    }
+}