feat!: use gix-error instead of thiserror

Byron · Byron · commit 0c68131e8663 · 2026-01-13T09:40:53.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/gix-chunk/Cargo.toml b/gix-chunk/Cargo.toml
@@ -17,4 +17,4 @@ doctest = false
 test = false
 
 [dependencies]
-thiserror = "2.0.17"
+gix-error = { version = "^0.0.0", path = "../gix-error" }
diff --git a/gix-chunk/src/file/decode.rs b/gix-chunk/src/file/decode.rs
@@ -1,79 +1,60 @@
+use gix_error::bstr::ByteSlice;
+use gix_error::ParseError;
 use std::ops::Range;
 
-mod error {
-    /// The value returned by [`crate::file::Index::from_bytes()`]
-    #[derive(Debug, thiserror::Error)]
-    #[allow(missing_docs)]
-    pub enum Error {
-        #[error("Sentinel value encountered while still processing chunks.")]
-        EarlySentinelValue,
-        #[error("Sentinel value wasn't found, saw {:?}", std::str::from_utf8(actual.as_ref()).unwrap_or("<non-ascii>"))]
-        MissingSentinelValue { actual: crate::Id },
-        #[error("The chunk offset {offset} went past the file of length {file_length} - was it truncated?")]
-        ChunkSizeOutOfBounds {
-            offset: crate::file::Offset,
-            file_length: u64,
-        },
-        #[error("All chunk offsets must be incrementing.")]
-        NonIncrementalChunkOffsets,
-        #[error("The chunk of kind {:?} was encountered more than once", std::str::from_utf8(kind.as_ref()).unwrap_or("<non-ascii>"))]
-        DuplicateChunk { kind: crate::Id },
-        #[error("The table of contents would be {expected} bytes, but got only {actual}")]
-        TocTooSmall { actual: usize, expected: usize },
-        #[error("Empty chunk indices are not allowed as the point of chunked files is to have chunks.")]
-        Empty,
-    }
-}
-pub use error::Error;
-
 use crate::{file, file::index};
 
 impl file::Index {
     /// Provided a mapped file at the beginning via `data`, starting at `toc_offset` decode all chunk information to return
     /// an index with `num_chunks` chunks.
-    pub fn from_bytes(data: &[u8], toc_offset: usize, num_chunks: u32) -> Result<Self, Error> {
+    pub fn from_bytes(data: &[u8], toc_offset: usize, num_chunks: u32) -> Result<Self, ParseError> {
         if num_chunks == 0 {
-            return Err(Error::Empty);
+            return Err(ParseError::new(
+                "Empty chunk indices are not allowed as the point of chunked files is to have chunks.",
+            ));
         }
 
         let data_len: u64 = data.len() as u64;
         let mut chunks = Vec::with_capacity(num_chunks as usize);
         let mut toc_entry = &data[toc_offset..];
         let expected_min_size = (num_chunks as usize + 1) * file::Index::ENTRY_SIZE;
         if toc_entry.len() < expected_min_size {
-            return Err(Error::TocTooSmall {
-                expected: expected_min_size,
-                actual: toc_entry.len(),
-            });
+            return Err(format!(
+                "The table of contents would be {expected_min_size} bytes, but got only {toc_entry_len}",
+                toc_entry_len = toc_entry.len()
+            ))?;
         }
 
-        for _ in 0..num_chunks {
+        for chunk_idx in 0..num_chunks {
             let (kind, offset) = toc_entry.split_at(4);
             let kind = to_kind(kind);
             if kind == crate::SENTINEL {
-                return Err(Error::EarlySentinelValue);
+                return Err(format!(
+                    "Sentinel value encountered while processing chunks {chunk_idx} of {num_chunks}"
+                ))?;
             }
             if chunks.iter().any(|c: &index::Entry| c.kind == kind) {
-                return Err(Error::DuplicateChunk { kind });
+                return Err(format!(
+                    "The chunk of kind '{}' was encountered more than once",
+                    kind.as_bstr()
+                ))?;
             }
 
             let offset = be_u64(offset);
             if offset > data_len {
-                return Err(Error::ChunkSizeOutOfBounds {
-                    offset,
-                    file_length: data_len,
-                });
+                return Err(format!(
+                    "The chunk offset {offset} went past the file of length {data_len} - was it truncated?",
+                ))?;
             }
             toc_entry = &toc_entry[file::Index::ENTRY_SIZE..];
             let next_offset = be_u64(&toc_entry[4..]);
             if next_offset > data_len {
-                return Err(Error::ChunkSizeOutOfBounds {
-                    offset: next_offset,
-                    file_length: data_len,
-                });
+                return Err(format!(
+                    "The chunk offset {next_offset} went past the file of length {data_len} - was it truncated?"
+                ))?;
             }
             if next_offset <= offset {
-                return Err(Error::NonIncrementalChunkOffsets);
+                return Err("All chunk offsets must be incrementing.")?;
             }
             chunks.push(index::Entry {
                 kind,
@@ -86,7 +67,7 @@ impl file::Index {
 
         let sentinel = to_kind(&toc_entry[..4]);
         if sentinel != crate::SENTINEL {
-            return Err(Error::MissingSentinelValue { actual: sentinel });
+            return Err(format!("Sentinel value wasn't found, saw '{}'", sentinel.as_bstr()))?;
         }
 
         Ok(file::Index {
diff --git a/gix-chunk/src/file/index.rs b/gix-chunk/src/file/index.rs
@@ -1,48 +1,14 @@
 use std::ops::Range;
 
 use crate::file::Index;
-
-///
-pub mod offset_by_kind {
-    use std::fmt::{Display, Formatter};
-
-    /// The error returned by [`Index::offset_by_id()`][super::Index::offset_by_id()].
-    #[allow(missing_docs)]
-    #[derive(Debug)]
-    pub struct Error {
-        pub kind: crate::Id,
-    }
-
-    impl Display for Error {
-        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-            write!(
-                f,
-                "Chunk named {:?} was not found in chunk file index",
-                std::str::from_utf8(&self.kind).unwrap_or("<non-ascii>")
-            )
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-///
-pub mod data_by_kind {
-    /// The error returned by [`Index::data_by_id()`][super::Index::data_by_id()].
-    #[derive(Debug, thiserror::Error)]
-    #[allow(missing_docs)]
-    pub enum Error {
-        #[error("The chunk wasn't found in the file index")]
-        NotFound(#[from] super::offset_by_kind::Error),
-        #[error("The offsets into the file couldn't be represented by usize")]
-        FileTooLarge,
-    }
-}
+use crate::Id;
+use gix_error::bstr::ByteSlice;
+use gix_error::{message, Message};
 
 /// An entry of a chunk file index
 pub struct Entry {
     /// The kind of the chunk file
-    pub kind: crate::Id,
+    pub kind: Id,
     /// The offset, relative to the beginning of the file, at which to find the chunk and its end.
     pub offset: Range<crate::file::Offset>,
 }
@@ -59,11 +25,11 @@ impl Index {
     }
 
     /// Find a chunk of `kind` and return its offset into the data if found
-    pub fn offset_by_id(&self, kind: crate::Id) -> Result<Range<crate::file::Offset>, offset_by_kind::Error> {
+    pub fn offset_by_id(&self, kind: Id) -> Result<Range<crate::file::Offset>, Message> {
         self.chunks
             .iter()
             .find_map(|c| (c.kind == kind).then(|| c.offset.clone()))
-            .ok_or(offset_by_kind::Error { kind })
+            .ok_or_else(make_message(kind))
     }
 
     /// Find a chunk of `kind` and return its offset as usize range into the data if found.
@@ -73,30 +39,31 @@ impl Index {
     ///
     /// - if the usize conversion fails, which isn't expected as memory maps can't be created if files are too large
     ///   to require such offsets.
-    pub fn usize_offset_by_id(&self, kind: crate::Id) -> Result<Range<usize>, offset_by_kind::Error> {
+    pub fn usize_offset_by_id(&self, kind: Id) -> Result<Range<usize>, Message> {
         self.chunks
             .iter()
             .find_map(|c| (c.kind == kind).then(|| crate::range::into_usize_or_panic(c.offset.clone())))
-            .ok_or(offset_by_kind::Error { kind })
+            .ok_or_else(make_message(kind))
     }
 
     /// Like [`Index::usize_offset_by_id()`] but with support for validation and transformation using a function.
     pub fn validated_usize_offset_by_id<T>(
         &self,
-        kind: crate::Id,
+        kind: Id,
         validate: impl FnOnce(Range<usize>) -> T,
-    ) -> Result<T, offset_by_kind::Error> {
+    ) -> Result<T, Message> {
         self.chunks
             .iter()
             .find_map(|c| (c.kind == kind).then(|| crate::range::into_usize_or_panic(c.offset.clone())))
             .map(validate)
-            .ok_or(offset_by_kind::Error { kind })
+            .ok_or_else(make_message(kind))
     }
 
     /// Find a chunk of `kind` and return its data slice based on its offset.
-    pub fn data_by_id<'a>(&self, data: &'a [u8], kind: crate::Id) -> Result<&'a [u8], data_by_kind::Error> {
+    pub fn data_by_id<'a>(&self, data: &'a [u8], kind: Id) -> Result<&'a [u8], Message> {
         let offset = self.offset_by_id(kind)?;
-        Ok(&data[crate::range::into_usize(offset).ok_or(data_by_kind::Error::FileTooLarge)?])
+        Ok(&data[crate::range::into_usize(offset)
+            .ok_or_else(|| message!("The offsets into the file couldn't be represented by usize"))?])
     }
 
     /// Return the end offset lf the last chunk, which is the highest offset as well.
@@ -105,3 +72,7 @@ impl Index {
         self.chunks.last().expect("at least one chunk").offset.end
     }
 }
+
+fn make_message(kind: Id) -> impl FnOnce() -> Message {
+    move || message!("Chunk named '{}' was not found in chunk file index", kind.as_bstr())
+}
diff --git a/gix-chunk/src/file/write.rs b/gix-chunk/src/file/write.rs
@@ -60,7 +60,7 @@ mod write_chunk {
                     "BUG: expected to write {} bytes, but only wrote {} for chunk {:?}",
                     entry.offset.end,
                     self.written_bytes,
-                    std::str::from_utf8(&entry.kind)
+                    (&entry.kind)
                 );
             }
             self.written_bytes = 0;
@@ -87,7 +87,7 @@ impl Index {
         assert!(
             !self.chunks.iter().any(|e| e.kind == chunk),
             "BUG: must not add chunk of same kind twice: {:?}",
-            std::str::from_utf8(&chunk)
+            (&chunk)
         );
         self.chunks.push(Entry {
             kind: chunk,
diff --git a/gix-pack/Cargo.toml b/gix-pack/Cargo.toml
@@ -38,6 +38,7 @@ gix-features = { version = "^0.45.2", path = "../gix-features", features = ["crc
 gix-path = { version = "^0.10.22", path = "../gix-path" }
 gix-hash = { version = "^0.21.2", path = "../gix-hash" }
 gix-chunk = { version = "^0.4.12", path = "../gix-chunk" }
+gix-error = { version = "^0.0.0", path = "../gix-error" }
 gix-object = { version = "^0.54.1", path = "../gix-object" }
 gix-hashtable = { version = "^0.11.0", path = "../gix-hashtable", optional = true }
 
diff --git a/gix-pack/src/multi_index/init.rs b/gix-pack/src/multi_index/init.rs
@@ -21,11 +21,7 @@ mod error {
         #[error("Unsupported hash kind: {kind})")]
         UnsupportedObjectHash { kind: u8 },
         #[error(transparent)]
-        ChunkFileDecode(#[from] gix_chunk::file::decode::Error),
-        #[error(transparent)]
-        MissingChunk(#[from] gix_chunk::file::index::offset_by_kind::Error),
-        #[error(transparent)]
-        FileTooLarge(#[from] gix_chunk::file::index::data_by_kind::Error),
+        ChunkFileDecode(#[from] gix_error::ParseError),
         #[error("The multi-pack fan doesn't have the correct size of 256 * 4 bytes")]
         MultiPackFanSize,
         #[error(transparent)]
