boggle-maker 0.1.4

Rust tools for Boggle enthusiasts: board generation and analysis.
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

use crate::genetic_boggle_maker;
use crate::boggle_board::Board;
use word_trie::TrieBuilder;

///The boggle board builder struct
#[derive(Default)]
pub struct BoggleBuilder {
    width : Option<usize>,
    length : Option<usize>,
    target_score: Option<isize>,
    dictionary_path: Option<String>,
}

impl BoggleBuilder {
    ///initiates a new instance of the boggle board builder
    pub fn new() -> Self {
        Self::default()
    }

    ///sets the trie dictionary text file path
    pub fn with_dictionary_path<P: Into<String>>(mut self, path: P) -> Self {
        self.dictionary_path = Some(path.into());
        self
    } 

    ///sets the desired target score for the board to be generated
    pub fn with_target_score(mut self, score: isize) -> Self {
        self.target_score = Some(score);
        self
    } 

    ///sets the board's width
    pub fn with_width(mut self, width: usize) -> Self {
        self.width = Some(width);
        self
    } 

    ///sets the board's length
    pub fn with_length(mut self, length: usize) -> Self {
        self.length = Some(length);
        self
    } 

    ///generates a boggle board instance
    ///
    /// # Examples
    ///
    /// ```
    /// use boggle_maker::BoggleBuilder;
    /// let builder = BoggleBuilder::new()
    ///.with_dictionary_path("words.txt")
    ///.with_target_score(2500)
    ///.with_length(4)
    ///.with_width(4);
    ///
    ///if let Some(board) = builder.build().expect("Failed to load trie from words.txt file"){
    ///   assert!(board.score().unwrap()>=2500);
    ///}
    ///else{
    ///assert!(false);
    ///}
    /// ```
    pub fn build(self) -> Result<Option<Board>, std::io::Error> {
        let width = match self.width {
            Some(w) => w,
            None => 4,
        };

        let length = match self.length {
            Some(l) => l,
            None => 4,
        };

        let target_score = match self.target_score {
            Some(score) => score,
            None => 0,
        };

        if let Some(path) = self.dictionary_path {
            let trie = TrieBuilder::new()
            .from_file(path)
            .expect("Failed to load trie from file");

            let board = genetic_boggle_maker::make(width,length,target_score,&trie);
            return Ok(board);
        }

        Ok(None)
    }
}

#[cfg(test)]
mod tests{

    use super::*;

    #[test]
    fn should_generate_a_board_with_3600_score(){
        should_generate_a_board_with_deired_score(3200);
    }

    #[test]
    fn should_generate_a_board_with_2500_score(){
        should_generate_a_board_with_deired_score(2500);
    }

    fn should_generate_a_board_with_deired_score(score:isize){
        let builder = BoggleBuilder::new()
         .with_dictionary_path("words.txt")
         .with_target_score(score)
         .with_length(4)
         .with_width(4);
        
         if let Some(board) = builder.build().expect("Failed to load trie from words.txt file"){
            assert!(board.score().unwrap()>=score);
         }
         else{
         assert!(false);
        }
    }
}