[자동차 경주] 이승철 미션 제출합니다.

README.md

@@ -1 +1,26 @@
-# java-racingcar-precourse
+# java-racingcar-precourse  
+
+## 기능 목록
+- [X] 자동차 이름 입력 안내문구를 출력한다
+- [X] 경주할 자동차 이름을 입력 받는다
+- [X] 경주할 자동차를 생성한다
+- [X] 경주할 각 자동차 이름 길이를 검증한다 (5자 이하)
+- [X] 시도 횟수 입력 안내문구를 출력한다
+- [X] 몇 번을 이동할 지 입력 받는다
+- [X] 무작위 값을 생성한다
+- [X] 무작위 값에 따라 하나의 자동차를 전진 혹은 정지시킨다
+- [X] 한 번의 이동시도를 수행한다. 입력받은 모든 자동차를 이동시도한다
+- [X] 모든 차의 상태를 출력한다
+- [X] 입력한 횟수 만큼의 이동시도 수행을 반복한다
+- [X] 이동시도 수행을 마치고 실행 결과를 출력한다
+- [X] 최종 우승자(들)을 판별한다
+- [X] 최종 우승자(들)을 출력한다
+
+--- 
+
+## 추가 예외 케이스, 개발 과정에서 수정 예정
+- [X] 시도 횟수를 검증한다 (숫자로 변환 가능한지, overflow 검증, 음수가 아닌지)
+- [X] 경주할 자동차 이름 입력을 검증한다
+    - [X] 자동차 이름 입력이 아예 없을 때를 검증한다
+    - [X] 자동차의 각 이름이 비어있을 때를 검증한다
+    - [X] 구분자 위치에 따른 다양한 예외 상황을 검증한다

src/main/java/racingcar/Application.java

@@ -1,7 +1,12 @@
 package racingcar;
 
+import racingcar.config.ControllerConfig;
+
 public class Application {
+
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        ControllerConfig config = new ControllerConfig();
+        config.controller().run();
     }
+
 }

src/main/java/racingcar/argumentresolver/ArgumentResolver.java

@@ -0,0 +1,7 @@
+package racingcar.argumentresolver;
+
+public interface ArgumentResolver<T> {
+
+    T parse(String parameter);
+
+}

src/main/java/racingcar/argumentresolver/AttemptCountArgumentResolver.java

@@ -0,0 +1,14 @@
+package racingcar.argumentresolver;
+
+public class AttemptCountArgumentResolver implements ArgumentResolver<Integer> {
+
+    @Override
+    public Integer parse(String parameter) {
+        try {
+            return Integer.parseInt(parameter);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("숫자로 변환가능한 입력이어야 합니다.");
+        }
+    }
+
+}

src/main/java/racingcar/argumentresolver/CarArgumentResolver.java

@@ -0,0 +1,28 @@
+package racingcar.argumentresolver;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class CarArgumentResolver implements ArgumentResolver<List<String>> {
+
+    private static final int NEGATIVE = -1;
+
+    @Override
+    public List<String> parse(String parameter) {
+        checkBlank(parameter);
+        return splitWithBlankAndTrim(parameter);
+    }
+
+    private List<String> splitWithBlankAndTrim(String parameter) {
+        return Arrays.stream(parameter.split(",", NEGATIVE))
+                .map(String::trim)
+                .toList();
+    }
+
+    private void checkBlank(String parameter) {
+        if (parameter == null || parameter.isBlank()) {
+            throw new IllegalArgumentException("비어있는 입력은 불가능합니다.");
+        }
+    }
+
+}

src/main/java/racingcar/config/ControllerConfig.java

@@ -0,0 +1,85 @@
+package racingcar.config;
+
+import java.util.List;
+import racingcar.domain.mover.AllCarMover;
+import racingcar.domain.mover.CarMover;
+import racingcar.controller.Controller;
+import racingcar.view.InputView;
+import racingcar.domain.winnerdecider.policy.MaxMoveWinningPolicy;
+import racingcar.domain.mover.policy.MovePolicy;
+import racingcar.view.OutputView;
+import racingcar.domain.mover.policy.RandomMovePolicy;
+import racingcar.domain.mover.policy.trigger.RandomNumberGenerator;
+import racingcar.domain.winnerdecider.WinnersDecider;
+import racingcar.domain.winnerdecider.policy.WinningPolicy;
+import racingcar.argumentresolver.ArgumentResolver;
+import racingcar.argumentresolver.AttemptCountArgumentResolver;
+import racingcar.argumentresolver.CarArgumentResolver;
+import racingcar.validator.RangeValidator;
+import racingcar.validator.SizeValidator;
+import racingcar.validator.Validator;
+
+public class ControllerConfig {
+
+    public Controller controller() {
+        return new Controller(
+                outputView(),
+                inputView(),
+                carArgumentResolver(),
+                attemptCountArgumentResolver(),
+                sizeValidator(),
+                rangeValidator(),
+                allCarMover(),
+                winnersDecider()
+        );
+    }
+
+    public OutputView outputView() {
+        return new OutputView();
+    }
+
+    public InputView inputView() {
+        return new InputView();
+    }
+
+    public ArgumentResolver<List<String>> carArgumentResolver() {
+        return new CarArgumentResolver();
+    }
+
+    public ArgumentResolver<Integer> attemptCountArgumentResolver() {
+        return new AttemptCountArgumentResolver();
+    }
+
+    public Validator<List<String>> sizeValidator() {
+        return new SizeValidator();
+    }
+
+    public Validator<Integer> rangeValidator() {
+        return new RangeValidator();
+    }
+
+    public AllCarMover allCarMover() {
+        return new AllCarMover(carMover());
+    }
+
+    public CarMover carMover() {
+        return new CarMover(movePolicy());
+    }
+
+    public MovePolicy movePolicy() {
+        return new RandomMovePolicy(randomNumberGenerator());
+    }
+
+    public RandomNumberGenerator randomNumberGenerator() {
+        return new RandomNumberGenerator();
+    }
+
+    public WinnersDecider winnersDecider() {
+        return new WinnersDecider(winningPolicy());
+    }
+
+    public WinningPolicy winningPolicy() {
+        return new MaxMoveWinningPolicy();
+    }
+
+}

src/main/java/racingcar/controller/Controller.java

@@ -0,0 +1,89 @@
+package racingcar.controller;
+
+import java.util.List;
+import racingcar.argumentresolver.ArgumentResolver;
+import racingcar.domain.Car;
+import racingcar.domain.mover.AllCarMover;
+import racingcar.util.CarConverter;
+import racingcar.domain.winnerdecider.WinnersDecider;
+import racingcar.validator.Validator;
+import racingcar.view.InputView;
+import racingcar.view.OutputView;
+
+public class Controller {
+
+    private final OutputView outputView;
+    private final InputView inputView;
+    private final ArgumentResolver<List<String>> carArgumentResolver;
+    private final ArgumentResolver<Integer> attemptCountArgumentResolver;
+    private final Validator<List<String>> sizeValidator;
+    private final Validator<Integer> rangeValidator;
+    private final AllCarMover allCarMover;
+    private final WinnersDecider winnersDecider;
+
+    public Controller(
+            OutputView outputView,
+            InputView inputView,
+            ArgumentResolver<List<String>> carArgumentResolver,
+            ArgumentResolver<Integer> attemptCountArgumentResolver,
+            Validator<List<String>> sizeValidator,
+            Validator<Integer> rangeValidator,
+            AllCarMover allCarMover,
+            WinnersDecider winnersDecider
+    ) {
+        this.outputView = outputView;
+        this.inputView = inputView;
+        this.carArgumentResolver = carArgumentResolver;
+        this.attemptCountArgumentResolver = attemptCountArgumentResolver;
+        this.sizeValidator = sizeValidator;
+        this.rangeValidator = rangeValidator;
+        this.allCarMover = allCarMover;
+        this.winnersDecider = winnersDecider;
+    }
+
+    public void run() {
+        List<Car> cars = getCarsFromInput();
+        int attemptCount = getAttemptCountFromInput();
+        runRace(cars, attemptCount);
+        printWinners(cars);
+    }
+
+    private List<Car> getCarsFromInput() {
+        outputView.println("경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)");
+        String racingCarNamesRequest = inputView.read();
+
+        List<String> carNames = carArgumentResolver.parse(racingCarNamesRequest);
+        sizeValidator.check(carNames);
+
+        return CarConverter.toCars(carNames);
+    }
+
+    private int getAttemptCountFromInput() {
+        outputView.println("시도할 횟수는 몇 회인가요?");
+        String attemptCountRequest = inputView.read();
+
+        int attemptCount = attemptCountArgumentResolver.parse(attemptCountRequest);
+        rangeValidator.check(attemptCount);
+
+        return attemptCount;
+    }
+
+    private void runRace(List<Car> cars, int attemptCount) {
+        outputView.endLine();
+        outputView.println("실행 결과");
+
+        for (int count = 0; count < attemptCount; count++) {
+            allCarMover.run(cars);
+            outputView.printCarsStatus(cars);
+            outputView.endLine();
+        }
+    }
+
+    private void printWinners(List<Car> cars) {
+        List<Car> winners = winnersDecider.run(cars);
+        List<String> winnerNames = CarConverter.toNames(winners);
+
+        outputView.print("최종 우승자 : ");
+        outputView.printNames(winnerNames);
+    }
+}

src/main/java/racingcar/domain/Car.java

@@ -0,0 +1,25 @@
+package racingcar.domain;
+
+public class Car {
+
+    private final String name;
+    private int moveCount;
+
+
+    public Car(String name) {
+        this.name = name;
+    }
+
+    public void move() {
+        moveCount++;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getMoveCount() {
+        return moveCount;
+    }
+
+}

src/main/java/racingcar/domain/mover/AllCarMover.java

@@ -0,0 +1,18 @@
+package racingcar.domain.mover;
+
+import java.util.List;
+import racingcar.domain.Car;
+
+public class AllCarMover {
+
+    private final CarMover carMover;
+
+    public AllCarMover(CarMover carMover) {
+        this.carMover = carMover;
+    }
+
+    public void run(List<Car> cars) {
+        cars.forEach(carMover::run);
+    }
+
+}

src/main/java/racingcar/domain/mover/CarMover.java

@@ -0,0 +1,20 @@
+package racingcar.domain.mover;
+
+import racingcar.domain.mover.policy.MovePolicy;
+import racingcar.domain.Car;
+
+public class CarMover {
+
+    private final MovePolicy movePolicy;
+
+    public CarMover(MovePolicy movePolicy) {
+        this.movePolicy = movePolicy;
+    }
+
+    public void run(final Car car) {
+        if (movePolicy.canMove()) {
+            car.move();
+        }
+    }
+
+}

src/main/java/racingcar/domain/mover/policy/MovePolicy.java

@@ -0,0 +1,7 @@
+package racingcar.domain.mover.policy;
+
+public interface MovePolicy {
+
+    boolean canMove();
+
+}

src/main/java/racingcar/domain/mover/policy/RandomMovePolicy.java

@@ -0,0 +1,20 @@
+package racingcar.domain.mover.policy;
+
+import racingcar.domain.mover.policy.trigger.RandomNumberGenerator;
+
+public class RandomMovePolicy implements MovePolicy {
+
+    private static final int MOVE_THRESHOLD = 4;
+    private final RandomNumberGenerator randomNumberGenerator;
+
+    public RandomMovePolicy(RandomNumberGenerator randomNumberGenerator) {
+        this.randomNumberGenerator = randomNumberGenerator;
+    }
+
+    @Override
+    public boolean canMove() {
+        int randomValue = randomNumberGenerator.run();
+        return randomValue >= MOVE_THRESHOLD;
+    }
+
+}

src/main/java/racingcar/domain/mover/policy/trigger/RandomNumberGenerator.java

@@ -0,0 +1,11 @@
+package racingcar.domain.mover.policy.trigger;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+public class RandomNumberGenerator {
+
+    public int run() {
+        return Randoms.pickNumberInRange(0, 9);
+    }
+
+}

src/main/java/racingcar/domain/winnerdecider/WinnersDecider.java

@@ -0,0 +1,19 @@
+package racingcar.domain.winnerdecider;
+
+import java.util.List;
+import racingcar.domain.Car;
+import racingcar.domain.winnerdecider.policy.WinningPolicy;
+
+public class WinnersDecider {
+
+    private final WinningPolicy winningPolicy;
+
+    public WinnersDecider(WinningPolicy winningPolicy) {
+        this.winningPolicy = winningPolicy;
+    }
+
+    public List<Car> run(final List<Car> cars) {
+        return winningPolicy.determineWinners(cars);
+    }
+
+}