refactor: 명령어 enum으로 분리 및 옵션 포함된 명령어 객체 추가

seongbeenkim · seongbeenkim · commit 1f16d1a86d99 · 2021-09-04T04:16:24.000+09:00
diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java
@@ -3,10 +3,13 @@
 import chess.controller.dto.BoardDto;
 import chess.domain.ChessGame;
 import chess.domain.board.Status;
-import chess.domain.command.Command;
+import chess.domain.command.CommandOptions;
+import chess.domain.command.MoveOptions;
 import chess.view.InputView;
 import chess.view.OutputView;
 
+import java.util.List;
+
 public class ChessController {
 
     private final InputView inputView;
@@ -18,50 +21,57 @@ public ChessController(final InputView inputView, final OutputView outputView) {
     }
 
     public void run() {
-        outputView.printGuide();
-        ChessGame chessGame = new ChessGame();
+        ChessGame chessGame = initialize();
 
         while (chessGame.isRunning()) {
-            try {
-                outputView.printTurn(chessGame.isWhiteTurn());
-                Command command = new Command(inputView.getCommand());
-                runCommand(chessGame, command);
-                printBoard(chessGame);
-            } catch (UnsupportedOperationException e) {
-                System.out.println(e.getMessage());
-            }
+            play(chessGame);
         }
 
-        printBoard(chessGame);
-        printStatus(chessGame);
+        printResult(chessGame);
+    }
+
+    private ChessGame initialize() {
+        outputView.printGuide();
+        ChessGame chessGame = new ChessGame();
+        CommandOptions initialCommandOptions = CommandOptions.of(inputView.getCommand());
+        executeInitialCommand(initialCommandOptions, chessGame);
+
+        return chessGame;
+    }
+
+    private void executeInitialCommand(final CommandOptions commandOptions, final ChessGame chessGame) {
+        commandOptions.validateInitialCommand();
+
+        if (commandOptions.isEnd()) {
+            chessGame.end();
+        }
     }
 
-    private void runCommand(final ChessGame chessGame, final Command command) {
+    private void play(final ChessGame chessGame) {
         try {
-            if (command.isStart()) {
-                return;
-            }
-
-            if (command.isEnd()) {
-                chessGame.end();
-                return;
-            }
-
-            if (command.isMove()) {
-                chessGame.move(command.getMoveParameters());
-                return;
-            }
-
-            if (command.isStatus()) {
-                printStatus(chessGame);
-                return;
-            }
+            outputView.printTurn(chessGame.isWhiteTurn());
+            CommandOptions commandOptions = CommandOptions.of(inputView.getCommand());
+            executeCommand(chessGame, commandOptions);
+            printBoard(chessGame);
         } catch (IllegalArgumentException e) {
             System.out.println(e.getMessage());
-            return;
+        }
+    }
+
+    private void executeCommand(final ChessGame chessGame, final CommandOptions commandOptions) {
+        if (commandOptions.isEnd()) {
+            chessGame.end();
+        }
+
+        if (commandOptions.isMove()) {
+            List<String> options = commandOptions.getOptions();
+            MoveOptions moveOptions = new MoveOptions(options);
+            chessGame.move(moveOptions);
         }
 
-        throw new UnsupportedOperationException("유효하지 않은 명령어입니다.");
+        if (commandOptions.isStatus()) {
+            printStatus(chessGame);
+        }
     }
 
     private void printBoard(final ChessGame chessGame) {
@@ -73,4 +83,9 @@ private void printStatus(final ChessGame chessGame) {
         Status status = chessGame.getStatus();
         outputView.printStatus(status);
     }
+
+    private void printResult(final ChessGame chessGame) {
+        printBoard(chessGame);
+        printStatus(chessGame);
+    }
 }
diff --git a/src/main/java/chess/domain/command/Command.java b/src/main/java/chess/domain/command/Command.java
@@ -1,57 +1,58 @@
 package chess.domain.command;
 
 import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
+import java.util.HashMap;
+import java.util.Map;
 
-public class Command {
+public enum Command {
 
-    private static final String DELIMITER = " ";
-    private static final int COMMAND_INDEX = 0;
+    START("start"),
+    END("end"),
+    MOVE("move"),
+    STATUS("status");
 
-    private static final String START = "start";
-    private static final String END = "end";
-    private static final String MOVE = "move";
-    private static final String STATUS = "status";
+    private static final Map<String, Command> COMMANDS = createCommands();
+
+    private static Map<String, Command> createCommands() {
+        Map<String, Command> commands = new HashMap<>();
+
+        Arrays.stream(values())
+                .forEach(command -> commands.put(command.command, command));
+
+        return commands;
+    }
 
     private final String command;
-    private final List<String> parameters;
 
-    public Command(final String commandLine) {
-        List<String> chunks = Arrays.stream(commandLine.split(DELIMITER))
-                .map(String::trim)
-                .map(String::toLowerCase)
-                .collect(Collectors.toList());
+    Command(final String command) {
+        this.command = command;
+    }
+
+    public static Command of(final String command) {
+        Command foundCommand = COMMANDS.get(command);
 
-        if (chunks.isEmpty()) {
-            throw new IllegalArgumentException();
+        if (foundCommand == null) {
+            throw new IllegalArgumentException("유효하지 않은 명령어입니다.");
         }
 
-        this.command = chunks.get(COMMAND_INDEX);
-        this.parameters = chunks.subList(COMMAND_INDEX + 1, chunks.size());
+        return foundCommand;
     }
 
-    public boolean isStart() {
-        return command.equals(START);
+    public void validateInitialCommand() {
+        if (isStatus() || isMove()) {
+            throw new IllegalArgumentException(String.format("%s 또는 %s를 입력해주세요.", START.command, END.command));
+        }
     }
 
     public boolean isEnd() {
-        return command.equals(END);
+        return this.equals(END);
     }
 
     public boolean isMove() {
-        return command.equals(MOVE);
+        return this.equals(MOVE);
     }
 
     public boolean isStatus() {
-        return command.equals(STATUS);
-    }
-
-    public MoveParameters getMoveParameters() {
-        if (parameters.size() != 2) {
-            throw new IllegalArgumentException();
-        }
-
-        return new MoveParameters(parameters);
+        return this.equals(STATUS);
     }
 }
diff --git a/src/main/java/chess/domain/command/CommandOptions.java b/src/main/java/chess/domain/command/CommandOptions.java
@@ -0,0 +1,77 @@
+package chess.domain.command;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CommandOptions {
+
+    private static final String DELIMITER = " ";
+    private static final int COMMAND_INDEX = 0;
+    private static final int CHECK_VALUE_IF_COMMAND_HAS_OPTIONS = 1;
+    private static final int FIRST_OPTION_INDEX = 1;
+
+    private final Command command;
+    private final List<String> options;
+
+    private CommandOptions(final Command command, final List<String> options) {
+        this.command = command;
+        this.options = options;
+    }
+
+    public static CommandOptions of(final String text) {
+        validateEmpty(text);
+        List<String> commandAndOptions = split(text);
+        Command command = Command.of(commandAndOptions.get(COMMAND_INDEX));
+        List<String> options = extractOptions(commandAndOptions);
+        System.out.println(options.size());
+
+        return new CommandOptions(command, options);
+    }
+
+    private static void validateEmpty(final String text) {
+        if (text == null) {
+            throw new IllegalArgumentException("명령어가 존재하지 않습니다.");
+        }
+    }
+
+    private static List<String> split(final String text) {
+        return Arrays.stream(text.split(DELIMITER))
+                .map(String::trim)
+                .map(String::toLowerCase)
+                .collect(Collectors.toList());
+    }
+
+    private static List<String> extractOptions(final List<String> commandAndOptions) {
+        if (hasOptions(commandAndOptions)) {
+            return commandAndOptions.subList(FIRST_OPTION_INDEX, commandAndOptions.size());
+        }
+
+        return Collections.emptyList();
+    }
+
+    private static boolean hasOptions(final List<String> splitText) {
+        return splitText.size() > CHECK_VALUE_IF_COMMAND_HAS_OPTIONS;
+    }
+
+    public void validateInitialCommand() {
+        command.validateInitialCommand();
+    }
+
+    public boolean isEnd() {
+        return command.isEnd();
+    }
+
+    public boolean isMove() {
+        return command.isMove();
+    }
+
+    public boolean isStatus() {
+        return command.isStatus();
+    }
+
+    public List<String> getOptions() {
+        return Collections.unmodifiableList(options);
+    }
+}
diff --git a/src/test/java/chess/domain/command/CommandOptionsTest.java b/src/test/java/chess/domain/command/CommandOptionsTest.java
@@ -0,0 +1,89 @@
+package chess.domain.command;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.NullSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class CommandOptionsTest {
+
+    @ParameterizedTest
+    @CsvSource(value = {"start, 0", "end, 0", "move b2 b3, 2", "status, 0"})
+    @DisplayName("옵션이 담긴 명령어를 반환한다.")
+    void of(String text, int expected) {
+        //when
+        CommandOptions commandOptions = CommandOptions.of(text);
+        System.out.println(commandOptions.getOptions().size());
+
+        //then
+        assertThat(commandOptions.getOptions()).hasSize(expected);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @DisplayName("명령어가 null일 경우 예외가 발생한다.")
+    void of_fail(String text) {
+        //when //then
+        assertThatThrownBy(() -> CommandOptions.of(text))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("명령어가 존재하지 않습니다.");
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = {"status, move"})
+    @DisplayName("시작 또는 종료 명령어가 아닐 경우 예외가 발생한다.")
+    void validateInitialCommand(String text) {
+        //given
+        CommandOptions commandOptions = CommandOptions.of(text);
+
+        //when // then
+        assertThatThrownBy(commandOptions::validateInitialCommand)
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("start 또는 end를 입력해주세요.");
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = {"start, false", "end, true", "move, false", "status, false"})
+    @DisplayName("종료 명령어인지 확인한다.")
+    void isEnd(String text, boolean expected) {
+        //given
+        CommandOptions commandOptions = CommandOptions.of(text);
+
+        //when
+        boolean actual = commandOptions.isEnd();
+
+        //then
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = {"start, false", "end, false", "move, true", "status, false"})
+    @DisplayName("종료 명령어인지 확인한다.")
+    void isMove(String text, boolean expected) {
+        //given
+        CommandOptions commandOptions = CommandOptions.of(text);
+
+        //when
+        boolean actual = commandOptions.isMove();
+
+        //then
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = {"start, false", "end, false", "move, false", "status, true"})
+    @DisplayName("종료 명령어인지 확인한다.")
+    void isStatus(String text, boolean expected) {
+        //given
+        CommandOptions commandOptions = CommandOptions.of(text);
+
+        //when
+        boolean actual = commandOptions.isStatus();
+
+        //then
+        assertThat(actual).isEqualTo(expected);
+    }
+}
diff --git a/src/test/java/chess/domain/command/CommandTest.java b/src/test/java/chess/domain/command/CommandTest.java
