use std::{fs, path::Path};
use indexmap::IndexMap;
pub mod paths;
pub use paths::{ConfigDirSource, ConfigPaths, PathEnv};
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Config {
#[serde(default)]
pub default_profile: Option<String>,
#[serde(default)]
pub profiles: IndexMap<String, Profile>,
}
impl Config {
pub fn load_from(path: &Path) -> Result<Self> {
Self::read(path)
}
pub fn load<P: AsRef<Path>>(path: Option<P>) -> Result<Self> {
let path = match path {
Some(p) => p.as_ref().to_path_buf(),
None => ConfigPaths::resolve()?.config_file(),
};
Self::read(&path)
}
fn read(path: &Path) -> Result<Self> {
if !path.exists() {
return Ok(Config::default());
}
let raw = fs::read_to_string(path)
.with_context(|| format!("Unable to read config file at {}", path.display()))?;
yaml_serde::from_str(&raw)
.with_context(|| format!("Malformed YAML in config file {}", path.display()))
}
pub fn save_to(&self, path: &Path) -> Result<()> {
if let Some(parent) = path.parent() {
paths::create_private_dir(parent)?;
}
let serialized = yaml_serde::to_string(self)?;
paths::write_private(path, serialized.as_bytes())
}
pub fn save<P: AsRef<Path>>(&self, path: Option<P>) -> Result<()> {
let path = match path {
Some(p) => p.as_ref().to_path_buf(),
None => ConfigPaths::resolve()?.config_file(),
};
self.save_to(&path)
}
pub fn profile(&self, name: &str) -> Option<&Profile> {
self.profiles.get(name)
}
pub fn resolve_profile<'a>(
&'a self,
requested: Option<&'a str>,
) -> Option<(&'a str, &'a Profile)> {
if let Some(name) = requested {
self.profiles.get(name).map(|profile| (name, profile))
} else if let Some(default_name) = self.default_profile.as_deref() {
self.profiles
.get(default_name)
.map(|profile| (default_name, profile))
} else if let Some((name, profile)) = self.profiles.iter().next() {
Some((name.as_str(), profile))
} else {
None
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Profile {
pub base_url: Option<String>,
pub email: Option<String>,
pub api_token: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub workspace: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bitbucket_token_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opsgenie_api_key: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opsgenie_region: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bamboo_base_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bitbucket_remote: Option<String>,
}
const WIKI_SUFFIX: &str = "/wiki";
pub fn site_base_url(base_url: &str) -> &str {
let trimmed = base_url.trim_end_matches('/');
let split = trimmed.len().saturating_sub(WIKI_SUFFIX.len());
if trimmed.len() >= WIKI_SUFFIX.len()
&& trimmed.is_char_boundary(split)
&& trimmed[split..].eq_ignore_ascii_case(WIKI_SUFFIX)
{
return &trimmed[..split];
}
trimmed
}
impl Profile {
pub fn site_base_url(&self) -> Option<&str> {
self.base_url.as_deref().map(site_base_url)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn example_config_file_parses() {
let path = concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../configs/config.example.yaml"
);
let raw = std::fs::read_to_string(path).expect("configs/config.example.yaml exists");
let config: Config = yaml_serde::from_str(&raw).expect("example config parses");
assert_eq!(config.default_profile.as_deref(), Some("personal"));
let personal = config.profiles.get("personal").expect("personal profile");
assert_eq!(
personal.base_url.as_deref(),
Some("https://example.atlassian.net")
);
}
use std::io::Write;
use tempfile::NamedTempFile;
#[test]
fn test_config_default() {
let config = Config::default();
assert!(config.default_profile.is_none());
assert!(config.profiles.is_empty());
}
#[test]
fn test_load_missing_file() {
let result = Config::load(Some("/nonexistent/config.yaml"));
assert!(result.is_ok());
let config = result.unwrap();
assert!(config.profiles.is_empty());
}
#[test]
fn test_save_and_load() {
let mut config = Config {
default_profile: Some("work".to_string()),
..Default::default()
};
let profile = Profile {
base_url: Some("https://test.atlassian.net".to_string()),
email: Some("test@example.com".to_string()),
..Default::default()
};
config.profiles.insert("work".to_string(), profile);
let temp_file = NamedTempFile::new().unwrap();
let temp_path = temp_file.path();
config.save(Some(temp_path)).unwrap();
let loaded = Config::load(Some(temp_path)).unwrap();
assert_eq!(loaded.default_profile, Some("work".to_string()));
assert_eq!(loaded.profiles.len(), 1);
let work_profile = loaded.profiles.get("work").unwrap();
assert_eq!(
work_profile.base_url,
Some("https://test.atlassian.net".to_string())
);
assert_eq!(work_profile.email, Some("test@example.com".to_string()));
}
#[test]
fn test_load_malformed_yaml() {
let mut temp_file = NamedTempFile::new().unwrap();
write!(temp_file, "invalid: yaml: [unclosed").unwrap();
let result = Config::load(Some(temp_file.path()));
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("Malformed YAML"));
}
#[test]
fn test_profile_retrieval() {
let mut config = Config::default();
let profile = Profile {
base_url: Some("https://test.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("test".to_string(), profile);
assert!(config.profile("test").is_some());
assert!(config.profile("nonexistent").is_none());
}
#[test]
fn test_resolve_profile_requested() {
let mut config = Config {
default_profile: Some("default".to_string()),
..Default::default()
};
let default_profile = Profile {
base_url: Some("https://default.atlassian.net".to_string()),
..Default::default()
};
config
.profiles
.insert("default".to_string(), default_profile);
let work_profile = Profile {
base_url: Some("https://work.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("work".to_string(), work_profile);
let (name, profile) = config.resolve_profile(Some("work")).unwrap();
assert_eq!(name, "work");
assert_eq!(
profile.base_url,
Some("https://work.atlassian.net".to_string())
);
}
#[test]
fn test_resolve_profile_default() {
let mut config = Config {
default_profile: Some("default".to_string()),
..Default::default()
};
let default_profile = Profile {
base_url: Some("https://default.atlassian.net".to_string()),
..Default::default()
};
config
.profiles
.insert("default".to_string(), default_profile);
let (name, profile) = config.resolve_profile(None).unwrap();
assert_eq!(name, "default");
assert_eq!(
profile.base_url,
Some("https://default.atlassian.net".to_string())
);
}
#[test]
fn test_resolve_profile_first_available() {
let mut config = Config::default();
let profile = Profile {
base_url: Some("https://only.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("only".to_string(), profile);
let result = config.resolve_profile(None);
assert!(result.is_some());
let (name, profile) = result.unwrap();
assert_eq!(name, "only");
assert_eq!(
profile.base_url,
Some("https://only.atlassian.net".to_string())
);
}
#[test]
fn test_resolve_profile_none_available() {
let config = Config::default();
assert!(config.resolve_profile(None).is_none());
}
#[test]
fn test_resolve_profile_nonexistent_requested() {
let mut config = Config::default();
let profile = Profile {
base_url: Some("https://test.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("test".to_string(), profile);
assert!(config.resolve_profile(Some("nonexistent")).is_none());
}
#[test]
fn test_profile_default() {
let profile = Profile::default();
assert!(profile.base_url.is_none());
assert!(profile.email.is_none());
assert!(profile.api_token.is_none());
}
#[test]
fn test_indexmap_preserves_insertion_order() {
let mut config = Config::default();
let profile1 = Profile {
base_url: Some("https://first.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("first".to_string(), profile1);
let profile2 = Profile {
base_url: Some("https://second.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("second".to_string(), profile2);
let profile3 = Profile {
base_url: Some("https://third.atlassian.net".to_string()),
..Default::default()
};
config.profiles.insert("third".to_string(), profile3);
let names: Vec<_> = config.profiles.keys().map(|s| s.as_str()).collect();
assert_eq!(names, vec!["first", "second", "third"]);
}
#[test]
fn test_resolve_profile_first_available_is_deterministic() {
let mut config = Config::default();
config.profiles.insert(
"alpha".to_string(),
Profile {
base_url: Some("https://alpha.atlassian.net".to_string()),
..Default::default()
},
);
config.profiles.insert(
"beta".to_string(),
Profile {
base_url: Some("https://beta.atlassian.net".to_string()),
..Default::default()
},
);
config.profiles.insert(
"gamma".to_string(),
Profile {
base_url: Some("https://gamma.atlassian.net".to_string()),
..Default::default()
},
);
for _ in 0..10 {
let (name, _) = config.resolve_profile(None).unwrap();
assert_eq!(
name, "alpha",
"First profile should always be selected deterministically"
);
}
}
#[test]
fn test_shift_remove_preserves_order() {
let mut config = Config::default();
config.profiles.insert("a".to_string(), Profile::default());
config.profiles.insert("b".to_string(), Profile::default());
config.profiles.insert("c".to_string(), Profile::default());
config.profiles.shift_remove("b");
let names: Vec<_> = config.profiles.keys().map(|s| s.as_str()).collect();
assert_eq!(
names,
vec!["a", "c"],
"Order should be preserved after removal"
);
}
#[test]
fn test_yaml_serialization() {
let mut config = Config {
default_profile: Some("prod".to_string()),
..Default::default()
};
let profile = Profile {
base_url: Some("https://prod.atlassian.net".to_string()),
email: Some("admin@example.com".to_string()),
api_token: Some("secret-token-123".to_string()),
..Default::default()
};
config.profiles.insert("prod".to_string(), profile);
let yaml = yaml_serde::to_string(&config).unwrap();
assert!(yaml.contains("default_profile: prod"));
assert!(yaml.contains("https://prod.atlassian.net"));
assert!(yaml.contains("admin@example.com"));
assert!(yaml.contains("secret-token-123"));
let deserialized: Config = yaml_serde::from_str(&yaml).unwrap();
assert_eq!(deserialized.default_profile, config.default_profile);
assert_eq!(deserialized.profiles.len(), 1);
}
#[test]
fn test_profile_bitbucket_token_type_default_none() {
let profile = Profile::default();
assert!(profile.bitbucket_token_type.is_none());
}
#[test]
fn test_profile_bitbucket_token_type_bearer() {
let profile = Profile {
bitbucket_token_type: Some("bearer".to_string()),
..Default::default()
};
assert_eq!(profile.bitbucket_token_type.as_deref(), Some("bearer"));
}
#[test]
fn test_profile_bitbucket_token_type_skipped_when_none() {
let profile = Profile {
email: Some("test@example.com".to_string()),
..Default::default()
};
let yaml = yaml_serde::to_string(&profile).unwrap();
assert!(!yaml.contains("bitbucket_token_type"));
}
#[test]
fn test_profile_bitbucket_token_type_serialized_when_set() {
let profile = Profile {
email: Some("test@example.com".to_string()),
bitbucket_token_type: Some("bearer".to_string()),
..Default::default()
};
let yaml = yaml_serde::to_string(&profile).unwrap();
assert!(yaml.contains("bitbucket_token_type: bearer"));
}
#[test]
fn test_profile_backwards_compat_missing_token_type() {
let yaml = "email: test@example.com\nworkspace: myteam\n";
let profile: Profile = yaml_serde::from_str(yaml).unwrap();
assert!(profile.bitbucket_token_type.is_none());
assert_eq!(profile.email.as_deref(), Some("test@example.com"));
assert_eq!(profile.workspace.as_deref(), Some("myteam"));
}
#[test]
fn test_config_with_bearer_profile_roundtrip() {
let mut config = Config {
default_profile: Some("ci".to_string()),
..Default::default()
};
let profile = Profile {
workspace: Some("myteam".to_string()),
bitbucket_token_type: Some("bearer".to_string()),
..Default::default()
};
config.profiles.insert("ci".to_string(), profile);
let temp_file = NamedTempFile::new().unwrap();
config.save(Some(temp_file.path())).unwrap();
let loaded = Config::load(Some(temp_file.path())).unwrap();
let ci_profile = loaded.profiles.get("ci").unwrap();
assert_eq!(ci_profile.bitbucket_token_type.as_deref(), Some("bearer"));
assert_eq!(ci_profile.workspace.as_deref(), Some("myteam"));
assert!(ci_profile.email.is_none());
}
#[test]
fn a_trailing_wiki_is_stripped_from_a_site_base_url() {
assert_eq!(
site_base_url("https://site.atlassian.net/wiki"),
"https://site.atlassian.net"
);
assert_eq!(
site_base_url("https://site.atlassian.net/wiki/"),
"https://site.atlassian.net"
);
}
#[test]
fn a_site_root_is_left_alone() {
assert_eq!(
site_base_url("https://site.atlassian.net"),
"https://site.atlassian.net"
);
assert_eq!(
site_base_url("https://site.atlassian.net/"),
"https://site.atlassian.net"
);
}
#[test]
fn a_path_that_merely_ends_in_wiki_is_left_alone() {
assert_eq!(
site_base_url("https://example.com/mywiki"),
"https://example.com/mywiki"
);
assert_eq!(
site_base_url("https://wiki.example.com"),
"https://wiki.example.com"
);
}
#[test]
fn only_one_wiki_segment_is_removed() {
assert_eq!(
site_base_url("https://site.atlassian.net/wiki/wiki"),
"https://site.atlassian.net/wiki"
);
}
#[test]
fn repeated_trailing_slashes_do_not_hide_the_suffix() {
assert_eq!(
site_base_url("https://site.atlassian.net/wiki//"),
"https://site.atlassian.net"
);
assert_eq!(
site_base_url("https://site.atlassian.net//"),
"https://site.atlassian.net"
);
}
#[test]
fn the_suffix_match_ignores_case() {
assert_eq!(
site_base_url("https://site.atlassian.net/WIKI"),
"https://site.atlassian.net"
);
assert_eq!(
site_base_url("https://site.atlassian.net/Wiki/"),
"https://site.atlassian.net"
);
}
#[test]
fn degenerate_input_does_not_panic() {
assert_eq!(site_base_url("/wiki"), "");
assert_eq!(site_base_url(""), "");
assert_eq!(site_base_url("/"), "");
assert_eq!(site_base_url("wiki"), "wiki");
assert_eq!(site_base_url("https://x/päge"), "https://x/päge");
}
#[test]
fn the_gateway_form_reduces_to_its_cloud_id_root() {
assert_eq!(
site_base_url("https://api.atlassian.com/ex/confluence/cloud-id/wiki"),
"https://api.atlassian.com/ex/confluence/cloud-id"
);
assert_eq!(
site_base_url("https://api.atlassian.com/ex/jira/cloud-id"),
"https://api.atlassian.com/ex/jira/cloud-id"
);
}
#[test]
fn an_unrelated_context_path_survives() {
assert_eq!(
site_base_url("https://example.com/bamboo"),
"https://example.com/bamboo"
);
}
#[test]
fn the_profile_accessor_follows_the_same_rule() {
let profile = Profile {
base_url: Some("https://site.atlassian.net/wiki/".to_string()),
..Default::default()
};
assert_eq!(profile.site_base_url(), Some("https://site.atlassian.net"));
assert_eq!(Profile::default().site_base_url(), None);
}
}