[사다리 - 함수형 프로그래밍] 박진형 리팩터링

src/main/java/ladder/Application.java

@@ -7,6 +7,7 @@
 import ladder.domain.LadderGameResult;
 import ladder.domain.LadderHeight;
 import ladder.domain.LadderResults;
+import ladder.domain.Lines;
 import ladder.domain.Participants;
 import ladder.view.InputView;
 import ladder.view.OutputView;
@@ -21,15 +22,15 @@ public static void main(String[] args) {
 
         LadderHeight height = InputView.inputHeight();
 
-        Ladder ladder = Ladder.of(participants, height, RANDOM::nextBoolean);
+        Lines lines = Lines.generate(participants.size(), height, RANDOM::nextBoolean);
+
+        Ladder ladder = Ladder.of(participants, lines);
 
         Map<Integer, Integer> path = ladder.generateResults();
 
         LadderGameResult gameResult = LadderGameResult.of(participants, results, path);
 
         OutputView.printLadder(participants, ladder, results);
         LadderGameController.runInquiry(gameResult);
-
     }
-
 }

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

@@ -1,54 +1,40 @@
 package ladder.domain;
 
-import java.util.ArrayList;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.function.BooleanSupplier;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class Ladder {
 
-    private final List<Line> lines;
+    private final Lines lines;
     private final int width;
 
-    private Ladder(List<Line> lines, int width) {
+    private Ladder(Lines lines, int width) {
         this.lines = lines;
         this.width = width;
     }
 
-    public static Ladder of(Participants participants, LadderHeight height, BooleanSupplier strategy) {
-        int participantCount = participants.size();
-        List<Line> lines = generateLines(participantCount, height, strategy);
-
-        return new Ladder(lines, participantCount);
+    public static Ladder of(Participants participants, Lines lines) {
+        return new Ladder(lines, participants.size());
     }
 
-    public int climb(int startIndex) {
-        int currentIndex = startIndex;
-        for (Line line : lines) {
-            currentIndex = line.move(currentIndex);
-        }
-        return currentIndex;
+    int climb(int startIndex) {
+        return lines.move(startIndex);
     }
 
     public Map<Integer, Integer> generateResults() {
-        Map<Integer, Integer> results = new LinkedHashMap<>();
-        for (int i = 0; i < width; i++) {
-            results.put(i, climb(i));
-        }
-        return results;
-    }
-
-    private static List<Line> generateLines(int participantCount, LadderHeight height, BooleanSupplier strategy) {
-        List<Line> lines = new ArrayList<>();
-        int pointCount = participantCount - 1;
-        for (int i = 0; i < height.getValue(); i++) {
-            lines.add(Line.from(pointCount, strategy));
-        }
-        return lines;
+        return IntStream.range(0, width)
+            .boxed()
+            .collect(Collectors.toMap(
+                index -> index,
+                this::climb,
+                (oldValue, newValue) -> newValue,
+                LinkedHashMap::new
+            ));
     }
 
-    public List<Line> getLines() {
+    public Lines getLines() {
         return lines;
     }
 }

src/main/java/ladder/domain/LadderResults.java

@@ -1,5 +1,6 @@
 package ladder.domain;
 
+import java.util.Collections;
 import java.util.List;
 
 public class LadderResults {
@@ -21,6 +22,6 @@ public static LadderResults of(List<String> rawResults, int participantCount) {
     }
 
     public List<LadderResult> getValues() {
-        return results;
+        return Collections.unmodifiableList(results);
     }
 }

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

@@ -1,47 +1,24 @@
 package ladder.domain;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.function.BooleanSupplier;
 
 public class Line {
 
-    private final List<Point> points;
+    private final Points points;
 
-    private Line(List<Point> points) {
+    private Line(Points points) {
         this.points = points;
     }
 
-    public static Line from(int size, BooleanSupplier strategy) {
-        return new Line(generatePoints(size, strategy));
-    }
-
-    public List<Point> getPoints() {
-        return points;
+    public static Line generate(int size, BooleanSupplier strategy) {
+        return new Line(Points.generate(size, strategy));
     }
 
     public int move(int index) {
-        if (index < points.size() && points.get(index).hasBridge()) {
-            return index + 1;
-        }
-        if (index > 0 && points.get(index - 1).hasBridge()) {
-            return index - 1;
-        }
-        return index;
+        return points.move(index);
     }
 
-    private static List<Point> generatePoints(int size, BooleanSupplier strategy) {
-        List<Point> points = new ArrayList<>();
-        boolean lastBridge = false;
-        for (int i = 0; i < size; i++) {
-            lastBridge = addPoint(points, lastBridge, strategy);
-        }
+    public Points getPoints() {
         return points;
     }
-
-    private static boolean addPoint(List<Point> points, boolean lastBridge, BooleanSupplier strategy) {
-        boolean currentBridge = !lastBridge && strategy.getAsBoolean();
-        points.add(Point.from(currentBridge));
-        return currentBridge;
-    }
 }

src/main/java/ladder/domain/Lines.java

@@ -0,0 +1,45 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.BooleanSupplier;
+
+public class Lines implements Iterable<Line> {
+    private final List<Line> lines;
+
+    private Lines(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public static Lines generate(int participantCount, LadderHeight height, BooleanSupplier strategy) {
+        List<Line> lines = new ArrayList<>();
+        int pointCount = participantCount - 1;
+        for (int i = 0; i < height.getValue(); i++) {
+            lines.add(Line.generate(pointCount, strategy));
+        }
+        return new Lines(lines);
+    }
+
+    public int move(int startIndex) {
+        int currentIndex = startIndex;
+        for (Line line : lines) {
+            currentIndex = line.move(currentIndex);
+        }
+        return currentIndex;
+    }
+
+    public Line get(int index) {
+        return lines.get(index);
+    }
+
+    public int size() {
+        return lines.size();
+    }
+
+    @Override
+    public Iterator<Line> iterator() {
+        return lines.iterator();
+    }
+}

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

@@ -15,7 +15,7 @@ private Participants(List<Name> participants) {
     public static Participants from(List<String> names) {
         List<Name> nameList = names.stream()
             .map(Name::from)
-            .collect(Collectors.toList());
+            .toList();
         return new Participants(nameList);
     }
 

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

@@ -1,24 +1,18 @@
 package ladder.domain;
 
-public class Point {
-
-    private static final Point BRIDGE = new Point(true);
-    private static final Point EMPTY = new Point(false);
+public enum Point {
+    BRIDGE(true),
+    EMPTY(false);
 
     private final boolean hasBridge;
 
-    private Point(boolean hasBridge) {
+    Point(boolean hasBridge) {
         this.hasBridge = hasBridge;
     }
 
     public static Point from(boolean hasBridge) {
-        if (hasBridge) {
-            return BRIDGE;
-        }
-        return EMPTY;
+        return hasBridge ? BRIDGE : EMPTY;
     }
 
-    public boolean hasBridge() {
-        return hasBridge;
-    }
+    public boolean hasBridge() { return hasBridge; }
 }

src/main/java/ladder/domain/Points.java

@@ -0,0 +1,65 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.BooleanSupplier;
+
+public class Points implements Iterable<Point> {
+    private final List<Point> points;
+
+    private Points(List<Point> points) {
+        this.points = points;
+    }
+
+    public static Points generate(int size, BooleanSupplier strategy) {
+        List<Point> points = new ArrayList<>();
+        boolean lastBridge = false;
+        for (int i = 0; i < size; i++) {
+            lastBridge = addPoint(points, lastBridge, strategy);
+        }
+        return new Points(points);
+    }
+
+    private static boolean addPoint(List<Point> points, boolean lastBridge, BooleanSupplier strategy) {
+        boolean currentBridge = !lastBridge && strategy.getAsBoolean();
+        points.add(Point.from(currentBridge));
+        return currentBridge;
+    }
+
+    public int move(int index) {
+        if (isRightStep(index)) {
+            return index + 1;
+        }
+        if (isLeftStep(index)) {
+            return index - 1;
+        }
+        return index;
+    }
+
+    private boolean isRightStep(int index) {
+        return index < points.size() && points.get(index).hasBridge();
+    }
+
+    private boolean isLeftStep(int index) {
+        return index > 0 && points.get(index - 1).hasBridge();
+    }
+
+    public Point get(int index) {
+        return points.get(index);
+    }
+
+    public int size() {
+        return points.size();
+    }
+
+    public List<Point> getValues() {
+        return Collections.unmodifiableList(points);
+    }
+
+    @Override
+    public Iterator<Point> iterator() {
+        return points.iterator();
+    }
+}

src/test/java/ladder/domain/LadderTest.java

@@ -38,10 +38,11 @@ void createLadder_WidthCheck() {
     void createLadder_StrategyCheck() {
         Ladder ladder = createLadder(NAMES_3, 1);
         Line firstLine = ladder.getLines().get(0);
+        Points points = firstLine.getPoints();
 
         assertAll(
-            () -> assertThat(firstLine.getPoints().get(0).hasBridge()).isTrue(),
-            () -> assertThat(firstLine.getPoints().get(1).hasBridge()).isFalse()
+            () -> assertThat(points.get(0).hasBridge()).isTrue(),
+            () -> assertThat(points.get(1).hasBridge()).isFalse()
         );
     }
 
@@ -72,10 +73,11 @@ void generateResults() {
     }
 
     private Ladder createLadder(List<String> names, int height) {
-        return Ladder.of(
-            Participants.from(names),
-            LadderHeight.from(height),
-            () -> true
-        );
+        Participants participants = Participants.from(names);
+        LadderHeight ladderHeight = LadderHeight.from(height);
+
+        Lines lines = Lines.generate(participants.size(), ladderHeight, () -> true);
+
+        return Ladder.of(participants, lines);
     }
 }

src/test/java/ladder/domain/LineTest.java

@@ -15,8 +15,8 @@ void createLine_AlwaysTrueStrategy() {
         // given
         int size = 3;
         // when
-        Line line = Line.from(size, () -> true);
-        List<Point> points = line.getPoints();
+        Line line = Line.generate(size, () -> true);
+        Points points = line.getPoints();
 
         // then
         assertAll(
@@ -32,7 +32,7 @@ void createLine_AlwaysFalseStrategy() {
         // given
         int size = 5;
         // when
-        Line line = Line.from(size, () -> false);
+        Line line = Line.generate(size, () -> false);
 
         // then
         assertThat(line.getPoints())
@@ -44,14 +44,14 @@ void createLine_AlwaysFalseStrategy() {
     @Test
     void createLine_SizeCheck() {
         int size = 10;
-        Line line = Line.from(size, () -> true);
+        Line line = Line.generate(size, () -> true);
         assertThat(line.getPoints()).hasSize(size);
     }
 
     @DisplayName("다리 유무에 따라 인덱스가 좌, 우로 이동하거나 그대로 유지된다.")
     @Test
     void move() {
-        Line line = Line.from(3, () -> true);
+        Line line = Line.generate(3, () -> true);
 
         assertAll(
             // 0번 기둥: 0번 포인트가 T이므로 오른쪽(1)으로 이동