[계산기] 공희상 제출합니다.

src/main/java/calculator/Application.java

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

src/main/java/calculator/common/constant/Constants.java

@@ -0,0 +1,14 @@
+package calculator.common.constant;
+
+public class Constants {
+
+    public static final String EMPTY = "";
+    public static final String COMMA = ",";
+    public static final String COLON = ":";
+    public static final String PIPE = "|";
+    public static final String ZERO = "0";
+    public static final String DEFAULT_DELIMITERS = String.join(PIPE, COMMA, COLON);
+    public static final String DEFAULT_DELIMITER_PATTERN = "^[0-9]+([,|:][0-9]+)*$";
+    public static final String CUSTOM_DELIMITER_PATTERN = "^//.*\\\\n(.*)?$";
+    public static final String CUSTOM_DELIMITER_PARSE_PATTERN = "//(.*)\\\\n(.*)";
+}

src/main/java/calculator/common/constant/message/ErrorMessages.java

@@ -0,0 +1,9 @@
+package calculator.common.constant.message;
+
+public class ErrorMessages {
+    public final static String INVALID_EMPTY = "입력 값은 비어 있을 수 없습니다.";
+    public final static String INVALID_INPUT_NULL = "입력 값이 유효하지 않습니다.";
+    public final static String INVALID_INPUT_FORMAT = "입력 문자열이 유효한 형식이 아닙니다.";
+    public final static String INVALID_CONTAIN_NUMBER = "입력 값에 숫자가 포함될 수 없습니다.";
+    public final static String INVALID_NUMBER = "유효하지 않은 숫자입니다.";
+}

src/main/java/calculator/common/constant/message/ViewMessages.java

@@ -0,0 +1,6 @@
+package calculator.common.constant.message;
+
+public class ViewMessages {
+    public static final String INPUT_PROMPT_MESSAGE = "덧셈할 문자열을 입력해주요.";
+    public static final String CALCULATOR_RESULT_MESSAGE = "결과 : %d";
+}

src/main/java/calculator/config/CalculatorConfig.java

@@ -0,0 +1,30 @@
+package calculator.config;
+
+import calculator.controller.CalculatorController;
+import calculator.service.CalculatorService;
+import calculator.util.parser.NumberParser;
+import calculator.util.validator.DelimiterValidator;
+import calculator.util.validator.InputValidator;
+import calculator.util.validator.NumberValidator;
+import calculator.view.InputView;
+import calculator.view.OutputView;
+
+public class CalculatorConfig {
+
+    private final CalculatorController calculatorController;
+
+    public CalculatorConfig() {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        InputValidator inputValidator = new InputValidator();
+        DelimiterValidator delimiterValidator = new DelimiterValidator();
+        NumberValidator numberValidator = new NumberValidator();
+        NumberParser numberParser = new NumberParser(delimiterValidator, numberValidator);
+        CalculatorService calculatorService = new CalculatorService(inputValidator, numberParser);
+        this.calculatorController = new CalculatorController(inputView, outputView, calculatorService);
+    }
+
+    public void run() {
+        calculatorController.run();
+    }
+}

src/main/java/calculator/controller/CalculatorController.java

@@ -0,0 +1,37 @@
+package calculator.controller;
+
+import calculator.service.CalculatorService;
+import calculator.view.InputView;
+import calculator.view.OutputView;
+
+public class CalculatorController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final CalculatorService calculatorService;
+
+    public CalculatorController(InputView inputView, OutputView outputView, CalculatorService calculatorService) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        this.calculatorService = calculatorService;
+    }
+
+    public void run() {
+        String input = input();
+        int result = calculate(input);
+        result(result);
+    }
+
+    public String input() {
+        outputView.printInputPrompt();
+        return inputView.getInput();
+    }
+
+    private int calculate(String input) {
+        return calculatorService.calculator(input);
+    }
+
+    private void result(int result) {
+        outputView.printResult(result);
+    }
+}

src/main/java/calculator/service/CalculatorService.java

@@ -0,0 +1,36 @@
+package calculator.service;
+
+import calculator.util.parser.NumberParser;
+import calculator.util.validator.InputValidator;
+import java.util.List;
+
+public class CalculatorService {
+    private final InputValidator inputValidator;
+    private final NumberParser numberParser;
+
+    public CalculatorService(InputValidator inputValidator, NumberParser numberParser) {
+        this.inputValidator = inputValidator;
+        this.numberParser = numberParser;
+    }
+
+    public int calculator(String input) {
+        if (input.isEmpty()) {
+            return 0;
+        }
+        validate(input);
+        List<Integer> numbers = parse(input);
+        return sum(numbers);
+    }
+
+    private void validate(String input) {
+        inputValidator.validate(input);
+    }
+
+    private List<Integer> parse(String input) {
+        return numberParser.parse(input);
+    }
+
+    private int sum(List<Integer> numbers) {
+        return numbers.stream().mapToInt(Integer::intValue).sum();
+    }
+}

src/main/java/calculator/util/parser/NumberParser.java

@@ -0,0 +1,88 @@
+package calculator.util.parser;
+
+import static calculator.common.constant.Constants.CUSTOM_DELIMITER_PARSE_PATTERN;
+import static calculator.common.constant.Constants.DEFAULT_DELIMITERS;
+import static calculator.common.constant.Constants.EMPTY;
+import static calculator.common.constant.Constants.PIPE;
+import static calculator.common.constant.Constants.ZERO;
+import static calculator.common.constant.message.ErrorMessages.INVALID_INPUT_FORMAT;
+
+import calculator.util.validator.DelimiterValidator;
+import calculator.util.validator.NumberValidator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.ArrayList;
+import java.util.List;
+
+public class NumberParser {
+    private final DelimiterValidator delimiterValidator;
+    private final NumberValidator numberValidator;
+
+    private static String delimiters = DEFAULT_DELIMITERS;
+
+    public NumberParser(DelimiterValidator delimiterValidator, NumberValidator numberValidator) {
+        this.delimiterValidator = delimiterValidator;
+        this.numberValidator = numberValidator;
+    }
+
+    public List<Integer> parse(String input) {
+        if(input.isEmpty()) {
+            return List.of(0);
+        }
+        List<String> tokens = splitTokens(input);
+        return toNumbers(tokens);
+    }
+
+    private List<String> splitTokens(String input) {
+        if (hasCustomDelimiter(input)) {
+            return customTokens(input);
+        }
+        return defaultTokens(input);
+    }
+
+    private boolean hasCustomDelimiter(String input) {
+        return input.startsWith("//");
+    }
+
+    private List<String> customTokens(String input) {
+        Matcher matcher = Pattern.compile(CUSTOM_DELIMITER_PARSE_PATTERN).matcher(input);
+        if (!matcher.find()) {
+            throw new IllegalArgumentException(INVALID_INPUT_FORMAT);
+        }
+        addDelimiter(matcher.group(1));
+        String numbers = matcher.group(2);
+        if(numbers == null || numbers.isEmpty()) {
+            return List.of(ZERO);
+        }
+        return splitByDelimiter(matcher.group(2));
+    }
+
+    private void addDelimiter(String customDelimiter) {
+        for (String delimiter : customDelimiter.split(EMPTY)) {
+            delimiterValidator.validate(delimiter);
+            delimiters = String.join(PIPE, delimiters, Pattern.quote(delimiter));
+        }
+    }
+
+    private List<String> defaultTokens(String input) {
+        return splitByDelimiter(input);
+    }
+
+    private List<String> splitByDelimiter(String input) {
+        List<String> tokens = new ArrayList<>();
+        for (String token : input.split(delimiters)) {
+            tokens.add(token);
+        }
+        return tokens;
+    }
+
+    private List<Integer> toNumbers(List<String> tokens) {
+        List<Integer> numbers = new ArrayList<>();
+        for (String token : tokens) {
+            numberValidator.validate(token);
+            numbers.add(Integer.parseInt(token));
+        }
+        return numbers;
+    }
+}
+

src/main/java/calculator/util/validator/DelimiterValidator.java

@@ -0,0 +1,16 @@
+package calculator.util.validator;
+
+import static calculator.common.constant.message.ErrorMessages.INVALID_CONTAIN_NUMBER;
+import static calculator.common.constant.message.ErrorMessages.INVALID_EMPTY;
+
+public class DelimiterValidator implements ValidatorStrategy<String> {
+    @Override
+    public void validate(String value) {
+        if (value == null || value.isEmpty()) {
+            throw new IllegalArgumentException(INVALID_EMPTY);
+        }
+        if (value.matches(".*\\d.*")) {
+            throw new IllegalArgumentException(INVALID_CONTAIN_NUMBER);
+        }
+    }
+}

src/main/java/calculator/util/validator/InputValidator.java

@@ -0,0 +1,32 @@
+package calculator.util.validator;
+
+import static calculator.common.constant.Constants.CUSTOM_DELIMITER_PATTERN;
+import static calculator.common.constant.Constants.DEFAULT_DELIMITER_PATTERN;
+import static calculator.common.constant.message.ErrorMessages.INVALID_INPUT_FORMAT;
+
+import java.util.regex.Pattern;
+
+public class InputValidator implements ValidatorStrategy<String> {
+
+    @Override
+    public void validate(String input) {
+        if (input == null) {
+            return;
+        }
+        if (!isValidInput(input)) {
+            throw new IllegalArgumentException(INVALID_INPUT_FORMAT);
+        }
+    }
+
+    private boolean isValidInput(String input) {
+        return isDefaultDelimiter(input) || isCustomDelimiter(input);
+    }
+
+    private boolean isDefaultDelimiter(String input) {
+        return Pattern.matches(DEFAULT_DELIMITER_PATTERN, input);
+    }
+
+    private boolean isCustomDelimiter(String input) {
+        return Pattern.matches(CUSTOM_DELIMITER_PATTERN, input);
+    }
+}

src/main/java/calculator/util/validator/NumberValidator.java

@@ -0,0 +1,16 @@
+package calculator.util.validator;
+
+import static calculator.common.constant.message.ErrorMessages.INVALID_NUMBER;
+
+public class NumberValidator implements ValidatorStrategy<String> {
+    @Override
+    public void validate(String value) {
+        try {
+            if (Integer.parseInt(value) < 0) {
+                throw new NumberFormatException(INVALID_NUMBER);
+            }
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException(INVALID_NUMBER);
+        }
+    }
+}

src/main/java/calculator/util/validator/ValidatorStrategy.java

@@ -0,0 +1,5 @@
+package calculator.util.validator;
+
+public interface ValidatorStrategy <T>{
+    void validate(T value);
+}

src/main/java/calculator/view/InputView.java

@@ -0,0 +1,11 @@
+package calculator.view;
+
+import static camp.nextstep.edu.missionutils.Console.readLine;
+
+public class InputView {
+
+    public String getInput() {
+        return readLine();
+    }
+
+}

src/main/java/calculator/view/OutputView.java

@@ -0,0 +1,15 @@
+package calculator.view;
+
+import static calculator.common.constant.message.ViewMessages.CALCULATOR_RESULT_MESSAGE;
+import static calculator.common.constant.message.ViewMessages.INPUT_PROMPT_MESSAGE;
+
+public class OutputView {
+
+    public void printInputPrompt() {
+        System.out.println(INPUT_PROMPT_MESSAGE);
+    }
+
+    public void printResult(int result) {
+        System.out.println(CALCULATOR_RESULT_MESSAGE.formatted(result));
+    }
+}

src/test/java/calculator/ApplicationTest.java

@@ -8,6 +8,23 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class ApplicationTest extends NsTest {
+
+    @Test
+    void 기본_구분자_사용() {
+        assertSimpleTest(() -> {
+            run("1,2,3");
+            assertThat(output()).contains("결과 : 6");
+        });
+    }
+
+    @Test
+    void 빈값_처리() {
+        assertSimpleTest(() -> {
+            run("\n");
+            assertThat(output()).contains("결과 : 0");
+        });
+    }
+
     @Test
     void 커스텀_구분자_사용() {
         assertSimpleTest(() -> {