le-robert 0.1.0

Get French word definitions, synonyms and use samples from the dictionary Le Robert
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

#![feature(let_chains)]

mod scrap;
mod tests;

#[derive(Debug)]
pub enum RobertError {
    ReqwestError(reqwest::Error),
    ParsercherError(String),
}

#[derive(Debug)]
pub struct UseSample {
    pub sample: String,
    pub source: String,
}

#[derive(Default)]
pub struct WordInfos {
    pub word: String,
    pub definitions: Vec<String>,
    pub synonyms: Vec<String>,
    pub use_samples: Vec<UseSample>,
}

impl WordInfos {
    pub fn new(word: &str) -> Result<Self, RobertError> {
        let dom = scrap::dom_for_word(word).map_err(RobertError::ReqwestError)?;
        let def = scrap::parse_def(&dom).map_err(RobertError::ParsercherError)?;
        let synonyms = scrap::parse_synonyms(&dom).map_err(RobertError::ParsercherError)?;
        let use_samples = scrap::parse_samples(&dom).map_err(RobertError::ParsercherError)?;

        Ok(WordInfos {
            word: String::from(word),
            definitions: def,
            synonyms: synonyms,
            use_samples: use_samples,
        })
    }
}

pub struct WordInfosBuilder {
    parse_def: bool,
    parse_synonyms: bool,
    parse_use_samples: bool,
}

impl WordInfosBuilder {
    pub fn new(parse_def: bool, parse_synonyms: bool, parse_use_samples: bool) -> Self {
        Self {
            parse_def,
            parse_synonyms,
            parse_use_samples,
        }
    }

    pub fn word_infos(&self, word: String) -> Result<WordInfos, RobertError> {
        let mut infos = WordInfos::default();
        infos.word = word.clone();

        let dom = scrap::dom_for_word(&word).map_err(RobertError::ReqwestError)?;

        if self.parse_def {
            let def = scrap::parse_def(&dom).map_err(RobertError::ParsercherError)?;
            infos.definitions = def;
        }

        if self.parse_synonyms {
            let syns = scrap::parse_synonyms(&dom).map_err(RobertError::ParsercherError)?;
            infos.synonyms = syns;
        }

        if self.parse_use_samples {
            let samples = scrap::parse_samples(&dom).map_err(RobertError::ParsercherError)?;
            infos.use_samples = samples;
        }

        Ok(infos)
    }
}