Step 5 - 자동차경주(리팩토링)

src/main/java/racingcar/Main.java

@@ -1,9 +1,10 @@
 package racingcar;
 
 import racingcar.domain.RacingCarSimulator;
+import racingcar.domain.movableStrategy.RandomMovableStrategy;
 import racingcar.dto.RacingResultDTO;
-import racingcar.ui.InputView;
-import racingcar.ui.ResultView;
+import racingcar.view.InputView;
+import racingcar.view.ResultView;
 
 import java.util.List;
 
@@ -12,8 +13,7 @@ public class Main {
     public static void main(String[] args) {
         List<String> carNames = InputView.inputCarNames();
         int tryNumber = InputView.inputTryNumber();
-
-        RacingResultDTO result = RacingCarSimulator.simulate(carNames, tryNumber);
+        RacingResultDTO result = RacingCarSimulator.simulate(carNames, tryNumber, RandomMovableStrategy.getInstance());
         ResultView.printRacingResult(result);
     }
 }

src/main/java/racingcar/domain/CarRacing.java

@@ -1,39 +1,33 @@
 package racingcar.domain;
 
-import racingcar.domain.movableStrategy.RandomMovableStrategy;
-import racingcar.dto.RacingCarStatesDTO;
-import racingcar.dto.RacingWrapResultDTO;
-import racingcar.dto.RacingWrapResultsDTO;
+import racingcar.domain.movableStrategy.MovableStrategy;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
 
 public class CarRacing {
     private final RacingFleet racingFleet;
-    private final RacingWrapResultsDTO wrapResults;
+    private final RacingHistories histories;
+    private final MovableStrategy movableStrategy;
 
-    private CarRacing(RacingFleet racingFleet, RacingWrapResultsDTO wrapResults) {
+    private CarRacing(RacingFleet racingFleet, RacingHistories histories, MovableStrategy movableStrategy) {
         this.racingFleet = racingFleet;
-        this.wrapResults = wrapResults;
+        this.histories = histories;
+        this.movableStrategy = movableStrategy;
     }
 
-    public static CarRacing valueOf(List<String> carNames) {
+    public static CarRacing valueOf(List<String> carNames,  MovableStrategy movableStrategy) {
         RacingFleet racingFleet = initializeRacingCars(carNames);
-        List<RacingWrapResultDTO> wrapResults = initializeWrapResults(racingFleet);
-        return new CarRacing(racingFleet, RacingWrapResultsDTO.valueOf(wrapResults));
+        RacingHistories histories = initializeRacingHistories(racingFleet);
+        return new CarRacing(racingFleet, histories, movableStrategy);
     }
 
     private static RacingFleet initializeRacingCars(List<String> carNames) {
         return RacingFleet.valueOf(carNames);
     }
 
-    private static List<RacingWrapResultDTO> initializeWrapResults(RacingFleet racingFleet) {
-        List<RacingWrapResultDTO> wrapResults = new ArrayList<>();
-        wrapResults.add(RacingWrapResultDTO.valueOf(0, RacingCarStatesDTO.valueOf(racingFleet.getRacingCars())));
-        return wrapResults;
+    private static RacingHistories initializeRacingHistories(RacingFleet racingFleet) {
+        return RacingHistories.newInstance(racingFleet);
     }
 
     public void proceedWraps(int tryNumber) {
@@ -43,19 +37,12 @@ public void proceedWraps(int tryNumber) {
     }
 
     private void proceedWrap() {
-        int currentWrapNo = findCurrentWrapNo();
-        List<RacingCar> racingCars = this.racingFleet.getRacingCars();
-        racingCars.forEach(racingCar -> racingCar.race(RandomMovableStrategy.getInstance()));
-        RacingCarStatesDTO carStates = RacingCarStatesDTO.valueOf(racingCars);
-        this.wrapResults.getWrapResults().add(RacingWrapResultDTO.valueOf(currentWrapNo + 1, carStates));
+        racingFleet.raceAll(movableStrategy);
+        this.histories.recordRacingState(racingFleet);
     }
 
-    private int findCurrentWrapNo() {
-        return Collections.max(this.wrapResults.getWrapResults(), Comparator.comparingInt(RacingWrapResultDTO::getWrapNumber)).getWrapNumber();
-    }
-
-    public RacingWrapResultsDTO getWrapResults() {
-        return this.wrapResults;
+    public RacingHistories getHistories() {
+        return this.histories;
     }
 
     public List<RacingCar> getRacingCars() {
@@ -71,11 +58,11 @@ public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         CarRacing carRacing = (CarRacing) o;
-        return Objects.equals(racingFleet, carRacing.racingFleet) && Objects.equals(wrapResults, carRacing.wrapResults);
+        return Objects.equals(racingFleet, carRacing.racingFleet) && Objects.equals(histories, carRacing.histories);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(racingFleet, wrapResults);
+        return Objects.hash(racingFleet, histories);
     }
 }

src/main/java/racingcar/domain/RacingCarSimulator.java

@@ -1,12 +1,13 @@
 package racingcar.domain;
 
+import racingcar.domain.movableStrategy.MovableStrategy;
 import racingcar.dto.RacingResultDTO;
 
 import java.util.List;
 
 public class RacingCarSimulator {
-    public static RacingResultDTO simulate(List<String> carNames, int tryNumber) {
-        CarRacing carRacing = CarRacing.valueOf(carNames);
+    public static RacingResultDTO simulate(List<String> carNames, int tryNumber, MovableStrategy movableStrategy) {
+        CarRacing carRacing = CarRacing.valueOf(carNames, movableStrategy);
         proceedRacing(tryNumber, carRacing);
         return RacingResultDTO.valueOf(carRacing);
     }

src/main/java/racingcar/domain/RacingCarState.java

@@ -0,0 +1,44 @@
+package racingcar.domain;
+
+import java.util.Objects;
+
+public class RacingCarState {
+    private final String carName;
+    private final int carNo;
+    private final int position;
+
+    private RacingCarState(String carName, int carNo, int position) {
+        this.carName = carName;
+        this.carNo = carNo;
+        this.position = position;
+    }
+
+    public static RacingCarState valueOf(RacingCar racingCar) {
+        return new RacingCarState(racingCar.getName(), racingCar.getCarNo(), racingCar.getPosition());
+    }
+
+    public String getCarName() {
+        return this.carName;
+    }
+
+    public int getCarNo() {
+        return this.carNo;
+    }
+
+    public int getPosition() {
+        return this.position;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RacingCarState that = (RacingCarState) o;
+        return getCarNo() == that.getCarNo() && getPosition() == that.getPosition() && Objects.equals(getCarName(), that.getCarName());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getCarName(), getCarNo(), getPosition());
+    }
+}

src/main/java/racingcar/domain/RacingCarStates.java

@@ -0,0 +1,39 @@
+package racingcar.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class RacingCarStates {
+    private final List<RacingCarState> carStates;
+
+    private RacingCarStates(List<RacingCarState> carStates) {
+        this.carStates = carStates;
+    }
+
+    public static RacingCarStates valueOf(RacingFleet fleet) {
+        List<RacingCar> racingCars = fleet.getRacingCars();
+        List<RacingCarState> carStates = new ArrayList<>();
+        for (RacingCar racingCar : racingCars) {
+            carStates.add(RacingCarState.valueOf(racingCar));
+        }
+        return new RacingCarStates(carStates);
+    }
+
+    public List<RacingCarState> value() {
+        return this.carStates;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RacingCarStates that = (RacingCarStates) o;
+        return Objects.equals(value(), that.value());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(value());
+    }
+}

src/main/java/racingcar/domain/RacingFleet.java

@@ -1,5 +1,7 @@
 package racingcar.domain;
 
+import racingcar.domain.movableStrategy.MovableStrategy;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -25,6 +27,10 @@ public List<RacingCar> getRacingCars() {
         return this.racingCars;
     }
 
+    public void raceAll(MovableStrategy movableStrategy) {
+        racingCars.forEach(racingCar -> racingCar.race(movableStrategy));
+    }
+
     public List<RacingCar> findWinners() {
         int topDistance = findTopDistance();
         return findCarNamesWithDistance(topDistance);

src/main/java/racingcar/domain/RacingHistories.java

@@ -0,0 +1,47 @@
+package racingcar.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+
+public class RacingHistories {
+    private final List<RacingHistory> value;
+
+    private RacingHistories(List<RacingHistory> histories) {
+        this.value = histories;
+    }
+
+    public static RacingHistories newInstance(RacingFleet racingFleet) {
+        List<RacingHistory> histories = new ArrayList<>();
+        histories.add(RacingHistory.valueOf(0, RacingCarStates.valueOf(racingFleet)));
+        return new RacingHistories(histories);
+    }
+
+    public List<RacingHistory> value() {
+        return value;
+    }
+
+    public void recordRacingState(RacingFleet racingFleet) {
+        RacingCarStates carStates = RacingCarStates.valueOf(racingFleet);
+        value.add(RacingHistory.valueOf(findCurrentWrapNo() + 1, carStates));
+    }
+
+    private int findCurrentWrapNo() {
+        return Collections.max(value, Comparator.comparingInt(RacingHistory::getWrapNumber)).getWrapNumber();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RacingHistories that = (RacingHistories) o;
+        return Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(value);
+    }
+}

src/main/java/racingcar/domain/RacingHistory.java

@@ -0,0 +1,38 @@
+package racingcar.domain;
+
+import java.util.Objects;
+
+public class RacingHistory {
+    private final int wrapNumber;
+    private final RacingCarStates carStates;
+
+    private RacingHistory(int wrapNumber, RacingCarStates catStates) {
+        this.wrapNumber = wrapNumber;
+        this.carStates = catStates;
+    }
+
+    public static RacingHistory valueOf(int wrapNumber, RacingCarStates catStates) {
+        return new RacingHistory(wrapNumber, catStates);
+    }
+
+    public int getWrapNumber() {
+        return this.wrapNumber;
+    }
+
+    public RacingCarStates getCarStates() {
+        return this.carStates;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RacingHistory that = (RacingHistory) o;
+        return getWrapNumber() == that.getWrapNumber() && Objects.equals(getCarStates(), that.getCarStates());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getWrapNumber(), getCarStates());
+    }
+}

src/main/java/racingcar/dto/RacingCarStateDTO.java

@@ -1,6 +1,7 @@
 package racingcar.dto;
 
 import racingcar.domain.RacingCar;
+import racingcar.domain.RacingCarState;
 
 public final class RacingCarStateDTO {
     private final String carName;
@@ -17,6 +18,10 @@ public static RacingCarStateDTO valueOf(RacingCar racingCar) {
         return new RacingCarStateDTO(racingCar.getName(), racingCar.getCarNo(), racingCar.getPosition());
     }
 
+    public static RacingCarStateDTO valueOf(RacingCarState state) {
+        return new RacingCarStateDTO(state.getCarName(), state.getCarNo(), state.getPosition());
+    }
+
     public String getCarName() {
         return this.carName;
     }

src/main/java/racingcar/dto/RacingCarStatesDTO.java

@@ -1,25 +1,37 @@
 package racingcar.dto;
 
 import racingcar.domain.RacingCar;
+import racingcar.domain.RacingCarState;
+import racingcar.domain.RacingCarStates;
+import racingcar.domain.RacingFleet;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public final class RacingCarStatesDTO {
-    public final List<RacingCarStateDTO> carStates;
+    private final List<RacingCarStateDTO> carStates;
 
     private RacingCarStatesDTO(List<RacingCarStateDTO> carStates) {
         this.carStates = carStates;
     }
 
-    public static RacingCarStatesDTO valueOf(List<RacingCar> racingCars) {
+    public static RacingCarStatesDTO valueOf(RacingFleet fleet) {
+        List<RacingCar> racingCars = fleet.getRacingCars();
         List<RacingCarStateDTO> carStates = new ArrayList<>();
         for (RacingCar racingCar : racingCars) {
             carStates.add(RacingCarStateDTO.valueOf(racingCar));
         }
         return new RacingCarStatesDTO(carStates);
     }
 
+    public static RacingCarStatesDTO valueOf(RacingCarStates states) {
+        List<RacingCarStateDTO> carStates = new ArrayList<>();
+        for (RacingCarState state : states.value()) {
+            carStates.add(RacingCarStateDTO.valueOf(state));
+        }
+        return new RacingCarStatesDTO(carStates);
+    }
+
     public List<RacingCarStateDTO> getCarStates() {
         return this.carStates;
     }

src/main/java/racingcar/dto/RacingResultDTO.java

@@ -12,7 +12,7 @@ private RacingResultDTO(RacingWinnerNamesDTO winners, RacingWrapResultsDTO wrapR
     }
 
     public static RacingResultDTO valueOf(CarRacing carRacing) {
-        return new RacingResultDTO(RacingWinnerNamesDTO.valueOf(carRacing.findWinners()), carRacing.getWrapResults());
+        return new RacingResultDTO(RacingWinnerNamesDTO.valueOf(carRacing.findWinners()), RacingWrapResultsDTO.valueOf(carRacing.getHistories()));
     }
 
     public RacingWinnerNamesDTO getWinners() {