[Step4] 자동차 경주

README.md

@@ -1 +1,6 @@
-# kotlin-racingcar
+# kotlin-racingcar
+
+## 기능목록
+
+- [x] 자동차 이름 입력받는다
+- [x] 우승자를 선정한다

scripts/git-hooks/pre-commit.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+######## KTLINT-GRADLE HOOK START ########
+
+CHANGED_FILES="$(git --no-pager diff --name-status --no-color --cached | awk '$1 != "D" && $2 ~ /\.kts|\.kt/ { print $2}')"
+
+if [ -z "$CHANGED_FILES" ]; then
+    echo "No Kotlin staged files."
+    exit 0
+fi;
+
+echo "Running ktlint over these files:"
+echo "$CHANGED_FILES"
+
+./gradlew --quiet ktlintFormat -PinternalKtlintGitFilter="$CHANGED_FILES"
+
+echo "Completed ktlint run."
+
+echo "$CHANGED_FILES" | while read -r file; do
+    if [ -f $file ]; then
+        git add $file
+    fi
+done
+
+echo "Completed ktlint hook."
+######## KTLINT-GRADLE HOOK END ########

src/main/kotlin/calculator/OperatorCalculatorState.kt

@@ -5,7 +5,7 @@ class OperatorCalculatorState(private val number: Int) : CalculatorState {
         val operator = Operator.from(value)
         return OperandCalculatorState(number, operator)
     }
-    
+
     override fun result(): Int {
         return number
     }

src/main/kotlin/racingcar/Car.kt

@@ -1,12 +1,18 @@
 package racingcar
 
-class Car(val position: Int) {
-    constructor() : this(INITIAL_POSITION)
+class Car(val name: String, val position: Int) {
+    init {
+        require(name.length in MINIMUM_CAR_NAME_LENGTH..MAXIMUM_CAR_NAME_LENGTH) {
+            "자동차의 이름은 ${MINIMUM_CAR_NAME_LENGTH}글자 이상 ${MAXIMUM_CAR_NAME_LENGTH}글자 이하만 가능합니다."
+        }
+    }
+
+    constructor(name: String) : this(name, INITIAL_POSITION)
 
     fun move(power: Int): Car {
         validatePower(power)
         if (power >= MINIMUM_AMOUNT_TO_MOVE) {
-            return Car(position + 1)
+            return Car(name, position + 1)
         }
         return this
     }
@@ -22,5 +28,7 @@ class Car(val position: Int) {
         const val MINIMUM_AMOUNT_TO_MOVE = 4
         const val MAXIMUM_MOVE_POWER = 9
         const val MINIMUM_MOVE_POWER = 0
+        const val MINIMUM_CAR_NAME_LENGTH = 1
+        const val MAXIMUM_CAR_NAME_LENGTH = 5
     }
 }

src/main/kotlin/racingcar/Cars.kt

@@ -1,17 +1,21 @@
 package racingcar
 
 class Cars(val cars: List<Car>, private val powerGenerator: PowerGenerator) {
+    init {
+        require(cars.isNotEmpty()) { "자동차는 최소 한 대 이상 존재해야 합니다." }
+    }
+
     fun move(): Cars {
         val movedCars = mutableListOf<Car>()
         cars.forEach { movedCars.add(it.move(powerGenerator.generate())) }
         return Cars(movedCars, powerGenerator)
     }
 
     companion object {
-        fun initializeWithNumberOfCars(numberOfCars: Int, powerGenerator: PowerGenerator): Cars {
+        fun initialize(numberOfCars: Int, names: List<String>, powerGenerator: PowerGenerator): Cars {
             val cars = mutableListOf<Car>()
             repeat(numberOfCars) {
-                cars.add(Car())
+                cars.add(Car(names[it]))
             }
             return Cars(cars, powerGenerator)
         }

src/main/kotlin/racingcar/InputView.kt

@@ -11,4 +11,9 @@ object InputView {
         println("시도할 회수는 몇 회 인가요?")
         return readln().toInt()
     }
+
+    fun inputNameOfCars(): List<String> {
+        println("자동차 이름을 입력하세요. (이름은 쉼표(,) 기준으로 구분)")
+        return readln().split(",")
+    }
 }

src/main/kotlin/racingcar/Main.kt

@@ -1,10 +1,15 @@
 package racingcar
 
 fun main() {
-    val numberOfCars = InputView.inputNumberOfCars()
-    val numberOfMoves = InputView.inputNumberOfMoves()
+    val cars = initializeCars()
+
+    val movedCars = moveCars(cars)
+    val winners = RacingRule.findWinners(movedCars)
+    OutputView.printWinners(winners)
+}
 
-    val cars = Cars.initializeWithNumberOfCars(numberOfCars, RandomPowerGenerator)
+private fun moveCars(cars: Cars): Cars {
+    val numberOfMoves = InputView.inputNumberOfMoves()
 
     OutputView.printResultTitle()
 
@@ -13,4 +18,11 @@ fun main() {
         movedCars = movedCars.move()
         OutputView.printResult(movedCars.cars)
     }
+    return movedCars
+}
+
+private fun initializeCars(): Cars {
+    val numberOfCars = InputView.inputNumberOfCars()
+    val namesOfCars = InputView.inputNameOfCars()
+    return Cars.initialize(numberOfCars, namesOfCars, RandomPowerGenerator)
 }

src/main/kotlin/racingcar/OutputView.kt

@@ -12,4 +12,9 @@ object OutputView {
         }
         println()
     }
+
+    fun printWinners(winners: List<Car>) {
+        val winnerNames = winners.joinToString(", ") { it.name }
+        println("$winnerNames 가 최종 우승했습니다.")
+    }
 }

src/main/kotlin/racingcar/RacingRule.kt

@@ -0,0 +1,9 @@
+package racingcar
+
+object RacingRule {
+
+    fun findWinners(cars: Cars): List<Car> {
+        val maxPosition = cars.cars.maxBy { it.position }.position
+        return cars.cars.filter { it.position == maxPosition }
+    }
+}

src/main/kotlin/racingcar/RandomPowerGenerator.kt

@@ -3,11 +3,9 @@ package racingcar
 import kotlin.random.Random
 
 object RandomPowerGenerator : PowerGenerator {
-
     private const val MAX_POWER = 10
     private const val MIN_POWER = 0
 
-
     override fun generate(): Int {
         return Random.nextInt(MIN_POWER, MAX_POWER)
     }

src/test/kotlin/racingcar/CarTest.kt

@@ -7,25 +7,34 @@ import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.ValueSource
 
 internal class CarTest {
+    @Test
+    fun `자동차의 이름은 1자 이상이어야 한다`() {
+        assertThrows<IllegalArgumentException> { Car("") }
+    }
+
+    @Test
+    fun `자동차의 이름은 5자 이하여야 한다`() {
+        assertThrows<IllegalArgumentException> { Car("123456") }
+    }
 
     @Test
     fun `자동차는 4 이상이 들어오면 움직인다`() {
-        val car = Car()
+        val car = Car("name")
         val result = car.move(4)
         assertThat(result.position).isOne()
     }
 
     @Test
     fun `자동차는 4 미만이 들어오면 움직이지 않는다`() {
-        val car = Car()
+        val car = Car("name")
         val result = car.move(3)
         assertThat(result.position).isZero()
     }
 
     @ParameterizedTest
     @ValueSource(ints = [-1, 10])
     fun `자동차는 0 이상 9 이하의 값만 가능하다`(power: Int) {
-        val car = Car()
+        val car = Car("name")
 
         assertThrows<IllegalArgumentException> {
             car.move(power)

src/test/kotlin/racingcar/CarsTest.kt

@@ -2,21 +2,27 @@ package racingcar
 
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 
 internal class CarsTest {
 
     @Test
-    fun `자동차들은 특정 숫자 이상이 들어오면 움직인다`() {
-        val cars = Cars.initializeWithNumberOfCars(3, FixedPowerGenerator(4))
+    fun `자동차들은 1대 이상 있어야 한다`() {
+        assertThrows<IllegalArgumentException> { Cars.initialize(0, listOf("a", "b", "c"), FixedPowerGenerator(5)) }
+    }
+
+    @Test
+    fun `자동차들은 4 이상이 들어오면 움직인다`() {
+        val cars = Cars.initialize(3, listOf("a", "b", "c"), FixedPowerGenerator(4))
 
         val result = cars.move()
 
         assertTrue(result.cars.all { it.position == 1 })
     }
 
     @Test
-    fun `자동차들은 특정 숫자 미만이 들어오면 움직이지 않는다`() {
-        val cars = Cars.initializeWithNumberOfCars(3, FixedPowerGenerator(3))
+    fun `자동차들은 4 미만이 들어오면 움직이지 않는다`() {
+        val cars = Cars.initialize(3, listOf("a", "b", "c"), FixedPowerGenerator(3))
 
         val result = cars.move()
 

src/test/kotlin/racingcar/RacingRuleTest.kt

@@ -0,0 +1,16 @@
+package racingcar
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class RacingRuleTest {
+
+    @Test
+    fun `Cars 가 들어오면 우승자를 가려낼 수 있다`() {
+        val cars = Cars(listOf(Car("aa", 2), Car("a", 1)), FixedPowerGenerator(5))
+
+        val result = RacingRule.findWinners(cars)
+
+        assertThat(result).usingRecursiveComparison().isEqualTo(listOf(Car("aa", 2)))
+    }
+}