stronger type for tag names — radicle-ci-broker

modified src/ci_event.rs

@@ -12,7 +12,7 @@ use radicle::{

     storage::RefUpdate,
 };
 use crate::refs::ref_string;
 use crate::refs::{ref_string, TagName};
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 #[non_exhaustive]

@@ -46,20 +46,20 @@ pub enum CiEventV1 {

     TagCreated {
         from_node: NodeId,
         repo: RepoId,
         tag: RefString,
         tag: TagName,
         tip: Oid,
     },
     TagUpdated {
         from_node: NodeId,
         repo: RepoId,
         tag: RefString,
         tag: TagName,
         tip: Oid,
         old_tip: Oid,
     },
     TagDeleted {
         from_node: NodeId,
         repo: RepoId,
         tag: RefString,
         tag: TagName,
         tip: Oid,
     },
     PatchCreated {

@@ -119,7 +119,7 @@ impl CiEvent {

         }
     }
     pub fn tag(&self) -> Option<&RefString> {
     pub fn tag(&self) -> Option<&TagName> {
         match self {
             Self::V1(CiEventV1::Shutdown) => None,
             Self::V1(CiEventV1::BranchCreated { .. }) => None,

@@ -211,7 +211,7 @@ impl CiEvent {

     pub fn tag_created(
         from_node: NodeId,
         repo: RepoId,
         tag: &RefString,
         tag: &TagName,
         tip: Oid,
     ) -> Result<Self, CiEventError> {
         assert!(!tag.starts_with("refs/"));

@@ -226,7 +226,7 @@ impl CiEvent {

     pub fn tag_updated(
         from_node: NodeId,
         repo: RepoId,
         tag: &RefString,
         tag: &TagName,
         tip: Oid,
         old_tip: Oid,
     ) -> Result<Self, CiEventError> {

@@ -243,7 +243,7 @@ impl CiEvent {

     pub fn tag_deleted(
         from_node: NodeId,
         repo: RepoId,
         tag: &RefString,
         tag: &TagName,
         tip: Oid,
     ) -> Result<Self, CiEventError> {
         assert!(!tag.starts_with("refs/"));

@@ -667,7 +667,7 @@ mod test {

 enum ParsedRef {
     Branch(BranchName),
     Patch(PatchId),
     Tag(RefString),
     Tag(TagName),
 }
 impl ParsedRef {

@@ -708,7 +708,7 @@ impl ParsedRef {

             if let Some(captures) = re.captures(refname) {
                 if let Some(tag_name) = captures.get(1) {
                     if let Ok(tag_name) = ref_string(tag_name.as_str()) {
                         return Some(ParsedRef::Tag(tag_name));
                         return Some(ParsedRef::Tag(tag_name.into()));
                     }
                 }
             }

@@ -758,6 +758,9 @@ mod test_parsed_ref {

     fn tag() {
         let actual = ref_string("refs/namespaces/NID/refs/tags/v0.0.0").unwrap();
         let wanted = ref_string("v0.0.0").unwrap();
         assert_eq!(ParsedRef::parse_ref(&actual), Some(ParsedRef::Tag(wanted)));
         assert_eq!(
             ParsedRef::parse_ref(&actual),
             Some(ParsedRef::Tag(wanted.into()))
         );
     }
 }

modified src/pages.rs

@@ -260,16 +260,16 @@ impl PageData {

                     repo,
                     tag,
                     tip,
                 }) => render_event(repo, self.repo_alias(*repo), tag, tip),
                 }) => render_event(repo, self.repo_alias(*repo), tag.as_str(), tip),
                 CiEvent::V1(CiEventV1::TagUpdated {
                     from_node: _,
                     repo,
                     tag,
                     tip,
                     old_tip: _,
                 }) => render_event(repo, self.repo_alias(*repo), tag, tip),
                 }) => render_event(repo, self.repo_alias(*repo), tag.as_str(), tip),
                 CiEvent::V1(CiEventV1::TagDeleted { repo, tag, tip, .. }) => {
                     render_event(repo, self.repo_alias(*repo), tag, tip)
                     render_event(repo, self.repo_alias(*repo), tag.as_str(), tip)
                 }
                 CiEvent::V1(CiEventV1::PatchCreated {
                     from_node: _,

modified src/refs.rs

@@ -2,11 +2,42 @@

 use std::str::FromStr;
 use serde::{Deserialize, Serialize};
 use radicle::{
     cob::patch::PatchId,
     git::{BranchName, Component, Namespaced, Qualified, RefStr, RefString},
 };
 /// A tag name.
 ///
 /// This is exactly like a [`RefString`], but meant to have stronger
 /// type safety as a separate type. It's also more self-documenting.
 #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
 pub struct TagName(RefString);
 impl TagName {
     pub fn starts_with(&self, s: &str) -> bool {
         self.as_ref().starts_with(s)
     }
     pub fn as_str(&self) -> &str {
         self.as_ref()
     }
 }
 impl From<RefString> for TagName {
     fn from(from: RefString) -> Self {
         Self(from)
     }
 }
 impl AsRef<str> for TagName {
     fn as_ref(&self) -> &str {
         self.0.as_str()
     }
 }
 /// Convert a plain branch name (`main`) from a Git ref
 pub fn branch_ref(name: &RefStr) -> Result<BranchName, RefError> {
     if name.starts_with("refs/") {