tengwar 1.1.0

Transliterate text into J.R.R. Tolkien's Tengwar.
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

use std::fmt::{Display, Formatter, Write};
use crate::{
    characters::{Glyph, Numeral, ZWJ},
    policy::{Policy, Standard},
};


/// A small container for either plain text or a [`Glyph`] specification. Serves
///     as the top level of throughput for the transliteration process.
#[derive(Clone, Copy, Debug)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub enum Token<P: Policy = Standard> {
    /// A single Unicode codepoint.
    Char(char),
    /// A specified base character and any extra tags it requires.
    Glyph(Glyph<P>),
    /// A numeric value.
    Number(Numeral),
    // /// UTF-8 text data.
    // String(Cow<'static, str>),
}

impl<P: Policy> Token<P> {
    /// Switch any [`Glyph`] in the token to use a different [`Policy`].
    pub const fn change_policy<Q: Policy>(self) -> Token<Q> {
        match self {
            Self::Glyph(glyph) => Token::Glyph(glyph.change_policy()),
            Self::Char(char) => Token::Char(char),
            Self::Number(number) => Token::Number(number),
        }
    }

    /// Return a reference to the [`Glyph`], if there is one.
    pub const fn glyph(&self) -> Option<&Glyph<P>> {
        match self {
            Self::Char(_) => None,
            Self::Glyph(g) => Some(g),
            Self::Number(_) => None,
        }
    }

    /// Return a reference to the [`Numeral`], if there is one.
    pub const fn numeral(&self) -> Option<&Numeral> {
        match self {
            Self::Char(_) => None,
            Self::Glyph(_) => None,
            Self::Number(n) => Some(n),
        }
    }
}

impl<P: Policy> Display for Token<P> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Char(ch) => f.write_char(*ch),
            Self::Glyph(g) => g.fmt(f),
            Self::Number(n) => n.fmt(f),
            // Self::String(s) => f.write_str(s),
        }
    }
}


impl<P: Policy> FromIterator<Token<P>> for String {
    fn from_iter<I: IntoIterator<Item=Token<P>>>(iter: I) -> Self {
        let mut iter = iter.into_iter().peekable();
        let mut buf = String::new();

        while let Some(token) = iter.next() {
            write!(buf, "{token}").expect("Error writing String");

            if let Token::Glyph(current) = token {
                if let Some(Token::Glyph(next)) = iter.peek() {
                    if current.ligates_with(next) {
                        buf.push(ZWJ);
                    }
                }
            }
        }

        buf
    }
}