bea4915317
Added translation support based on the Fractal i18n. To do this I've
added the gettext-rs crate dep. I'm using my own fork because the
official gettext-rs release includes the gettext source files and that
increase the distribution package a lot and for distribution with
flatkap we don't need to build gettext, the lib is in the gnome sdk. So
this gettext-rs fork is the same, but removing the not needed gettext
source files.
The i18n.rs file adds some useful functions to translate strings. These
functions wraps the original gettext and adds more functionality, to be
able to translate compound strings, something that's not supported by
the gettext function.
The 'i18n' function works like the gettext, receives a plain string
without params.
The 'i18n_f' function receives a string with "{}" and a ref to an array
of &str with substitutions for the "{}" in the original string. The
substitution is done by order.
The 'i18n_k' function receives a string with "{named}" and a ref to an
array of (&str, &str) with substitutions for the "{named}" in the
original string. The substitution is done by name, where the first &str
in the tuple is the name and the second the string to use for the
replace.
This mod also include ni18n variants of the three functions for plural
and singular translations.
I've also created the spanish translation.
See #61
https://gitlab.gnome.org/World/podcasts/issues/61
136 lines
3.8 KiB
Rust
136 lines
3.8 KiB
Rust
extern crate gettextrs;
|
|
extern crate regex;
|
|
use self::gettextrs::gettext;
|
|
use self::gettextrs::ngettext;
|
|
use self::regex::Captures;
|
|
use self::regex::Regex;
|
|
|
|
#[allow(dead_code)]
|
|
fn freplace(input: String, args: &[&str]) -> String {
|
|
let mut parts = input.split("{}");
|
|
let mut output = parts.next().unwrap_or("").to_string();
|
|
for (p, a) in parts.zip(args.iter()) {
|
|
output += &(a.to_string() + &p.to_string());
|
|
}
|
|
output
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn kreplace(input: String, kwargs: &[(&str, &str)]) -> String {
|
|
let mut s = input.clone();
|
|
for (k, v) in kwargs {
|
|
if let Ok(re) = Regex::new(&format!("\\{{{}\\}}", k)) {
|
|
s = re
|
|
.replace_all(&s, |_: &Captures| v.to_string().clone())
|
|
.to_string();
|
|
}
|
|
}
|
|
|
|
s
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn i18n(format: &str) -> String {
|
|
gettext(format)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn i18n_f(format: &str, args: &[&str]) -> String {
|
|
let s = gettext(format);
|
|
freplace(s, args)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn i18n_k(format: &str, kwargs: &[(&str, &str)]) -> String {
|
|
let s = gettext(format);
|
|
kreplace(s, kwargs)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn ni18n(single: &str, multiple: &str, number: u32) -> String {
|
|
ngettext(single, multiple, number)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn ni18n_f(single: &str, multiple: &str, number: u32, args: &[&str]) -> String {
|
|
let s = ngettext(single, multiple, number);
|
|
freplace(s, args)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn ni18n_k(single: &str, multiple: &str, number: u32, kwargs: &[(&str, &str)]) -> String {
|
|
let s = ngettext(single, multiple, number);
|
|
kreplace(s, kwargs)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn test_i18n() {
|
|
let out = i18n("translate1");
|
|
assert_eq!(out, "translate1");
|
|
|
|
let out = ni18n("translate1", "translate multi", 1);
|
|
assert_eq!(out, "translate1");
|
|
let out = ni18n("translate1", "translate multi", 2);
|
|
assert_eq!(out, "translate multi");
|
|
}
|
|
|
|
#[test]
|
|
fn test_i18n_f() {
|
|
let out = i18n_f("{} param", &["one"]);
|
|
assert_eq!(out, "one param");
|
|
|
|
let out = i18n_f("middle {} param", &["one"]);
|
|
assert_eq!(out, "middle one param");
|
|
|
|
let out = i18n_f("end {}", &["one"]);
|
|
assert_eq!(out, "end one");
|
|
|
|
let out = i18n_f("multiple {} and {}", &["one", "two"]);
|
|
assert_eq!(out, "multiple one and two");
|
|
|
|
let out = ni18n_f("singular {} and {}", "plural {} and {}", 2, &["one", "two"]);
|
|
assert_eq!(out, "plural one and two");
|
|
let out = ni18n_f("singular {} and {}", "plural {} and {}", 1, &["one", "two"]);
|
|
assert_eq!(out, "singular one and two");
|
|
}
|
|
|
|
#[test]
|
|
fn test_i18n_k() {
|
|
let out = i18n_k("{one} param", &[("one", "one")]);
|
|
assert_eq!(out, "one param");
|
|
|
|
let out = i18n_k("middle {one} param", &[("one", "one")]);
|
|
assert_eq!(out, "middle one param");
|
|
|
|
let out = i18n_k("end {one}", &[("one", "one")]);
|
|
assert_eq!(out, "end one");
|
|
|
|
let out = i18n_k("multiple {one} and {two}", &[("one", "1"), ("two", "two")]);
|
|
assert_eq!(out, "multiple 1 and two");
|
|
|
|
let out = i18n_k("multiple {two} and {one}", &[("one", "1"), ("two", "two")]);
|
|
assert_eq!(out, "multiple two and 1");
|
|
|
|
let out = i18n_k("multiple {one} and {one}", &[("one", "1"), ("two", "two")]);
|
|
assert_eq!(out, "multiple 1 and 1");
|
|
|
|
let out = ni18n_k(
|
|
"singular {one} and {two}",
|
|
"plural {one} and {two}",
|
|
1,
|
|
&[("one", "1"), ("two", "two")],
|
|
);
|
|
assert_eq!(out, "singular 1 and two");
|
|
let out = ni18n_k(
|
|
"singular {one} and {two}",
|
|
"plural {one} and {two}",
|
|
2,
|
|
&[("one", "1"), ("two", "two")],
|
|
);
|
|
assert_eq!(out, "plural 1 and two");
|
|
}
|
|
}
|