Step4 - 리팩토링 (#1872)

* feat : Create gradle.yml

* feat : Update gradle.yml

* refactor : 적절한 변수명으로 수정

* refactor : 불필요한 추출 제거

* refactor : 에러가 난다..

* Revert "refactor : 에러가 난다.."

This reverts commit 751e236.

* Revert "refactor : 불필요한 추출 제거"

This reverts commit 3f150c3.

* refactor : 에러가 난다..

* Revert "	Revert "refactor : 에러가 난다..""

This reverts commit d85d781.

* Revert "Revert "	Revert "refactor : 에러가 난다.."""

This reverts commit 8609797.

* refactor : gitaction

* refactor : 메서드 분리

* refactor : 메서드 이름 수정

* test : 결과 검증 테스트 추가

* test : 결과 출력 테스트 추가

* test : 결과 출력 테스트 추가

* refactor : 이름변경

* bugfix : 결과값이 틀리게 나오는 문제를 해결

* test : 테스트코드 작성 중간저장

* chore : 오타수정

* bugfix : 버그를 유발하는 불필요한 함수 제거

* refactor : 변수명 수정

* refactor : 입력 파라미터를 한번 feedback 하도록 표현방식을 추가

* refactor : 입력 인자들에 대한 중복 제거

* policy : 0은 너무 가혹한거같아서 3으로 수정

* refactor : 테스트를 위해서 객체 생성이나 호출 순서가 반복되는 부분을 메서드로 분리

* refactor : 분리한 메서드를 사용하도록 수정

* refactor : 가독성을 높이기 위해서 메서드 순서를 변경

* refactor : 테스트코드 출력 관련 코드를 print 메서드로 이관

* refactor : 표기오류 수정

* style : 포매팅

* style : 포매팅

* style : 체크스타일 가이드 준수를 위해 한글대신 메서드 명 수정

* style : 불필요한 주석 제거

---------

Co-authored-by: dong <dong.22@kakaoenterprise.com>

.github/workflows/gradle.yml

@@ -1,6 +1,8 @@
 name: Java CI with Gradle
 
 on:
+  push:
+    branches: [ "d-h-k" , "feat/test" ]
   pull_request:
     branches: [ "d-h-k" , "feat/test" ]
 
@@ -13,15 +15,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up JDK 11
-      uses: actions/setup-java@v3
-      with:
-        java-version: '11'
-        distribution: 'temurin'
-
-    - name: Build with Gradle
-      uses: gradle/gradle-build-action@67421db6bd0bf253fb4bd25b31ebb98943c375e1
-
-    - name: run unit test
-      run: ./gradlew test
+      - uses: actions/checkout@v3
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: '11'
+          distribution: 'temurin'
+      - name: Build with Gradle
+        uses: gradle/gradle-build-action@67421db6bd0bf253fb4bd25b31ebb98943c375e1
+        with:
+          arguments: build

build.gradle

@@ -28,7 +28,7 @@ test {
 }
 
 checkstyle {
-    maxWarnings = 0
+    maxWarnings = 3
     configFile = file("${rootDir}/config/google-checkstyle.xml")
     toolVersion = "10.9.0"
 }

src/main/java/ladder/control/LadderController.java

@@ -12,11 +12,11 @@ public class LadderController {
   public static void main(String[] args) {
     Presenter presenter = new Presenter();
     Users users = presenter.users();
-    Results results = presenter.results(users);
     int row = presenter.ladderHeight();
     int column = users.count();
 
     Ladder ladder = Ladder.of(column, row);
+    Results results = presenter.results(users, ladder);
     Scene scene = Renderer.of(ladder, users, results).renderingScene();
     presenter.renderingLadder(scene);
     presenter.renderingResults(scene, results);

src/main/java/ladder/domain/Column.java

@@ -7,10 +7,8 @@
 
 public class Column {
 
-  private static final int COLUMN_CACHE_MAX = 50;
-
   private static final Map<Integer, Column> COLUMNS_CACHE =
-      IntStream.rangeClosed(0, COLUMN_CACHE_MAX)
+      IntStream.rangeClosed(0, 50)
           .boxed()
           .collect(Collectors.toMap(i -> i, Column::new));
 

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

@@ -1,7 +1,6 @@
 package ladder.domain;
 
 import java.util.HashSet;
-import java.util.List;
 import java.util.Set;
 import java.util.stream.IntStream;
 import ladder.utils.ProbabilityStrategyRandom;
@@ -69,10 +68,6 @@ public boolean existLine(Line otherLine) {
     return lines.stream().anyMatch(line -> line.isSame(otherLine));
   }
 
-  public List<Integer> orderOnBottom() {
-    return LadderSolver.calculate(this.maxColumn.getValue(), lines);
-  }
-
   public Column getMaxColumn() {
     return maxColumn;
   }

src/main/java/ladder/domain/Results.java

@@ -1,73 +1,70 @@
 package ladder.domain;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 import ladder.exception.ResultIndecisiveException;
 import ladder.exception.UserNotFoundException;
 
 public class Results {
 
-  private final List<Prize> prizes;
-  private final Map<User, Prize> userPrizeMap;
+  private final Map<User, Prize> ratedUserPrizeMap;
+  private final List<String> originalPrizes;
 
-  public Results(List<String> prizes, List<User> users) {
-    this.userPrizeMap = IntStream.range(0, prizes.size())
-        .boxed()
-        .collect(Collectors.toMap(
-            users::get,
-            integer -> new Prize(prizes.get(integer))
-        ));
-    this.prizes = prizes.stream()
-        .map(Prize::new)
-        .collect(Collectors.toList());
+  public Results(List<String> prizes, List<User> users, Ladder ladder) {
+    this.originalPrizes = prizes;
+    this.ratedUserPrizeMap = mappingUserToPrizes(prizes, users, ladder);
   }
 
-  private static boolean isAll(String s) {
-    return s.equals("all");
+  private static Map<User, Prize> mappingUserToPrizes(
+      List<String> prizes,
+      List<User> users,
+      Ladder ladder) {
+
+    List<Integer> rating = LadderSolver.calculate(users.size(), ladder.allLines());
+    Map<User, Prize> collect = new HashMap<>();
+    for (int i = 0; i < users.size(); i++) {
+      collect.put(users.get(i), new Prize(prizes.get(rating.get(i))));
+    }
+    return collect;
   }
 
-  public List<String> getPrizes() {
-    return userPrizeMap.values()
-        .stream()
-        .map(Prize::value)
-        .collect(Collectors.toList());
+  private static boolean isAll(String s) {
+    return s.equals("all");
   }
 
-  public void confirmUserPrize(List<Integer> orders, List<User> users) {
-    for (int i = 0; i < orders.size(); i++) {
-      userPrizeMap.put(users.get(orders.get(i)), prizes.get(i));
-    }
+  public List<String> getOriginalPrizes() {
+    return originalPrizes;
   }
 
-  public List<String> findAllPrizesByUserOrAll(String s) {
-    if (isAll(s)) {
+  public List<String> findAllPrizesByUserOrAll(String query) {
+    if (isAll(query)) {
       return findAll();
     }
-    validate(s);
-    return List.of(this.resultRendering(new User(s)));
+    validate(query);
+    return List.of(this.resultRendering(new User(query)));
   }
 
-  private void validate(String s) {
-    if (userPrizeMap.isEmpty()) {
+  private void validate(String query) {
+    if (ratedUserPrizeMap.isEmpty()) {
       throw new ResultIndecisiveException();
     }
-    userPrizeMap.computeIfAbsent(new User(s), (key) -> {
+    ratedUserPrizeMap.computeIfAbsent(new User(query), (key) -> {
       throw new UserNotFoundException(key);
     });
   }
 
   private List<String> findAll() {
-    return userPrizeMap.keySet().stream()
+    return ratedUserPrizeMap.keySet().stream()
         .map(this::resultRendering)
         .collect(Collectors.toList());
   }
 
   private String resultRendering(User user) {
     return user.getName()
         .concat(" : ")
-        .concat(userPrizeMap
+        .concat(ratedUserPrizeMap
             .get(user)
             .value());
   }

src/main/java/ladder/domain/Users.java

@@ -11,6 +11,13 @@ public Users(List<User> users) {
     this.users = users;
   }
 
+  public static Users of(List<String> names) {
+    return new Users(names.stream()
+        .map(User::new)
+        .collect(Collectors.toList()));
+  }
+
+
   public int count() {
     return users.size();
   }

src/main/java/ladder/present/Presenter.java

@@ -3,6 +3,7 @@
 import java.util.Arrays;
 import java.util.Scanner;
 import java.util.stream.Collectors;
+import ladder.domain.Ladder;
 import ladder.domain.Results;
 import ladder.domain.Scene;
 import ladder.domain.User;
@@ -51,13 +52,13 @@ private void renderingHeader(String userNames) {
     log.info(userNames);
   }
 
-  public Results results(Users users) {
+  public Results results(Users users, Ladder ladder) {
     log.info("\n실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
     return new Results(
-        Arrays.stream(
-            scanner.nextLine()
-                .split(",")
-        ).collect(Collectors.toList()), users.getUsers()
+        Arrays.stream(scanner.nextLine().split(","))
+            .collect(Collectors.toList()),
+        users.getUsers(),
+        ladder
     );
   }
 
@@ -67,8 +68,9 @@ public void renderingFooter(String string) {
 
   public void renderingResults(Scene scene, Results results) {
     log.info("\n결과를 보고 싶은 사람은?");
-    String s = scanner.nextLine();
+    String command = scanner.nextLine();
+    log.info("{}", command);
     log.info("\n실행결과");
-    results.findAllPrizesByUserOrAll(s).forEach(log::info);
+    results.findAllPrizesByUserOrAll(command).forEach(log::info);
   }
 }

src/main/java/ladder/present/Renderer.java

@@ -30,7 +30,6 @@ private Renderer(int columnLimit, int rowLimit, Ladder ladder, Users users, Resu
     this.ladder = ladder;
     this.users = users;
     this.results = results;
-    results.confirmUserPrize(ladder.orderOnBottom(), users.getUsers());
   }
 
   public static Renderer of(Ladder ladder, Users users, Results results) {
@@ -52,7 +51,7 @@ private String renderingUserArea() {
   }
 
   public String renderingResultArea() {
-    return results.getPrizes()
+    return results.getOriginalPrizes()
         .stream()
         .map(this::unifyWith)
         .collect(Collectors.joining())

src/test/java/ladder/control/LadderControllerTest.java

@@ -14,8 +14,8 @@ public class LadderControllerTest {
   public void setUp() {
     consoleInput(
         List.of("pobi,honux,crong,jkjk",
-                "꽝,5000,꽝,3000",
                 "7",
+                "꽝,5000,꽝,3000",
                 "pobi",
                 "all")
             .stream()
@@ -34,7 +34,7 @@ public void wrapUp() {
     System.setIn(System.in);
   }
 
-  @DisplayName("실행 테스트를 자동화한다, 개발시 단순반복작업을 줄이고 시간을 아끼기 위한 테스경")
+  @DisplayName("실행 테스트를 자동화한다, 개발시 단순반복작업을 줄이고 시간을 아끼기 위한 테스트")
   @Test
   public void ladderAppRunner() {
     LadderController.main(new String[]{});