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

use std::sync::Arc;

use crate::{
    descriptors::{PostProcessors, PreProcessors},
    language_d::{AnyTextProcessor, TextProcessorWithId},
};

use super::{
    descriptors::{self, LANGUAGE_DESCRIPTOR_MAP},
    language_d::{
        LanguageAndProcessors, LanguageAndReadingNormalizer, LanguageAndTransforms, LanguageSummary,
    },
};

pub fn get_language_summaries() -> Vec<LanguageSummary> {
    LANGUAGE_DESCRIPTOR_MAP
        .values()
        .map(|entry| LanguageSummary {
            name: entry.name,
            iso: entry.iso,
            iso639_3: entry.iso639_3,
            example_text: entry.example_text,
        })
        .collect::<Vec<LanguageSummary>>()
}

fn test_get_language_summaries() {
    let s = get_language_summaries();
    dbg!(s);
}

pub fn get_all_language_reading_normalizers() -> Vec<LanguageAndReadingNormalizer> {
    LANGUAGE_DESCRIPTOR_MAP
        .values()
        .filter_map(|entry| {
            if let Some(reading_normalizer) = entry.reading_normalizer {
                return Some(LanguageAndReadingNormalizer {
                    iso: entry.iso,
                    reading_normalizer,
                });
            };
            None
        })
        .collect::<Vec<LanguageAndReadingNormalizer>>()
}

pub fn is_text_lookup_worthy(text: &str, language: &str) -> bool {
    if let Some(descriptor) = LANGUAGE_DESCRIPTOR_MAP.get(language) {
        if let Some(itlw_fn) = descriptor.is_text_lookup_worthy {
            return itlw_fn(text);
        }
    }
    false
}

pub fn get_all_language_transform_descriptors() -> Vec<LanguageAndTransforms> {
    let mut results: Vec<LanguageAndTransforms> = Vec::new();
    for entry in LANGUAGE_DESCRIPTOR_MAP.values() {
        if let Some(language_transforms) = entry.language_transforms {
            let item = LanguageAndTransforms {
                iso: entry.iso,
                language_transforms: language_transforms.clone(),
            };
            results.push(item);
        }
    }
    results
}

// Retrieves a list of language processors for all configured languages.
///
/// This function iterates over the `LANGUAGE_DESCRIPTOR_MAP`, and for each language,
/// it extracts the ISO code, and clones its pre-defined text preprocessors and postprocessors.
/// The structure of `LanguageDescriptor` in Rust already stores processors in a format
/// (`Vec<TextProcessorWithId>`) that matches the desired output, simplifying the translation
/// from the JavaScript equivalent which performs an object-to-array transformation.
///
/// # Returns
///
/// A `Vec<LanguageAndProcessors>` where each element contains the ISO code
/// and the respective lists of preprocessors and postprocessors.
pub fn get_all_language_text_processors() -> Vec<LanguageAndProcessors> {
    let mut processor_results = Vec::with_capacity(LANGUAGE_DESCRIPTOR_MAP.values().len());

    for lang_descriptor in LANGUAGE_DESCRIPTOR_MAP.values() {
        let iso = lang_descriptor.iso;
        let pre: Vec<TextProcessorWithId> = lang_descriptor.text_processors.pre.clone();
        let post: Vec<TextProcessorWithId> = lang_descriptor.text_processors.post.clone();
        processor_results.push(LanguageAndProcessors { iso, pre, post });
    }
    processor_results
}