refactor: improve names for errors indicating missing fields

SKalt · SKalt · commit 734f6dbf83d8 · 2024-02-11T11:51:54.000-05:00
diff --git a/src/ambiguous/domain_or_tagged_ref.rs b/src/ambiguous/domain_or_tagged_ref.rs
@@ -80,7 +80,7 @@ fn map_err(e: err::Error<u8>) -> err::Error<u16> {
 impl<'src> DomainOrRefSpan<'src> {
     pub(crate) fn new(src: &'src str) -> Result<Self, Error> {
         let left = HostOrPathSpan::new(src, HostOrPathKind::Any)?
-            .ok_or(Error::at(0, err::Kind::HostOrPathNoMatch))?;
+            .ok_or(Error::at(0, err::Kind::HostOrPathMissing))?;
         let right_src = &src[left.len()..];
         let right = match right_src.bytes().next() {
             Some(b':') => {
@@ -151,7 +151,7 @@ impl<'src> DomainOrRefSpan<'src> {
                         Any => {
                             return Err(Error::at(
                                 len.try_into().unwrap(),
-                                err::Kind::HostOrPathNoMatch,
+                                err::Kind::HostOrPathMissing,
                             ))
                         }
                     }
diff --git a/src/digest/algorithm.rs b/src/digest/algorithm.rs
@@ -36,7 +36,7 @@ impl_span_methods_on_tuple!(AlgorithmSpan, u8, NonZeroU8);
 
 type Error = err::Error<u16>;
 use err::Kind::{
-    AlgorithmInvalidChar, AlgorithmInvalidNumericPrefix, AlgorithmNoMatch, InvalidOciAlgorithm,
+    AlgorithmInvalidChar, AlgorithmInvalidNumericPrefix, AlgorithmMissing, InvalidOciAlgorithm,
 };
 fn try_add(a: NonZeroU8, b: u8) -> Result<NonZeroU8, Error> {
     a.checked_add(b)
@@ -49,7 +49,7 @@ pub const ALGORITHM_MAX_LEN: u8 = u8::MAX;
 impl<'src> AlgorithmSpan<'src> {
     pub(crate) fn new(src: &'src str) -> Result<(Self, Compliance), Error> {
         let (mut len, mut compliance) =
-            component(src, Compliance::Universal)?.ok_or(Error::at(0, AlgorithmNoMatch))?;
+            component(src, Compliance::Universal)?.ok_or(Error::at(0, AlgorithmMissing))?;
         let max_len = src.len().try_into().unwrap_or(ALGORITHM_MAX_LEN);
         loop {
             if u8::from(len) >= max_len {
@@ -65,7 +65,7 @@ impl<'src> AlgorithmSpan<'src> {
             }
             let (component_len, component_compliance) =
                 component(&src[len.as_usize()..], compliance)?
-                    .ok_or(Error::at(u8::from(len).into(), AlgorithmNoMatch))?;
+                    .ok_or(Error::at(u8::from(len).into(), AlgorithmMissing))?;
             len = try_add(len, component_len.into())?;
             compliance = component_compliance; // narrow compliance from Universal -> (Oci | Distribution)
         }
@@ -76,7 +76,7 @@ impl<'src> AlgorithmSpan<'src> {
         if span.len() == src.len() {
             Ok((span, compliance))
         } else {
-            Error::at(span.short_len().upcast().into(), AlgorithmNoMatch).into()
+            Error::at(span.short_len().upcast().into(), AlgorithmMissing).into()
         }
     }
 }
diff --git a/src/digest/mod.rs b/src/digest/mod.rs
@@ -92,13 +92,13 @@ impl<'src> DigestSpan<'src> {
         let rest = &src[len.as_usize()..];
         len = match rest.bytes().next() {
             Some(b':') => len.checked_add(1).ok_or(err::Kind::AlgorithmTooLong),
-            None => Err(err::Kind::AlgorithmNoMatch),
+            None => Err(err::Kind::AlgorithmMissing),
             _ => Err(err::Kind::AlgorithmInvalidChar),
         }
         .map_err(|kind| Error::at(len.into(), kind))?;
         let rest = &src[len.as_usize()..];
         let (encoded, compliance) = EncodedSpan::new(rest, compliance)?
-            .ok_or(Error::at(len.into(), err::Kind::EncodedNoMatch))?;
+            .ok_or(Error::at(len.into(), err::Kind::EncodedMissing))?;
 
         {
             let rest = &src[len.as_usize()..];
diff --git a/src/domain/host.rs b/src/domain/host.rs
@@ -37,7 +37,7 @@ fn disambiguate_err(e: Error) -> Error {
     let kind = match e.kind() {
         err::Kind::HostOrPathInvalidChar => err::Kind::HostInvalidChar,
         err::Kind::HostOrPathTooLong => err::Kind::HostTooLong,
-        err::Kind::HostOrPathNoMatch => err::Kind::HostNoMatch,
+        err::Kind::HostOrPathMissing => err::Kind::HostMissing,
         _ => e.kind(),
     };
     Error::at(e.index(), kind)
@@ -140,7 +140,7 @@ impl<'src> HostStr<'src> {
         let result = HostSpan::new(src)?;
         let len = result.as_ref().map(|r| r.short_len().into()).unwrap_or(0);
         if (len as usize) != src.len() {
-            return Err(Error::at(len, crate::err::Kind::HostNoMatch));
+            return Err(Error::at(len, crate::err::Kind::HostInvalidChar));
         }
         Ok(result.map(|r| Self::from_span_of(src, r)))
     }
diff --git a/src/domain/ipv6.rs b/src/domain/ipv6.rs
@@ -130,7 +130,7 @@ impl<'src> Ipv6Span<'src> {
         let mut index: NonZeroU8 = match ascii.next() {
             None => return Ok(None),
             Some(b'[') => Ok(nonzero!(u8, 1)), // consume the opening bracket
-            Some(_) => Err(Error::at(0, err::Kind::Ipv6NoMatch)),
+            Some(_) => Err(Error::at(0, err::Kind::Ipv6InvalidChar)),
         }?;
         let mut state = State(0);
         loop {
@@ -140,7 +140,8 @@ impl<'src> Ipv6Span<'src> {
                     b'a'..=b'f' | b'A'..=b'F' | b'0'..=b'9' => state.increment_position_in_group(),
                     b':' => state.set_colon(),
                     b']' => break, // done!
-                    _ => Err(err::Kind::Ipv6MissingClosingBracket),
+                    b'/' => Err(err::Kind::Ipv6MissingClosingBracket),
+                    _ => Err(err::Kind::Ipv6InvalidChar),
                 }
                 .map_err(|kind| Error::at(index.upcast(), kind))?;
             } else {
diff --git a/src/domain/mod.rs b/src/domain/mod.rs
@@ -131,7 +131,7 @@ impl<'src> DomainStr<'src> {
         let result = DomainSpan::new(src)?;
         let len = result.as_ref().map(|r| r.short_len().into()).unwrap_or(0);
         if (len as usize) != src.len() {
-            return Err(Error::at(len, ErrorKind::HostNoMatch));
+            return Err(Error::at(len, ErrorKind::HostInvalidChar));
         }
         Ok(result.map(|span| Self { src, span }))
     }
diff --git a/src/err.rs b/src/err.rs
@@ -5,12 +5,10 @@
 // since ErrorKind can fit 256 unique errors, use it for all non-ambiguous cases
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Kind {
-    // FIXME: rename errors from *NoMatch to *Missing
-
     // ambiguous::host_or_path ---------------------------------
     /// unable to match a host or path of length > 0. This is caused by
     /// attempting to parse an empty string.
-    HostOrPathNoMatch,
+    HostOrPathMissing,
     /// parsing the host or path section exceeded 255 characters.
     HostOrPathTooLong,
     HostOrPathInvalidChar,
@@ -25,12 +23,12 @@ pub enum Kind {
     /// the name (including host, port, and path) is over 255 characters long.
     NameTooLong,
     // name::domain::host --------------------------------------------
-    HostNoMatch,
+    HostMissing,
     HostComponentInvalidEnd,
     HostInvalidChar,
     HostTooLong,
     // name::domain::ipv6 -------------------------------------------
-    Ipv6NoMatch,
+    Ipv6InvalidChar,
     Ipv6TooLong,
     Ipv6BadColon,
     Ipv6TooManyHexDigits,
@@ -44,7 +42,7 @@ pub enum Kind {
     /// an empty port was observed (like "host:/", or "host:" at the end of the string)
     PortMissing,
     // name::path ----------------------------------------------------
-    PathNoMatch,
+    PathMissing,
     PathComponentInvalidEnd,
     PathInvalidChar,
     PathTooLong,
@@ -55,8 +53,7 @@ pub enum Kind {
 
     // digest::algorithm ----------------------------------------
     /// 0-length algorithm in an "algorithm:encoded" section detected
-    // TODO: deprecate in favor of Option<Algorithm>
-    AlgorithmNoMatch,
+    AlgorithmMissing,
     /// If parsing in OCI-digest mode, uppercase letters are not allowed.
     InvalidOciAlgorithm,
     /// At least one algorithm component starts with a number, which is allowed
@@ -72,7 +69,7 @@ pub enum Kind {
     AlgorithmTooLong,
     // digest::encoded ------------------------------------------
     /// Nothing after the ":" in an "algorithm:encoded" section.
-    EncodedNoMatch,
+    EncodedMissing,
     /// a non-base64 character was encountered.
     EncodedInvalidChar,
     ///non-lower-hex characters are not allowed when parsing in `distribution/reference` mode
@@ -86,7 +83,7 @@ pub enum Kind {
     EncodingTooLong,
     // reference ----------------------------------------
     /// empty string or non-canonical reference
-    RefNoMatch,
+    RefMissing,
 }
 
 /// The `Error` type contains an `err::Kind` and an index within the source string.
diff --git a/src/lib.rs b/src/lib.rs
@@ -37,7 +37,7 @@ struct RefSpan<'src> {
 impl<'src> RefSpan<'src> {
     pub fn new(src: &'src str) -> Result<Self, Error> {
         if src.is_empty() {
-            return Error::at(0, err::Kind::RefNoMatch).into();
+            return Error::at(0, err::Kind::RefMissing).into();
         };
         let prefix = DomainOrRefSpan::new(src)?;
         let rest = &src[prefix.len()..];
@@ -183,19 +183,19 @@ pub struct CanonicalSpan<'src> {
 }
 impl<'src> CanonicalSpan<'src> {
     pub fn new(src: &'src str) -> Result<Self, Error> {
-        let domain = DomainSpan::new(src)?.ok_or(Error::at(0, err::Kind::HostNoMatch))?;
+        let domain = DomainSpan::new(src)?.ok_or(Error::at(0, err::Kind::HostMissing))?;
         let mut len = domain.short_len().into();
         match &src[len as usize..].bytes().next() {
             Some(b'/') => Ok(()),
             Some(_) => Err(err::Kind::PathInvalidChar),
-            None => Err(err::Kind::RefNoMatch),
+            None => Err(err::Kind::PathMissing),
         }
         .map_err(|kind| Error::at(len, kind))?;
 
         let path = PathSpan::new(&src[len as usize..])
             .map_err(|e| e.into())
             .map_err(|e: Error| e + len)?
-            .ok_or(Error::at(len, err::Kind::PathNoMatch))?;
+            .ok_or(Error::at(len, err::Kind::PathMissing))?;
         len += path.short_len().upcast() as u16;
         if len > NAME_TOTAL_MAX_LENGTH as u16 {
             return Error::at(len, err::Kind::NameTooLong).into();
@@ -207,11 +207,11 @@ impl<'src> CanonicalSpan<'src> {
         len += match src.as_bytes()[len as usize..].iter().next() {
             Some(b'@') => Ok(1),
             Some(_) => Error::at(len, err::Kind::PathInvalidChar).into(),
-            None => Error::at(len, err::Kind::RefNoMatch).into(),
+            None => Error::at(len, err::Kind::AlgorithmMissing).into(),
         }?;
         let digest = DigestSpan::new(&src[len as usize..])
             .map_err(|e| e + len)?
-            .ok_or(Error::at(len, err::Kind::AlgorithmNoMatch))?;
+            .ok_or(Error::at(len, err::Kind::AlgorithmMissing))?;
         Ok(Self {
             domain,
             path,
@@ -354,14 +354,14 @@ impl<'src> TryInto<CanonicalSpan<'src>> for RefSpan<'src> {
     type Error = Error;
     fn try_into(self) -> Result<CanonicalSpan<'src>, self::Error> {
         // a canonical reference needs a domain, path, and digest
-        let domain = self.domain.ok_or(Error::at(0, err::Kind::HostNoMatch))?;
+        let domain = self.domain.ok_or(Error::at(0, err::Kind::HostMissing))?;
         let path = self.path.ok_or(Error::at(
             self.path_index().try_into().unwrap(),
-            err::Kind::PathNoMatch,
+            err::Kind::PathMissing,
         ))?;
         let digest = self.digest.ok_or(Error::at(
             self.digest_index().try_into().unwrap(), // safe to unwrap since host + path + tag + algorithm MUST be under u16::MAX
-            err::Kind::AlgorithmNoMatch,             // TODO: more specific error?
+            err::Kind::AlgorithmMissing,             // TODO: more specific error?
         ))?;
 
         Ok(CanonicalSpan {
@@ -564,7 +564,7 @@ mod tests {
             src.push_str("0@");
             src.push_str(&"0".repeat(255));
             src.push_str(":");
-            should_fail_with(&src, Error::at(258, err::Kind::EncodedNoMatch))
+            should_fail_with(&src, Error::at(258, err::Kind::EncodedMissing))
         };
     }
     #[test]
diff --git a/src/path.rs b/src/path.rs
@@ -35,7 +35,7 @@ type Error = err::Error<u8>;
 /// adapt ambiguous error kinds into path-specific error kinds
 fn map_error(e: Error) -> Error {
     let kind = match e.kind() {
-        err::Kind::HostOrPathNoMatch => err::Kind::PathNoMatch,
+        err::Kind::HostOrPathMissing => err::Kind::PathMissing,
         err::Kind::HostOrPathInvalidChar => err::Kind::PathInvalidChar,
         err::Kind::HostOrPathTooLong => err::Kind::PathTooLong,
         _ => e.kind(),

Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ impl<'src> DomainStr<'src> {`
`131`	`131`	`let result = DomainSpan::new(src)?;`
`132`	`132`	`let len = result.as_ref().map(\|r\| r.short_len().into()).unwrap_or(0);`
`133`	`133`	`if (len as usize) != src.len() {`
`134`		`- return Err(Error::at(len, ErrorKind::HostNoMatch));`
	`134`	`+ return Err(Error::at(len, ErrorKind::HostInvalidChar));`
`135`	`135`	`}`
`136`	`136`	`Ok(result.map(\|span\| Self { src, span }))`
`137`	`137`	`}`