cntp_i18n_parlance_source 0.3.0

Support library for integrating cntp-i18n with the Parlance TMS
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

use cntp_i18n::{I18nString, I18nStringPart};

enum StateMachine {
    Idle(String),
    OneBrace(String),
    Variable(String),
    VariableClosing(String),
}

#[derive(Clone)]
pub enum I18nFullStringPart {
    Static(I18nString),
    Variable(I18nString),
    Count,
}

impl I18nFullStringPart {
    pub fn calculate_string_part(&self, _this_key: &str) -> I18nStringPart {
        match self {
            I18nFullStringPart::Static(i18n_string) => I18nStringPart::Static(i18n_string.clone()),
            I18nFullStringPart::Variable(i18n_string) => {
                // let variables = &variable_list()[this_key];
                I18nStringPart::Variable(
                    i18n_string.clone(),
                    0, // variables
                       //     .iter()
                       //     .position(|string_to_check| **string_to_check == **i18n_string)
                       //     .expect("Expected variable list to contain all present variables"),
                )
            }
            I18nFullStringPart::Count => {
                // let variables = &variable_list()[this_key];
                I18nStringPart::Count(
                    1, // variables
                      //     .iter()
                      //     .position(|variable| variable == "count")
                      //     .expect("Expected variable list to contain a count variable"),
                )
            }
        }
    }
}

pub fn parse_raw_string(string: &str) -> Vec<I18nFullStringPart> {
    let mut parts = Vec::new();
    let mut state_machine = StateMachine::Idle(String::default());
    for char in string.chars() {
        match state_machine {
            StateMachine::Idle(string) => {
                if char == '{' {
                    state_machine = StateMachine::OneBrace(string);
                } else {
                    state_machine = StateMachine::Idle(format!("{string}{char}"));
                }
            }
            StateMachine::OneBrace(string) => {
                if char == '{' {
                    parts.push(I18nFullStringPart::Static(string.into()));
                    state_machine = StateMachine::Variable(String::default());
                } else {
                    state_machine = StateMachine::Idle(format!("{string}{{{char}"));
                }
            }
            StateMachine::Variable(string) => {
                if char == '}' {
                    state_machine = StateMachine::VariableClosing(string);
                } else {
                    state_machine = StateMachine::Variable(format!("{string}{char}"));
                }
            }
            StateMachine::VariableClosing(string) => {
                if char == '}' {
                    if string == "count" {
                        parts.push(I18nFullStringPart::Count);
                    } else {
                        parts.push(I18nFullStringPart::Variable(string.into()));
                    }
                    state_machine = StateMachine::Idle(String::default());
                } else {
                    state_machine = StateMachine::Idle(format!("{string}}}{char}"));
                }
            }
        }
    }

    match state_machine {
        StateMachine::Idle(string) => {
            if !string.is_empty() {
                parts.push(I18nFullStringPart::Static(string.into()));
            }
        }
        StateMachine::OneBrace(string) => {
            parts.push(I18nFullStringPart::Static(format!("{string}{{").into()));
        }
        StateMachine::Variable(string) => {
            parts.push(I18nFullStringPart::Static(format!("{{{{{string}").into()));
        }
        StateMachine::VariableClosing(string) => {
            parts.push(I18nFullStringPart::Static(format!("{{{{{string}}}").into()));
        }
    }

    parts
}