feat(config): support config file reading and global access

Author: chengpeiquan

src/config/error.rs

@@ -0,0 +1,26 @@
+use crate::i18n::t;
+
+#[derive(Debug)]
+pub enum ConfigError {
+    FileNotFound(String),
+    ParseError(String),
+    InvalidConfig(String),
+}
+
+impl std::error::Error for ConfigError {}
+
+impl std::fmt::Display for ConfigError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ConfigError::FileNotFound(msg) => {
+                write!(f, "{}", t("config_file_not_found").replace("{}", msg))
+            }
+            ConfigError::ParseError(msg) => {
+                write!(f, "{}", t("failed_parse_config").replace("{}", msg))
+            }
+            ConfigError::InvalidConfig(msg) => {
+                write!(f, "{}", t("config_invalid").replace("{}", msg))
+            }
+        }
+    }
+}

src/config/mod.rs

@@ -0,0 +1,29 @@
+mod error;
+mod schema;
+mod store;
+mod types;
+
+use error::ConfigError;
+use schema::ConfigFile;
+use std::path::Path;
+pub use store::{init, is_chinese, print_config};
+pub use types::{Config, Language};
+
+const CONFIG_FILE_PATH: &str = "config.json";
+
+/// 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(
+            "config.json not found".to_string(),
+        ));
+    }
+
+    ConfigFile::from_file(CONFIG_FILE_PATH)
+        .map_err(|e| ConfigError::ParseError(e.to_string()))
+        .and_then(|file_config| {
+            let config = Config::new_from_file(&file_config)?;
+            init(config.clone());
+            Ok(config)
+        })
+}

src/config/schema.rs

@@ -0,0 +1,67 @@
+use super::error::ConfigError;
+use serde::Deserialize;
+use std::{collections::HashMap, fs};
+
+// The schema of the config file
+#[derive(Debug, Deserialize)]
+pub struct ConfigFile {
+    /// Language setting: 'en' or 'zh'
+    pub lang: String,
+
+    /// List of author names
+    /// Vec<String> is equivalent to string[] in TypeScript
+    pub authors: Vec<String>,
+
+    /// Date range: [start_date, end_date]
+    /// Vec<String> here represents a fixed-length array of 2 strings
+    #[serde(rename = "dateRange")]
+    pub date_range: Vec<String>,
+
+    /// List of Git repository paths
+    pub repos: Vec<String>,
+
+    /// Repository name formatting map
+    /// HashMap<K,V> is equivalent to Record<K,V> in TypeScript
+    /// or { [key: string]: string }
+    pub format: HashMap<String, String>,
+
+    /// List of commit types to include
+    pub includes: Vec<String>,
+
+    /// List of keywords to exclude
+    pub excludes: Vec<String>,
+}
+
+impl ConfigFile {
+    pub fn from_file(path: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        // Reading file contents
+        let content = fs::read_to_string(path)?;
+
+        // Parsing JSON
+        let config: ConfigFile = serde_json::from_str(&content)?;
+
+        // Validate the config
+        config.validate()?;
+
+        Ok(config)
+    }
+
+    fn validate(&self) -> Result<(), ConfigError> {
+        if self.date_range.len() != 2 {
+            return Err(ConfigError::InvalidConfig(
+                "date_range must contain exactly 2 dates".to_string(),
+            ));
+        }
+        if self.authors.is_empty() {
+            return Err(ConfigError::InvalidConfig(
+                "authors list cannot be empty".to_string(),
+            ));
+        }
+        if self.repos.is_empty() {
+            return Err(ConfigError::InvalidConfig(
+                "repos list cannot be empty".to_string(),
+            ));
+        }
+        Ok(())
+    }
+}

src/config/store.rs

@@ -0,0 +1,40 @@
+use super::error::ConfigError;
+use super::types::Config;
+use crate::i18n::t;
+use std::sync::OnceLock;
+
+// Global Configuration Instance
+static GLOBAL_CONFIG: OnceLock<Config> = OnceLock::new();
+
+/// Initialize the global configuration
+pub fn init(config: Config) {
+    let _ = GLOBAL_CONFIG.set(config);
+}
+
+/// Get the global configuration instance
+/// Returns an error if the configuration is not initialized
+pub fn global() -> Result<&'static Config, ConfigError> {
+    GLOBAL_CONFIG
+        .get()
+        .ok_or_else(|| ConfigError::InvalidConfig(t("global_config_not_initialized").to_string()))
+}
+
+/// Check if the current language is Chinese
+pub fn is_chinese() -> bool {
+    global()
+        .map(|config| matches!(config.language, super::types::Language::Chinese))
+        .unwrap_or(false)
+}
+
+pub fn print_config() {
+    match global() {
+        Ok(config) => {
+            println!();
+            println!("{}", config);
+            println!();
+        }
+        Err(e) => {
+            eprintln!("{}", t("failed_print_config").replace("{}", &e.to_string()));
+        }
+    }
+}

src/config/types.rs

@@ -0,0 +1,108 @@
+use super::{error::ConfigError, schema::ConfigFile};
+use crate::i18n::t;
+use std::fmt;
+
+/// Language options for the application
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum Language {
+    English,
+    Chinese,
+}
+
+// Implement the Display trait
+// e.g. `println!("{}", Language::English);` will print `en`
+impl fmt::Display for Language {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Language::English => write!(f, "en"),
+            Language::Chinese => write!(f, "zh"),
+        }
+    }
+}
+
+/// Parsing from string to enumeration implementation
+impl Language {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "en" => Some(Language::English),
+            "zh" => Some(Language::Chinese),
+            _ => None,
+        }
+    }
+}
+
+/// Global configuration structure
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub language: Language,
+    pub authors: Vec<String>,
+    pub date_range: Vec<String>,
+    pub repos: Vec<String>,
+    pub format: std::collections::HashMap<String, String>,
+    pub includes: Vec<String>,
+    pub excludes: Vec<String>,
+}
+
+impl Config {
+    /// Create a new configuration instance with default values
+    pub fn new_from_file(file_config: &ConfigFile) -> Result<Self, ConfigError> {
+        let language = Language::from_str(&file_config.lang)
+            .ok_or_else(|| ConfigError::InvalidConfig("Invalid language setting".to_string()))?;
+
+        Ok(Self {
+            language,
+            authors: file_config.authors.clone(),
+            date_range: file_config.date_range.clone(),
+            repos: file_config.repos.clone(),
+            format: file_config.format.clone(),
+            includes: file_config.includes.clone(),
+            excludes: file_config.excludes.clone(),
+        })
+    }
+}
+
+impl fmt::Display for Config {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "")?;
+        writeln!(f, "{}", t("config_details"))?;
+        writeln!(f, "")?;
+        writeln!(
+            f,
+            "{}: {}",
+            t("language"),
+            if matches!(self.language, Language::Chinese) {
+                "Chinese"
+            } else {
+                "English"
+            }
+        )?;
+        writeln!(f, "{}: {:?}", t("authors"), self.authors)?;
+        writeln!(
+            f,
+            "{}: {} - {}",
+            t("date_range"),
+            self.date_range.get(0).unwrap_or(&"N/A".to_string()),
+            self.date_range.get(1).unwrap_or(&"N/A".to_string())
+        )?;
+        writeln!(f, "{}:", t("repos"))?;
+        for repo in &self.repos {
+            if let Some(display_name) = self.format.get(repo) {
+                writeln!(f, "  - {} ({})", display_name, repo)?;
+            } else {
+                writeln!(f, "  - {}", repo)?;
+            }
+        }
+        writeln!(f, "{}:", t("includes"))?;
+        for inc in &self.includes {
+            writeln!(f, "  - {}", inc)?;
+        }
+        writeln!(f, "{}:", t("excludes"))?;
+        for exc in &self.excludes {
+            writeln!(f, "  - {}", exc)?;
+        }
+        writeln!(f, "")?;
+        writeln!(f, "--------------------------------")?;
+        Ok(())
+    }
+}