gettr 0.0.2

i18n framework for Rust and yew
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
122
123
124
125
126
127
128
129
130
131
132
133
134

# gettr

gettr is a i18n framework for rust.

It's initial objective is to support i18n for yew applications.

## Getting Started

Add gettr as dependency and as build-dependency.

```Cargo.toml
[dependencies]
gettr = "0.0.1"
[build-dependencies]
gettr = "0.0.1"
```

add build step to `build.rs`:

```rs
use std::path::PathBuf;
pub fn main() -> std::io::Result<()> {
    gettr::update_translations(
        // list all languages you want to support here
        // each language will create a file in the destination directory
        vec!["de"],

        // The directory to search for message to translate
        PathBuf::from("src"),

        // destination directory
        PathBuf::from("src/i18n")
    )?;
    Ok(())
}
```

_build.rs_

use gettr

```rs
pub fn main() {
    // init gettr once at start
    gettr::init("en", vec![
        ("de", include_str!("i18n/de"))
    ]);

    // print a message based on the language
    // gettr! can handle {} placeholders ATM
    println!("{}", gettr::gettr!("Hello World! {}", 18));
}
```

_src/main.rs_

gettr will search all files in `src` and find calls of the `gettr!` macro. The default language is used as translation key and fallback. For each call a translation file is generated in `src/i18n`. In this case the following file is generated:

```js
// This file is generated and automatically updated by gettr.
// Values set to keys will be kept on updates.

// src/main.rs#8
"Hello World! {}" = ""
```

_src/i18n/de_

You can maintain the translation for `Hello World!` in this file. It will be automatically updated on every build. Existing keys will be kept. If a maintained key can no longer be found in the code it is removed.

## Integration with yew

Using the `yew` feature you can use the provided `GettrContext` and `use_gettr` to integrate gettr in your yew client.

```rs
use routing::Routing;
use yew::{function_component, html, Html};

use gettr::GettrProvider;

fn main() {
    gettr::init("en", vec![
        ("de", include_str!("i18n/de"))
    ]);
    yew::Renderer::<App>::new().render();
}

#[function_component(App)]
pub fn app() -> Html {
    html! {
        <GettrProvider>
            <Home></Home>
        </GettrProvider>
    }
}

use gettr::{use_gettr, gettr};

#[function_component(Home)]
pub fn home() -> Html {
    use_gettr() // call the hook to ensure your component updates when the language is changed
    html! {
        <div>
            {gettr!("Hello World!")}
        </div>
    }
}
```

## Limitations

### formatting

gettr uses a regular expression to find `regex!` calls in the code. This means it won't work well with formatting these calls in more than one line.

Good: 
```rs
gettr!("This is an example {}", 124);
```
Bad:
```rs
gettr!(
    "This is an example {}",
    124
);
```

### placeholders

Rusts fmt macros allow named arguments. gettr can not handle them ATM.

### plurals

gettr has no support for plural forms other than specifing them manually.