Merge pull request #259 from J-ZhengLi/remastered

detects running mode by checking config instead of checking executable name & QOL improvements

Author: J-ZhengLi

Cargo.toml

@@ -62,6 +62,9 @@ tokio.workspace = true
 [dev-dependencies]
 rim-test-support = { version = "0.1.0", path = "rim_test/rim-test-support" }
 
+[build-dependencies]
+rim_common = { path = "rim_common" }
+
 [target."cfg(windows)".dependencies]
 winreg = "0.52.0"
 winapi = { version = "0.3", features = ["winuser", "winbase"] }

README.md

@@ -64,12 +64,11 @@ After env setup, it will guide you through installing Rust `toolkit`.
 - Debug `installer` mode:
   - Commandline interface
   ```bash
-  cargo run
+  cargo dev run --cli --installer
   ```
   - Graphical interface
   ```bash
-  cd rim_gui
-  pnpm run tauri dev
+  pnpm dev run --installer
   ```
 - Debug `manager` mode:
   > Running `manager` is not as straight forward as running in `Installer` mode.
@@ -78,7 +77,7 @@ After env setup, it will guide you through installing Rust `toolkit`.
   so you can test `manager`'s functionalities easier.
 
   ```bash
-  cargo dev run-manager
+  cargo dev run --manager
   ```
 
 ### Release
@@ -140,12 +139,8 @@ Options:
 
 ### Manager mode (CLI)
 
-> Manager mode can be activated by:
->
-> 1. Renaming the binary to one that contains `manager`, such as `manager-cli`
-> 2. Having a `MODE` environment variable set to `manager` before running the program, such as running `export MODE='manager'` in Unix systems.
->
-> NOTE: **Manager will be automatically deployed after installation, and must be run inside of the installation directory to avoid crash**
+> Manager mode will run after an installation record was detected, and it can also be overridden by
+> having a `MODE` environment variable set to `manager` before running the program, such as running `export MODE='manager'` in Unix systems.
 
 ```console
 Usage: MODE='manager' rim-cli.exe [OPTIONS] [COMMAND]

build.rs

@@ -23,4 +23,6 @@ fn main() {
 
     let edition = env::var(EDITION_OVERRIDE_ENV).unwrap_or(DEFAULT_EDITION.to_string());
     println!("cargo::rustc-env=EDITION={edition}");
+
+    rim_common::setup_version_info!();
 }

locales/en-US.json

@@ -162,5 +162,10 @@
     "unable_to_run_check": "unable to perform check, maybe the rule-set wasn't installed properly",
     "use_offline_dist_server": "attempt to use offline dist server at: '%{url}'",
     "program_does_not_exits": "unable to execute command because the program '%{program}' does not exist in the PATH variable",
-    "skip_env_modification": "skip modifying environment variables as requested"
+    "skip_env_modification": "skip modifying environment variables as requested",
+    "install_record_not_found": "installation record cannot be found at '%{path}', try re-install this program to fix the problem",
+    "install_dir_is_root": "the program is installed but the installation directory appears to be root or empty, try re-install this program to fix the problem",
+    "install_dir_is_os_dir": "the program is installed but the installation directory appears to be an OS specific directory '%{path}', try re-install this program to fix the problem",
+    "uninstall_self_residual_info": "uninstall finished successfully, some files might not get removed until next system reboot",
+    "duplicated_config_files": "duplicated config file detected at these locations:\n1. %{first}\n2. %{second}\nconfiguration of the first one will be used"
 }

locales/zh-CN.json

@@ -158,5 +158,10 @@
     "unable_to_run_check": "无法执行检查，可能是规则集未正确安装",
     "use_offline_dist_server": "尝试使用 rustup 本地服务器: '%{url}'",
     "program_does_not_exits": "无法运行指定命令，应用程序 '%{program}' 不在 PATH 变量中",
-    "skip_env_modification": "跳过环境变量修改步骤"
+    "skip_env_modification": "跳过环境变量修改步骤",
+    "install_record_not_found": "找不到安装记录 '%{path}'，请尝试重新安装该程序修复此问题。",
+    "install_dir_is_root": "程序已安装，但安装目录似乎为空或处于根目录，请尝试重新安装该程序以解决问题。",
+    "install_dir_is_os_dir": "程序已安装，但其安装目录位于系统专用路径 '%{path}'，建议检查或重新安装。",
+    "uninstall_self_residual_info": "卸载已完成，某些文件将在系统重启后彻底移除。",
+    "duplicated_config_files": "检查到以下重复配置文件:\n1. %{first}\n2. %{second}\n将读取第一个文件"
 }

rim_common/src/dirs.rs

@@ -0,0 +1,79 @@
+//! Common Directories that are outside of install dir
+
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+#[macro_export]
+/// Declare a statically allocated `OnceLock` path, and create that directory if it does not exists.
+macro_rules! get_path_and_create {
+    ($path_ident:ident, $init:expr) => {{
+        static $path_ident: std::sync::OnceLock<std::path::PathBuf> = std::sync::OnceLock::new();
+        $path_ident.get_or_init(|| {
+            let __path__ = $init;
+            $crate::utils::ensure_dir(&__path__)
+                .expect("unable to create one of the directory under installation folder");
+            __path__
+        })
+    }};
+}
+
+/// Get a path to user's "home" directory.
+///
+/// The home directory is determined by a combination of ways
+/// with a fallback order:
+///
+/// 1. The `HOME` environment variable
+/// 2. The `USERPROFILE` environment variable (Windows only)
+/// 3. The [`home_dir`](dirs::home_dir) function of the `dirs` crate
+///
+/// # Panic
+///
+/// Will panic if such directory cannot be determined by neither the `HOME` env var
+/// nor [`dirs::home_dir`] function.
+pub fn home_dir() -> PathBuf {
+    let base = env::var_os("HOME").filter(|oss| !oss.is_empty());
+    #[cfg(windows)]
+    let base = base.or_else(|| env::var_os("USERPROFILE").filter(|oss| !oss.is_empty()));
+
+    base.map(PathBuf::from)
+        .unwrap_or_else(|| dirs::home_dir().expect("home directory cannot be determined."))
+}
+
+/// (User) Configuration directory to store all our configs.
+///
+/// Note: This dir will be stored under OS's `config_dir`, which can be:
+/// - `$HOME/.config/rim` on Linux
+/// - `$HOME/Library/Application Support/rim` on macOS
+/// - `$HOME\AppData\Roaming\rim` on Windows
+///
+/// # Panic
+/// Panic if the OS's config directory cannot be determined, which typically meaning
+/// that the `HOME` env var is missing and the current OS is not support by the [`dirs`] crate.
+pub fn rim_config_dir() -> &'static Path {
+    get_path_and_create!(RIM_CONFIG_DIR, {
+        let mut config_root = home_dir();
+
+        cfg_if::cfg_if! {
+            if #[cfg(target_os = "linux")] {
+                config_root.push(".config")
+            } else if #[cfg(windows)] {
+                config_root.push("AppData");
+                config_root.push("Roaming");
+            } else if #[cfg(target_os = "macos")] {
+                config_root.push("Library");
+                config_root.push("Application Support");
+            } else {
+                // fallback to directly use `dir::config_dir`.
+                // The reason we not directly using it was because we can
+                // support mocked test on Windows by setting the `HOME` env var.
+                dirs::config_dir().expect(
+                    "unable to determine config directory, maybe your OS is not supported"
+                );
+            }
+        }
+        config_root.push("rim");
+        config_root
+    })
+}

rim_common/src/lib.rs

@@ -3,8 +3,10 @@ extern crate log;
 #[macro_use]
 extern crate rust_i18n;
 
+pub mod dirs;
 pub mod types;
 pub mod utils;
+pub mod version_info;
 
 use types::BuildConfig;
 

rim_common/src/utils/file_system.rs

@@ -7,29 +7,6 @@ use std::path::{Component, Path, PathBuf};
 use std::time::Duration;
 use tempfile::NamedTempFile;
 
-/// Get a path to user's "home" directory.
-///
-/// The home directory is determined by a combination of ways
-/// with a fallback order:
-///
-/// 1. The `HOME` environment variable
-/// 2. The `USERPROFILE` environment variable (Windows only)
-/// 3. The [`home_dir`](dirs::home_dir) function of the `dirs` crate
-///
-/// # Panic
-///
-/// Will panic if such directory cannot be determined,
-/// which could be the result of missing certain environment variable at runtime,
-/// check [`dirs::home_dir`] for more information.
-pub fn home_dir() -> PathBuf {
-    let base = env::var_os("HOME").filter(|oss| !oss.is_empty());
-    #[cfg(windows)]
-    let base = base.or_else(|| env::var_os("USERPROFILE").filter(|oss| !oss.is_empty()));
-
-    base.map(PathBuf::from)
-        .unwrap_or_else(|| dirs::home_dir().expect("home directory cannot be determined."))
-}
-
 /// Wrapper to [`std::fs::read_to_string`] but with additional error context.
 pub fn read_to_string<P: AsRef<Path>>(name: &str, path: P) -> Result<String> {
     fs::read_to_string(path.as_ref()).with_context(|| {

rim_common/src/utils/process.rs

@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 use std::process::{Command, ExitStatus};
 use std::{env, io};
 
-use anyhow::{bail, Result};
+use anyhow::{bail, Context, Result};
 
 use super::set_exec_permission;
 
@@ -90,6 +90,20 @@ pub fn execute(cmd: Command) -> Result<()> {
     execute_command(cmd, true, true).map(|_| ())
 }
 
+/// Covenient function to execute a command to finish then collect its output.
+pub fn command_output(mut cmd: Command) -> Result<String> {
+    let inner_ = |cmd: &mut Command| -> Result<String> {
+        let output = cmd.output()?;
+        if !output.status.success() {
+            bail!("{}", String::from_utf8_lossy(&output.stderr));
+        }
+        Ok(String::from_utf8_lossy(&output.stdout).trim().into())
+    };
+
+    inner_(&mut cmd)
+        .with_context(|| format!("failed when executing command: {}", cmd_to_string(cmd)))
+}
+
 /// Execute a command.
 ///
 /// - When `expect_success` is `true`,

rim_common/src/version_info.rs

@@ -0,0 +1,82 @@
+//! Retrieve detailed version information with the help of `git`
+//!
+//! (Inspired by clippy's [`rustc_tools_utils` crate](https://crates.io/crates/rustc_tools_util))
+
+use std::path::PathBuf;
+
+use crate::{cmd, utils::command_output};
+
+/// Get version string that includes git commit information.
+#[macro_export]
+macro_rules! get_version_info {
+    () => {{
+        let version = std::option_env!("TAG_VERSION").unwrap_or(std::env!("CARGO_PKG_VERSION"));
+        let commit_hash = std::option_env!("GIT_HASH");
+        let commit_date = std::option_env!("COMMIT_DATE");
+
+        if let (Some(hash), Some(date)) = (commit_hash, commit_date) {
+            std::format!("{version} ({} {})", hash.trim(), date.trim())
+        } else {
+            version.to_string()
+        }
+    }};
+}
+
+#[macro_export]
+macro_rules! setup_version_info {
+    () => {{
+        $crate::version_info::rerun_if_git_changes();
+        if let Some(hash_) = $crate::version_info::git_commit_hash() {
+            println!("cargo:rustc-env=GIT_HASH={hash_}");
+        }
+        if let Some(date_) = $crate::version_info::git_commit_date() {
+            println!("cargo:rustc-env=COMMIT_DATE={date_}");
+        }
+        if let Some(tag_) = $crate::version_info::git_tag_as_version() {
+            println!("cargo:rustc-env=TAG_VERSION={tag_}");
+        }
+    }};
+}
+
+pub fn rerun_if_git_changes() {
+    let Ok(git_head_file) =
+        command_output(cmd!("git", "rev-parse", "--git-path", "HEAD")).map(PathBuf::from)
+    else {
+        return;
+    };
+    if git_head_file.exists() {
+        println!("cargo::rerun-if-changed={}", git_head_file.display());
+    }
+
+    let Ok(git_head_ref_file) = command_output(cmd!("git", "symbolic-ref", "-q", "HEAD"))
+        .and_then(|head_ref| command_output(cmd!("git", "rev-parse", "--git-path", &head_ref)))
+        .map(PathBuf::from)
+    else {
+        return;
+    };
+    if git_head_ref_file.exists() {
+        println!("cargo::rerun-if-changed={}", git_head_ref_file.display());
+    }
+}
+
+/// Getting git tag name if that exists.
+pub fn git_tag_as_version() -> Option<String> {
+    let raw = command_output(cmd!("git", "describe", "--exact-match", "--tags")).ok()?;
+    // remove the leading `v`
+    Some(raw.trim_start_matches('v').into())
+}
+
+pub fn git_commit_hash() -> Option<String> {
+    command_output(cmd!("git", "rev-parse", "--short", "HEAD")).ok()
+}
+
+pub fn git_commit_date() -> Option<String> {
+    command_output(cmd!(
+        "git",
+        "log",
+        "-1",
+        "--date=short",
+        "--pretty=format:%cd"
+    ))
+    .ok()
+}