allow file level language configuration

Author: J-ZhengLi

src/core/parser/configuration.rs rim_common/src/types/configuration.rssrc/core/parser/configuration.rs renamed to rim_common/src/types/configuration.rs

@@ -1,10 +1,12 @@
 //! The major configuration file for this app, containing information about which version to skip,
 //! when the updates are checked, how long until next updates will be checked etc.
 
+use crate::setter;
+use crate::{dirs::rim_config_dir, types::TomlParser};
 use anyhow::Result;
 use chrono::{NaiveDateTime, Utc};
-use rim_common::{dirs::rim_config_dir, types::TomlParser};
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 use std::{collections::HashMap, fmt::Display, time::Duration};
 
 /// Default update check timeout is 1440 minutes (1 day)
@@ -15,6 +17,7 @@ pub const DEFAULT_UPDATE_CHECK_DURATION: Duration =
 
 #[derive(Debug, Deserialize, Serialize, Default)]
 pub struct Configuration {
+    pub language: Option<Language>,
     pub update: UpdateCheckerOpt,
 }
 
@@ -36,12 +39,17 @@ impl Configuration {
         self
     }
 
-    /// Try loading from [`rim_config_dir`].
+    /// Try loading from [`rim_config_dir`], return `None` if it doesn't exists yet.
+    pub fn try_load_from_config_dir() -> Option<Self> {
+        Self::load_from_dir(rim_config_dir()).ok()
+    }
+
+    /// Loading from [`rim_config_dir`] or return default.
     ///
     /// This guarantee to return a [`VersionSkip`] object,
     /// even if the file does not exists, the default will got returned.
     pub fn load_from_config_dir() -> Self {
-        Self::load_from_dir(rim_config_dir()).unwrap_or_default()
+        Self::try_load_from_config_dir().unwrap_or_default()
     }
 
     /// Write the configuration to [`rim_config_dir`].
@@ -52,6 +60,51 @@ impl Configuration {
     pub fn update_skipped<T: AsRef<str>>(&self, target: UpdateTarget, version: T) -> bool {
         self.update.is_skipped(target, version)
     }
+
+    setter!(set_language(self.language, Option<Language>));
+}
+
+#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Language {
+    CN,
+    #[default]
+    EN,
+}
+
+impl Language {
+    pub fn possible_values() -> &'static [Language] {
+        &[Self::CN, Self::EN]
+    }
+    /// Returns the string representation of this enum,
+    /// this will be the same one that parsed from commandline input.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::CN => "cn",
+            Self::EN => "en",
+        }
+    }
+    /// This is the `str` used for setting locale,
+    /// make sure the values match the filenames under `<root>/locales`.
+    pub fn locale_str(&self) -> &str {
+        match self {
+            Self::CN => "zh-CN",
+            Self::EN => "en-US",
+        }
+    }
+}
+
+impl FromStr for Language {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "cn" | "zh-cn" => Ok(Self::CN),
+            "en" | "en-us" => Ok(Self::EN),
+            _ => Err(anyhow::anyhow!(
+                "invalid or unsupported language option: {s}"
+            )),
+        }
+    }
 }
 
 // If we ever need to support more things for update checker,
@@ -227,4 +280,19 @@ manager = { last-run = "1970-01-01T00:00:00" }"#;
         expected = expected.remind_later(manager, 60);
         assert_eq!(expected.conf_mut(manager).timeout, Some(120));
     }
+
+    #[test]
+    fn lang_config() {
+        let input = r#"language = "CN"
+
+[update]
+"#;
+
+        let expected = Configuration::from_str(input).unwrap();
+        assert_eq!(expected.language, Some(Language::CN));
+
+        // check if the language consistance since we have a `FromStr` impl for it.
+        let back_to_str = toml::to_string(&expected).unwrap();
+        assert_eq!(back_to_str, input);
+    }
 }

rim_common/src/types/mod.rs

@@ -1,10 +1,12 @@
 mod build_config;
+mod configuration;
 mod tool_info;
 mod tool_map;
 mod toolkit_manifest;
 
 // re-exports
 pub use build_config::*;
+pub use configuration::*;
 pub use tool_info::*;
 pub use tool_map::*;
 pub use toolkit_manifest::*;

rim_common/src/utils/mod.rs

@@ -19,13 +19,16 @@ pub use progress_bar::*;
 use std::{
     ffi::OsStr,
     path::{Path, PathBuf},
+    str::FromStr,
     sync::{LazyLock, Mutex},
     time::Duration,
 };
 
 use anyhow::Result;
 use url::Url;
 
+use crate::types::{Configuration, Language};
+
 static CURRENT_LOCALE: LazyLock<Mutex<String>> = LazyLock::new(|| Mutex::new(String::new()));
 
 /// Insert a `.exe` postfix to given input.
@@ -188,17 +191,38 @@ pub fn to_string_lossy<S: AsRef<OsStr>>(s: S) -> String {
     s.as_ref().to_string_lossy().to_string()
 }
 
-/// Allowing the i18n framework to use the current system locale.
+/// Use configured locale or detect system's current locale.
 pub fn use_current_locale() {
-    let locale = sys_locale::get_locale().unwrap_or_else(|| "en".to_string());
-    set_locale(&locale);
+    set_locale(&get_locale());
+}
+
+/// Getting the current locale by:
+/// 1. Checking RIM configuration file, return the configured language if has.
+/// 2. Check system's current locale using [`sys_locale`] crate.
+/// 3. Fallback to english locale.
+pub fn get_locale() -> String {
+    Configuration::try_load_from_config_dir()
+        .and_then(|c| c.language)
+        .map(|lang| lang.locale_str().to_string())
+        .or_else(|| sys_locale::get_locale())
+        .unwrap_or_else(|| Language::EN.locale_str().to_string())
 }
 
 pub fn set_locale(loc: &str) {
     rust_i18n::set_locale(loc);
 
     // update the current locale
     *CURRENT_LOCALE.lock().unwrap() = loc.to_string();
+    // update persistant locale config, but don't fail the program,
+    // because locale setting is not that critical.
+    let set_locale_inner_ = || -> Result<()> {
+        Configuration::load_from_config_dir()
+            .set_language(Some(Language::from_str(loc)?))
+            .write()
+    };
+    if let Err(e) = set_locale_inner_() {
+        error!("unable to save locale settings after changing to '{loc}': {e}");
+    }
 }
 
 /// Get the configured locale string from `configuration.toml`

rim_dev/src/main.rs

@@ -1,3 +1,4 @@
+// bool::then_some().unwrap_or*() is much clean, clippy, why be a hater?
 #![allow(clippy::obfuscated_if_else)]
 
 mod common;

rim_gui/src-tauri/src/common.rs

@@ -16,6 +16,7 @@ use rim::{
     update::UpdateCheckBlocker,
     AppInfo, InstallConfiguration, UninstallConfiguration,
 };
+use rim_common::types::Language as DisplayLanguage;
 use rim_common::{types::ToolkitManifest, utils};
 use serde::{Deserialize, Serialize};
 use tauri::{App, AppHandle, Manager, Window, WindowUrl};
@@ -169,44 +170,36 @@ pub(crate) fn uninstall_toolkit_in_new_thread(window: tauri::Window, remove_self
 
 #[derive(serde::Serialize)]
 pub struct Language {
-    pub id: String,
-    pub name: String,
+    id: String,
+    name: String,
 }
 
 #[tauri::command]
 pub(crate) fn supported_languages() -> Vec<Language> {
-    rim::Language::possible_values()
+    DisplayLanguage::possible_values()
         .iter()
         .map(|lang| {
-            let id = lang.as_str();
-            match lang {
-                rim::Language::EN => Language {
-                    id: id.to_string(),
-                    name: "English".to_string(),
-                },
-                rim::Language::CN => Language {
-                    id: id.to_string(),
-                    name: "简体中文".to_string(),
-                },
-                _ => Language {
-                    id: id.to_string(),
-                    name: id.to_string(),
-                },
-            }
+            let id = lang.locale_str().to_string();
+            let name = match lang {
+                DisplayLanguage::EN => "English".to_string(),
+                DisplayLanguage::CN => "简体中文".to_string(),
+                _ => id.clone(),
+            };
+            Language { id, name }
         })
         .collect()
 }
 
 #[tauri::command]
 pub(crate) fn set_locale(language: String) -> Result<()> {
-    let lang: rim::Language = language.parse()?;
+    let lang: DisplayLanguage = language.parse()?;
     utils::set_locale(lang.locale_str());
     Ok(())
 }
 
 #[tauri::command]
 pub(crate) fn get_locale() -> String {
-    rust_i18n::locale().to_string()
+    utils::get_locale()
 }
 
 #[tauri::command]

rim_gui/src-tauri/src/manager_mode.rs

@@ -14,11 +14,11 @@ use rim::{
     toolkit::{self, Toolkit},
     update::{self, UpdateCheckBlocker, UpdateOpt},
 };
-use rim::{
-    configuration::{Configuration, UpdateTarget, DEFAULT_UPDATE_CHECK_DURATION},
-    get_toolkit_manifest, AppInfo,
+use rim::{get_toolkit_manifest, AppInfo};
+use rim_common::types::{
+    Configuration, ToolkitManifest, UpdateTarget, DEFAULT_UPDATE_CHECK_DURATION,
 };
-use rim_common::{types::ToolkitManifest, utils};
+use rim_common::utils;
 use tauri::{async_runtime, AppHandle, Manager};
 use url::Url;
 
@@ -55,6 +55,7 @@ pub(super) fn main(
             check_updates_in_background,
             get_toolkit_from_url,
             common::supported_languages,
+            common::get_locale,
             common::set_locale,
             common::app_info,
             self_update_now,

rim_gui/src/i18n.ts

@@ -3,13 +3,52 @@ import App from './App.vue';
 import { router } from './router';
 import theme from './theme';
 import 'virtual:uno.css';
-import i18n from './i18n';
+import { createI18n } from 'vue-i18n';
+import enUS from '../../locales/en-US.json';
+import zhCN from '../../locales/zh-CN.json';
+import { invokeCommand } from './utils';
+
+// rust-i18n uses Ruby-on-rails styled placeholder `%{}`,
+// but vue-i18n uses its own (maybe) placeholder style where the
+// `%` is not needed, therefore the percent sign need to be removed
+// before passing to vue-i18n.
+// NB (J-ZhengLi): I would use custom formatter if the documentation of
+// vue-i18n is not that damn limited!
+function convertRailsPlaceholders(obj: any): any {
+    if (typeof obj === 'string') {
+        return obj.replace(/%\{(\w+)\}/g, '{$1}')
+    } else if (Array.isArray(obj)) {
+        return obj.map(convertRailsPlaceholders)
+    } else if (typeof obj === 'object' && obj !== null) {
+        const result: Record<string, any> = {}
+        for (const key in obj) {
+            result[key] = convertRailsPlaceholders(obj[key])
+        }
+        return result
+    }
+    return obj
+}
+
+async function setup() {
+    const locale = await invokeCommand('get_locale') as string;
+    console.log("current locale:", locale);
+    const i18n = createI18n({
+        legacy: false,
+        locale,
+        messages: {
+            'en-US': convertRailsPlaceholders(enUS),
+            'zh-CN': convertRailsPlaceholders(zhCN),
+        }
+    });
+
+    createApp(App)
+        .use(router)
+        .use(theme)
+        .use(i18n)
+        .mount('#app');
+}
 
 // disable context menu on right click
 document.addEventListener('contextmenu', event => event.preventDefault());
 
-createApp(App)
-    .use(router)
-    .use(theme)
-    .use(i18n)
-    .mount('#app');
+setup();