1855817 refactor: use ergo module in trigger command — radicle-ci-broker

radicle-ci-broker

rad:zwTxygwuz5LDGBq255RA2CbNGrz8

Radicle CI broker

refactor: use ergo module in trigger command

Lars Wirzenius committed 8 months ago

commit 1855817e21141eae502c838445135f0272f1dc9f
parent 4b232bd

1 file changed +43 -72

modified src/bin/cibtoolcmd/trigger.rs

@@ -1,11 +1,9 @@

 use radicle::{
     cob::patch::{cache::Patches, Patch, PatchId},
     identity::RepoId,
     profile::Profile,
     storage::ReadStorage,
 };
 use radicle::{cob::patch::PatchId, git::BranchName, storage::git::Repository};
 use radicle_ci_broker::refs::{branch_ref, ref_string};
 use radicle_ci_broker::{
     ergo,
     refs::{branch_ref, ref_string},
 };
 use super::*;

@@ -53,41 +51,23 @@ pub struct TriggerCmd {

 impl Leaf for TriggerCmd {
     fn run(&self, args: &Args) -> Result<(), CibToolError> {
         let profile = util::load_profile()?;
         let nid = util::lookup_nid(&profile)?;
         let nid = self.node.unwrap_or(nid);
         let (rid, _repo_name) = util::lookup_repo(&profile, &self.repo)?;
         let r = ergo::Radicle::new().map_err(TriggerError::Ergonomic)?;
         let oid = if let Some(commit) = &self.commit {
             util::oid_from_cli_arg(&profile, rid, commit)?
         } else if let Some(wanted) = &self.patch {
             let mut oid = None;
             for (patch_id, patch) in patches(&profile, &rid)? {
                 if &patch_id == wanted {
                     oid = Some(*patch.head());
                     break;
                 }
             }
             oid.ok_or(TriggerError::NoSuchPatch(*wanted, rid))?
         } else {
             util::oid_from_cli_arg(&profile, rid, "HEAD")?
         };
         let profile = r.profile();
         let nid = self.node.unwrap_or(*profile.id());
         let repo = r
             .repository_by_name(&self.repo)
             .map_err(TriggerError::Ergonomic)?;
         let base = util::lookup_commit(&profile, rid, &format!("{oid}^")).unwrap_or(oid);
         let branch_name = if let Some(name) = &self.name {
             branch_ref(&ref_string(name).map_err(CibToolError::RefError)?)
                 .map_err(CibToolError::RefError)?
         } else {
             let repo = profile
                 .storage
                 .repository(rid)
                 .map_err(|err| CibToolError::RepoOpen(rid, err))?;
             let project = repo
                 .project()
                 .map_err(|err| CibToolError::GetProject(rid, err))?;
             project.default_branch().clone()
         };
         let event = CiEvent::branch_updated(nid, rid, &branch_name, oid, base)
         let oid = self.oid(&r, &repo)?;
         let base = r
             .resolve_commit(&repo.id, &format!("{oid}^"))
             .unwrap_or(oid);
         let branch_name = self.branch(&r, &repo)?;
         let event = CiEvent::branch_updated(nid, repo.id, &branch_name, oid, base)
             .map_err(CibToolError::CiEvent)?;
         if self.stdout {

@@ -112,42 +92,33 @@ impl Leaf for TriggerCmd {

     }
 }
 pub fn patches(profile: &Profile, repo_id: &RepoId) -> Result<Vec<(PatchId, Patch)>, TriggerError> {
     let repo = profile
         .storage
         .repository(*repo_id)
         .map_err(|err| TriggerError::LoadRepo(*repo_id, Box::new(err)))?;
     let patches = profile
         .home
         .patches(&repo)
         .map_err(|err| TriggerError::LoadPathces(*repo_id, Box::new(err)))?;
     let mut items = vec![];
     let list = patches
         .list()
         .map_err(|err| TriggerError::ListCache(*repo_id, err))?;
     for result in list {
         let (id, patch) = result.map_err(|err| TriggerError::CacheListItem(*repo_id, err))?;
         items.push((id, patch));
 impl TriggerCmd {
     fn oid(&self, r: &ergo::Radicle, repo: &Repository) -> Result<Oid, TriggerError> {
         let oid = if let Some(commit) = &self.commit {
             r.resolve_commit(&repo.id, commit)?
         } else if let Some(wanted) = &self.patch {
             *r.patch(&repo.id, wanted)?.head()
         } else {
             r.resolve_commit(&repo.id, "HEAD")?
         };
         Ok(oid)
     }
     fn branch(&self, r: &ergo::Radicle, repo: &Repository) -> Result<BranchName, TriggerError> {
         if let Some(name) = &self.name {
             Ok(branch_ref(&ref_string(name)?)?)
         } else {
             let project = r.project(&repo.id).map_err(TriggerError::Ergonomic)?;
             Ok(project.default_branch().clone())
         }
     }
     Ok(items)
 }
 #[derive(Debug, thiserror::Error)]
 pub enum TriggerError {
     #[error("failed to load info from Radicle node storage for repository {0}")]
     LoadRepo(RepoId, #[source] Box<radicle::storage::RepositoryError>),
     #[error("failed to load patch list from Radicle node storage for repository {0}")]
     LoadPathces(RepoId, #[source] Box<radicle::profile::Error>),
     #[error("failed to list patches for repository {0}")]
     ListCache(RepoId, #[source] radicle::patch::cache::Error),
     #[error("failed to list info for patch {0}")]
     CacheListItem(RepoId, #[source] radicle::patch::cache::Error),
     #[error(transparent)]
     Ergonomic(#[from] radicle_ci_broker::ergo::ErgoError),
     #[error("can't find patch {0} in repository {1}")]
     NoSuchPatch(PatchId, RepoId),
     #[error(transparent)]
     RefError(#[from] radicle_ci_broker::refs::RefError),
 }