[step5] 자동차 경주(리팩토링)

src/main/kotlin/racingcar/controller/RacingController.kt

@@ -2,24 +2,24 @@ package racingcar.controller
 
 import racingcar.domain.Cars
 import racingcar.domain.WinnerCar
+import racingcar.dto.CarsDto
 import racingcar.service.RacingService
+import racingcar.view.OutputView
 import racingcar.view.OutputView.printWinners
 import racingcar.view.inputCarName
 
 class RacingController(
     private val racingService: RacingService = RacingService()
 ) {
-    fun play(): Cars {
-        return racingService.play(join())
+    fun play(): CarsDto {
+        val snapshots = racingService.play(join())
+        OutputView.printRacing(snapshots)
+        return snapshots.last()
     }
 
-    private fun join(): Cars = Cars.of(inputCarName().split(RACING_CAR_DELIMITER))
+    private fun join(): Cars = Cars.of(inputCarName())
 
-    fun win(playRacingCar: Cars) {
+    fun win(playRacingCar: CarsDto) {
         printWinners(WinnerCar.from(playRacingCar))
     }
-
-    companion object {
-        private const val RACING_CAR_DELIMITER = ","
-    }
 }

src/main/kotlin/racingcar/domain/Car.kt

@@ -1,5 +1,7 @@
 package racingcar.domain
 
+import racingcar.dto.CarDto
+
 class Car(val name: String) {
     var position: Int = DEFAULT_POSITION
         private set
@@ -33,16 +35,17 @@ class Cars(cars: List<Car>) {
         }
     }
 
-    fun maxOfPositions(): Int {
-        return cars.maxOf { car -> car.position }
-    }
-
     companion object {
-        fun of(names: List<String>): Cars {
+        private const val RACING_CAR_DELIMITER = ","
+
+        fun of(inputName: String): Cars {
+            val names = inputName.split(RACING_CAR_DELIMITER)
             val cars = names.map {
                 Car.from(it)
             }
             return Cars(cars)
         }
     }
+
+    fun toCarDtoList(): List<CarDto> = cars.map { CarDto.from(it) }
 }

src/main/kotlin/racingcar/domain/WinnerCar.kt

@@ -1,8 +1,10 @@
 package racingcar.domain
 
+import racingcar.dto.CarDto
+import racingcar.dto.CarsDto
+
 object WinnerCar {
-    fun from(racingCars: Cars): List<Car> {
-        return racingCars.cars
-            .filter { it.position == racingCars.maxOfPositions() }
+    fun from(racingCars: CarsDto): List<CarDto> {
+        return racingCars.contentsFilter { it -> it.position == racingCars.maxOfPositions() }
     }
 }

src/main/kotlin/racingcar/dto/CarDto.kt

@@ -0,0 +1,34 @@
+package racingcar.dto
+
+import racingcar.domain.Car
+
+data class CarDto(val name: String, val position: Int) {
+    companion object {
+        fun from(car: Car): CarDto {
+            return CarDto(
+                name = car.name,
+                position = car.position
+            )
+        }
+    }
+}
+
+data class CarsDto(val carsDto: List<CarDto>) {
+    fun racingTrace() = buildString {
+        carsDto.forEach {
+            appendLine("${it.name} : ${RACING_COURSE.repeat(maxOf(0, it.position))}")
+        }
+    }
+
+    fun contentsFilter(predicate: (CarDto) -> Boolean): List<CarDto> {
+        return carsDto.filter(predicate)
+    }
+
+    fun maxOfPositions(): Int {
+        return carsDto.maxOf { car -> car.position }
+    }
+
+    companion object {
+        private const val RACING_COURSE = "-"
+    }
+}

src/main/kotlin/racingcar/service/RacingService.kt

@@ -1,15 +1,16 @@
 package racingcar.service
 
 import racingcar.domain.Cars
-import racingcar.view.OutputView
+import racingcar.dto.CarsDto
 import racingcar.view.inputTryCount
 
 class RacingService {
-    fun play(racingCars: Cars): Cars {
+    fun play(racingCars: Cars): List<CarsDto> {
+        val snapshots = mutableListOf<CarsDto>()
         repeat(inputTryCount()) {
             racingCars.move()
-            OutputView.printRacing(racingCars)
+            snapshots.add(CarsDto(racingCars.toCarDtoList()))
         }
-        return racingCars
+        return snapshots
     }
 }

src/main/kotlin/racingcar/view/OutputView.kt

@@ -1,23 +1,21 @@
 package racingcar.view
 
-import racingcar.domain.Car
-import racingcar.domain.Cars
+import racingcar.dto.CarDto
+import racingcar.dto.CarsDto
 
 object OutputView {
 
     private const val WINNER_JOIN_SEPARATOR = ","
-    private const val RACING_COURSE = "-"
-    fun printRacing(racingCars: Cars) {
+    fun printRacing(snapShots: List<CarsDto>) {
         val result = buildString {
-            racingCars.cars.forEach {
-                appendLine("${it.name} : ${RACING_COURSE.repeat(maxOf(0, it.position))}")
+            snapShots.forEach {
+                appendLine(it.racingTrace())
             }
-            appendLine()
         }
         println(result)
     }
 
-    fun printWinners(winnerCars: List<Car>): String = buildString {
+    fun printWinners(winnerCars: List<CarDto>): String = buildString {
         val winnersCarNames = winnerCars
             .joinToString(WINNER_JOIN_SEPARATOR) { it.name }
 

src/test/kotlin/racingcar/CarsTest.kt

@@ -0,0 +1,15 @@
+package racingcar
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+import racingcar.domain.Cars
+
+class CarsTest {
+    @ValueSource(strings = ["test,123,ㅅㄷㅈ", "민균,한솔,재성"])
+    @ParameterizedTest
+    fun `각 자동차 이름을 구분자(,)로 구분한다`(param: String) {
+        val cars = Cars.of(param)
+        cars.cars shouldBe param.split(",")
+    }
+}