scores

config.rs (5197B)

---

 use crate::error::{AppError, Result};
 use crate::league::League;
 use clap::{CommandFactory, Parser};
 use std::fs;
 use std::path::{Path, PathBuf};
 
 #[derive(Parser, Debug)]
 #[command(name = "scores")]
 #[command(about = "Display football scores and standings from football-data.org")]
 #[command(
     after_help = "LEAGUES:\n  epl             Premier League\n  efl             Championship\n  laliga          La Liga\n  ucl             Champions League"
 )]
 pub struct Cli {
     /// API token from football-data.org (or set ~/.config/scores)
     #[arg(long, short = 't')]
     pub token: Option<String>,
 
     /// Show league standings/table
     #[arg(long, short = 's')]
     pub standings: bool,
 
     /// List all matches across every competition (default)
     #[arg(long, short = 'a')]
     pub all: bool,
 
     /// Filter by team name or abbreviation
     #[arg(long, short = 'f')]
     pub filter: Option<String>,
 
     /// League to display
     #[arg(long, short = 'l', value_name = "LEAGUE")]
     pub league: Option<String>,
 }
 
 impl Cli {
     pub fn parse_cli() -> Self {
         Self::parse()
     }
 }
 
 pub struct Config {
     pub api_token: String,
     pub league: Option<League>,
     pub show_all: bool,
     pub show_standings: bool,
     pub team_filter: Option<String>,
 }
 
 impl Config {
     pub fn from_cli(cli: &Cli) -> Result<Self> {
         let sources = TokenSources::default();
         let token_from_file = sources
             .config_path
             .as_deref()
             .and_then(read_token_from_file)
             .is_some();
 
         let Some(api_token) = resolve_token(cli.token.as_deref(), &sources) else {
             Cli::command().print_help().unwrap();
             std::process::exit(0);
         };
 
         let league = match &cli.league {
             Some(arg) => {
                 Some(League::from_arg(arg).ok_or_else(|| AppError::InvalidLeague(arg.clone()))?)
             }
             None => None,
         };
 
         Ok(Self {
             api_token,
             league,
             show_all: cli.all || token_from_file,
             show_standings: cli.standings,
             team_filter: cli.filter.clone(),
         })
     }
 }
 
 pub struct TokenSources {
     pub config_path: Option<PathBuf>,
 }
 
 impl Default for TokenSources {
     fn default() -> Self {
         Self {
             config_path: config_file_path(),
         }
     }
 }
 
 fn resolve_token(cli_token: Option<&str>, sources: &TokenSources) -> Option<String> {
     if let Some(t) = cli_token {
         return Some(t.to_string());
     }
     if let Some(path) = &sources.config_path
         && let Some(t) = read_token_from_file(path)
     {
         return Some(t);
     }
     None
 }
 
 fn read_token_from_file(path: &Path) -> Option<String> {
     let token = fs::read_to_string(path).ok()?;
     let token = token.trim().to_string();
     if token.is_empty() { None } else { Some(token) }
 }
 
 fn config_file_path() -> Option<PathBuf> {
     let home = std::env::var("HOME").ok()?;
     Some(PathBuf::from(home).join(".config").join("scores"))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     fn no_sources() -> TokenSources {
         TokenSources { config_path: None }
     }
 
     #[test]
     fn test_config_from_cli_valid() {
         let cli = Cli {
             token: Some("test-token".to_string()),
             standings: false,
             all: true,
             filter: Some("arsenal".to_string()),
             league: Some("epl".to_string()),
         };
 
         let config = Config::from_cli(&cli).unwrap();
         assert_eq!(config.api_token, "test-token");
         assert_eq!(config.league, Some(League::PremierLeague));
         assert!(config.show_all);
         assert!(!config.show_standings);
         assert_eq!(config.team_filter, Some("arsenal".to_string()));
     }
 
     #[test]
     fn test_config_no_league_defaults_to_all() {
         let cli = Cli {
             token: Some("test-token".to_string()),
             standings: false,
             all: false,
             filter: None,
             league: None,
         };
 
         let config = Config::from_cli(&cli).unwrap();
         assert_eq!(config.league, None);
     }
 
     #[test]
     fn test_config_missing_token() {
         assert_eq!(resolve_token(None, &no_sources()), None);
     }
 
     #[test]
     fn test_config_invalid_league() {
         let cli = Cli {
             token: Some("test-token".to_string()),
             standings: false,
             all: false,
             filter: None,
             league: Some("bundesliga".to_string()),
         };
 
         let result = Config::from_cli(&cli);
         assert!(matches!(result, Err(AppError::InvalidLeague(_))));
     }
 
     #[test]
     fn test_config_reads_token_from_file() {
         let dir = std::env::temp_dir().join("scores-test-home-12345");
         let config_dir = dir.join(".config");
         fs::create_dir_all(&config_dir).unwrap();
         let path = config_dir.join("scores");
         fs::write(&path, "file-token-abc").unwrap();
 
         let sources = TokenSources {
             config_path: Some(path.clone()),
         };
         let token = resolve_token(None, &sources);
         assert_eq!(token.as_deref(), Some("file-token-abc"));
 
         fs::remove_dir_all(&dir).ok();
     }
 }