yosina 0.2.0

Japanese text transliteration library
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

use crate::char::{Char, CharPool};
use crate::transliterator::{
    TransliterationError, Transliterator, TransliteratorFactory, TransliteratorFactoryError,
};
use serde::{Deserialize, Serialize};

include!("./circled_or_squared_data.rs");

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct CircledOrSquaredTransliteratorOptions {
    pub include_emojis: bool,
}

impl Default for CircledOrSquaredTransliteratorOptions {
    fn default() -> Self {
        Self {
            include_emojis: true,
        }
    }
}

pub struct CircledOrSquaredTransliterator {
    include_emojis: bool,
}

impl CircledOrSquaredTransliterator {
    pub fn new(options: CircledOrSquaredTransliteratorOptions) -> Self {
        Self {
            include_emojis: options.include_emojis,
        }
    }
}

impl Transliterator for CircledOrSquaredTransliterator {
    fn transliterate<'a, 'b>(
        &self,
        pool: &mut CharPool<'a, 'b>,
        input: &[&'a Char<'a, 'b>],
    ) -> Result<Vec<&'a Char<'a, 'b>>, TransliterationError> {
        let mut result = Vec::new();
        let mut offset = 0;

        for &input_char in input {
            if input_char.c.is_empty() {
                // Preserve sentinel characters
                result.push(input_char);
                continue;
            }

            let char_str = input_char.c.as_ref();

            // Check if this character has a mapping
            if let Some(record) = MAPPINGS.get(char_str) {
                // Skip emoji characters if include_emojis is false
                if !self.include_emojis && record.emoji {
                    let nc = pool.new_with_offset(input_char, offset);
                    offset += nc.c.len();
                    result.push(nc);
                    continue;
                }

                // Create the replacement based on type and rendering
                let replacement = match record.type_.as_str() {
                    "circle" => format!("({})", record.rendering),
                    "square" => format!("[{}]", record.rendering),
                    _ => record.rendering.clone(), // fallback to just the rendering
                };

                // Create new character with the replacement string
                let nc =
                    pool.new_char_from(std::borrow::Cow::Owned(replacement), offset, input_char);
                offset += nc.c.len();
                result.push(nc);
            } else {
                // Character not in mapping, keep as-is
                let nc = pool.new_with_offset(input_char, offset);
                offset += nc.c.len();
                result.push(nc);
            }
        }

        Ok(result)
    }
}

pub struct CircledOrSquaredTransliteratorFactory {
    options: CircledOrSquaredTransliteratorOptions,
}

impl CircledOrSquaredTransliteratorFactory {
    pub fn new(options: CircledOrSquaredTransliteratorOptions) -> Self {
        Self { options }
    }
}

impl TransliteratorFactory for CircledOrSquaredTransliteratorFactory {
    fn new_transliterator(&self) -> Result<Box<dyn Transliterator>, TransliteratorFactoryError> {
        Ok(Box::new(CircledOrSquaredTransliterator::new(
            self.options.clone(),
        )))
    }
}