WIP: add github crate

crates/forge-forgejo/src/branch/get_all.rs

@@ -6,7 +6,7 @@ use kxio::network::{self, Network};
 pub async fn get_all(
     repo_details: &git::RepoDetails,
     net: &Network,
-) -> git::branch::Result<Vec<config::BranchName>> {
+) -> Result<Vec<config::BranchName>, git::branch::Error> {
     let hostname = &repo_details.forge.hostname();
     let repo_path = &repo_details.repo_path;
     use secrecy::ExposeSecret;

crates/forge-forgejo/src/branch/mod.rs

@@ -1,3 +1,6 @@
 mod get_all;
+mod validate_positions;
 
 pub use get_all::get_all;
+
+pub use validate_positions::validate_positions;

crates/forge-forgejo/src/branch/validate_positions.rs

@@ -1,24 +1,17 @@
 //
-use crate as git;
+use crate as forgejo;
+use git::ForgeLike as _;
 use git_next_config as config;
+use git_next_git as git;
 
 use tracing::{debug, error, info, warn};
 
-pub type Result<T> = core::result::Result<T, Error>;
-
-pub struct Positions {
-    pub main: git::Commit,
-    pub next: git::Commit,
-    pub dev: git::Commit,
-    pub dev_commit_history: Vec<git::Commit>,
-}
-
 #[allow(clippy::cognitive_complexity)] // TODO: (#83) reduce complexity
 pub fn validate_positions(
+    forge: &forgejo::ForgeJo,
     repository: &git::OpenRepository,
-    repo_details: &git::RepoDetails,
     repo_config: config::RepoConfig,
-) -> Result<Positions> {
+) -> git::validation::Result {
     // Collect Commit Histories for `main`, `next` and `dev` branches
     repository.fetch()?;
     let commit_histories = get_commit_histories(repository, &repo_config);
@@ -26,7 +19,7 @@ pub fn validate_positions(
         Ok(commit_histories) => commit_histories,
         Err(err) => {
             error!(?err, "Failed to get commit histories");
-            return Err(git::validation::positions::Error::CommitLog(err));
+            return Err(git::validation::Error::CommitLog(err));
         }
     };
     // Validations
@@ -35,7 +28,7 @@ pub fn validate_positions(
             "No commits on main branch '{}'",
             repo_config.branches().main()
         );
-        return Err(git::validation::positions::Error::BranchHasNoCommits(
+        return Err(git::validation::Error::BranchHasNoCommits(
             repo_config.branches().main(),
         ));
     };
@@ -48,7 +41,7 @@ pub fn validate_positions(
             repo_config.branches().main(),
             repo_config.branches().main(),
         );
-        return Err(git::validation::positions::Error::DevBranchNotBasedOn(
+        return Err(git::validation::Error::DevBranchNotBasedOn(
             repo_config.branches().main(),
         ));
     }
@@ -58,27 +51,26 @@ pub fn validate_positions(
             "No commits on next branch '{}",
             repo_config.branches().next()
         );
-        return Err(git::validation::positions::Error::BranchHasNoCommits(
+        return Err(git::validation::Error::BranchHasNoCommits(
             repo_config.branches().next(),
         ));
     };
     let next_is_ancestor_of_dev = commit_histories.dev.iter().any(|dev| dev == &next);
     if !next_is_ancestor_of_dev {
         info!("Next is not an ancestor of dev - resetting next to main");
-        if let Err(err) = git::branch::reset(
+        if let Err(err) = forge.branch_reset(
             repository,
-            repo_details,
             repo_config.branches().next(),
             main.into(),
             git::push::Force::From(next.clone().into()),
         ) {
             warn!(?err, "Failed to reset next to main");
-            return Err(git::validation::positions::Error::FailedToResetBranch {
+            return Err(git::validation::Error::FailedToResetBranch {
                 branch: repo_config.branches().next(),
                 commit: next,
             });
         }
-        return Err(git::validation::positions::Error::BranchReset(
+        return Err(git::validation::Error::BranchReset(
             repo_config.branches().next(),
         ));
     }
@@ -95,20 +87,19 @@ pub fn validate_positions(
             repo_config.branches().main(),
             repo_config.branches().next()
         );
-        if let Err(err) = git::branch::reset(
+        if let Err(err) = forge.branch_reset(
             repository,
-            repo_details,
             repo_config.branches().next(),
             main.into(),
             git::push::Force::From(next.clone().into()),
         ) {
             warn!(?err, "Failed to reset next to main");
-            return Err(git::validation::positions::Error::FailedToResetBranch {
+            return Err(git::validation::Error::FailedToResetBranch {
                 branch: repo_config.branches().next(),
                 commit: next,
             });
         }
-        return Err(git::validation::positions::Error::BranchReset(
+        return Err(git::validation::Error::BranchReset(
             repo_config.branches().next(),
         ));
     }
@@ -117,7 +108,7 @@ pub fn validate_positions(
             "No commits on next branch '{}'",
             repo_config.branches().next()
         );
-        return Err(git::validation::positions::Error::BranchHasNoCommits(
+        return Err(git::validation::Error::BranchHasNoCommits(
             repo_config.branches().next(),
         ));
     };
@@ -131,7 +122,7 @@ pub fn validate_positions(
             repo_config.branches().dev(),
             repo_config.branches().next()
         );
-        return Err(git::validation::positions::Error::DevBranchNotBasedOn(
+        return Err(git::validation::Error::DevBranchNotBasedOn(
             repo_config.branches().next(),
         )); // dev is not based on next
     }
@@ -140,11 +131,11 @@ pub fn validate_positions(
             "No commits on dev branch '{}'",
             repo_config.branches().dev()
         );
-        return Err(git::validation::positions::Error::BranchHasNoCommits(
+        return Err(git::validation::Error::BranchHasNoCommits(
             repo_config.branches().dev(),
         ));
     };
-    Ok(git::validation::positions::Positions {
+    Ok(git::validation::Positions {
         main,
         next,
         dev,
@@ -155,7 +146,7 @@ pub fn validate_positions(
 fn get_commit_histories(
     repository: &git::repository::OpenRepository,
     repo_config: &config::RepoConfig,
-) -> git::commit::log::Result<git::commit::Histories> {
+) -> Result<git::commit::Histories, git::commit::log::Error> {
     let main = (repository.commit_log(&repo_config.branches().main(), &[]))?;
     let main_head = [main[0].clone()];
     let next = repository.commit_log(&repo_config.branches().next(), &main_head)?;
@@ -169,28 +160,3 @@ fn get_commit_histories(
     let histories = git::commit::Histories { main, next, dev };
     Ok(histories)
 }
-#[derive(Debug, derive_more::Display)]
-pub enum Error {
-    Fetch(git::fetch::Error),
-
-    CommitLog(git::commit::log::Error),
-
-    #[display("Failed to Reset Branch {branch} to {commit}")]
-    FailedToResetBranch {
-        branch: config::BranchName,
-        commit: git::Commit,
-    },
-
-    BranchReset(config::BranchName),
-
-    BranchHasNoCommits(config::BranchName),
-
-    DevBranchNotBasedOn(config::BranchName),
-}
-impl std::error::Error for Error {}
-
-impl From<git::fetch::Error> for Error {
-    fn from(value: git::fetch::Error) -> Self {
-        Self::Fetch(value)
-    }
-}

crates/forge-forgejo/src/lib.rs

@@ -4,7 +4,6 @@ mod file;
 #[cfg(test)]
 mod tests;
 
-use git::validation::repo::validate_repo;
 use git_next_config as config;
 use git_next_git as git;
 
@@ -44,6 +43,25 @@ impl git::ForgeLike for ForgeJo {
         file::contents_get(&self.repo_details, &self.net, branch, file_path).await
     }
 
+    async fn branches_validate_positions(
+        &self,
+        repository: git::OpenRepository,
+        repo_config: config::RepoConfig,
+    ) -> git::validation::Result {
+        branch::validate_positions(self, &repository, repo_config)
+    }
+
+    fn branch_reset(
+        &self,
+        repository: &git::OpenRepository,
+        branch_name: config::BranchName,
+        to_commit: git::GitRef,
+        force: git::push::Force,
+    ) -> git::push::Result {
+        repository.fetch()?;
+        repository.push(&self.repo_details, branch_name, to_commit, force)
+    }
+
     async fn commit_status(&self, commit: &git::Commit) -> git::commit::Status {
         let repo_details = &self.repo_details;
         let hostname = &repo_details.forge.hostname();
@@ -99,7 +117,7 @@ impl git::ForgeLike for ForgeJo {
             self.repo.open(&gitdir)?
         };
         info!("Validating...");
-        validate_repo(&repository, &self.repo_details)
+        git::validate(&repository, &self.repo_details)
             .map_err(|e| git::repository::Error::Validation(e.to_string()))?;
         Ok(repository)
     }

crates/forge-github/src/lib.rs

@@ -32,6 +32,27 @@ impl git_next_git::ForgeLike for Github {
         todo!();
     }
 
+    /// Assesses the relative positions of the main, next and dev branch and updates their
+    /// positions as needed.
+    async fn branches_validate_positions(
+        &self,
+        _repository: git::OpenRepository,
+        _repo_config: config::RepoConfig,
+    ) -> git::validation::Result {
+        todo!();
+    }
+
+    /// Moves a branch to a new commit.
+    fn branch_reset(
+        &self,
+        _repository: &git::OpenRepository,
+        _branch_name: config::BranchName,
+        _to_commit: git::GitRef,
+        _force: git::push::Force,
+    ) -> git::push::Result {
+        todo!();
+    }
+
     /// Checks the results of any (e.g. CI) status checks for the commit.
     async fn commit_status(&self, _commit: &git::Commit) -> git::commit::Status {
         todo!();

crates/forge/src/mock_forge.rs

@@ -27,6 +27,24 @@ impl git::ForgeLike for MockForge {
         todo!()
     }
 
+    async fn branches_validate_positions(
+        &self,
+        _repository: git::OpenRepository,
+        _repo_config: config::RepoConfig,
+    ) -> git::validation::Result {
+        todo!()
+    }
+
+    fn branch_reset(
+        &self,
+        _repository: &git::OpenRepository,
+        _branch_name: config::BranchName,
+        _to_commit: git::GitRef,
+        _force: git::push::Force,
+    ) -> git::push::Result {
+        todo!()
+    }
+
     async fn commit_status(&self, _commit: &git::Commit) -> git::commit::Status {
         todo!()
     }

crates/git/src/branch.rs

@@ -1,26 +1,6 @@
-//
-use crate as git;
-use git_next_config as config;
-
-pub type Result<T> = core::result::Result<T, Error>;
-
 #[derive(Debug, derive_more::Display, derive_more::From)]
 pub enum Error {
+    #[display("network: {}", 0)]
     Network(kxio::network::NetworkError),
-
-    Fetch(git::fetch::Error),
-
-    Push(git::push::Error),
 }
 impl std::error::Error for Error {}
-
-pub fn reset(
-    repository: &git::OpenRepository,
-    repo_details: &git::RepoDetails,
-    branch_name: config::BranchName,
-    to_commit: git::GitRef,
-    force: git::push::Force,
-) -> Result<()> {
-    repository.fetch()?;
-    Ok(repository.push(repo_details, branch_name, to_commit, force)?)
-}

crates/git/src/commit.rs

@@ -36,8 +36,6 @@ pub struct Histories {
 pub mod log {
     use derive_more::{Display, From};
 
-    pub type Result<T> = core::result::Result<T, Error>;
-
     #[derive(Debug, Display, From)]
     pub enum Error {
         Gix(String),

crates/git/src/forge_like.rs

@@ -15,6 +15,23 @@ pub trait ForgeLike {
         file_path: &str,
     ) -> Result<String, git::file::Error>;
 
+    /// Assesses the relative positions of the main, next and dev branch and updates their
+    /// positions as needed.
+    async fn branches_validate_positions(
+        &self,
+        repository: git::OpenRepository,
+        repo_config: config::RepoConfig,
+    ) -> git::validation::Result;
+
+    /// Moves a branch to a new commit.
+    fn branch_reset(
+        &self,
+        repository: &git::OpenRepository,
+        branch_name: config::BranchName,
+        to_commit: git::GitRef,
+        force: git::push::Force,
+    ) -> git::push::Result;
+
     /// Checks the results of any (e.g. CI) status checks for the commit.
     async fn commit_status(&self, commit: &git::Commit) -> git::commit::Status;
 

crates/git/src/lib.rs

@@ -11,6 +11,7 @@ mod git_remote;
 pub mod push;
 mod repo_details;
 pub mod repository;
+pub mod validate;
 pub mod validation;
 
 #[cfg(test)]
@@ -24,3 +25,4 @@ pub use git_remote::GitRemote;
 pub use repo_details::RepoDetails;
 pub use repository::OpenRepository;
 pub use repository::Repository;
+pub use validate::validate;

crates/git/src/push.rs

@@ -17,6 +17,7 @@ impl std::fmt::Display for Force {
 #[derive(Debug, derive_more::From, derive_more::Display)]
 pub enum Error {
     Open(Box<gix::open::Error>),
+    Fetch(super::fetch::Error),
     Push,
     Lock,
 }

crates/git/src/repository/tests.rs

@@ -1,12 +1,10 @@
 mod validate {
-
     use assert2::let_assert;
     use git_next_config::{ForgeDetails, GitDir, Hostname, RepoPath};
 
     use crate::{
-        repository,
+        repository::{self, Direction},
-        validation::{self, repo::validate_repo},
+        validate, GitRemote, RepoDetails,
-        GitRemote, RepoDetails,
     };
 
     #[test]
@@ -29,9 +27,8 @@ mod validate {
                 |open_repo| {
                     let_assert!(
                         Ok(_) = open_repo.lock().map(|mut open_repo| {
-                            open_repo
+                            open_repo.has_default_remote(Direction::Push, remote.clone());
-                                .has_default_remote(repository::Direction::Push, remote.clone());
+                            open_repo.has_default_remote(Direction::Fetch, remote);
-                            open_repo.has_default_remote(repository::Direction::Fetch, remote);
                         })
                     );
                 }
@@ -40,7 +37,7 @@ mod validate {
 
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
 
-        let_assert!(Ok(_) = validation::repo::validate_repo(&open_repository, &repo_details));
+        let_assert!(Ok(_) = validate(&open_repository, &repo_details));
     }
 
     #[test]
@@ -64,7 +61,7 @@ mod validate {
                     let_assert!(
                         Ok(_) = open_repo.lock().map(|mut open_repo| {
                             // INFO: open_repo.has_default_remote(Direction::Push, remote.clone());
-                            open_repo.has_default_remote(repository::Direction::Fetch, remote);
+                            open_repo.has_default_remote(Direction::Fetch, remote);
                         })
                     );
                 }
@@ -73,7 +70,7 @@ mod validate {
 
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
 
-        let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
+        let_assert!(Err(_) = validate(&open_repository, &repo_details));
     }
     #[test]
     fn should_fail_where_no_default_fetch_remote() {
@@ -95,7 +92,7 @@ mod validate {
                 |open_repo| {
                     let_assert!(
                         Ok(_) = open_repo.lock().map(|mut open_repo| {
-                            open_repo.has_default_remote(repository::Direction::Push, remote);
+                            open_repo.has_default_remote(Direction::Push, remote);
                             // INFO: open_repo.has_default_remote(Direction::Fetch, remote);
                         })
                     );
@@ -105,7 +102,7 @@ mod validate {
 
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
 
-        let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
+        let_assert!(Err(_) = validate(&open_repository, &repo_details));
     }
     #[test]
     fn should_fail_where_invalid_default_push_remote() {
@@ -131,8 +128,8 @@ mod validate {
                 |open_repo| {
                     let_assert!(
                         Ok(_) = open_repo.lock().map(|mut open_repo| {
-                            open_repo.has_default_remote(repository::Direction::Push, other_remote);
+                            open_repo.has_default_remote(Direction::Push, other_remote);
-                            open_repo.has_default_remote(repository::Direction::Fetch, remote);
+                            open_repo.has_default_remote(Direction::Fetch, remote);
                         })
                     );
                 }
@@ -141,7 +138,7 @@ mod validate {
 
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
 
-        let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
+        let_assert!(Err(_) = validate(&open_repository, &repo_details));
     }
     #[test]
     fn should_fail_where_invalid_default_fetch_remote() {
@@ -167,9 +164,8 @@ mod validate {
                 |open_repo| {
                     let_assert!(
                         Ok(_) = open_repo.lock().map(|mut open_repo| {
-                            open_repo.has_default_remote(repository::Direction::Push, remote);
+                            open_repo.has_default_remote(Direction::Push, remote);
-                            open_repo
+                            open_repo.has_default_remote(Direction::Fetch, other_remote);
-                                .has_default_remote(repository::Direction::Fetch, other_remote);
                         })
                     );
                 }
@@ -178,7 +174,7 @@ mod validate {
 
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
 
-        let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
+        let_assert!(Err(_) = validate(&open_repository, &repo_details));
     }
 }
 
@@ -186,7 +182,7 @@ mod git_clone {
     use assert2::let_assert;
     use git_next_config::{ForgeDetails, GitDir, Hostname, RepoPath};
 
-    use crate::{repository, GitRemote, RepoDetails};
+    use crate::{repository::Direction, GitRemote, RepoDetails};
 
     #[test]
     fn should_clone_repo() {
@@ -199,7 +195,7 @@ mod git_clone {
             .with_gitdir(GitDir::new(fs.base()))
             .with_repo_path(RepoPath::new("kemitix/git-next".to_string()));
         let_assert!(Ok(open_repo) = r.git_clone(&repo_details));
-        let_assert!(Some(remote) = open_repo.find_default_remote(repository::Direction::Fetch));
+        let_assert!(Some(remote) = open_repo.find_default_remote(Direction::Fetch));
         assert_eq!(
             remote,
             GitRemote::new(

crates/git/src/validate.rs

@@ -1,17 +1,15 @@
 use tracing::info;
 
-use crate as git;
+use crate::repository::{Direction, OpenRepository};
+
+use super::{GitRemote, RepoDetails};
 
 #[tracing::instrument(skip_all)]
-pub fn validate_repo(
+pub fn validate(repository: &OpenRepository, repo_details: &RepoDetails) -> Result<()> {
-    repository: &git::OpenRepository,
+    let Some(push_remote) = repository.find_default_remote(Direction::Push) else {
-    repo_details: &git::RepoDetails,
-) -> Result<()> {
-    let Some(push_remote) = repository.find_default_remote(git::repository::Direction::Push) else {
         return Err(Error::NoDefaultPushRemote);
     };
-    let Some(fetch_remote) = repository.find_default_remote(git::repository::Direction::Fetch)
+    let Some(fetch_remote) = repository.find_default_remote(Direction::Fetch) else {
-    else {
         return Err(Error::NoDefaultFetchRemote);
     };
     let git_remote = repo_details.git_remote();
@@ -42,13 +40,13 @@ pub enum Error {
     Io(std::io::Error),
     #[display("MismatchDefaultPushRemote(found: {found}, expected: {expected})")]
     MismatchDefaultPushRemote {
-        found: git::GitRemote,
+        found: GitRemote,
-        expected: git::GitRemote,
+        expected: GitRemote,
     },
     #[display("MismatchDefaultFetchRemote(found: {found}, expected: {expected})")]
     MismatchDefaultFetchRemote {
-        found: git::GitRemote,
+        found: GitRemote,
-        expected: git::GitRemote,
+        expected: GitRemote,
     },
 }
 impl std::error::Error for Error {}

crates/git/src/validation.rs

@@ -0,0 +1,37 @@
+use crate as git;
+use git_next_config::BranchName;
+
+pub type Result = core::result::Result<Positions, Error>;
+
+pub struct Positions {
+    pub main: git::Commit,
+    pub next: git::Commit,
+    pub dev: git::Commit,
+    pub dev_commit_history: Vec<git::Commit>,
+}
+
+#[derive(Debug, derive_more::Display)]
+pub enum Error {
+    Fetch(git::fetch::Error),
+
+    CommitLog(git::commit::log::Error),
+
+    #[display("Failed to Reset Branch {branch} to {commit}")]
+    FailedToResetBranch {
+        branch: BranchName,
+        commit: git::Commit,
+    },
+
+    BranchReset(BranchName),
+
+    BranchHasNoCommits(BranchName),
+
+    DevBranchNotBasedOn(BranchName),
+}
+impl std::error::Error for Error {}
+
+impl From<git::fetch::Error> for Error {
+    fn from(value: git::fetch::Error) -> Self {
+        Self::Fetch(value)
+    }
+}

crates/git/src/validation/mod.rs

@@ -1,2 +0,0 @@
-pub mod positions;
-pub mod repo;

crates/repo-actor/src/branch.rs

@@ -1,21 +1,21 @@
-//
+use std::time::Duration;
+
 use actix::prelude::*;
 
 use git_next_config as config;
+use git_next_forge as forge;
 use git_next_git as git;
 use tracing::{info, warn};
 
 use crate::{MessageToken, ValidateRepo};
 
-use std::time::Duration;
-
 // advance next to the next commit towards the head of the dev branch
 #[tracing::instrument(fields(next), skip_all)]
 pub async fn advance_next(
     next: git::Commit,
     dev_commit_history: Vec<git::Commit>,
-    repo_details: git::RepoDetails,
     repo_config: config::RepoConfig,
+    forge: forge::Forge,
     repository: git::OpenRepository,
     addr: Addr<super::RepoActor>,
     message_token: MessageToken,
@@ -30,9 +30,8 @@ pub async fn advance_next(
         return;
     }
     info!("Advancing next to commit '{}'", commit);
-    if let Err(err) = git::branch::reset(
+    if let Err(err) = forge.branch_reset(
         &repository,
-        &repo_details,
         repo_config.branches().next(),
         commit.into(),
         git::push::Force::No,
@@ -79,14 +78,13 @@ pub fn find_next_commit_on_dev(
 #[tracing::instrument(fields(next), skip_all)]
 pub async fn advance_main(
     next: git::Commit,
-    repo_details: &git::RepoDetails,
     repo_config: &config::RepoConfig,
+    forge: &forge::Forge,
     repository: &git::OpenRepository,
 ) {
     info!("Advancing main to next");
-    if let Err(err) = git::branch::reset(
+    if let Err(err) = forge.branch_reset(
         repository,
-        repo_details,
         repo_config.branches().main(),
         next.into(),
         git::push::Force::No,

crates/repo-actor/src/lib.rs

@@ -9,7 +9,6 @@ mod tests;
 use std::time::Duration;
 
 use actix::prelude::*;
-use git::validation::positions::{validate_positions, Positions};
 
 use crate as repo_actor;
 use git_next_config as config;
@@ -20,11 +19,11 @@ use kxio::network::Network;
 use tracing::{debug, info, warn, Instrument};
 
 #[derive(Debug, derive_more::Display)]
-#[display("{}:{}:{}", generation, repo_details.forge.forge_name(), repo_details.repo_alias)]
+#[display("{}:{}:{}", generation, details.forge.forge_name(), details.repo_alias)]
 pub struct RepoActor {
     generation: git::Generation,
     message_token: MessageToken,
-    repo_details: git::RepoDetails,
+    details: git::RepoDetails,
     webhook: config::server::Webhook,
     webhook_id: Option<webhook::WebhookId>, // INFO: if [None] then no webhook is configured
     webhook_auth: Option<webhook::WebhookAuth>, // INFO: if [None] then no webhook is configured
@@ -54,7 +53,7 @@ impl RepoActor {
         Self {
             generation,
             message_token: MessageToken::new(),
-            repo_details: details,
+            details,
             webhook,
             webhook_id: None,
             webhook_auth: None,
@@ -69,12 +68,12 @@ impl RepoActor {
 }
 impl Actor for RepoActor {
     type Context = Context<Self>;
-    #[tracing::instrument(name = "RepoActor::stopping", skip_all, fields(repo = %self.repo_details))]
+    #[tracing::instrument(name = "RepoActor::stopping", skip_all, fields(repo = %self.details))]
     fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
         info!("Checking webhook");
         match self.webhook_id.take() {
             Some(webhook_id) => {
-                let repo_details = self.repo_details.clone();
+                let repo_details = self.details.clone();
                 let net = self.net.clone();
                 info!(%webhook_id, "Unregistring webhook");
                 webhook::unregister(webhook_id, repo_details, net)
@@ -93,13 +92,13 @@ impl Actor for RepoActor {
 pub struct CloneRepo;
 impl Handler<CloneRepo> for RepoActor {
     type Result = ();
-    #[tracing::instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.repo_details, gitdir = %self.repo_details.gitdir))]
+    #[tracing::instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.details, gitdir = %self.details.gitdir))]
     fn handle(&mut self, _msg: CloneRepo, ctx: &mut Self::Context) -> Self::Result {
-        let gitdir = self.repo_details.gitdir.clone();
+        let gitdir = self.details.gitdir.clone();
         match self.forge.repo_clone(gitdir) {
             Ok(repository) => {
                 self.repository.replace(repository);
-                if self.repo_details.repo_config.is_none() {
+                if self.details.repo_config.is_none() {
                     ctx.address().do_send(LoadConfigFromRepo);
                 } else {
                     ctx.address().do_send(ValidateRepo {
@@ -117,9 +116,9 @@ impl Handler<CloneRepo> for RepoActor {
 pub struct LoadConfigFromRepo;
 impl Handler<LoadConfigFromRepo> for RepoActor {
     type Result = ();
-    #[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))]
+    #[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.details))]
     fn handle(&mut self, _msg: LoadConfigFromRepo, ctx: &mut Self::Context) -> Self::Result {
-        let details = self.repo_details.clone();
+        let details = self.details.clone();
         let addr = ctx.address();
         let forge = self.forge.clone();
         repo_actor::load::load_file(details, addr, forge)
@@ -134,10 +133,10 @@ impl Handler<LoadConfigFromRepo> for RepoActor {
 struct LoadedConfig(git_next_config::RepoConfig);
 impl Handler<LoadedConfig> for RepoActor {
     type Result = ();
-    #[tracing::instrument(name = "RepoActor::LoadedConfig", skip_all, fields(repo = %self.repo_details, branches = %msg.0))]
+    #[tracing::instrument(name = "RepoActor::LoadedConfig", skip_all, fields(repo = %self.details, branches = %msg.0))]
     fn handle(&mut self, msg: LoadedConfig, ctx: &mut Self::Context) -> Self::Result {
         let repo_config = msg.0;
-        self.repo_details.repo_config.replace(repo_config);
+        self.details.repo_config.replace(repo_config);
 
         ctx.address().do_send(ValidateRepo {
             message_token: self.message_token,
@@ -152,7 +151,7 @@ pub struct ValidateRepo {
 }
 impl Handler<ValidateRepo> for RepoActor {
     type Result = ();
-    #[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.message_token))]
+    #[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.details, token = %msg.message_token))]
     fn handle(&mut self, msg: ValidateRepo, ctx: &mut Self::Context) -> Self::Result {
         match msg.message_token {
             message_token if self.message_token < message_token => {
@@ -169,7 +168,7 @@ impl Handler<ValidateRepo> for RepoActor {
         }
         if self.webhook_id.is_none() {
             webhook::register(
-                self.repo_details.clone(),
+                self.details.clone(),
                 self.webhook.clone(),
                 ctx.address(),
                 self.net.clone(),
@@ -178,16 +177,18 @@ impl Handler<ValidateRepo> for RepoActor {
             .into_actor(self)
             .wait(ctx);
         }
-        if let (Some(repository), Some(repo_config)) = (
+        if let (Some(repository), Some(repo_config)) =
-            self.repository.clone(),
+            (self.repository.clone(), self.details.repo_config.clone())
-            self.repo_details.repo_config.clone(),
+        {
-        ) {
+            let forge = self.forge.clone();
-            let repo_details = self.repo_details.clone();
             let addr = ctx.address();
             let message_token = self.message_token;
             async move {
-                match validate_positions(&repository, &repo_details, repo_config) {
+                match forge
-                    Ok(Positions {
+                    .branches_validate_positions(repository, repo_config)
+                    .await
+                {
+                    Ok(git::validation::Positions {
                         main,
                         next,
                         dev,
@@ -220,10 +221,10 @@ pub struct StartMonitoring {
 impl Handler<StartMonitoring> for RepoActor {
     type Result = ();
     #[tracing::instrument(name = "RepoActor::StartMonitoring", skip_all, 
-        fields(token = %self.message_token, repo = %self.repo_details, main = %msg.main, next= %msg.next, dev = %msg.dev))
+        fields(token = %self.message_token, repo = %self.details, main = %msg.main, next= %msg.next, dev = %msg.dev))
     ]
     fn handle(&mut self, msg: StartMonitoring, ctx: &mut Self::Context) -> Self::Result {
-        let Some(repo_config) = self.repo_details.repo_config.clone() else {
+        let Some(repo_config) = self.details.repo_config.clone() else {
             warn!("No config loaded");
             return;
         };
@@ -245,8 +246,8 @@ impl Handler<StartMonitoring> for RepoActor {
                 branch::advance_next(
                     msg.next,
                     msg.dev_commit_history,
-                    self.repo_details.clone(),
                     repo_config,
+                    forge,
                     repository,
                     addr,
                     self.message_token,
@@ -264,7 +265,7 @@ impl Handler<StartMonitoring> for RepoActor {
 pub struct WebhookRegistered(webhook::WebhookId, webhook::WebhookAuth);
 impl Handler<WebhookRegistered> for RepoActor {
     type Result = ();
-    #[tracing::instrument(name = "RepoActor::WebhookRegistered", skip_all, fields(repo = %self.repo_details, webhook_id = %msg.0))]
+    #[tracing::instrument(name = "RepoActor::WebhookRegistered", skip_all, fields(repo = %self.details, webhook_id = %msg.0))]
     fn handle(&mut self, msg: WebhookRegistered, _ctx: &mut Self::Context) -> Self::Result {
         self.webhook_id.replace(msg.0);
         self.webhook_auth.replace(msg.1);
@@ -276,9 +277,9 @@ impl Handler<WebhookRegistered> for RepoActor {
 pub struct AdvanceMainTo(git::Commit);
 impl Handler<AdvanceMainTo> for RepoActor {
     type Result = ();
-    #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = %msg.0))]
+    #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.details, commit = %msg.0))]
     fn handle(&mut self, msg: AdvanceMainTo, ctx: &mut Self::Context) -> Self::Result {
-        let Some(repo_config) = self.repo_details.repo_config.clone() else {
+        let Some(repo_config) = self.details.repo_config.clone() else {
             warn!("No config loaded");
             return;
         };
@@ -286,11 +287,11 @@ impl Handler<AdvanceMainTo> for RepoActor {
             warn!("No repository opened");
             return;
         };
-        let repo_details = self.repo_details.clone();
+        let forge = self.forge.clone();
         let addr = ctx.address();
         let message_token = self.message_token;
         async move {
-            branch::advance_main(msg.0, &repo_details, &repo_config, &repository).await;
+            branch::advance_main(msg.0, &repo_config, &forge, &repository).await;
             match repo_config.source() {
                 git_next_config::RepoConfigSource::Repo => addr.do_send(LoadConfigFromRepo),
                 git_next_config::RepoConfigSource::Server => {

crates/repo-actor/src/webhook.rs

@@ -182,7 +182,7 @@ impl Handler<WebhookMessage> for RepoActor {
     type Result = ();
 
     #[allow(clippy::cognitive_complexity)] // TODO: (#49) reduce complexity
-    #[tracing::instrument(name = "RepoActor::WebhookMessage", skip_all, fields(token = %self.message_token, repo = %self.repo_details))]
+    #[tracing::instrument(name = "RepoActor::WebhookMessage", skip_all, fields(token = %self.message_token, repo = %self.details))]
     fn handle(&mut self, msg: WebhookMessage, ctx: &mut Self::Context) -> Self::Result {
         let Some(expected_authorization) = &self.webhook_auth else {
             warn!("Don't know what authorization to expect");
@@ -199,7 +199,7 @@ impl Handler<WebhookMessage> for RepoActor {
         match serde_json::from_str::<Push>(body.as_str()) {
             Err(err) => warn!(?err, ?body, "Not a 'push'"),
             Ok(push) => {
-                if let Some(config) = &self.repo_details.repo_config {
+                if let Some(config) = &self.details.repo_config {
                     match push.branch(config.branches()) {
                         None => warn!(
                             ?push,

crates/server/src/config/tests.rs

@@ -1,6 +1,6 @@
 //
 use assert2::let_assert;
-use git::{repository::Direction, validation::repo::validate_repo};
+use git::repository::Direction;
 use git_next_config::{
     self as config, ForgeType, GitDir, Hostname, RepoBranches, RepoConfig, RepoConfigSource,
     RepoPath,
@@ -46,7 +46,7 @@ fn gitdir_should_display_as_pathbuf() {
 // git.kemitix.net:kemitix/git-next
 // If the default push remote is something else, then this test will fail
 fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> {
-    let cli_crate_dir = std::env::current_dir().map_err(git::validation::repo::Error::Io)?;
+    let cli_crate_dir = std::env::current_dir().map_err(git::validate::Error::Io)?;
     let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
     let mut repo_details = git::common::repo_details(
         1,
@@ -77,7 +77,7 @@ fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> {
 
 #[test]
 fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
-    let cli_crate_dir = std::env::current_dir().map_err(git::validation::repo::Error::Io)?;
+    let cli_crate_dir = std::env::current_dir().map_err(git::validate::Error::Io)?;
     let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
     let mut repo_details = git::common::repo_details(
         1,
@@ -92,16 +92,14 @@ fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
     repo_details.repo_path = RepoPath::new("kemitix/git-next".to_string());
     let gitdir = &repo_details.gitdir;
     let repository = git::repository::new().open(gitdir)?;
-    validate_repo(&repository, &repo_details)?;
+    git::validate(&repository, &repo_details)?;
 
     Ok(())
 }
 
 #[test]
 fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> {
-    let_assert!(
+    let_assert!(Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validate::Error::Io));
-        Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validation::repo::Error::Io)
-    );
     let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
     let mut repo_details = git::common::repo_details(
         1,
@@ -113,7 +111,7 @@ fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> {
     repo_details.repo_path = RepoPath::new("hello/world".to_string());
     let gitdir = &repo_details.gitdir;
     let repository = git::repository::new().open(gitdir)?;
-    let_assert!(Err(_) = validate_repo(&repository, &repo_details));
+    let_assert!(Err(_) = git::validate(&repository, &repo_details));
 
     Ok(())
 }