use std::{ collections::HashMap, fmt::{Display, Formatter}, }; use secrecy::ExposeSecret; use serde::Deserialize; use terrors::OneOf; use crate::filesystem::FileSystem; /// Mapped from the `git-next-server.toml` file #[derive(Debug, PartialEq, Eq, Deserialize)] pub struct ServerConfig { forge: HashMap, } impl ServerConfig { pub(crate) fn load(fs: &FileSystem) -> Result> { let str = fs.read_file("git-next-server.toml").map_err(OneOf::new)?; toml::from_str(&str).map_err(OneOf::new) } pub(crate) fn forges(&self) -> impl Iterator { self.forge .iter() .map(|(name, forge)| (ForgeName(name.clone()), forge)) } } /// Mapped from `.git-next.toml` file in target repo /// Is also derived from the optional parameters in `git-next-server.toml` at /// `forge.{forge}.repos.{repo}.(main|next|dev)` #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] pub struct RepoConfig { branches: RepoBranches, } impl RepoConfig { #[allow(dead_code)] pub(crate) fn load(toml: &str) -> Result> { toml::from_str(toml).map_err(OneOf::new) } pub(crate) const fn branches(&self) -> &RepoBranches { &self.branches } } impl Display for RepoConfig { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self.branches) } } /// Mapped from `.git-next.toml` file at `branches` #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] pub struct RepoBranches { main: String, next: String, dev: String, } impl RepoBranches { pub fn main(&self) -> BranchName { BranchName(self.main.clone()) } pub fn next(&self) -> BranchName { BranchName(self.next.clone()) } pub fn dev(&self) -> BranchName { BranchName(self.dev.clone()) } } impl Display for RepoBranches { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self) } } /// Defines a Forge to connect to /// Maps from `git-next-server.toml` at `forge.{forge}` #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] pub struct Forge { forge_type: ForgeType, hostname: String, user: String, token: String, // API Token // Private SSH Key Path repos: HashMap, } impl Forge { #[allow(dead_code)] pub const fn forge_type(&self) -> &ForgeType { &self.forge_type } pub fn hostname(&self) -> Hostname { Hostname(self.hostname.clone()) } pub fn user(&self) -> User { User(self.user.clone()) } pub fn token(&self) -> ApiToken { ApiToken(self.token.clone().into()) } pub fn repos(&self) -> impl Iterator { self.repos .iter() .map(|(name, repo)| (RepoName(name.clone()), repo)) } } impl Display for Forge { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{} - {}@{}", self.forge_type, self.user, self.hostname) } } /// Defines a Repo within a Forge to be monitored by the server /// Maps from `git-next-server.toml` at `forge.{forge}.repos.{name}` #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] pub struct Repo { repo: String, branch: String, } impl Repo { #[allow(dead_code)] pub fn repo(&self) -> RepoPath { RepoPath(self.repo.clone()) } #[allow(dead_code)] pub fn branch(&self) -> BranchName { BranchName(self.branch.clone()) } } #[cfg(test)] impl AsRef for Repo { fn as_ref(&self) -> &Self { self } } impl Display for Repo { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{} - {}", self.repo, self.branch) } } /// The name of a Forge to connect to #[derive(Clone, Debug, PartialEq, Eq)] pub struct ForgeName(pub String); impl Display for ForgeName { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) } } /// The hostname of a forge #[derive(Clone, Debug, PartialEq, Eq)] pub struct Hostname(pub String); impl Display for Hostname { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) } } /// The user within the forge to connect as #[derive(Clone, Debug, PartialEq, Eq)] pub struct User(pub String); impl Display for User { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) } } /// The API Token for the [user] /// ForgeJo: https://{hostname}/user/settings/applications /// Github: https://github.com/settings/tokens #[derive(Clone, Debug)] pub struct ApiToken(pub secrecy::Secret); impl From for ApiToken { fn from(value: String) -> Self { Self(value.into()) } } /// The API Token is in effect a password, so it must be explicitly exposed to access its value impl ExposeSecret for ApiToken { fn expose_secret(&self) -> &String { self.0.expose_secret() } } /// The derived information about a Forge, used to create interactions with it #[derive(Clone, Debug)] pub struct ForgeDetails { pub name: ForgeName, pub forge_type: ForgeType, pub hostname: Hostname, pub user: User, pub token: ApiToken, // API Token // Private SSH Key Path } impl From<(&ForgeName, &Forge)> for ForgeDetails { fn from(forge: (&ForgeName, &Forge)) -> Self { Self { name: forge.0.clone(), forge_type: forge.1.forge_type.clone(), hostname: forge.1.hostname(), user: forge.1.user(), token: forge.1.token(), } } } /// The name of a repo // TODO: (#39) rename as RepoAlias /// This is the alias for the repo within `git-next-server.toml` #[derive(Clone, Debug, PartialEq, Eq)] pub struct RepoName(pub String); impl Display for RepoName { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) } } /// The path for the repo within the forge. /// Typically this is composed of the user or organisation and the name of the repo /// e.g. `{user}/{repo}` #[derive(Clone, Debug, PartialEq, Eq)] pub struct RepoPath(pub String); impl Display for RepoPath { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) } } /// The name of a Branch #[derive(Clone, Debug, Hash, PartialEq, Eq)] pub struct BranchName(pub String); impl Display for BranchName { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) } } /// The derived information about a repo, used to interact with it #[derive(Clone, Debug)] pub struct RepoDetails { pub name: RepoName, pub repo: RepoPath, pub branch: BranchName, pub forge: ForgeDetails, } impl RepoDetails { pub fn new(name: &RepoName, repo: &Repo, forge_name: &ForgeName, forge: &Forge) -> Self { Self { name: name.clone(), repo: RepoPath(repo.repo.clone()), branch: BranchName(repo.branch.clone()), forge: ForgeDetails { name: forge_name.clone(), forge_type: forge.forge_type.clone(), hostname: forge.hostname(), user: forge.user(), token: forge.token(), }, } } } impl Display for RepoDetails { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!( f, "{}/{} ({}): {}:{}/{} @ {}", self.forge.name, self.name, self.forge.forge_type, self.forge.hostname, self.forge.user, self.repo, self.branch, ) } } /// Identifier for the type of Forge #[derive(Clone, Debug, PartialEq, Eq, Deserialize)] pub enum ForgeType { #[cfg(feature = "forgejo")] ForgeJo, // Gitea, // GitHub, // GitLab, // BitBucket, #[cfg(test)] MockForge, } impl Display for ForgeType { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self) } } #[cfg(feature = "forgejo")] #[cfg(test)] mod tests { use crate::filesystem::FileSystem; use super::*; #[test] #[cfg(feature = "forgejo")] fn test_server_config_load() -> Result<(), OneOf<(std::io::Error, toml::de::Error)>> { let fs = FileSystem::new_temp().map_err(OneOf::new)?; fs.write_file( "git-next-server.toml", r#" [forge.default] forge_type = "ForgeJo" hostname = "git.example.net" user = "Bob" token = "API-Token" [forge.default.repos] hello = { repo = "user/hello", branch = "main" } world = { repo = "user/world", branch = "master" } "#, ) .map_err(OneOf::new)?; let config = ServerConfig::load(&fs)?; let expected = ServerConfig { forge: HashMap::from([( "default".to_string(), Forge { forge_type: ForgeType::ForgeJo, hostname: "git.example.net".to_string(), user: "Bob".to_string(), token: "API-Token".to_string(), repos: HashMap::from([ ( "hello".to_string(), Repo { repo: "user/hello".to_string(), branch: "main".to_string(), }, ), ( "world".to_string(), Repo { repo: "user/world".to_string(), branch: "master".to_string(), }, ), ]), }, )]), }; assert_eq!(config, expected); Ok(()) } #[test] fn test_repo_config_load() -> Result<(), OneOf<(toml::de::Error,)>> { let toml = r#" [branches] main = "main" next = "next" dev = "dev" [options] "#; let config = RepoConfig::load(toml)?; assert_eq!( config, RepoConfig { branches: RepoBranches { main: "main".to_string(), next: "next".to_string(), dev: "dev".to_string(), }, } ); Ok(()) } }