use std::collections::HashMap;
use std::fmt;
use super::option::{OptionRegistry, OptionType, OptionValue};
#[derive(Debug, Clone)]
pub enum ConfigSource {
Defaults,
Environment,
ConfigFile,
CommandLine,
}
impl fmt::Display for ConfigSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Defaults => write!(f, "defaults"),
Self::Environment => write!(f, "environment"),
Self::ConfigFile => write!(f, "config-file"),
Self::CommandLine => write!(f, "command-line"),
}
}
}
#[derive(Debug, Clone)]
pub struct ConfigError {
pub source: ConfigSource,
pub option: String,
pub message: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConfigErrorContext {
pub line: usize,
pub content: String,
}
impl fmt::Display for ConfigError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[{}] {}: {}", self.source, self.option, self.message)
}
}
pub struct ConfigParser {
options: HashMap<String, OptionValue>,
option_sources: HashMap<String, ConfigSource>,
sources: Vec<ConfigSource>,
errors: Vec<ConfigError>,
error_contexts: HashMap<usize, ConfigErrorContext>,
registry: OptionRegistry,
}
impl ConfigParser {
pub fn new() -> Self {
Self {
options: HashMap::new(),
option_sources: HashMap::new(),
sources: Vec::new(),
errors: Vec::new(),
error_contexts: HashMap::new(),
registry: OptionRegistry::new(),
}
}
pub fn with_registry(registry: OptionRegistry) -> Self {
Self {
registry,
..Self::new()
}
}
pub fn set(&mut self, name: impl Into<String>, value: OptionValue) {
let original_key = name.into();
let key = OptionRegistry::canonical_name(&original_key).to_string();
if let Some(def) = self.registry.get(&key) {
match def.parse_value(&value.to_string()) {
Ok(v) => {
self.options.insert(key.clone(), v);
self.option_sources.insert(key, ConfigSource::CommandLine);
}
Err(e) => self.errors.push(ConfigError {
source: ConfigSource::CommandLine,
option: original_key,
message: e,
}),
}
} else {
self.options.insert(key.clone(), value);
self.option_sources.insert(key, ConfigSource::CommandLine);
}
}
pub fn set_raw(&mut self, name: impl Into<String>, value: impl Into<String>) {
self.set_raw_from(name, value, ConfigSource::CommandLine);
}
fn set_raw_from(
&mut self,
name: impl Into<String>,
value: impl Into<String>,
source: ConfigSource,
) {
let original_key = name.into();
let key = OptionRegistry::canonical_name(&original_key).to_string();
let val_str = value.into();
if let Some(def) = self.registry.get(&key) {
if def.cumulative_delimiter.is_some() && self.options.contains_key(&key) {
match def.parse_value(&val_str) {
Ok(new_parsed) => {
let existing = self
.options
.get(&key)
.cloned()
.unwrap_or(new_parsed.clone());
match (existing, new_parsed) {
(
OptionValue::List(mut existing_list),
OptionValue::List(new_items),
) => {
existing_list.extend(new_items);
self.options
.insert(key.clone(), OptionValue::List(existing_list));
self.option_sources.insert(key, source.clone());
}
(OptionValue::Str(existing_str), OptionValue::Str(new_str)) => {
let delim = def.cumulative_delimiter.unwrap_or("");
let combined = existing_str + delim + &new_str;
self.options.insert(key.clone(), OptionValue::Str(combined));
self.option_sources.insert(key, source.clone());
}
(_, new) => {
self.options.insert(key.clone(), new);
self.option_sources.insert(key, source.clone());
}
}
}
Err(e) => self.errors.push(ConfigError {
source: source.clone(),
option: original_key.clone(),
message: e,
}),
}
} else {
match def.parse_value(&val_str) {
Ok(v) => {
self.options.insert(key.clone(), v);
self.option_sources.insert(key, source.clone());
}
Err(e) => self.errors.push(ConfigError {
source: source.clone(),
option: original_key.clone(),
message: e,
}),
}
}
} else {
self.options
.insert(original_key.clone(), OptionValue::Str(val_str));
self.option_sources.insert(original_key, source);
}
}
pub fn get(&self, name: &str) -> Option<&OptionValue> {
self.options.get(OptionRegistry::canonical_name(name))
}
pub fn get_str(&self, name: &str) -> Option<&str> {
self.get(name).and_then(|v| v.as_str())
}
pub fn get_i64(&self, name: &str) -> Option<i64> {
self.get(name).and_then(|v| v.as_i64())
}
pub fn get_bool(&self, name: &str) -> Option<bool> {
self.get(name).and_then(|v| v.as_bool())
}
pub fn contains(&self, name: &str) -> bool {
self.options
.contains_key(OptionRegistry::canonical_name(name))
}
pub fn option_source(&self, name: &str) -> Option<&ConfigSource> {
self.option_sources
.get(OptionRegistry::canonical_name(name))
}
pub fn parse_cli_args(&mut self, args: &[&str]) {
self.sources.push(ConfigSource::CommandLine);
let mut i = 0;
while i < args.len() {
let arg = &args[i];
if let Some(opt_name) = arg.strip_prefix("--") {
if let Some((name, value)) = opt_name.split_once('=') {
if name.starts_with("no-") && name.len() > 3 && !self.registry.contains(name) {
self.set(name[3..].to_string(), OptionValue::Bool(false));
} else {
self.set_raw(name, value);
}
} else if opt_name.starts_with("no-") && opt_name.len() > 3 {
if self.registry.contains(opt_name) {
self.set(opt_name, OptionValue::Bool(true));
} else {
let real_name = &opt_name[3..];
self.set(real_name, OptionValue::Bool(false));
}
} else if let Some(def) = self.registry.get(opt_name) {
if def.opt_type() == OptionType::Boolean {
self.set(opt_name, OptionValue::Bool(true));
} else if i + 1 < args.len() && !args[i + 1].starts_with('-') {
self.set_raw(opt_name, args[i + 1]);
i += 1;
} else {
self.errors.push(ConfigError {
source: ConfigSource::CommandLine,
option: opt_name.to_string(),
message: "option requires a value".to_string(),
});
}
} else if i + 1 < args.len() && !args[i + 1].starts_with('-') {
self.set_raw(opt_name, args[i + 1]);
i += 1;
} else {
self.set_raw(opt_name, "");
}
} else if arg.starts_with('-') && arg.len() == 2 {
let c = arg.chars().nth(1).unwrap();
let opt_name = self
.registry
.get_by_short_name(c)
.map(|def| def.name().to_string());
if let Some(name) = opt_name {
if self
.registry
.get(&name)
.is_some_and(|def| def.opt_type() != OptionType::Boolean)
&& i + 1 < args.len()
&& !args[i + 1].starts_with('-')
{
self.set_raw(&name, args[i + 1]);
i += 1;
} else if self
.registry
.get(&name)
.is_some_and(|def| def.opt_type() == OptionType::Boolean)
{
self.set(&name, OptionValue::Bool(true));
} else {
self.errors.push(ConfigError {
source: ConfigSource::CommandLine,
option: name,
message: "option requires a value".to_string(),
});
}
}
} else if let Some(rest) = arg.strip_prefix('@') {
self.parse_file(rest);
} else {
i += 1;
}
i += 1;
}
}
pub fn parse_file(&mut self, path: &str) {
self.sources.push(ConfigSource::ConfigFile);
if let Ok(content) = std::fs::read_to_string(path) {
for (line_index, source_line) in content.lines().enumerate() {
let line_number = line_index + 1;
let source_content = source_line.trim().to_string();
let line = source_content.as_str();
if line.is_empty()
|| line.starts_with('#')
|| line.starts_with('[')
|| line.starts_with(';')
{
continue;
}
let (name, value) = match line.find('=') {
Some(eq_pos) => (line[..eq_pos].trim(), line[eq_pos + 1..].trim()),
None => (line, ""),
};
if name.is_empty() {
continue;
}
let definition = self.registry.get(name);
if let Some(definition) = definition {
if !definition.is_supported() {
tracing::warn!(
"Ignoring unsupported option '{}' in config file '{}'",
name,
path
);
continue;
}
let value =
if !line.contains('=') && definition.opt_type() == OptionType::Boolean {
"true"
} else {
value
};
let error_start = self.errors.len();
self.set_raw_from(name, value, ConfigSource::ConfigFile);
for error_index in error_start..self.errors.len() {
self.error_contexts.insert(
error_index,
ConfigErrorContext {
line: line_number,
content: source_content.clone(),
},
);
}
} else {
tracing::warn!("Unknown option '{}' in config file '{}'", name, path);
if line.contains('=') {
self.set_raw_from(name, value, ConfigSource::ConfigFile);
}
}
}
}
}
pub fn parse_env_vars(&mut self) {
self.sources.push(ConfigSource::Environment);
for (key, value) in std::env::vars() {
if let Some(rest) = key.strip_prefix("ARIA2_") {
let opt_name = rest.to_lowercase().replace('_', "-");
self.set_raw_from(opt_name, &value, ConfigSource::Environment);
}
}
}
pub fn parse_proxy_env_vars(&mut self) {
self.sources.push(ConfigSource::Environment);
let proxy_vars: &[(&str, &str)] = &[
("http_proxy", "http-proxy"),
("https_proxy", "https-proxy"),
("ftp_proxy", "ftp-proxy"),
("all_proxy", "all-proxy"),
("no_proxy", "no-proxy"),
];
for (env_name, opt_name) in proxy_vars {
let value = std::env::var(env_name)
.or_else(|_| std::env::var(env_name.to_uppercase()))
.unwrap_or_default();
if !value.is_empty() {
self.set_raw(*opt_name, &value);
}
}
}
pub fn apply_defaults(&mut self) {
self.sources.push(ConfigSource::Defaults);
for def in self.registry.all().values() {
if !matches!(def.default_value(), OptionValue::None)
&& let Some(default_value) = def.parse_default_value()
{
let name = def.name().to_string();
if let std::collections::hash_map::Entry::Vacant(entry) =
self.options.entry(name.clone())
{
entry.insert(default_value);
self.option_sources.insert(name, ConfigSource::Defaults);
}
}
}
}
pub fn load_defaults_first(&mut self) {
self.apply_defaults();
let conf_path = self
.get_str("conf-path")
.map(|s| s.to_string())
.unwrap_or_default();
if !conf_path.is_empty() && std::path::Path::new(&conf_path).exists() {
self.parse_file(&conf_path);
}
self.parse_env_vars();
self.parse_proxy_env_vars();
}
pub fn options(&self) -> &HashMap<String, OptionValue> {
&self.options
}
pub fn errors(&self) -> &[ConfigError] {
&self.errors
}
pub fn error_context(&self, index: usize) -> Option<&ConfigErrorContext> {
self.error_contexts.get(&index)
}
pub fn has_errors(&self) -> bool {
!self.errors.is_empty()
}
pub fn source_count(&self) -> usize {
self.sources.len()
}
pub fn to_json_map(&self) -> serde_json::Value {
let mut map = serde_json::Map::new();
for (k, v) in &self.options {
map.insert(
k.clone(),
<&OptionValue as Into<serde_json::Value>>::into(v),
);
}
serde_json::Value::Object(map)
}
}
impl Default for ConfigParser {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_config_source_display() {
assert_eq!(ConfigSource::CommandLine.to_string(), "command-line");
assert_eq!(ConfigSource::Defaults.to_string(), "defaults");
}
#[test]
fn test_parser_creation() {
let p = ConfigParser::new();
assert_eq!(p.source_count(), 0);
assert!(!p.has_errors());
}
#[test]
fn test_set_and_get() {
let mut p = ConfigParser::new();
p.set("dir", OptionValue::Str("/downloads".into()));
assert_eq!(p.get_str("dir").unwrap(), "/downloads");
assert!(p.contains("dir"));
assert!(matches!(
p.option_source("dir"),
Some(ConfigSource::CommandLine)
));
assert!(!p.contains("nonexistent"));
}
#[test]
fn test_option_source_tracks_file_and_environment_overrides() {
let temp_dir = tempfile::tempdir().unwrap();
let config_path = temp_dir.path().join("aria2.conf");
std::fs::write(&config_path, "timeout=120\n").unwrap();
let mut parser = ConfigParser::new();
parser.apply_defaults();
parser.parse_file(config_path.to_str().unwrap());
assert_eq!(parser.get_i64("timeout"), Some(120));
assert!(matches!(
parser.option_source("timeout"),
Some(ConfigSource::ConfigFile)
));
parser.set_raw_from("timeout", "180", ConfigSource::Environment);
assert_eq!(parser.get_i64("timeout"), Some(180));
assert!(matches!(
parser.option_source("timeout"),
Some(ConfigSource::Environment)
));
}
#[test]
fn test_set_raw_string() {
let mut p = ConfigParser::new();
p.set_raw("split", "8");
assert_eq!(p.get_i64("split").unwrap(), 8);
}
#[cfg(feature = "bittorrent")]
#[test]
fn test_repeated_index_out_values_preserve_original_newline_wire_form() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--index-out=1=first.iso", "--index-out", "2=second.iso"]);
assert_eq!(p.get_str("index-out"), Some("1=first.iso\n2=second.iso"));
assert!(!p.has_errors());
}
#[test]
fn test_set_raw_bool() {
let mut p = ConfigParser::new();
p.set_raw("check-certificate", "false");
assert!(!p.get_bool("check-certificate").unwrap());
}
#[test]
fn test_parse_cli_args_basic() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--dir=/tmp", "--split=3", "--quiet"]);
assert_eq!(p.get_str("dir").unwrap(), "/tmp");
assert_eq!(p.get_i64("split").unwrap(), 3);
assert!(p.get_bool("quiet").unwrap());
}
#[test]
fn test_explicit_empty_cli_values_do_not_use_defaults() {
let mut p = ConfigParser::new();
p.apply_defaults();
p.parse_cli_args(&["--dir=", "--split="]);
assert_eq!(p.get_str("dir"), Some(""));
assert!(p.has_errors());
assert_eq!(p.get_i64("split"), Some(16));
}
#[test]
fn test_missing_value_for_non_boolean_cli_option_is_an_error() {
let mut p = ConfigParser::new();
p.apply_defaults();
p.parse_cli_args(&["--dir", "--quiet"]);
assert!(p.has_errors());
assert_eq!(p.get_str("dir"), Some("."));
assert_eq!(p.get_bool("quiet"), Some(true));
}
#[test]
fn test_config_file_explicit_empty_values_use_the_same_seam() {
let mut p = ConfigParser::new();
let temp_dir = tempfile::tempdir().unwrap();
let config_path = temp_dir.path().join("aria2.conf");
std::fs::write(&config_path, "dir=\nquiet=\nsplit=\n").unwrap();
p.parse_file(config_path.to_str().unwrap());
assert_eq!(p.get_str("dir"), Some(""));
assert_eq!(p.get_bool("quiet"), Some(true));
assert!(p.has_errors());
assert!(!p.contains("split"));
}
#[test]
fn test_parse_cli_args_no_prefix() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--no-check-certificate", "--no-continue"]);
assert!(!p.get_bool("check-certificate").unwrap());
assert!(!p.get_bool("continue").unwrap());
}
#[test]
fn test_registered_no_prefix_names_accept_their_own_values() {
let mut p = ConfigParser::new();
p.parse_cli_args(&[
"--no-proxy=localhost,127.0.0.1",
"--no-file-allocation-limit=1",
"--no-netrc=true",
"--no-want-digest-header=true",
]);
assert!(
!p.has_errors(),
"registered no-* option errors: {:?}",
p.errors()
);
assert_eq!(
p.get("no-proxy").and_then(OptionValue::as_list),
Some(&vec!["localhost".to_string(), "127.0.0.1".to_string()])
);
assert_eq!(p.get_i64("no-file-allocation-limit"), Some(1));
assert_eq!(p.get_bool("no-netrc"), Some(true));
assert_eq!(p.get_bool("no-want-digest-header"), Some(true));
}
#[test]
fn test_parse_cli_args_space_separated() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--dir", "/opt/downloads", "--out", "file.iso"]);
assert_eq!(p.get_str("dir").unwrap(), "/opt/downloads");
assert_eq!(p.get_str("out").unwrap(), "file.iso");
}
#[test]
fn test_parse_cli_boolean_flag() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["-q", "--dry-run"]);
assert!(p.get_bool("quiet").unwrap());
assert!(p.get_bool("dry-run").unwrap());
}
#[test]
fn test_apply_defaults() {
let mut p = ConfigParser::new();
p.apply_defaults();
assert_eq!(p.get_str("dir").unwrap(), ".");
assert_eq!(p.get_i64("split").unwrap(), 16);
assert!(p.get_bool("enable-color").unwrap());
}
#[test]
fn test_load_order() {
let mut p = ConfigParser::new();
p.load_defaults_first();
p.set("dir", OptionValue::Str("/override".into()));
assert_eq!(p.get_str("dir").unwrap(), "/override");
}
#[test]
fn test_to_json_map() {
let mut p = ConfigParser::new();
p.set("dir", OptionValue::Str("/tmp".into()));
p.set("split", OptionValue::Int(10));
let map = p.to_json_map();
assert!(map.get("dir").is_some());
assert!(map.get("split").is_some());
}
#[test]
fn test_error_on_invalid_integer() {
let mut p = ConfigParser::new();
p.set_raw("split", "not_a_number");
assert!(p.has_errors());
assert_eq!(p.errors()[0].option, "split");
}
#[test]
fn test_error_on_out_of_range() {
let mut p = ConfigParser::new();
p.set_raw("retry-wait", "601");
assert!(p.has_errors());
}
#[test]
fn test_error_display() {
let err = ConfigError {
source: ConfigSource::CommandLine,
option: "split".into(),
message: "value 200 exceeds maximum 128".into(),
};
let s = format!("{}", err);
assert!(s.contains("split"));
assert!(s.contains("command-line"));
}
#[test]
fn test_default_parser() {
let p = ConfigParser::default();
assert_eq!(p.source_count(), 0);
}
#[test]
fn test_d6_01_short_option_dir_maps_to_tmp() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["-d", "/tmp"]);
assert_eq!(p.get_str("dir").unwrap(), "/tmp");
}
#[test]
fn test_d6_02_short_option_split_maps_to_8() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["-s", "8"]);
assert_eq!(p.get_i64("split").unwrap(), 8);
}
#[test]
fn test_d6_03_long_option_timeout_equals_30() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--timeout=30"]);
assert_eq!(p.get_i64("timeout").unwrap(), 30);
}
#[test]
fn test_d6_04_boolean_flag_quiet_sets_true() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--quiet"]);
assert!(p.get_bool("quiet").unwrap());
}
#[test]
fn test_d6_05_list_option_header_parses_correctly() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--header=X:Y,Z:W"]);
let val = p.get("header").unwrap();
let list = val.as_list().unwrap();
assert_eq!(list.len(), 2);
assert_eq!(list[0], "X:Y");
assert_eq!(list[1], "Z:W");
}
#[test]
fn test_d6_06_unknown_option_returns_error() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--totally-nonexistent-option"]);
assert!(p.contains("totally-nonexistent-option"));
let val = p.get("totally-nonexistent-option").unwrap();
assert_eq!(val.as_str().unwrap(), "");
}
#[test]
fn test_d6_07_out_of_range_value_rejected() {
let mut p = ConfigParser::new();
p.set_raw("split", "0");
assert!(p.has_errors());
assert!(p.errors()[0].option == "split");
}
#[test]
fn test_d6_08_default_values_applied_when_not_specified() {
let mut p = ConfigParser::new();
p.apply_defaults();
assert_eq!(p.get_str("dir").unwrap(), ".");
assert_eq!(p.get_i64("split").unwrap(), 16);
assert_eq!(p.get_i64("timeout").unwrap(), 60);
assert!(!p.get_bool("quiet").unwrap());
}
#[test]
fn test_d6_09_multiple_options_parsed_together() {
let mut p = ConfigParser::new();
p.parse_cli_args(&[
"--dir=/downloads",
"--split=4",
"--timeout=30",
"--quiet",
"--out=output.bin",
]);
assert_eq!(p.get_str("dir").unwrap(), "/downloads");
assert_eq!(p.get_i64("split").unwrap(), 4);
assert_eq!(p.get_i64("timeout").unwrap(), 30);
assert!(p.get_bool("quiet").unwrap());
assert_eq!(p.get_str("out").unwrap(), "output.bin");
}
#[test]
fn test_d6_10_help_flag_skipped_without_error() {
let mut p = ConfigParser::new();
p.parse_cli_args(&["--help", "--version", "-h"]);
assert_eq!(p.source_count(), 1);
assert!(!p.has_errors());
}
}