deinflector 0.0.1

Attempts to be a 1 to 1 reimplementation of Yomitan's MultiLanguageTransformer.
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

use std::collections::HashMap;

use crate::{
    languages::get_all_language_transform_descriptors,
    transformer::{InflectionRule, InflectionRuleChain, LanguageTransformer, TransformedText},
};

// key: language (ie: "en", "ja")
// valueL LanguageTransformer
#[derive(Clone, Debug)]
pub struct MultiLanguageTransformer {
    inner: HashMap<&'static str, LanguageTransformer>,
}

impl Default for MultiLanguageTransformer {
    fn default() -> Self {
        let mut mlt = Self {
            inner: HashMap::default(),
        };
        mlt.prepare();
        mlt
    }
}

impl MultiLanguageTransformer {
    fn prepare(&mut self) {
        let langs = get_all_language_transform_descriptors();
        for transforms in langs {
            let mut lt = LanguageTransformer::new();
            let descriptor = transforms.language_transforms;
            lt.add_descriptor(&descriptor).unwrap();
            let language = descriptor.language;
            self.inner.insert(language, lt);
        }
    }

    pub fn get_condition_flags_from_parts_of_speech(
        &self,
        language: &str,
        parts_of_speech: &[String],
    ) -> usize {
        self.inner
            .get(language)
            .map(|lt| lt.get_condition_flags_from_parts_of_speech(parts_of_speech))
            .unwrap_or(0)
    }

    pub fn get_condition_flags_from_condition_types(
        &self,
        language: &str,
        condition_types: &[String],
    ) -> usize {
        self.inner
            .get(language)
            .map(|lt| lt.get_condition_flags_from_condition_types(condition_types))
            .unwrap_or(0)
    }

    pub fn get_condition_flags_from_condition_type(
        &self,
        language: &str,
        condition_type: &str,
    ) -> usize {
        self.inner
            .get(language)
            .map(|lt| lt.get_condition_flags_from_single_condition_type(condition_type))
            .unwrap_or(0)
    }

    pub fn transform(&self, language: &str, source_text: &str) -> Vec<TransformedText> {
        match self.inner.get(language) {
            Some(lt) => lt.transform(source_text),
            None => vec![TransformedText::create_transformed_text(
                source_text.to_owned(),
                0,
                Vec::new(),
            )],
        }
    }

    pub fn get_user_facing_inflection_rules(
        &self,
        language: &str,
        inflection_rules: &[String],
    ) -> InflectionRuleChain {
        match self.inner.get(language) {
            Some(lt) => lt.get_user_facing_inflection_rules(inflection_rules),
            None => inflection_rules
                .iter()
                .map(|rule| InflectionRule {
                    name: rule.clone(),
                    description: None,
                })
                .collect(),
        }
    }
}

#[cfg(test)]
mod mlt {
    use crate::transformer::{Trace, TraceFrame, TransformedText};

    use super::MultiLanguageTransformer;
    use pretty_assertions::assert_eq as passert_eq;

    #[test]
    fn transform_jp() {
        let json: &str = include_str!("../tests/multi_language_transformer/transform.json");
        let expected: Vec<TransformedText> = serde_json::from_str(json).unwrap();
        let mlt = MultiLanguageTransformer::default();
        let res = mlt.transform("ja", "流れて");
        passert_eq!(res, expected);
        dbg!(res);
    }

    #[test]
    fn transform_es() {
        let mlt = MultiLanguageTransformer::default();
        let res = mlt.transform("es", "bueno");
        dbg!(res);
    }
}