goya 0.1.9

Yet another morphological analyzer for Rust and WebAssembly
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

use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};

const CLASS_DEFAULT: &str = "DEFAULT";

#[derive(
    Debug, PartialEq, Eq, Serialize, Deserialize, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,
)]
pub enum InvokeTiming {
    Fallback,
    Always,
}
#[derive(
    Debug, PartialEq, Eq, Serialize, Deserialize, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,
)]
pub struct CharDefinition {
    pub class: String,
    pub timing: InvokeTiming,
    pub group_by_same_kind: bool,
    pub len: usize,
    pub compatibilities: HashSet<String>, // elements = class name
}
impl CharDefinition {
    pub fn compatible_with(&self, class_name: &str) -> bool {
        self.class.eq(class_name) || self.compatibilities.contains(class_name)
    }
}

#[derive(Debug, Serialize, Deserialize, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub struct CharClass {
    range: (u32, u32),
    class: String,
}
impl CharClass {
    pub fn from(range: (u32, u32), class: String) -> CharClass {
        CharClass { range, class }
    }

    pub fn in_range(&self, c: &char) -> bool {
        let code = *c as u32;
        self.range.0 <= code && code <= self.range.1
    }
}

#[derive(Debug, Serialize, Deserialize, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
pub struct CharClassifier {
    chars: HashMap<String, CharDefinition>,
    ranges: Vec<CharClass>,
}
impl CharClassifier {
    pub fn from(chars: HashMap<String, CharDefinition>, ranges: Vec<CharClass>) -> CharClassifier {
        CharClassifier { chars, ranges }
    }

    pub fn classify(&self, c: &char) -> &CharDefinition {
        let class = self.get_class_name(c);
        self.chars.get(class).unwrap()
    }

    pub fn take_unknown_chars(&self, def: &CharDefinition, text: &str, start: &usize) -> String {
        if !def.group_by_same_kind {
            return text.chars().skip(*start).take(def.len).collect();
        }

        let mut len = 0;
        text.chars()
            .enumerate()
            .skip(*start)
            .take_while(|(_, c)| {
                if def.len != 0 && len >= def.len || !def.compatible_with(self.get_class_name(c)) {
                    return false;
                }
                len += 1;
                true
            })
            .map(|(_, c)| c)
            .collect()
    }

    fn get_class_name(&self, c: &char) -> &str {
        self.ranges
            .iter()
            .find(|class| class.in_range(c))
            .map(|class| class.class.as_str())
            .unwrap_or_else(|| CLASS_DEFAULT)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn compatible_with_without_compatibilities() {
        let def_a = CharDefinition {
            class: String::from("A"),
            timing: InvokeTiming::Always,
            group_by_same_kind: false,
            len: 2,
            compatibilities: HashSet::new(),
        };
        assert_eq!(def_a.compatible_with("A"), true);
        assert_eq!(def_a.compatible_with("B"), false);
    }

    #[test]
    fn compatible_with_with_compatibilities() {
        let mut compatibilities = HashSet::new();
        compatibilities.insert(String::from("B"));
        let def_a = CharDefinition {
            class: String::from("A"),
            timing: InvokeTiming::Always,
            group_by_same_kind: false,
            len: 2,
            compatibilities,
        };
        assert_eq!(def_a.compatible_with("A"), true);
        assert_eq!(def_a.compatible_with("B"), true);
        assert_eq!(def_a.compatible_with("C"), false);
    }

    #[test]
    fn in_range() {
        let class = CharClass::from((1, 2), String::new());
        assert_eq!(class.in_range(&(0 as char)), false);
        assert_eq!(class.in_range(&(1 as char)), true);
        assert_eq!(class.in_range(&(2 as char)), true);
        assert_eq!(class.in_range(&(3 as char)), false);
    }
}