l10n 0.1.3

Opinionated localization library built upon fluent-bundle.
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

use std::io::Read;
use std::path::PathBuf;
use std::{env, fs};

const L10N_CONFIG_FILE: &str = "L10N_CONFIG_FILE";

#[test]
fn ui() {
    let default_config_path = PathBuf::from("tests/ui/default_l10n.toml")
        .canonicalize()
        .unwrap();

    for entry in fs::read_dir("tests/ui").unwrap() {
        let entry_path = entry.unwrap().path();
        if !entry_path.is_dir() {
            continue;
        }

        let kind = entry_path.file_name().unwrap().to_str().unwrap();
        let is_pass = match kind {
            "pass" => true,
            "fail" => {
                // Prior to 1.58 errors are "spanned" differently for
                // `Span::call_site()` (i.e. include `;`)
                // So I don't check error messages for fail tests before 1.58.
                if rustversion::cfg!(since(1.58)) {
                    false
                } else {
                    continue;
                }
            }
            _ => continue,
        };

        for entry in entry_path.read_dir().unwrap() {
            unsafe {
                env::remove_var("L10N_PATH_ENV");
            }

            let entry_path = entry.unwrap().path();
            if let Some(name) = entry_path.file_name().map(|name| name.to_string_lossy()) {
                if let Some(feature) = name.strip_prefix("feature-") {
                    match feature {
                        "allow-incomplete" => {
                            if cfg!(not(feature = "allow-incomplete")) {
                                continue;
                            }
                        }
                        _ => {
                            unimplemented!("unrecognized feature flag {}", feature);
                        }
                    }
                }
            }

            unsafe {
                env::set_var(L10N_CONFIG_FILE, default_config_path.as_os_str());
            }

            let files: Vec<_> = if entry_path.is_dir() {
                if entry_path.join("l10n.toml").exists() {
                    let config_path = env::current_dir()
                        .unwrap()
                        .join(&entry_path)
                        .join("l10n.toml");
                    unsafe {
                        env::set_var(L10N_CONFIG_FILE, config_path.as_os_str());
                    }
                }

                let env_file = entry_path.join(".l10n_path_env");
                if env_file.exists() {
                    let mut f = fs::File::open(env_file).unwrap();
                    let mut s = String::new();
                    f.read_to_string(&mut s).unwrap();
                    unsafe {
                        env::set_var("L10N_PATH_ENV", s.trim());
                    }
                }

                entry_path
                    .read_dir()
                    .unwrap()
                    .filter_map(|entry| {
                        let path = entry.unwrap().path();
                        match path.extension() {
                            Some(ext) if ext == "rs" => Some(path),
                            _ => None,
                        }
                    })
                    .collect()
            } else {
                vec![entry_path]
            };

            let t = trybuild::TestCases::new();
            if is_pass {
                for file in files {
                    t.pass(&file);
                }
            } else {
                for file in files {
                    t.compile_fail(&file);
                }
            }
        }
    }
}