daa73ab refactor: use new Git ref parser to simplify from_node_event constructor — radicle-ci-broker

radicle-ci-broker

rad:zwTxygwuz5LDGBq255RA2CbNGrz8

Radicle CI broker

refactor: use new Git ref parser to simplify from_node_event constructor

Lars Wirzenius committed 1 year ago

commit daa73ab7c22ab856941bf71d6f2777a2d98d96ec
parent 504f132

1 file changed +22 -117

modified src/ci_event.rs

@@ -12,8 +12,6 @@ use radicle::{

     storage::RefUpdate,
 };
 use crate::refs::{branch_from_namespaced, namespaced_from_str};
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 #[non_exhaustive]
 pub enum CiEvent {

@@ -191,40 +189,39 @@ impl CiEvent {

                     let e = match update {
                         RefUpdate::Created { name, oid } => {
                             let origin = originator(name.to_namespaced().unwrap())?;
                             if let Ok(patch_id) = patch_id(name) {
                                 Self::patch_created(origin, *rid, patch_id, *oid)
                             } else if let Ok(branch) = namespaced_from_str(name) {
                                 if let Ok(branch) = branch_from_namespaced(&branch) {
                             match ParsedRef::parse_ref(name) {
                                 Some(ParsedRef::Branch(branch)) => {
                                     Self::branch_created(origin, *rid, &branch, *oid)?
                                 } else {
                                     continue;
                                 }
                             } else {
                                 continue;
                                 Some(ParsedRef::Patch(patch_id)) => {
                                     Self::patch_created(origin, *rid, patch_id, *oid)
                                 }
                                 Some(ParsedRef::Tag(_tag_name)) => unimplemented!(),
                                 None => continue,
                             }
                         }
                         RefUpdate::Updated { name, old, new } => {
                             let origin = originator(name.to_namespaced().unwrap())?;
                             if let Ok(patch_id) = patch_id(name) {
                                 Self::patch_updated(origin, *rid, patch_id, *new)
                             } else if let Ok(branch) = namespaced_from_str(name) {
                                 if let Ok(branch) = branch_from_namespaced(&branch) {
                             match ParsedRef::parse_ref(name) {
                                 Some(ParsedRef::Branch(branch)) => {
                                     Self::branch_updated(origin, *rid, &branch, *new, *old)?
                                 } else {
                                     continue;
                                 }
                             } else {
                                 continue;
                                 Some(ParsedRef::Patch(patch_id)) => {
                                     Self::patch_updated(origin, *rid, patch_id, *new)
                                 }
                                 Some(ParsedRef::Tag(_tag_name)) => unimplemented!(),
                                 None => continue,
                             }
                         }
                         RefUpdate::Deleted { name, oid } => {
                             let origin = originator(name.to_namespaced().unwrap())?;
                             let branch = namespaced_from_str(name)
                                 .map_err(|err| CiEventError::branch_name(name, err))?;
                             if let Ok(branch) = branch_from_namespaced(&branch) {
                                 Self::branch_deleted(origin, *rid, &branch, *oid)?
                             } else {
                                 continue;
                             match ParsedRef::parse_ref(name) {
                                 Some(ParsedRef::Branch(branch)) => {
                                     Self::branch_deleted(origin, *rid, &branch, *oid)?
                                 }
                                 Some(ParsedRef::Patch(_patch_id)) => continue,
                                 Some(ParsedRef::Tag(_tag_name)) => unimplemented!(),
                                 None => continue,
                             }
                         }
                         RefUpdate::Skipped { .. } => continue,

@@ -296,16 +293,9 @@ pub enum CiEventError {

     #[error("failed to encode CI event as JSON")]
     ToJson(#[source] serde_json::Error),
     #[error(transparent)]
     Parwe(#[from] ParseError),
 }
 impl CiEventError {
     fn branch_name(name: &str, err: crate::refs::RefError) -> Self {
         Self::BranchName(name.into(), err)
     }
     fn read_file(filename: &Path, err: std::io::Error) -> Self {
         Self::ReadFile(filename.into(), err)
     }

@@ -330,7 +320,7 @@ mod test {

     use radicle::{prelude::NodeId, storage::RefUpdate};
     use std::str::FromStr;
     use crate::refs::ref_string;
     use crate::refs::{branch_from_namespaced, ref_string};
     const MAIN_BRANCH_REF_NAME: &str =
         "refs/namespaces/z6MkiB8T5cBEQHnrs2MgjMVqvpSVj42X81HjKfFi2XBoMbtr/refs/heads/main";

@@ -569,90 +559,6 @@ mod test {

     }
 }
 fn patch_id(refname: &str) -> Result<PatchId, ParseError> {
     const PAT_PATCH: &str = r"^refs/namespaces/[^/]+/refs/heads/patches/([^/]+)$";
     let patch_re = Regex::new(PAT_PATCH).map_err(|e| ParseError::regex(PAT_PATCH, e))?;
     if let Some(patch_captures) = patch_re.captures(refname) {
         if let Some(patch_id) = patch_captures.get(1) {
             let oid = Oid::try_from(patch_id.as_str())
                 .map_err(|e| ParseError::oid(patch_id.as_str(), e))?;
             return Ok(oid.into());
         }
     }
     Err(ParseError::not_patch(refname))
 }
 #[derive(Debug, thiserror::Error)]
 pub enum ParseError {
     #[error("programming error: unacceptable regular expression {0:?}")]
     Regex(&'static str, regex::Error),
     #[error("Git ref name without name space: {0:?}")]
     NotBranch(String),
     #[error("unacceptable Git ref for patch: {0:?}")]
     NotPatch(String),
     #[error("Git ref name includes unacceptable Git object id: {0:?}")]
     Oid(String, radicle::git::raw::Error),
     #[error("failed to create a Git branch name from {0:?}")]
     BranchName(String, #[source] crate::refs::RefError),
 }
 impl ParseError {
     fn regex(pattern: &'static str, err: regex::Error) -> Self {
         Self::Regex(pattern, err)
     }
     fn not_patch(refname: &str) -> Self {
         Self::NotPatch(refname.into())
     }
     fn oid(refname: &str, err: radicle::git::raw::Error) -> Self {
         Self::Oid(refname.into(), err)
     }
 }
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod test_patch_id {
     use super::{patch_id, Oid, ParseError};
     #[test]
     fn empty() {
         assert!(matches!(patch_id(""), Err(ParseError::NotPatch(_))));
     }
     #[test]
     fn lacks_namespace() {
         assert!(matches!(patch_id(""), Err(ParseError::NotPatch(_))));
     }
     #[test]
     fn has_namespace() {
         let x = patch_id(
             "refs/namespaces/DID/refs/heads/patches/f9fa90725474de9002be503ae3cda4670c9a1741",
         );
         assert!(x.is_ok());
         assert_eq!(
             x.unwrap(),
             Oid::try_from("f9fa90725474de9002be503ae3cda4670c9a1741")
                 .unwrap()
                 .into()
         );
     }
     #[test]
     fn has_namespace_with_path() {
         assert!(matches!(
             patch_id("refs/namespaces/DID/refs/heads/patches/coffee/beef"),
             Err(ParseError::NotPatch(_))
         ));
     }
 }
 #[derive(Debug, Eq, PartialEq)]
 #[allow(dead_code)]
 enum ParsedRef {

@@ -662,7 +568,6 @@ enum ParsedRef {

 }
 impl ParsedRef {
     #[cfg(test)]
     #[allow(clippy::unwrap_used)]
     fn parse_ref(refname: &RefString) -> Option<Self> {
         use crate::refs::branch_from_str;