feat: env-based root path selection & extract config constants

- Use APP_ENV to switch between current_dir and current_exe as root path
- Move config/report file names to constants
- Update error messages and output for better user experience

Author: chengpeiquan

src/config/constants.rs

@@ -0,0 +1,5 @@
+pub const CONFIG_FILE_NAME: &str = "config.json";
+
+pub const REPORT_FILE_NAME: &str = "report.txt";
+
+pub const CATEGORY_ORDER: &[&str] = &["feat", "fix", "docs", "style", "refactor", "test", "chore"];

src/config/error.rs

@@ -1,3 +1,5 @@
+use crate::config::constants::CONFIG_FILE_NAME;
+
 #[derive(Debug)]
 pub enum ConfigError {
     FileNotFound,
@@ -13,13 +15,15 @@ impl std::fmt::Display for ConfigError {
             ConfigError::FileNotFound => {
                 write!(
                     f,
-                    "\nPlease make sure there is a config.json file in the program directory."
+                    "\nPlease make sure there is a {} file in the program directory.",
+                    CONFIG_FILE_NAME
                 )
             }
             ConfigError::ParseError => {
                 write!(
                     f,
-                    "\nFailed to parse config.json, please check the file format."
+                    "\nFailed to parse {}, please check the file format.",
+                    CONFIG_FILE_NAME
                 )
             }
             ConfigError::InvalidConfig(msg) => {

src/config/mod.rs

@@ -1,23 +1,32 @@
+pub mod constants;
 mod error;
 mod schema;
 mod store;
 mod types;
 
+use constants::CONFIG_FILE_NAME;
 use error::ConfigError;
 use schema::ConfigFile;
-use std::path::Path;
+use std::path::PathBuf;
+
 pub use store::{init, is_chinese, print_config};
 pub use types::Config;
 
-const CONFIG_FILE_PATH: &str = "config.json";
+fn find_config_file(root_path: &PathBuf) -> Option<PathBuf> {
+    let config_file_path = root_path.join(CONFIG_FILE_NAME);
+    if config_file_path.exists() {
+        return Some(config_file_path);
+    }
+
+    // 3. If both are not found, return None
+    None
+}
 
 /// Initialize configuration from file or use default settings
-pub fn init_config() -> Result<Config, ConfigError> {
-    if !Path::new(CONFIG_FILE_PATH).exists() {
-        return Err(ConfigError::FileNotFound);
-    }
+pub fn init_config(root_path: &PathBuf) -> Result<Config, ConfigError> {
+    let config_path = find_config_file(root_path).ok_or(ConfigError::FileNotFound)?;
 
-    ConfigFile::from_file(CONFIG_FILE_PATH)
+    ConfigFile::from_file(config_path.to_str().unwrap())
         .map_err(|_e| ConfigError::ParseError)
         .and_then(|file_config| {
             let config = Config::new_from_file(&file_config)?;

src/main.rs

@@ -2,7 +2,7 @@ mod config;
 mod i18n;
 mod utils;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, path::PathBuf};
 
 use config::{init_config, print_config};
 use i18n::t;
@@ -15,12 +15,12 @@ use utils::{
     save_report::save_report_markdown,
 };
 
-fn run() -> Result<(), Box<dyn std::error::Error>> {
+fn run(root_path: PathBuf) -> Result<(), Box<dyn std::error::Error>> {
     // Initialize global configuration.
     // After initialization, the config is stored in a global OnceLock singleton,
     // and can be accessed from other modules via `config::store::global()`,
     // such as in the i18n module.
-    let config = init_config()?;
+    let config = init_config(&root_path)?;
 
     print_config();
 
@@ -68,8 +68,7 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
                 .push(log_info);
         }
 
-        // save_report_markdown(&result, "report.txt").expect(t("report_gen_error"));
-        save_report_markdown(&result, "report.txt")?;
+        save_report_markdown(&result, &root_path)?;
 
         exit_on_keypress(Some(t("press_to_exit")));
     }
@@ -78,13 +77,24 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn main() {
-    // Print the current working directory
-    // When the program crashes, it can help locate the cause
+    // Get the APP_ENV environment variable from the startup command (see Makefile.toml).
+    // Since the working directories differ between development and production,
+    // we need to handle them separately.
+    let env = std::env::var("APP_ENV").unwrap_or_else(|_| "production".to_string());
+
+    let root_path = if env == "development" {
+        std::env::current_dir().unwrap()
+    } else {
+        std::env::current_exe()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .to_path_buf()
+    };
+
+    // Print the root path to help locate issues if the program crashes.
     println!("");
-    println!(
-        "Current working directory: \n{}",
-        &std::env::current_dir().unwrap().display()
-    );
+    println!("\nProgram root directory:\n{}", root_path.display());
 
     // Using `?` to propagate errors to `main` causes Rust's default error output
     // (via the `std::process::Termination` trait) to use the Debug format (`{:?}`)
@@ -93,7 +103,7 @@ fn main() {
     //
     // Wrapping the main logic in a separate `run` function and handling errors
     // explicitly with `eprintln!` ensures that the Display output is used.
-    if let Err(e) = run() {
+    if let Err(e) = run(root_path) {
         eprintln!("{}", e); // Use Display format to output the error
         std::process::exit(1);
     }

src/utils/save_report.rs

@@ -1,11 +1,10 @@
+use crate::config::constants::{CATEGORY_ORDER, REPORT_FILE_NAME};
 use crate::i18n::t;
 use crate::utils::format_log::LogInfo;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
-use std::path::Path;
-
-const CATEGORY_ORDER: &[&str] = &["feat", "fix", "docs", "style", "refactor", "test", "chore"];
+use std::path::{Path, PathBuf};
 
 fn get_category_label(type_name: &str) -> &str {
     match type_name {
@@ -23,7 +22,7 @@ fn get_category_label(type_name: &str) -> &str {
 /// Save Markdown report
 pub fn save_report_markdown(
     result: &HashMap<String, HashMap<String, Vec<LogInfo>>>,
-    path: &str,
+    root_path: &PathBuf,
 ) -> std::io::Result<()> {
     // Check if result is empty
     if result.is_empty() {
@@ -53,10 +52,14 @@ pub fn save_report_markdown(
         md.push('\n');
     }
 
-    let mut file = File::create(Path::new(path))?;
+    let output_path = root_path.join(REPORT_FILE_NAME);
+    let mut file = File::create(Path::new(&output_path))?;
     file.write_all(md.as_bytes())?;
 
-    println!("{}", t("report_saved").replace("{}", path));
+    println!(
+        "{}",
+        t("report_saved").replace("{}", output_path.to_str().unwrap())
+    );
     println!("");
 
     Ok(())