[부나] 2단계 자동차 경주 제출합니다.

build.gradle.kts

@@ -14,8 +14,6 @@ dependencies {
     testImplementation("org.junit.jupiter", "junit-jupiter", "5.8.2")
     testImplementation("org.assertj", "assertj-core", "3.22.0")
     testImplementation("io.kotest", "kotest-runner-junit5", "5.2.3")
-
-    testImplementation(kotlin("test"))
 }
 
 tasks {

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

@@ -1,63 +1,55 @@
 package racingcar.controller
 
-import racingcar.model.Car
-import racingcar.model.Round
+import racingcar.dto.car.CarsDto
+import racingcar.dto.car.WinnersDto
+import racingcar.dto.round.RoundDto
 import racingcar.service.RacingService
 import racingcar.view.InputView
 import racingcar.view.OutputView
 
 class RacingController(
     private val inputView: InputView = InputView(),
     private val outputView: OutputView = OutputView(),
-    private val racingService: RacingService = RacingService(),
 ) {
-    fun runRacing() {
-        val cars = racingService.createCars(readCarNames())
-        racingService.insertCars(cars)
+    private lateinit var racingService: RacingService
 
+    fun runRacing() {
+        initRacingService()
         val round = readRound()
-
-        runRounds(round.count, cars)
+        runRounds(round)
 
         val winners = getWinners()
         printWinners(winners)
     }
 
-    private fun readCarNames(): List<String> {
+    private fun initRacingService() {
+        racingService = RacingService(readCarNames())
+    }
+
+    private fun readCarNames(): CarsDto {
         outputView.printMessage(CAR_NAMES_REQUEST_MESSAGE)
         return inputView.readCarNames()
     }
 
-    private fun readRound(): Round {
+    private fun readRound(): RoundDto {
         outputView.printMessage(ROUND_COUNT_REQUEST_MESSAGE)
-        return Round(inputView.readNumber())
+        return inputView.readRound()
     }
 
     private fun printRoundCountRequestMessage() = outputView.printMessage(ROUNDS_RESULT_NOTIFICATION_MESSAGE)
 
-    private fun printRoundResult(cars: List<Car>) = outputView.printRoundResult(cars)
+    private fun printRoundResult(cars: CarsDto) = outputView.printRoundResult(cars)
 
-    private fun printWinners(winners: List<Car>) = outputView.printWinners(winners)
+    private fun printWinners(winners: WinnersDto) = outputView.printWinners(winners)
 
-    private fun runRounds(roundCount: Int, cars: List<Car>) {
+    private fun runRounds(round: RoundDto) {
         printRoundCountRequestMessage()
-        repeat(roundCount) {
-            runRound(cars)
-        }
-    }
-
-    private fun runRound(cars: List<Car>) {
-        moveCarsRandomly(cars)
-        printRoundResult(cars)
-    }
-
-    private fun moveCarsRandomly(cars: List<Car>) {
-        cars.forEach { car ->
-            racingService.moveRandomly(car)
+        racingService.runAllRounds(round) { eachRoundCars ->
+            printRoundResult(eachRoundCars)
         }
     }
 
-    private fun getWinners(): List<Car> = racingService.getWinners()
+    private fun getWinners(): WinnersDto = racingService.getWinners()
 
     companion object {
         private const val CAR_NAMES_REQUEST_MESSAGE = "경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분)."

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

@@ -0,0 +1,7 @@
+package racingcar.dto.car
+
+import racingcar.model.car.CarName
+
+class CarDto(_carName: String, val position: Int = 0) {
+    val carName: CarName = CarName(_carName.trim())
+}

src/main/kotlin/racingcar/dto/car/CarsDto.kt

@@ -0,0 +1,3 @@
+package racingcar.dto.car
+
+class CarsDto(_cars: List<CarDto>) : List<CarDto> by _cars

src/main/kotlin/racingcar/dto/car/WinnersDto.kt

@@ -0,0 +1,5 @@
+package racingcar.dto.car
+
+import racingcar.model.car.Car
+
+class WinnersDto(winners: List<Car>) : List<Car> by winners

src/main/kotlin/racingcar/dto/round/RoundDto.kt

@@ -0,0 +1,3 @@
+package racingcar.dto.round
+
+class RoundDto(val count: Int)

src/main/kotlin/racingcar/model/car/Car.kt

@@ -0,0 +1,12 @@
+package racingcar.model.car
+
+import racingcar.model.car.move.step.MoveStep
+
+class Car(name: String, private var _position: Int = 0) {
+    val carName: CarName = CarName(name)
+    val position: Int get() = _position
+
+    fun move(moveStep: MoveStep) {
+        _position += moveStep.move()
+    }
+}

src/main/kotlin/racingcar/model/car/CarName.kt

@@ -0,0 +1,19 @@
+package racingcar.model.car
+
+class CarName(private var _value: String) {
+    val value: String get() = _value.trim()
+
+    init {
+        require(value.length in MIN_CAR_NAME_LENGTH..MAX_CAR_NAME_LENGTH) {
+            CAR_NAME_LENGTH_OVER_BOUNDARY_ERROR_MESSAGE
+        }
+    }
+
+    companion object {
+        private const val MIN_CAR_NAME_LENGTH = 1
+        private const val MAX_CAR_NAME_LENGTH = 5
+
+        private const val CAR_NAME_LENGTH_OVER_BOUNDARY_ERROR_MESSAGE =
+            "자동차 이름 길이의 범위는 $MIN_CAR_NAME_LENGTH 이상 $MAX_CAR_NAME_LENGTH 이하입니다."
+    }
+}

src/main/kotlin/racingcar/model/car/Cars.kt

@@ -0,0 +1,41 @@
+package racingcar.model.car
+
+import racingcar.model.car.move.condition.CarMoveCondition
+import racingcar.model.car.move.step.OneStep
+import racingcar.model.car.move.step.ZeroStep
+
+class Cars(_cars: List<Car>) : List<Car> by _cars {
+    init {
+        validateExistDuplicatedCarName()
+    }
+
+    private fun validateExistDuplicatedCarName() {
+        val nonDuplicatedCarsForName = this.distinctBy { it.carName.value }
+
+        require(this.size == nonDuplicatedCarsForName.size) {
+            DUPLICATED_CAR_NAME_ERROR_MESSAGE
+        }
+    }
+
+    fun moveAll(carMoveCondition: CarMoveCondition): Cars = this.onEach { car ->
+        if (isSatisfyCondition(carMoveCondition)) {
+            car.move(OneStep)
+        } else {
+            car.move(ZeroStep)
+        }
+    }
+
+    private fun isSatisfyCondition(carMoveCondition: CarMoveCondition) =
+        carMoveCondition() >= MOVE_CONDITION
+
+    fun getWinners(): Winners {
+        val winnerStandard = this.maxBy { it.position }
+        return Winners(this.filter { it.position == winnerStandard.position })
+    }
+
+    companion object {
+        private const val DUPLICATED_CAR_NAME_ERROR_MESSAGE =
+            "중복된 자동차 이름이 존재합니다."
+        private const val MOVE_CONDITION = 4
+    }
+}

src/main/kotlin/racingcar/model/car/Winners.kt

@@ -0,0 +1,7 @@
+package racingcar.model.car
+
+import racingcar.dto.car.WinnersDto
+
+class Winners(winners: List<Car>) : List<Car> by winners {
+    fun toDto(): WinnersDto = WinnersDto(this)
+}

src/main/kotlin/racingcar/model/car/move/condition/CarMoveCondition.kt

@@ -0,0 +1,5 @@
+package racingcar.model.car.move.condition
+
+interface CarMoveCondition {
+    operator fun invoke(): Int
+}

src/main/kotlin/racingcar/model/car/move/condition/CarRandomMoveCondition.kt

@@ -0,0 +1,11 @@
+package racingcar.model.car.move.condition
+
+class CarRandomMoveCondition : CarMoveCondition {
+    override operator fun invoke(): Int =
+        (START_RANDOM_MOVEMENT_PROBABILITY..END_RANDOM_MOVEMENT_PROBABILITY).random()
+
+    companion object {
+        private const val START_RANDOM_MOVEMENT_PROBABILITY = 0
+        private const val END_RANDOM_MOVEMENT_PROBABILITY = 9
+    }
+}

src/main/kotlin/racingcar/model/car/move/step/MoveStep.kt

@@ -0,0 +1,17 @@
+package racingcar.model.car.move.step
+
+sealed class MoveStep {
+    abstract fun move(): Int
+}
+
+object ZeroStep : MoveStep() {
+    private const val ZERO_STEP = 0
+
+    override fun move(): Int = ZERO_STEP
+}
+
+object OneStep : MoveStep() {
+    private const val ONE_STEP = 1
+
+    override fun move(): Int = ONE_STEP
+}

src/main/kotlin/racingcar/model/Round.kt → src/main/kotlin/racingcar/model/round/Round.kt

@@ -1,4 +1,4 @@
-package racingcar.model
+package racingcar.model.round
 
 class Round(val count: Int) {
     init {

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

@@ -1,38 +1,27 @@
 package racingcar.service
 
-import racingcar.model.Car
-import racingcar.repository.CarRepository
-import racingcar.repository.Repository
+import racingcar.dto.car.CarsDto
+import racingcar.dto.car.WinnersDto
+import racingcar.dto.round.RoundDto
+import racingcar.model.car.move.condition.CarMoveCondition
+import racingcar.model.car.move.condition.CarRandomMoveCondition
+import racingcar.utils.mapper.toDto
+import racingcar.utils.mapper.toModel
 
 class RacingService(
-    private val carRepository: Repository<Car> = CarRepository()
+    _cars: CarsDto,
+    private val carMoveCondition: CarMoveCondition = CarRandomMoveCondition()
 ) {
-    fun getAll(): List<Car> = carRepository.selectAll()
+    private val cars = _cars.toModel()
 
-    fun insertCars(cars: List<Car>) {
-        cars.forEach { insertCar(it) }
+    fun runAllRounds(round: RoundDto, doEachRoundResult: (CarsDto) -> Unit) {
+        repeat(round.toModel().count) {
+            doEachRoundResult(moveCars())
+        }
     }
 
-    private fun insertCar(car: Car) = carRepository.insert(car)
+    private fun moveCars(): CarsDto =
+        cars.moveAll(carMoveCondition).toDto()
 
-    fun createCars(names: List<String>): List<Car> =
-        names.map { Car(it) }
-
-    fun moveRandomly(car: Car) {
-        car.move(getRandomProbability())
-    }
-
-    private fun getRandomProbability(): Int =
-        (START_RANDOM_MOVEMENT_PROBABILITY..END_RANDOM_MOVEMENT_PROBABILITY).random()
-
-    fun getWinners(): List<Car> {
-        val cars = getAll()
-        val winnerStandard = cars.maxBy { it.position }
-        return cars.filter { it.position == winnerStandard.position }
-    }
-
-    companion object {
-        private const val START_RANDOM_MOVEMENT_PROBABILITY = 1
-        private const val END_RANDOM_MOVEMENT_PROBABILITY = 10
-    }
+    fun getWinners(): WinnersDto = cars.getWinners().toDto()
 }

src/main/kotlin/racingcar/utils/Extensions.kt

@@ -1,3 +1,4 @@
 package racingcar.utils
 
-fun List<String>.removeBlank() = map { it.trim() }
+fun List<String>.removeBlank(): List<String> =
+    this.map { it.trim() }

src/main/kotlin/racingcar/utils/mapper/CarMapper.kt

@@ -0,0 +1,8 @@
+package racingcar.utils.mapper
+
+import racingcar.dto.car.CarDto
+import racingcar.model.car.Car
+
+fun CarDto.toModel(): Car = Car(carName.value, position)
+
+fun Car.toDto(): CarDto = CarDto(carName.value, position)

src/main/kotlin/racingcar/utils/mapper/CarsMapper.kt

@@ -0,0 +1,10 @@
+package racingcar.utils.mapper
+
+import racingcar.dto.car.CarsDto
+import racingcar.model.car.Cars
+
+fun CarsDto.toModel(): Cars = Cars(this.map { it.toModel() })
+
+fun Cars.toDto(): CarsDto = CarsDto(
+    this.map { car -> car.toDto() }
+)

src/main/kotlin/racingcar/utils/mapper/RoundMapper.kt

@@ -0,0 +1,6 @@
+package racingcar.utils.mapper
+
+import racingcar.dto.round.RoundDto
+import racingcar.model.round.Round
+
+fun RoundDto.toModel(): Round = Round(count)