refactor : 공정성 향상 및 요구사항 기반 리팩토링

Author: TwooTwoo

Diff for: src/main/java/LadderApplication.java

@@ -2,7 +2,7 @@
 
 public class LadderApplication {
     public static void main(String[] args) {
-        LadderController ladderController = new LadderController();
+        LadderController ladderController = LadderController.getInstance();
 
         ladderController.run();
     }

Diff for: src/main/java/controller/LadderController.java

@@ -1,20 +1,32 @@
 package controller;
 
+import dto.LineDto;
 import model.Ladder;
 import model.Line;
 import view.LadderOutputView;
 
 import java.util.List;
 
 public class LadderController {
-    LadderOutputView ladderOutputView = new LadderOutputView();
+    private static final LadderController ladderController = new LadderController();
+
+    private final LadderOutputView ladderOutputView = LadderOutputView.getInstance();
+
+    private LadderController() {
+    }
+
+    public static LadderController getInstance() {
+        return ladderController;
+    }
 
     public void run() {
         Ladder ladder = new Ladder(4, 4);
         List<Line> lines = ladder.getLines();
 
-        for(Line line : lines) {
-            ladderOutputView.printLine(line.getLinks());
+        ladderOutputView.printResultHeader();
+        for (Line line : lines) {
+            LineDto lineDto = LineDto.from(line);
+            ladderOutputView.printLine(lineDto);
         }
     }
 

Diff for: src/main/java/dto/LineDto.java

@@ -0,0 +1,29 @@
+package dto;
+
+import model.Line;
+import model.Link;
+import model.LinkStatus;
+
+import java.util.List;
+
+public class LineDto {
+    private final List<Boolean> linkExistCollection;
+
+    private LineDto(List<Boolean> linkExistCollection) {
+        this.linkExistCollection = linkExistCollection;
+    }
+
+    public static LineDto from(Line line) {
+        List<Boolean> linkExistCollection = line.getLinks().stream()
+                .map(Link::getLinkstatus)
+                .map(LinkStatus::isPresent)
+                .toList();
+
+        return new LineDto(linkExistCollection);
+    }
+
+    public List<Boolean> getLinkExistCollection() {
+        return List.copyOf(linkExistCollection);
+    }
+
+}

Diff for: src/main/java/model/Ladder.java

@@ -5,11 +5,11 @@
 import java.util.List;
 
 public class Ladder {
-    private List<Line> lines;
+    private final List<Line> lines;
 
     public Ladder(int width, int height) {
         List<Line> lines = new ArrayList<>();
-        for(int i = 0; i < height; i++) {
+        for (int i = 0; i < height; i++) {
             lines.add(new Line(width));
         }
 
@@ -19,4 +19,5 @@ public Ladder(int width, int height) {
     public List<Line> getLines() {
         return List.copyOf(lines);
     }
+
 }

Diff for: src/main/java/model/Line.java

@@ -1,45 +1,99 @@
 package model;
 
-import java.sql.Array;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 
+import static model.LinkStatus.PRESENT;
+import static model.LinkStatus.UNDEFINED;
+
 public class Line {
     private static final Random random = new Random();
 
-    private final List<Boolean> links;
+    private final List<Link> links;
 
     public Line(int width) {
-        List<Boolean> links = new ArrayList<>();
-        for (int i = 0; i < width-1; i++) {
-            links.add(getConnectDecider(i, links));
+        int size = width - 1;
+        List<Link> links = initializeLinks(size);
+
+        setupLinks(links);
+
+        this.links = List.copyOf(links);
+    }
+
+    public List<Link> getLinks() {
+        return List.copyOf(links);
+    }
+
+    private List<Link> initializeLinks(int size) {
+        List<Link> links = new ArrayList<>();
+        for (int i = 0; i < size; i++) {
+            links.add(Link.getUndefinedLink());
         }
 
-        this.links = Collections.unmodifiableList(links);
+        return List.copyOf(links);
     }
 
-    // 메서드명 미정
-    private boolean getConnectDecider (int index, List<Boolean> links) {
-        if(!isConnectable(index, links)) {
-            return false;
+    private void setupLinks(List<Link> links) {
+        int index = getRandomStartIndex(links);
+
+        while (containsUndefined(links)) {
+            boolean connectDecider = getConnectDecider();
+            boolean connectable = isConnectable(index, links);
+
+            Link link = links.get(index);
+            link.setLinkStatus(connectDecider, connectable);
+
+            index = getNextIndex(index, links);
         }
-        // 랜덤 돌리고
+    }
+
+    private int getRandomStartIndex(List<Link> links) {
+        return random.nextInt(links.size());
+    }
+
+    private boolean containsUndefined(List<Link> links) {
+        return links.stream()
+                .anyMatch(link -> link.getLinkstatus() == UNDEFINED);
+    }
+
+    private boolean getConnectDecider() {
         return random.nextBoolean();
     }
 
-    // 연결 가능한지 검사
-    private boolean isConnectable(int index, List<Boolean> links) {
-        return isFirstIndex(index) || !(links.get(index-1));
+    private boolean isConnectable(int index, List<Link> links) {
+        if (isFirstIndex(index)) {
+            return isRightNotPresent(index, links);
+        }
+        if (isLastIndex(index, links)) {
+            return isLeftNotPresent(index, links);
+        }
+
+        return isRightNotPresent(index, links) && isLeftNotPresent(index, links);
     }
 
-    // 첫번째 인덱스인지 확인
     private boolean isFirstIndex(int index) {
         return index == 0;
     }
 
-    public List<Boolean> getLinks() {
-        return List.copyOf(links);
+    private boolean isLastIndex(int index, List<Link> links) {
+        return index == links.size() - 1;
     }
+
+    private boolean isRightNotPresent(int index, List<Link> links) {
+        Link rightLink = links.get(index + 1);
+
+        return rightLink.getLinkstatus() != PRESENT;
+    }
+
+    private boolean isLeftNotPresent(int index, List<Link> links) {
+        Link leftLink = links.get(index - 1);
+
+        return leftLink.getLinkstatus() != PRESENT;
+    }
+
+    private int getNextIndex(int index, List<Link> linkStatuses) {
+        return ++index % linkStatuses.size();
+    }
+
 }

Diff for: src/main/java/model/Link.java

@@ -0,0 +1,39 @@
+package model;
+
+public class Link {
+    private LinkStatus linkstatus;
+
+    private Link(LinkStatus linkstatus) {
+        this.linkstatus = linkstatus;
+    }
+
+    public static Link getUndefinedLink() {
+        return new Link(LinkStatus.UNDEFINED);
+    }
+
+    public void setLinkStatus(boolean connectDecider, boolean connectable) {
+        validateUpdateStatus();
+
+        if (connectDecider && connectable) {
+            this.linkstatus = LinkStatus.PRESENT;
+            return;
+        }
+
+        this.linkstatus = LinkStatus.ABSENT;
+    }
+
+    public LinkStatus getLinkstatus() {
+        return linkstatus;
+    }
+
+    private void validateUpdateStatus() {
+        if (isAlreadyFixed()) {
+            throw new UnsupportedOperationException("이미 값이 결정된 링크입니다");
+        }
+    }
+
+    private boolean isAlreadyFixed() {
+        return this.linkstatus != LinkStatus.UNDEFINED;
+    }
+
+}

Diff for: src/main/java/model/LinkStatus.java

@@ -0,0 +1,10 @@
+package model;
+
+public enum LinkStatus {
+    UNDEFINED, ABSENT, PRESENT;
+
+    public boolean isPresent() {
+        return this == present;
+    }
+
+}

Diff for: src/main/java/view/LadderOutputView.java

@@ -1,31 +1,47 @@
 package view;
 
-import java.util.List;
+import dto.LineDto;
 
 public class LadderOutputView {
 
-    private static String DASH_COUPLER = "-----";
-    private static String BLANK_COUPLER = "     ";
+    private static final String INDENTATION = "    ";
+    private static final String DASH_COUPLER = "-----";
+    private static final String BLANK_COUPLER = "     ";
+    private static final String PILLAR = "|";
 
-    public void printLine(List<Boolean> line) {
-        StringBuilder output = new StringBuilder();
-        output.append("|");
+    private LadderOutputView() {
+    }
+
+    private static final LadderOutputView ladderOutputView = new LadderOutputView();
 
-        for(boolean isConnected : line) {
-            output.append(getJoiner(isConnected));
-            output.append("|");
+    public static LadderOutputView getInstance() {
+        return ladderOutputView;
+    }
+
+    public void printResultHeader() {
+        System.out.println("실행결과");
+        System.out.println();
+    }
+
+    public void printLine(LineDto lineDto) {
+        StringBuilder output = new StringBuilder()
+                .append(INDENTATION)
+                .append(PILLAR);
+
+        for (boolean isExist : lineDto.getLinkExistCollection()) {
+            String coupler = getCoupler(isExist);
+            output.append(coupler)
+                    .append(PILLAR);
         }
 
         System.out.println(output);
     }
 
-    private String getJoiner(boolean isConnected) {
-        if(isConnected) {
+    private String getCoupler(boolean isLinkExist) {
+        if (isLinkExist) {
             return DASH_COUPLER;
         }
         return BLANK_COUPLER;
     }
 
-
-
 }