[문자열 덧셈 계산기] 이예진 미션 제출합니다.

README.md

@@ -1 +1,140 @@
-# java-calculator-precourse
+# java-calculator-precourse
+
+## 문자열 덧셈 계산기
+
+입력한 문자열에서 **숫자를 추출하여 합산하는 계산기**를 구현한다.  
+기본 구분자는 쉼표(`,`)와 콜론(`:`)이며,  
+사용자는 `"//[구분자]\\n"` 형식으로 **커스텀 구분자**를 지정할 수 있다.  
+잘못된 입력에 대해서는 `IllegalArgumentException`을 발생시키고 프로그램을 종료한다.
+
+---
+
+## 1. 기능 구현 목록
+
+### 1. 입력
+- [x] 콘솔에서 문자열을 입력받는다
+  - `camp.nextstep.edu.missionutils.Console.readLine()`을 사용
+  - 예: `"1,2:3"`
+
+
+### 2. 입력 검증
+- [x] null, 빈 문자열, 커스텀 구분자 헤더 형식을 검증한다 → `IllegalArgumentException`
+- [x] null 입력 → 예외 발생
+- [x] 빈 문자열(`""`) 입력 → 정상 처리
+- [x] 커스텀 구분자 형식 오류 (예: `"//;\n"` 누락) → 예외 발생
+- [ ] 비숫자/음수 검증은 문자열 파싱 단계에서 수행
+
+
+### 3. 구분자 파싱
+- [x] 입력값의 맨 앞에 `"//"`가 있고, 그 뒤에 `"\n"`이 있으면 커스텀 구분자로 인식한다
+  - `"//;\n1;2;3"` → 구분자: `;` → 결과: `6`
+- [x] 커스텀 구분자는 **여러 문자를 허용**한다
+  - `"//***\n1***2***3"` → 결과: `6`
+- [x] 커스텀 구분자에 공백 포함 시 → 예외 발생 `IllegalArgumentException`
+- [x] 예약어(`//`, `\n`, `,`, `:`) 사용 불가 → 예외 발생 `IllegalArgumentException`
+- [x] 커스텀 구분자 식별에 실패할 경우 → `IllegalArgumentException`
+
+
+### 4. 문자열 파싱
+- [x] 구분자(기본 또는 커스텀)를 기준으로 문자열을 분리한다
+- [x] 분리된 각 요소가 숫자로만 이루어져 있는지 검사한다
+  - `"a"`, `"--"`, `"-2"` 등 → `IllegalArgumentException`
+- [x] 숫자로 변환 불가 시 → `IllegalArgumentException`
+- [x] 정상 입력이면 문자열 배열을 반환한다
+  - 입력: `"1,2:3"` → 출력: `["1", "2", "3"]`
+
+### 5. 계산
+- [x] 문자열 배열을 정수 배열로 변환한다
+- [x] 모든 정수를 합산하여 결과를 반환한다
+- [x] 음수 또는 비정상 입력 시 → `IllegalArgumentException`
+  - 입력: `["1", "-2", "3"]` → 예외 발생
+  - 입력: `["1", "a", "3"]` → 예외 발생
+
+
+### 6. 출력
+- [x] 최종 합산 결과를 `"결과 : X"` 형식으로 출력한다
+  - 예: `"결과 : 6"`
+
+---
+
+## 2. 예외 처리 정책
+
+### 1. 입력 단계
+| 조건 | 처리 방식                      | 메시지 |
+|------|----------------------------|-------------|
+| null 입력 | `IllegalArgumentException` | `"입력값이 존재하지 않습니다."` |
+| 빈 문자열 | 정상 처리                      | - |
+| 커스텀 구분자 형식 오류 | `IllegalArgumentException` | `"커스텀 구분자 형식이 올바르지 않습니다."` |
+
+
+### 2. 검증 단계
+| 조건 | 처리 방식 | 메시지 |
+|------|-------------|-------------|
+| 음수 입력 | `IllegalArgumentException` | `"음수는 입력할 수 없습니다."` |
+| 비숫자 포함 | `IllegalArgumentException` | `"숫자와 구분자만 입력해주세요."` |
+
+
+### 3. 구분자 파싱 단계
+| 조건 | 처리 방식 | 메시지 |
+|------|-------------|-------------|
+| 커스텀 구분자 식별 실패 | `IllegalArgumentException` | `"커스텀 구분자 형식이 올바르지 않습니다."` |
+| 공백 포함 | `IllegalArgumentException` | `"공백은 구분자로 사용할 수 없습니다."` |
+| 예약어(`//`, `\n`, `,`, `:`) 포함 | `IllegalArgumentException` | `"예약어는 구분자로 사용할 수 없습니다."` |
+
+
+### 4. 문자열 파싱 단계
+| 조건 | 처리 방식 | 메시지 |
+|------|-------------|-------------|
+| 숫자 변환 실패 | `IllegalArgumentException` | `"숫자 형식이 올바르지 않습니다."` |
+| 음수 존재 | `IllegalArgumentException` | `"음수는 입력할 수 없습니다."` |
+
+
+### 5. 계산 단계
+| 조건 | 처리 방식 | 메시지 |
+|------|-------------|-------------|
+| 파싱 결과가 비어 있음 | `IllegalArgumentException` | `"계산할 숫자가 없습니다."` |
+
+
+---
+
+## 3. 프로젝트 구조
+
+```
+src
+└─ main/java/calculator
+   ├─ Application.java                # 실행 진입점(main)
+   │
+   ├─ controller
+   │   └─ CalculatorController.java   # 전체 흐름 제어
+   │
+   ├─ view
+   │   ├─ InputView.java              # 사용자 입력
+   │   └─ OutputView.java             # 결과 출력
+   │
+   ├─ model
+   │   ├─ calculator                  # 문자열 파싱 및 합산 로직
+   │   │   ├─ Calculator.java         # 계산 로직(덧셈)
+   │   │   └─ Result.java             # 계산 결과를 값 객체로 캡슐화
+   │   ├─ parser
+   │   │   ├─ DelimiterParser.java    # 기본/커스텀 구분자 추출
+   │   │   ├─ NumberParser.java       # 문자열 파싱, 숫자 배열로 변환
+   │   │   └─ DelimiterPattern.java   # 커스텀 구분자 패턴 정의
+   │   └─ validation                  
+   │       └─ Validator.java          # 입력값 유효성 검사
+   │
+   └─ util
+       ├─ Constants.java              # 기본 구분자, 정규식 패턴 등의 상수
+       └─ ExceptionMessages.java      # 예외 메시지
+```
+
+---
+## 4. 품질 요구사항
+
+- **코드 컨벤션 준수**
+  - Java Style Guide 
+  - Git Commit Convention
+- **단일 책임 원칙 준수**
+- **예외 명세화**
+  - ExceptionMessages를 도입해 예외 메시지를 상수로 관리
+  - 하드코딩된 메시지를 제거하여 유지보수성과 일관성 강화
+

src/main/java/calculator/Application.java

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

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

@@ -0,0 +1,48 @@
+package calculator.controller;
+
+import calculator.model.calculator.Calculator;
+import calculator.model.calculator.Result;
+import calculator.model.parser.DelimiterParseResult;
+import calculator.model.parser.DelimiterParser;
+import calculator.model.parser.NumberParser;
+import calculator.model.validation.Validator;
+import calculator.view.InputView;
+import calculator.view.OutputView;
+
+public class CalculatorController {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+
+    public void run() {
+        String input = readInput();
+        Result result = processInput(input);
+        printResult(result);
+    }
+
+    /** 사용자 입력 */
+    private String readInput() {
+        return inputView.read();
+    }
+
+    /** 입력 처리 로직 (공통 사용: run() + testRun()) */
+    private Result processInput(String input) {
+        Validator.validateInput(input);
+
+        DelimiterParseResult parseResult = DelimiterParser.parse(input);
+        String[] tokens = NumberParser.parse(parseResult.getBody(), parseResult.getDelimiters());
+
+        return Calculator.calculate(tokens);
+    }
+
+    /** 결과 출력 */
+    private void printResult(Result result) {
+        outputView.printResult(result);
+    }
+
+    /** 테스트 전용 메서드 (콘솔 I/O 배제) */
+    public String testRun(String input) {
+        Result result = processInput(input);
+        return "결과 : " + result.getValue();
+    }
+}

src/main/java/calculator/model/calculator/Calculator.java

@@ -0,0 +1,40 @@
+package calculator.model.calculator;
+
+import calculator.util.ExceptionMessages;
+import java.util.Arrays;
+
+/**
+ * 파싱된 문자열 토큰을 정수로 변환해 합산한다
+ */
+public class Calculator {
+
+    private Calculator() {}
+
+    public static Result calculate(String[] tokens) {
+        if (tokens == null || tokens.length == 0) {
+            throw new IllegalArgumentException(ExceptionMessages.INPUT_EMPTY.get());
+        }
+
+        int sum = Arrays.stream(tokens)
+                .mapToInt(Calculator::parseAndValidate)
+                .sum();
+
+        return new Result(sum);
+    }
+
+    private static int parseAndValidate(String token) {
+        if (token == null || token.isBlank()) {
+            throw new IllegalArgumentException(ExceptionMessages.INPUT_EMPTY.get());
+        }
+
+        try {
+            int number = Integer.parseInt(token);
+            if (number < 0) {
+                throw new IllegalArgumentException(ExceptionMessages.NEGATIVE_NUMBER.get());
+            }
+            return number;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ExceptionMessages.INVALID_NUMBER_FORMAT.get());
+        }
+    }
+}

src/main/java/calculator/model/calculator/Result.java

@@ -0,0 +1,18 @@
+package calculator.model.calculator;
+
+public class Result {
+    private final int value;
+
+    public Result(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return "결과 : " + value;
+    }
+}

src/main/java/calculator/model/parser/DelimiterParseResult.java

@@ -0,0 +1,21 @@
+package calculator.model.parser;
+
+import java.util.List;
+
+public class DelimiterParseResult {
+    private final List<String> delimiters;
+    private final String body;
+
+    public DelimiterParseResult(List<String> delimiters, String body) {
+        this.delimiters = delimiters;
+        this.body = body;
+    }
+
+    public List<String> getDelimiters() {
+        return delimiters;
+    }
+
+    public String getBody() {
+        return body;
+    }
+}

src/main/java/calculator/model/parser/DelimiterParser.java

@@ -0,0 +1,73 @@
+package calculator.model.parser;
+
+import calculator.util.Constants;
+import calculator.util.ExceptionMessages;
+import java.util.Arrays;
+import java.util.List;
+
+public class DelimiterParser {
+
+    private static final List<String> DEFAULT_DELIMITERS = List.of(
+            Constants.DEFAULT_DELIMITER_COMMA.get(),
+            Constants.DEFAULT_DELIMITER_COLON.get()
+    );
+
+    private DelimiterParser() {}
+
+    /**
+     * 입력 문자열에서 구분자 목록과 본문(body)을 함께 추출한다
+     *
+     * @param input 전체 입력 문자열
+     * @return 구분자 목록과 본문을 담은 DelimiterParseResult
+     */
+    public static DelimiterParseResult parse(String input) {
+        // 개행 문자 이스케이프 처리
+        input = input.replace(
+                Constants.CUSTOM_NEWLINE_ESCAPE.get(),
+                Constants.CUSTOM_NEWLINE_ACTUAL.get()
+        );
+
+        // 커스텀 구분자가 없는 경우
+        if (!input.startsWith(Constants.CUSTOM_PREFIX.get())) {
+            return new DelimiterParseResult(DEFAULT_DELIMITERS, input);
+        }
+
+        int newlineIndex = input.indexOf(Constants.CUSTOM_NEWLINE_ACTUAL.get());
+        if (newlineIndex == -1) {
+            throw new IllegalArgumentException(ExceptionMessages.INVALID_CUSTOM_FORMAT.get());
+        }
+
+        String customDelimiter = input.substring(
+                Constants.CUSTOM_PREFIX.get().length(),
+                newlineIndex
+        );
+
+        validateCustomDelimiter(customDelimiter);
+
+        List<String> delimiters = Arrays.asList(
+                customDelimiter,
+                Constants.DEFAULT_DELIMITER_COMMA.get(),
+                Constants.DEFAULT_DELIMITER_COLON.get()
+        );
+
+        String body = input.substring(newlineIndex + 1);
+
+        return new DelimiterParseResult(delimiters, body);
+    }
+
+    /**
+     * 커스텀 구분자 유효성 검사
+     */
+    private static void validateCustomDelimiter(String delimiter) {
+        if (delimiter.isBlank() || delimiter.contains(" ")) {
+            throw new IllegalArgumentException(ExceptionMessages.INVALID_CUSTOM_WHITESPACE.get());
+        }
+
+        if (delimiter.contains(Constants.DEFAULT_DELIMITER_COMMA.get())
+                || delimiter.contains(Constants.DEFAULT_DELIMITER_COLON.get())
+                || delimiter.contains(Constants.CUSTOM_PREFIX.get())
+                || delimiter.contains(Constants.CUSTOM_NEWLINE_ACTUAL.get())) {
+            throw new IllegalArgumentException(ExceptionMessages.INVALID_CUSTOM_RESERVED.get());
+        }
+    }
+}

src/main/java/calculator/model/parser/DelimiterPattern.java

@@ -0,0 +1,20 @@
+package calculator.model.parser;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DelimiterPattern {
+    private static final String REGEX_SPECIALS = "([\\\\^$.|?*+()\\[\\]])";
+
+    // 모든 구분자를 OR (|)로 연결해서 하나의 정규식 패턴 생성
+    public static String buildPattern(List<String> delimiters) {
+        return delimiters.stream()
+                .map(DelimiterPattern::escapeSpecialChars)
+                .collect(Collectors.joining("|"));
+    }
+
+    // 정규식 예약문자(\, *, [, ]) 등을 이스케이프 처리
+    private static String escapeSpecialChars(String delimiter) {
+        return delimiter.replaceAll(REGEX_SPECIALS, "\\\\$1");
+    }
+}