[문자열 덧셈 계산기] 조건희 미션 제출합니다

README.md

@@ -1 +1,41 @@
-# java-calculator-precourse
+# java-calculator-precourse
+
+## 구현할 기능 목록
+
+### 1. 문자열을 입력 받는 기능
+
+### 2. 문자열에 추가 구분자 입력이 있는지 확인하는 기능
+
+### 3. 문자열을 구분자를 기준으로 나누는 기능
+
+### 4. 구분자로 나눠진 문자열에 숫자 외의 다른 문자가 있는지 확인하는 기능 있으면 IllegalArgumentException
+
+### 5. 나눠진 숫자를 더하는 기능
+
+## 테스트 필요 하다 생각 되는 것들
+
+- [x] 문자열을 아무 것도 주지 않았을 때
+- [x] 추가 구분자로 숫자를 줬을 때
+- [x] 소수 넣어 보기(추가 구분자로 .을 줬을 때와 아닐 때)
+- [x] 역슬래시(이스케이프 문자를 구분자로 줬을 때)
+- [x] 구분자 사이에 숫자가 없을 때
+
+## 확인 필요
+
+### 1. 커스텀 구분자가 여러 개라면?
+    현재 만들어진 로직은 커스텀 구분자가 한 개인 경우만을 받고 있으나 그렇지 않을 수도 있음.
+    만약에 //와 \n 사이에 두 개가 들어가면 그건 따로 떨어뜨려서 구분을 해야하나?
+    //ea\n1ea2ea3ea 이 주어지면 ea로 묶어서 구분자로 사용해야 하나?
+
+### 2. 커스텀 구분자에 숫자가 들어온다면?
+    당연히 계산기라면 커스텀 구분자에 숫자가 들어오면 안되긴 함. 
+    커스텀 구분자에 숫자가 들어오는 경우 IllegalArgumentException 해야하는가? 
+    아니면 구분자로 인식하고 계산시켜야 하는가?
+    지금은 계산하도록 만들어둠.
+
+### 3. 아무 입력도 하지 않았다면?
+    입력이 없으면 0을 출력하도록 했음. 근데 IllegalArgumentException 해야하는지?
+
+### 4. 구분자 사이에 숫자가 없다면?
+    현재는 사이에 숫자가 없다면 0으로 인식하고 계산을 진행하도록 하였음.
+    이것도 throw 해야하는 경우인가?

src/main/java/calculator/Application.java

@@ -1,7 +1,13 @@
 package calculator;
 
+import calculator.config.Configuration;
+import calculator.controller.CalculatorController;
+
 public class Application {
+    private static final Configuration configuration = Configuration.getInstance();
+
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        CalculatorController calculatorController = configuration.getCalculatorController();
+        calculatorController.input();
     }
 }

src/main/java/calculator/config/Configuration.java

@@ -0,0 +1,19 @@
+package calculator.config;
+
+import calculator.controller.CalculatorController;
+
+public class Configuration {
+    private static final Configuration configuration = new Configuration();
+    private final CalculatorController calculatorController = new CalculatorController();
+
+    private Configuration() {
+    }
+
+    public static Configuration getInstance() {
+        return configuration;
+    }
+
+    public CalculatorController getCalculatorController() {
+        return calculatorController;
+    }
+}

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

@@ -0,0 +1,29 @@
+package calculator.controller;
+
+import calculator.service.CalculatorService;
+import calculator.view.InputView;
+import calculator.view.OutputView;
+
+public class CalculatorController {
+    private final CalculatorService calculatorService;
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public CalculatorController() {
+        this.inputView = new InputView();
+        this.outputView = new OutputView();
+        this.calculatorService = new CalculatorService();
+    }
+
+    public void input() {
+        String s = inputView.inputString();
+        inputView.close();
+        int addedResult = calculatorService.add(s);
+        output(addedResult);
+    }
+
+    private void output(int i) {
+        outputView.outputInteger(i);
+    }
+
+}

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

@@ -0,0 +1,78 @@
+package calculator.service;
+
+import java.util.Arrays;
+
+public class CalculatorService {
+    private String s;
+    private String customSeparator;
+
+    /**
+     * 덧셈 로직을 순차적으로 진행한다.
+     */
+    public int add(String s) {
+        this.s = s;
+        boolean hasCustomSeparator = checkCustomSeparator();
+        String[] separatedString = separate(hasCustomSeparator);
+        hasNaN(separatedString);
+        return sumSeparatedStringArr(separatedString);
+    }
+
+    /**
+     * 커스텀 구분자가 있는지 확인한다.
+     *
+     * @return 만약 커스텀 구분자가 있다면 true, 없다면 false 를 반환한다.
+     */
+    private boolean checkCustomSeparator() {
+        if (s.length() >= 5 && s.startsWith("//") && s.startsWith("\\n", 3)) {
+            customSeparator = String.valueOf(s.charAt(2));
+            s = s.substring(5);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 받은 문자열을 구분자를 기준으로 나눈다. 만약 커스텀 구분자에 역슬래시가 있다면 문제가 생기지 않도록 한다.
+     *
+     * @param hasCustomSeparator 커스텀 구분자가 있다면 true, 없다면 false 를 입력한다.
+     * @return 분리된 문자열을 반환한다. 이 문자열에는 반드시 숫자만 있는 것은 아니다.
+     */
+    private String[] separate(boolean hasCustomSeparator) {
+        if (!hasCustomSeparator) {
+            return s.split("[:,]");
+        }
+        if (customSeparator.equals("\\")) {
+            return s.split("[:," + customSeparator.repeat(2) + "]");
+        }
+        return s.split("[:," + customSeparator + "]");
+    }
+
+    /**
+     * 숫자가 아닌 문자열이 있는지 확인한다. 만약 있다면 IllegalArgumentException 으로 처리한다.
+     *
+     * @param separatedStringArr 숫자 외의 문자가 있는지 확인하고 싶은 문자열을 입력한다.
+     */
+    private void hasNaN(String[] separatedStringArr) {
+        if (Arrays.stream(separatedStringArr)
+                .flatMapToInt(String::chars)
+                .anyMatch(it -> it < '0' || it > '9')) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    /**
+     * 문자열을 int 형으로 바꾼 뒤 합한다.
+     *
+     * @param separatedStringArr 숫자로만 이루어진 문자열 배열을 입력한다.
+     * @return 합한다.
+     */
+    private int sumSeparatedStringArr(String[] separatedStringArr) {
+        int sum = 0;
+        for (String separatedString : separatedStringArr) {
+            if (!separatedString.isEmpty()) {
+                sum += Integer.parseInt(separatedString);
+            }
+        }
+        return sum;
+    }
+}

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

@@ -0,0 +1,14 @@
+package calculator.view;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class InputView {
+    public String inputString() {
+        System.out.println("덧셈할 문자열을 입력해주세요.");
+        return Console.readLine();
+    }
+
+    public void close() {
+        Console.close();
+    }
+}

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

@@ -0,0 +1,7 @@
+package calculator.view;
+
+public class OutputView {
+    public void outputInteger(int i) {
+        System.out.println("결과 : " + i);
+    }
+}

src/test/java/calculator/ApplicationTest.java

@@ -1,12 +1,12 @@
 package calculator;
 
-import camp.nextstep.edu.missionutils.test.NsTest;
-import org.junit.jupiter.api.Test;
-
 import static camp.nextstep.edu.missionutils.test.Assertions.assertSimpleTest;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import camp.nextstep.edu.missionutils.test.NsTest;
+import org.junit.jupiter.api.Test;
+
 class ApplicationTest extends NsTest {
     @Test
     void 커스텀_구분자_사용() {
@@ -19,13 +19,75 @@ class ApplicationTest extends NsTest {
     @Test
     void 예외_테스트() {
         assertSimpleTest(() ->
-            assertThatThrownBy(() -> runException("-1,2,3"))
-                .isInstanceOf(IllegalArgumentException.class)
+                assertThatThrownBy(() -> runException("-1,2,3"))
+                        .isInstanceOf(IllegalArgumentException.class)
         );
     }
 
     @Override
     public void runMain() {
         Application.main(new String[]{});
     }
+
+    @Test
+    public void 숫자_구분자_사용() {
+        assertSimpleTest(() -> {
+            run("//1\\n2:213");
+            assertThat(output()).contains("결과 : 7");
+        });
+    }
+
+    @Test
+    public void 탈출_문자_사용() {
+        assertSimpleTest(() -> {
+            assertThatThrownBy(() -> runException("1\\2:3"))
+                    .isInstanceOf(IllegalArgumentException.class);
+        });
+    }
+
+    @Test
+    public void 탈출_문자_구분자_사용() {
+        assertSimpleTest(() -> {
+            run("//\\\\n1\\2:3,4");
+            assertThat(output()).contains("결과 : 10");
+        });
+    }
+
+    @Test
+    public void 마침표_구분자_사용() {
+        assertSimpleTest(() -> {
+            run("//.\\n1.2.4:3");
+            assertThat(output()).contains("결과 : 10");
+        });
+    }
+
+    @Test
+    public void 마침표_사용(){
+        assertThatThrownBy(() -> runException("1.2.3:4"))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void 따옴표_구분자_사용() {
+        assertSimpleTest(() -> {
+            run("//\"\\n1\"2\"4:3");
+            assertThat(output()).contains("결과 : 10");
+        });
+    }
+
+    @Test
+    public void 구분자_사이에_문자열_없음() {
+        assertSimpleTest(() -> {
+            run("1,:2");
+            assertThat(output()).contains("결과 : 3");
+        });
+    }
+
+    @Test
+    public void 문자열_없음(){
+        assertSimpleTest(() -> {
+            run("\n");
+            assertThat(output()).contains("결과 : 0");
+        });
+    }
 }