hebrew 0.1.1

Hebrew alephbet primatives and parsing library for rust.
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

pub mod end_word;
pub mod non_end_word;

use super::*;

use unicode_segmentation::*;

#[derive(Clone, PartialEq, Eq)]
pub struct Word {
    pub original: String,
    letters: Vec<Letter>, 
}

impl Word {
    pub fn new(original: String, letters: Vec<Letter>) -> Self {
        Self { original, letters }
    }

    pub fn from_str<S: AsRef<str>>(stringlike: S) -> Self {
        let original = stringlike.as_ref().to_owned();
        assert!(!original.is_empty());

        let graphemes = stringlike.as_ref().graphemes(true);
        let letters: Vec<Letter> = graphemes
            .into_iter()
            .map(|x| {
                Letter::from_str(x)
            }).collect();

        Self::new(original, letters)
    }

    pub fn letters(&self) -> Vec<Letter> {
        self.letters.clone()
    }

    pub fn original(&self) -> String {
        let original = self.original.to_owned();
        // TODO: String returned is escaped unicode. Is there a way
        // to return the grapheme?
        original
    }

    pub fn dotless(&self) -> String {
        self.letters.iter().map(|x| x.base.to_string()).collect()
    }

    // The representation will place in a final character if it is 
    // available at the end of a word. It will also remove a final
    // letter that is not at the end of a word.
    pub fn dotless_proper_str(&self) -> String {
        self.dotless_proper()
            .letters
            .into_iter()
            .map(|x| {
                x.base.to_string()
            })
            .collect()
    }

    pub fn dotless_proper(&self) -> Self {
        let letters = &self.letters;
        if letters.len() == 0 { return self.clone() }
        let split_last = self.letters.split_last();

        if split_last.is_none() { 
            let msg = "Unsplitable string: ";
            panic!("{}{:#?}", msg, self);
        }

        let (last, elements) = split_last.unwrap();

        let endified = last.endify();

        let mut rest: Vec<Letter> = elements
            .into_iter()
            .map(|x| x.clone())
            .collect();

        rest.push(endified);
        Word::new(self.original.to_owned(), rest)
    }

    pub fn first_letter(&self) -> Letter {
        let first = self.letters.get(0).unwrap();
        first.clone()
    }
}

pub trait ToHebrewWord: Display {
    fn to_heb_word(&self) -> Word {
        let word_string = self.to_string();
        Word::from_str(word_string)
    }
}

impl fmt::Debug for Word {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Word")
            //.field("letters", &self.letters)
            //.field("string_final", &self.string_final())
            //.field("dotless_proper", &self.dotless_proper())
            .field("original", &self.original())
            .field("dotless", &self.dotless())
            .finish()
    }
}

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

    #[test]
    fn test_dotless_proper() {
        let jonathan: Word = heb_word!(יונתנ);
        assert_eq!("יונתן", jonathan.dotless_proper_str());
    }

}