feat!: move locales to config dir + add test-config command + new -c

argument to specify config path

Author: coko7

locales/asia_en.toml config/asia_en.tomllocales/asia_en.toml renamed to config/asia_en.toml

@@ -25,6 +25,9 @@ pub struct Cli {
     // #[arg(short = 'j', long = "json")]
     // pub output_json: bool,
 
+    #[arg(short = 'c', long = "config-dir")]
+    pub config_directory_path: Option<PathBuf>,
+
     #[command(flatten)]
     pub verbose: clap_verbosity_flag::Verbosity,
 }
@@ -52,6 +55,9 @@ pub enum Commands {
     /// Launch into interactive mode
     #[command(name = "inter", alias = "interactive", alias = "int")]
     Interactive,
+    /// Test what configuration files are found
+    #[command(name = "test-config", alias = "test-conf")]
+    TestConfig,
 }
 
 #[derive(ValueEnum, Copy, Clone, Debug, PartialEq, Eq)]

locales/en.toml config/en.tomllocales/en.toml renamed to config/en.toml

@@ -1,7 +1,7 @@
 use std::{
     fs,
     io::{self, Write},
-    path::PathBuf,
+    path::{Path, PathBuf},
     time::Instant,
 };
 
@@ -12,7 +12,7 @@ use yansi::Paint;
 
 use crate::{cli::LanguageCode, localizer::Localizer, scraper::OpTcgScraper, storage::DataStore};
 
-pub fn show_interactive() -> Result<()> {
+pub fn show_interactive(config_dir: &Path) -> Result<()> {
     println!("{}", "+---------------------------+".yellow());
     println!(
         "{} {} {}",
@@ -83,7 +83,7 @@ pub fn show_interactive() -> Result<()> {
 
     let download_images = is_yes(value);
 
-    let localizer = Localizer::load(language)?;
+    let localizer = Localizer::load(config_dir, language)?;
     let scraper = OpTcgScraper::new(&localizer);
     let store = DataStore::new(&data_dir, language);
 

locales/jp.toml config/jp.tomllocales/jp.toml renamed to config/jp.toml

@@ -1,8 +1,7 @@
-use std::{collections::HashMap, fs, path::PathBuf};
-
-use anyhow::{Context, Result};
+use anyhow::{ensure, Context, Result};
 use log::{debug, info};
 use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, fs, path::Path};
 
 use crate::cli::LanguageCode;
 
@@ -43,25 +42,52 @@ impl Localizer {
         Self::reverse_search(&self.rarities, value)
     }
 
-    pub fn load(language: LanguageCode) -> Result<Localizer> {
+    pub fn find_locales(config_dir: &Path) -> Result<()> {
+        ensure!(
+            config_dir.exists(),
+            format!("config directory not found: {}", config_dir.display())
+        );
+
+        let entries = fs::read_dir(config_dir)?;
+        println!("config directory: {}", config_dir.display());
+
+        for entry in entries {
+            let entry = entry?;
+            let file_name = entry.file_name();
+            println!("- {}", file_name.to_string_lossy());
+        }
+
+        Ok(())
+    }
+
+    pub fn load(config_dir: &Path, language: LanguageCode) -> Result<Localizer> {
         match language {
-            LanguageCode::ChineseHongKong => Self::load_from_file("zh_hk"),
-            LanguageCode::ChineseSimplified => Self::load_from_file("zh_cn"),
-            LanguageCode::ChineseTaiwan => Self::load_from_file("zh_tw"),
-            LanguageCode::English => Self::load_from_file("en"),
-            LanguageCode::EnglishAsia => Self::load_from_file("en_asia"),
-            LanguageCode::Japanese => Self::load_from_file("jp"),
-            LanguageCode::Thai => Self::load_from_file("th"),
+            LanguageCode::ChineseHongKong => Self::load_from_file(config_dir, "zh_hk"),
+            LanguageCode::ChineseSimplified => Self::load_from_file(config_dir, "zh_cn"),
+            LanguageCode::ChineseTaiwan => Self::load_from_file(config_dir, "zh_tw"),
+            LanguageCode::English => Self::load_from_file(config_dir, "en"),
+            LanguageCode::EnglishAsia => Self::load_from_file(config_dir, "en_asia"),
+            LanguageCode::Japanese => Self::load_from_file(config_dir, "jp"),
+            LanguageCode::Thai => Self::load_from_file(config_dir, "th"),
         }
     }
 
-    pub fn load_from_file(locale: &str) -> Result<Localizer> {
-        let path = format!("./locales/{}.toml", locale);
-        let path = PathBuf::from(path);
-        info!("load {} locale from: {}", locale, path.to_string_lossy());
+    pub fn load_from_file(config_dir: &Path, locale: &str) -> Result<Localizer> {
+        ensure!(
+            config_dir.exists(),
+            format!("config directory not found: {}", config_dir.display())
+        );
+
+        let locale_path = config_dir.join(format!("{}.toml", locale));
+        ensure!(
+            locale_path.exists(),
+            format!("locale file not found: {}", locale_path.display())
+        );
+
+        info!("load {} locale from: {}", locale, locale_path.display());
 
-        let locale_data = fs::read_to_string(&path)
-            .with_context(|| format!("Failed to open file: {}", path.display()))?;
+        let locale_data = fs::read_to_string(&locale_path)
+            .with_context(|| format!("Failed to open file: {}", locale_path.display()))?;
         debug!("loaded {}", locale_data);
 
         let localizer: Localizer = toml::from_str(&locale_data)?;

src/cli.rs

@@ -1,4 +1,4 @@
-use std::{fs, path::PathBuf, time::Instant};
+use std::{env, fs, path::Path, process::ExitCode, time::Instant};
 
 use anyhow::{bail, Result};
 use clap::Parser;
@@ -17,30 +17,52 @@ mod pack;
 mod scraper;
 mod storage;
 
-fn main() -> Result<()> {
+fn main() -> ExitCode {
     let args = Cli::parse();
     env_logger::Builder::new()
         .filter_level(args.verbose.log_level_filter())
         .init();
 
-    process_args(args)?;
-    Ok(())
+    match process_args(args) {
+        Ok(_) => ExitCode::SUCCESS,
+        Err(e) => {
+            error!("{}", e);
+            ExitCode::FAILURE
+        }
+    }
 }
 
 fn process_args(args: Cli) -> Result<()> {
+    let default_config_dir = env::current_dir()?.join("config");
+    let config_dir = args.config_directory_path.unwrap_or(default_config_dir);
+    info!("using configuration from: {}", config_dir.display());
+
     match args.command {
-        cli::Commands::Packs => list_packs(args.language),
-        cli::Commands::Cards { pack_id } => list_cards(args.language, &pack_id.to_string_lossy()),
-        cli::Commands::Interactive => interactive::show_interactive(),
+        cli::Commands::Packs => list_packs(&config_dir, args.language),
+        cli::Commands::Cards { pack_id } => {
+            list_cards(&config_dir, args.language, &pack_id.to_string_lossy())
+        }
+        cli::Commands::Interactive => interactive::show_interactive(&config_dir),
         cli::Commands::Images {
             pack_id,
             output_dir,
-        } => download_images(args.language, &pack_id.to_string_lossy(), output_dir),
+        } => download_images(
+            &config_dir,
+            args.language,
+            &pack_id.to_string_lossy(),
+            &output_dir,
+        ),
+        cli::Commands::TestConfig => Localizer::find_locales(&config_dir),
     }
 }
 
-fn download_images(language: LanguageCode, pack_id: &str, output_dir: PathBuf) -> Result<()> {
-    let localizer = Localizer::load(language)?;
+fn download_images(
+    config_dir: &Path,
+    language: LanguageCode,
+    pack_id: &str,
+    output_dir: &Path,
+) -> Result<()> {
+    let localizer = Localizer::load(config_dir, language)?;
     let scraper = OpTcgScraper::new(&localizer);
 
     if output_dir.exists() {
@@ -51,7 +73,7 @@ fn download_images(language: LanguageCode, pack_id: &str, output_dir: PathBuf) -
         );
     }
 
-    match fs::create_dir_all(&output_dir) {
+    match fs::create_dir_all(output_dir) {
         Ok(_) => info!("successfully created `{}`", output_dir.display()),
         Err(e) => bail!("failed to create `{}`: {}", output_dir.display(), e),
     }
@@ -98,8 +120,8 @@ fn download_images(language: LanguageCode, pack_id: &str, output_dir: PathBuf) -
     Ok(())
 }
 
-fn list_packs(language: LanguageCode) -> Result<()> {
-    let localizer = Localizer::load(language)?;
+fn list_packs(config_dir: &Path, language: LanguageCode) -> Result<()> {
+    let localizer = Localizer::load(config_dir, language)?;
     let scraper = OpTcgScraper::new(&localizer);
 
     info!("fetching all pack ids...");
@@ -117,8 +139,8 @@ fn list_packs(language: LanguageCode) -> Result<()> {
     Ok(())
 }
 
-fn list_cards(language: LanguageCode, pack_id: &str) -> Result<()> {
-    let localizer = Localizer::load(language)?;
+fn list_cards(config_dir: &Path, language: LanguageCode, pack_id: &str) -> Result<()> {
+    let localizer = Localizer::load(config_dir, language)?;
     let scraper = OpTcgScraper::new(&localizer);
 
     info!("fetching all cards...");