runmunch 0.1.0

A Rust implementation of hunspell's unmunch tool for expanding dictionary words using affix files
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

pub mod affix;
pub mod dictionary;
pub mod expander;
pub mod error;

pub use affix::{AffixFile, AffixRule, AffixType};
pub use dictionary::Dictionary;
pub use expander::WordExpander;
pub use error::{RunmunchError, Result};

use std::collections::HashSet;

pub struct Runmunch {
    affix_file: Option<AffixFile>,
    dictionary: Option<Dictionary>,
    expander: WordExpander,
}

impl Runmunch {
    pub fn new() -> Self {
        Self {
            affix_file: None,
            dictionary: None,
            expander: WordExpander::new(),
        }
    }

    pub fn load_affix_file<P: AsRef<std::path::Path>>(&mut self, path: P) -> Result<()> {
        let affix_file = AffixFile::load(path)?;
        self.expander.set_affix_file(&affix_file);
        self.affix_file = Some(affix_file);
        Ok(())
    }

    pub fn load_dictionary<P: AsRef<std::path::Path>>(&mut self, path: P) -> Result<()> {
        let dictionary = Dictionary::load(path)?;
        self.dictionary = Some(dictionary);
        Ok(())
    }

    pub fn expand_word(&self, word: &str) -> Result<Vec<String>> {
        self.expander.expand(word)
    }

    pub fn find_base_and_expand(&self, inflected_word: &str) -> Result<Vec<String>> {
        let dictionary = self.dictionary.as_ref()
            .ok_or_else(|| RunmunchError::NoDictionary)?;
        self.expander.find_base_and_expand(inflected_word, dictionary)
    }

    pub fn expand_words(&self, words: &[String]) -> Result<Vec<String>> {
        let mut result = Vec::new();
        let mut seen = HashSet::new();

        for word in words {
            let expanded = self.expand_word(word)?;
            for expanded_word in expanded {
                if seen.insert(expanded_word.clone()) {
                    result.push(expanded_word);
                }
            }
        }

        Ok(result)
    }

    pub fn unmunch(&self) -> Result<Vec<String>> {
        let dictionary = self.dictionary.as_ref()
            .ok_or_else(|| RunmunchError::NoDictionary)?;

        let mut result = Vec::new();
        let mut seen = HashSet::new();

        for (word, flags) in dictionary.entries() {
            let expanded = if flags.is_empty() {
                vec![word.clone()]
            } else {
                self.expander.expand_with_flags(word, flags)?
            };

            for expanded_word in expanded {
                if seen.insert(expanded_word.clone()) {
                    result.push(expanded_word);
                }
            }
        }

        Ok(result)
    }
}

impl Default for Runmunch {
    fn default() -> Self {
        Self::new()
    }
}