mod decide;
mod source;
use tauri::plugin::{Builder, TauriPlugin};
use tauri::{AppHandle, Manager, Runtime, State as Managed};
use source::Source;
pub use decide::{Gate, State};
pub use source::Config;
const PLATFORM: &str = if cfg!(target_os = "ios") {
"ios"
} else if cfg!(target_os = "android") {
"android"
} else if cfg!(target_os = "macos") {
"macos"
} else if cfg!(target_os = "windows") {
"windows"
} else if cfg!(target_os = "linux") {
"linux"
} else {
"unknown"
};
#[must_use]
pub fn init<R: Runtime>(config: Config) -> TauriPlugin<R> {
Builder::new("update-gate")
.invoke_handler(tauri::generate_handler![check])
.setup(|app, _api| {
app.manage(Source::new(config));
Ok(())
})
.build()
}
#[tauri::command]
async fn check<R: Runtime>(
app: AppHandle<R>,
source: Managed<'_, Source>,
lang: Option<String>,
) -> Result<Gate, String> {
let running = app.package_info().version.to_string();
let lang = resolve_language(
lang.as_deref(),
env_language(|key| std::env::var(key).ok()).as_deref(),
);
Ok(source.gate(&running, &lang, PLATFORM).await)
}
fn resolve_language(caller: Option<&str>, env: Option<&str>) -> String {
caller
.and_then(parse_language)
.or_else(|| env.and_then(parse_language))
.unwrap_or_else(|| "en".to_string())
}
fn env_language(var: impl Fn(&str) -> Option<String>) -> Option<String> {
["LC_ALL", "LC_MESSAGES", "LANG"]
.into_iter()
.find_map(|key| var(key).filter(|v| !v.is_empty()))
}
fn parse_language(raw: &str) -> Option<String> {
raw.split(['_', '.', '-'])
.next()
.map(str::to_lowercase)
.filter(|code| code.len() == 2 && code.bytes().all(|b| b.is_ascii_lowercase()))
}
#[cfg(test)]
mod tests {
use super::{env_language, resolve_language};
fn env<'a>(vars: &'a [(&str, &str)]) -> impl Fn(&str) -> Option<String> + 'a {
move |key| {
vars.iter()
.find(|(k, _)| *k == key)
.map(|(_, v)| (*v).to_string())
}
}
#[test]
fn the_environment_is_read_in_posix_order() {
let all = [
("LANG", "en_US"),
("LC_MESSAGES", "fr_FR"),
("LC_ALL", "vi_VN"),
];
assert_eq!(env_language(env(&all)).as_deref(), Some("vi_VN"));
let no_all = [("LANG", "en_US"), ("LC_MESSAGES", "fr_FR")];
assert_eq!(env_language(env(&no_all)).as_deref(), Some("fr_FR"));
assert_eq!(
env_language(env(&[("LANG", "en_US")])).as_deref(),
Some("en_US")
);
assert_eq!(env_language(env(&[])), None);
}
#[test]
fn an_empty_variable_counts_as_unset() {
let vars = [("LANG", "en_US"), ("LC_ALL", "")];
assert_eq!(env_language(env(&vars)).as_deref(), Some("en_US"));
}
#[test]
fn the_callers_language_wins_over_the_environment() {
assert_eq!(resolve_language(Some("vi"), Some("en_US.UTF-8")), "vi");
}
#[test]
fn the_callers_language_is_parsed_the_same_way_as_the_environment() {
assert_eq!(resolve_language(Some("vi-VN"), None), "vi");
}
#[test]
fn an_absent_or_unusable_caller_falls_back_to_the_environment() {
assert_eq!(resolve_language(None, Some("fr.UTF-8")), "fr");
assert_eq!(resolve_language(Some(""), Some("fr.UTF-8")), "fr");
assert_eq!(resolve_language(Some("123"), Some("fr.UTF-8")), "fr");
}
#[test]
fn neither_side_usable_falls_back_to_english() {
assert_eq!(resolve_language(None, None), "en");
assert_eq!(resolve_language(Some("C"), Some("POSIX")), "en");
}
}