wordlea 0.1.4

A algorithm to check Wordle's word guess
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Wordle is a simple word guessing game
//! this crate provides the logic for the game.

#[derive(Debug, Copy, Clone)]
/// `PartResult` is a struct that holds the result of a guess
/// for a single letter
pub struct PartResult {
    letter: char,
    in_word: bool,
    in_position: bool,
}

impl PartResult {
    #[must_use]
    /// Returns the letter that was guessed
    pub fn letter(&self) -> char {
        self.letter
    }

    #[must_use]
    /// Returns true if the letter is in the word
    pub fn in_word(&self) -> bool {
        self.in_word
    }

    #[must_use]
    /// Returns true if the letter is in the correct position
    pub fn in_position(&self) -> bool {
        self.in_position
    }
}

#[derive(Debug)]
/// `GuessResult` is a struct that holds the result of a guess
/// for the entire word
pub struct GuessResult {
    word: String,
    parts: Vec<PartResult>,
}

impl GuessResult {
    #[must_use]
    /// Returns the word that was guessed
    pub fn word(&self) -> &str {
        &self.word
    }

    #[must_use]
    /// Returns a vector of `PartResult`
    pub fn parts(&self) -> &Vec<PartResult> {
        &self.parts
    }
}

#[derive(Debug)]
/// Wordle is the main struct for the game
pub struct Wordle<'a> {
    word: &'a str,
    count: u32,
    won: bool,
}

impl Wordle<'_> {
    #[must_use]
    /// Creates a new Wordle struct
    pub fn new(word: &str) -> Wordle {
        Wordle {
            word,
            count: 0,
            won: false,
        }
    }

    /// Wordle guess check algorithm
    /// # Panics
    /// Panics if the guess is not the same length as the word
    pub fn guess(&mut self, guess: &str) -> GuessResult {
        if self.word == guess {
            self.set_won();
        }

        assert!(
            guess.len() == self.word.len(),
            "Guess must be the same length as the word"
        );

        let mut results = Vec::new();
        let mut word_clone = self.word.clone().to_string();

        for c in guess.char_indices() {
            let letter = c.1;
            let in_word = word_clone.contains(letter);
            let in_position = self.word.chars().nth(c.0) == Some(letter);

            if in_word {
                for (i, c) in word_clone.char_indices() {
                    if c == letter {
                        word_clone.replace_range(i..i + 1, "_");
                        break;
                    }
                }
            }

            results.push(PartResult {
                letter,
                in_word,
                in_position,
            });
        }

        GuessResult {
            word: guess.to_string(),
            parts: results,
        }
    }

    #[must_use]
    /// Returns the number of guesses
    pub fn count(&self) -> u32 {
        self.count
    }

    #[must_use]
    /// Returns true if the word has been guessed
    pub fn won(&self) -> bool {
        self.won
    }

    #[must_use]
    /// Returns the length of the word
    pub fn length(&self) -> usize {
        self.word.len()
    }

    #[must_use]
    /// Returns the word
    pub fn word(&self) -> &str {
        self.word
    }

    /// Sets the won flag to true
    fn set_won(&mut self) {
        self.won = true;
    }
}