feat: 준비준비와 파코님과의 과제입니다

README.md

@@ -20,10 +20,43 @@
 - 정답과 답안은 `words.txt`에 존재하는 단어여야 한다.
 - 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
 
+
+### 기능 명세서
+- [X] 단어
+  - [X] 단어를 만들 수 있다
+    - [X] 단어는 5글자가 아닌 경우 예외를 던진다
+  - [X] 단어는 알파벳이어야한다
+  - [X] 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다
+- [X] 타일
+  - [X] 타일은 노란색, 초록색, 회색을 가진다
+  - [X] 회색 타일은 ⬜, 초록색 타일은 🟩, 노란색 타일은 🟨 값을 가진다
+- [ ] 매칭
+  - [X] 답안과 정답의 한 단어가 위치와 스펠이 같은 경우 초록색이 된다
+  - [X] 답안과 정답의 한 단어가 위치는 같지만 스펠이 다른 경우 노란색이 된다
+  - [X] 답안과 정답의 한 단어가 위치도 다르고 스펠도 다른 경우 회색이 된다
+  - [ ] 답안과 정답의 단어 중 앞서 한 단어가 판별이 난 경우 뒤에 있는 동일한 단어는 판별되지 않는다
+    - (예 - 정답이 ROYAL인 경우 MOONY를 입력하면 회초회회노 가 결과로 나온다)
+    - hello가 답이고 llloo 라고 입력하면 GRAY, YELLO, GREEN, GRAY, GREEN 로 나와야한다
+    - 우선순위가 GREEN -> YELLO -> GRAY 순
+- [X] 게임
+  - [X] 5글자의 모든 위치와 스펠을 6번안에 맞추는 경우 게임에 승리한다
+    - [X] 6번의 기회안에 5글자를 모두 맞추면 성공한다.
+    - [X] 6번의 기회동안 맞추지 못하면 패배한다
+    - [X] 5글자의 모든 위치와 스펠이 같지 않은 경우 시도 횟수가 더해진다
+    - [X] 정답과 답안을 비교하여 결과 타일을 담아 전달한다
+    - [X] 답안을 입력받는다
+  - [X] 정답과 답안(단어)는 words.txt 안에 있는 것이어야 한다
+    - [X] 정답이 words.txt 에 없는 것인 경우 재입력을 받는다
+    - [X] 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다
+  - [X] 결과를 출력한다
+    - [X] 결과를 누적해서 보여준다
+    - [X] 종료 시 시도한 횟수와 총 횟수를 출력한다.
+
 ### 입출력 요구 사항
 
 #### 실행 결과 예시
 
+
 ```
 WORDLE을 6번 만에 맞춰 보세요.
 시도의 결과는 타일의 색 변화로 나타납니다.

src/main/kotlin/wordle/controller/Application.kt

@@ -0,0 +1,40 @@
+package wordle.controller
+
+import wordle.domain.Answer
+import wordle.domain.Game
+import wordle.domain.ResultTiles
+import wordle.domain.Position
+import wordle.domain.Word
+import wordle.utils.WordsCreator
+import wordle.view.InputView
+import wordle.view.ResultView
+
+private const val LAST_PLAY_COUNT = 6
+
+fun main() {
+    val game = Game(Answer(WordsCreator(), Position(Answer.ANSWER_POSITION)).answer)
+
+    ResultView.printInit()
+
+    playGame(game)
+}
+
+private fun playGame(game: Game) {
+    val results = ResultTiles()
+
+    var tryCount = 0
+
+    while (tryCount < LAST_PLAY_COUNT) {
+        val inputWord = InputView.askWord(WordsCreator.WORDS)
+        val resultTiles = game.play(Word(inputWord))
+        val combined = results.combine(resultTiles)
+        ResultView.printAllResults(combined.resultTiles)
+
+        tryCount++
+
+        if (game.isWinner(resultTiles)) {
+            ResultView.printGamePlayCount(tryCount)
+            break
+        }
+    }
+}

src/main/kotlin/wordle/domain/Answer.kt

@@ -0,0 +1,19 @@
+package wordle.domain
+
+import wordle.utils.Creator
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+class Answer(private val creator: Creator, private val position: Position) {
+    val answer: Word
+        get() = createAnswer()
+
+    fun createAnswer(): Word {
+        return creator.createWords().findAnswer(position)
+    }
+
+    companion object {
+        private val SUBTRACT_DATE_FOR_ANSWER = LocalDate.of(2021, 6, 19)
+        val ANSWER_POSITION = ChronoUnit.DAYS.between(SUBTRACT_DATE_FOR_ANSWER, LocalDate.now()).toInt()
+    }
+}

src/main/kotlin/wordle/domain/Game.kt

@@ -0,0 +1,19 @@
+package wordle.domain
+
+class Game(private val answer: Word) {
+
+    fun play(input: Word): Tiles {
+        val inputChars = input.value.toCharArray()
+        val wordMatcher = WordMatcher(answer)
+
+        return createResultTiles(inputChars, wordMatcher)
+    }
+
+    private fun createResultTiles(inputChars: CharArray, wordMatcher: WordMatcher): Tiles {
+        return Tiles(inputChars.mapIndexed { index, it -> wordMatcher.match(it.toString(), index) })
+    }
+
+    fun isWinner(resultTiles: Tiles): Boolean {
+        return resultTiles.isWinner()
+    }
+}

src/main/kotlin/wordle/domain/Position.kt

@@ -0,0 +1,8 @@
+package wordle.domain
+
+class Position(private val position: Int) {
+
+    fun percent(value: Int): Int {
+        return position % value
+    }
+}

src/main/kotlin/wordle/domain/ResultTiles.kt

@@ -0,0 +1,8 @@
+package wordle.domain
+
+class ResultTiles(val resultTiles: List<Tiles>) {
+
+    constructor(): this(listOf())
+
+    fun combine(newResults: Tiles): ResultTiles = ResultTiles(resultTiles + newResults)
+}

src/main/kotlin/wordle/domain/Tile.kt

@@ -0,0 +1,7 @@
+package wordle.domain
+
+enum class Tile {
+    YELLOW,
+    GREEN,
+    GRAY
+}

src/main/kotlin/wordle/domain/Tiles.kt

@@ -0,0 +1,15 @@
+package wordle.domain
+
+@JvmInline
+value class Tiles(val tiles: List<Tile>) {
+
+    fun isWinner(): Boolean {
+        val count = tiles.count { it == Tile.GREEN }
+
+        return count == TOTAL_TILE_COUNT
+    }
+
+    companion object {
+        private const val TOTAL_TILE_COUNT = 5
+    }
+}

src/main/kotlin/wordle/domain/Word.kt

@@ -0,0 +1,31 @@
+package wordle.domain
+
+@JvmInline
+value class Word(val value: String) {
+
+    init {
+        require(isWordSizeAndAlphabet()) {
+            WRONG_WORD_SIZE_MESSAGE
+        }
+    }
+
+    private fun isWordSizeAndAlphabet() = value.length == WORD_SIZE && ALPHABET_REGEX.matches(value)
+
+    fun findAlphabet(index: Int): String {
+        require(index >= FIRST_INDEX && index <= value.length) { INDEX_OUT_RANGE_MESSAGE }
+
+        return value[index].toString()
+    }
+
+    fun contains(compareValue: String): Boolean {
+        return value.contains(compareValue)
+    }
+
+    companion object {
+        private const val FIRST_INDEX = 0
+        private const val WORD_SIZE = 5
+        private const val WRONG_WORD_SIZE_MESSAGE = "5글자여야합니다"
+        private const val INDEX_OUT_RANGE_MESSAGE = "인덱스 범위를 초과했습니다."
+        private val ALPHABET_REGEX = Regex("^[a-zA-Z]*$")
+    }
+}

src/main/kotlin/wordle/domain/WordMatcher.kt

@@ -0,0 +1,16 @@
+package wordle.domain
+
+class WordMatcher(private val answer: Word) {
+
+    fun match(alphabet: String, index: Int): Tile {
+        if (alphabet == answer.findAlphabet(index)) {
+            return Tile.GREEN
+        }
+
+        if (answer.contains(alphabet)) {
+            return Tile.YELLOW
+        }
+
+        return Tile.GRAY
+    }
+}

src/main/kotlin/wordle/domain/Words.kt

@@ -0,0 +1,12 @@
+package wordle.domain
+
+class Words(private val words: List<Word>) {
+
+    fun findAnswer(position: Position): Word {
+        return words[position.percent(words.size)]
+    }
+
+    fun contains(value: String): Boolean {
+        return words.contains(Word(value))
+    }
+}

src/main/kotlin/wordle/utils/Creator.kt

@@ -0,0 +1,8 @@
+package wordle.utils
+
+import wordle.domain.Words
+
+interface Creator {
+
+    fun createWords(): Words
+}

src/main/kotlin/wordle/utils/WordsCreator.kt

@@ -0,0 +1,22 @@
+package wordle.utils
+
+import wordle.domain.Word
+import wordle.domain.Words
+import java.io.File
+
+class WordsCreator : Creator {
+
+    override fun createWords(): Words {
+        val wordsFile = read().readLines()
+        return Words(wordsFile.map { Word(it) })
+    }
+
+    private fun read(): File {
+        return File(ClassLoader.getSystemResource(ANSWERS_TEXT_PATH).file)
+    }
+
+    companion object {
+        private const val ANSWERS_TEXT_PATH = "words.txt"
+        val WORDS = WordsCreator().createWords()
+    }
+}

src/main/kotlin/wordle/view/InputView.kt

@@ -0,0 +1,22 @@
+package wordle.view
+
+import wordle.domain.Words
+
+object InputView {
+
+    fun askWord(words: Words): String {
+        while (true) {
+            val input = question()
+            if (words.contains(input)) {
+                return input
+            }
+
+            println("올바르지 않은 단어입니다.")
+        }
+    }
+
+    private fun question(): String {
+        println("정답을 입력해 주세요.")
+        return readln()
+    }
+}

src/main/kotlin/wordle/view/ResultView.kt

@@ -0,0 +1,39 @@
+package wordle.view
+
+import wordle.domain.Tile
+import wordle.domain.Tiles
+
+private const val MAX_TRY_COUNT = 6
+
+object ResultView {
+
+    fun printInit() {
+        println("WORDLE을 ${MAX_TRY_COUNT}번 만에 맞춰 보세요.\n시도의 결과는 타일의 색 변화로 나타납니다.")
+    }
+
+    fun printGamePlayCount(index: Int) {
+        println("$index /$MAX_TRY_COUNT")
+    }
+
+    fun printAllResults(results: List<Tiles>) {
+        results.forEach {
+            printAllTiles(it.tiles)
+            println()
+        }
+    }
+
+    private fun printAllTiles(tiles: List<Tile>) {
+        tiles.forEach { tile ->
+            print(tile.viewTile())
+        }
+    }
+
+    private val Tile.viewTile: () -> String
+        get() = {
+            when (this) {
+                Tile.GREEN -> "\uD83D\uDFE9"
+                Tile.YELLOW -> "\uD83D\uDFE8"
+                Tile.GRAY -> "⬜"
+            }
+        }
+}

src/test/kotlin/wordle/domain/GameTest.kt

@@ -0,0 +1,19 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class GameTest {
+
+    @Test
+    fun `6번의 기회안에 5글자를 모두 맞추면 성공한다`() {
+        val givenAnswer = Word("words")
+        val game = Game(givenAnswer)
+        val givenInput = Word("words")
+
+        val result = game.play(givenInput)
+        val isWinner = game.isWinner(result)
+
+        assertThat(isWinner).isTrue
+    }
+}

src/test/kotlin/wordle/domain/MockingCreator.kt

@@ -0,0 +1,10 @@
+package wordle.domain
+
+import wordle.utils.Creator
+
+class MockingCreator : Creator {
+
+    override fun createWords(): Words {
+        return Words(listOf(Word("queen"), Word("chunk"), Word("awake")))
+    }
+}

src/test/kotlin/wordle/domain/PositionTest.kt

@@ -0,0 +1,16 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+class PositionTest {
+
+    @ParameterizedTest
+    @CsvSource("10, 20, 10", "2, 5, 2", "0, 5, 0")
+    fun `위치 값과 전달받은 분모값을 나눈다`(positionValue: Int, denominator: Int, expected: Int) {
+        val position = Position(positionValue)
+
+        assertThat(position.percent(denominator)).isEqualTo(expected)
+    }
+}

src/test/kotlin/wordle/domain/ResultsTest.kt

@@ -0,0 +1,20 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class ResultsTest {
+
+    @Test
+    fun `기존에_존재하는_결과타일에_타일결과를_추가한다`() {
+        val results = ResultTiles()
+
+        val firstCombined = results.combine(Tiles(listOf(Tile.YELLOW, Tile.YELLOW, Tile.YELLOW, Tile.GRAY, Tile.YELLOW)))
+        val secondCombined = firstCombined.combine(Tiles(listOf(Tile.GREEN, Tile.GRAY, Tile.GREEN, Tile.GRAY, Tile.YELLOW)))
+
+        assertThat(secondCombined.resultTiles).containsExactly(
+            Tiles(listOf(Tile.YELLOW, Tile.YELLOW, Tile.YELLOW, Tile.GRAY, Tile.YELLOW)),
+            Tiles(listOf(Tile.GREEN, Tile.GRAY, Tile.GREEN, Tile.GRAY, Tile.YELLOW))
+        )
+    }
+}