Merge pull request #78 from orbitinghail/feat/remove-culprit

remove culprit

Author: carlsverre

Cargo.lock

@@ -23,7 +23,6 @@ assert_matches = "1.5.0"
 bitvec = "1.0.1"
 bytes = "1.10"
 crc64fast-nvme = "1.2.0"
-culprit = "0.4"
 either = "1.15"
 itertools = "0.14"
 num = "0.4"

Cargo.toml

@@ -1,5 +1,4 @@
 use bytes::{BufMut, Bytes, BytesMut};
-use culprit::Culprit;
 use thiserror::Error;
 use zerocopy::{ConvertError, SizeError};
 
@@ -94,9 +93,9 @@ pub enum DecodeErr {
 
 impl DecodeErr {
     #[inline]
-    fn ensure_bytes_available(data: &[u8], len: usize) -> culprit::Result<(), DecodeErr> {
+    fn ensure_bytes_available(data: &[u8], len: usize) -> Result<(), DecodeErr> {
         if data.len() < len {
-            Err(Culprit::new(Self::Length))
+            Err(Self::Length)
         } else {
             Ok(())
         }

src/codec.rs

@@ -1,5 +1,4 @@
 use bitvec::{order::Lsb0, slice::BitSlice};
-use culprit::ResultExt;
 use either::Either;
 use num::traits::{AsPrimitive, Bounded};
 use zerocopy::{FromBytes, TryFromBytes};
@@ -14,9 +13,7 @@ use crate::{
     util::{RangeExt, RangeIter},
 };
 
-pub(super) fn decode_len_from_suffix<L: Level>(
-    data: &[u8],
-) -> culprit::Result<(&[u8], usize), DecodeErr> {
+pub(super) fn decode_len_from_suffix<L: Level>(data: &[u8]) -> Result<(&[u8], usize), DecodeErr> {
     let (data, len) = L::ValueUnaligned::try_read_from_suffix(data)?;
     // length is decremented when stored
     Ok((data, len.into().as_() + 1))
@@ -33,10 +30,7 @@ pub enum NonRecursivePartitionRef<'a, L: Level> {
 }
 
 impl<'a, L: Level> NonRecursivePartitionRef<'a, L> {
-    pub fn from_suffix_with_kind(
-        kind: PartitionKind,
-        data: &'a [u8],
-    ) -> culprit::Result<Self, DecodeErr> {
+    pub fn from_suffix_with_kind(kind: PartitionKind, data: &'a [u8]) -> Result<Self, DecodeErr> {
         match kind {
             PartitionKind::Empty => Ok(Self::Empty),
             PartitionKind::Full => Ok(Self::Full),
@@ -57,9 +51,7 @@ impl<'a, L: Level> NonRecursivePartitionRef<'a, L> {
                     values: <[L::ValueUnaligned]>::ref_from_bytes_with_elems(&data[range], len)?,
                 })
             }
-            PartitionKind::Run => Ok(Self::Run {
-                runs: RunsRef::from_suffix(data).or_into_ctx()?,
-            }),
+            PartitionKind::Run => Ok(Self::Run { runs: RunsRef::from_suffix(data)? }),
             PartitionKind::Tree => unreachable!("non-recursive"),
         }
     }
@@ -81,7 +73,7 @@ impl<'a> NonRecursivePartitionRef<'a, Block> {
         kind: PartitionKind,
         num_children: usize,
         data: &'a [u8],
-    ) -> culprit::Result<Self, DecodeErr> {
+    ) -> Result<Self, DecodeErr> {
         match kind {
             PartitionKind::Full => Ok(Self::Full),
             PartitionKind::Bitmap => {
@@ -326,12 +318,12 @@ pub enum PartitionRef<'a, L: Level> {
 }
 
 impl<'a, L: Level> PartitionRef<'a, L> {
-    pub fn from_suffix(data: &'a [u8]) -> culprit::Result<Self, DecodeErr> {
+    pub fn from_suffix(data: &'a [u8]) -> Result<Self, DecodeErr> {
         let (data, kind) = PartitionKind::try_read_from_suffix(data)?;
         match kind {
-            PartitionKind::Tree => Ok(Self::Tree(TreeRef::from_suffix(data).or_into_ctx()?)),
+            PartitionKind::Tree => Ok(Self::Tree(TreeRef::from_suffix(data)?)),
             kind => Ok(Self::NonRecursive(
-                NonRecursivePartitionRef::from_suffix_with_kind(kind, data).or_into_ctx()?,
+                NonRecursivePartitionRef::from_suffix_with_kind(kind, data)?,
             )),
         }
     }

src/codec/partition_ref.rs

@@ -1,6 +1,5 @@
 use std::{iter::FusedIterator, ops::RangeInclusive};
 
-use culprit::ResultExt;
 use range_set_blaze::{SortedDisjoint, SortedStarts};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};
 
@@ -18,8 +17,8 @@ pub struct RunsRef<'a, L: Level> {
 }
 
 impl<'a, L: Level> RunsRef<'a, L> {
-    pub(super) fn from_suffix(data: &'a [u8]) -> culprit::Result<Self, DecodeErr> {
-        let (data, runs) = decode_len_from_suffix::<L>(data).or_into_ctx()?;
+    pub(super) fn from_suffix(data: &'a [u8]) -> Result<Self, DecodeErr> {
+        let (data, runs) = decode_len_from_suffix::<L>(data)?;
         let bytes = runs * size_of::<L::ValueUnaligned>() * 2;
         DecodeErr::ensure_bytes_available(data, bytes)?;
         let range = (data.len() - bytes)..data.len();

src/codec/runs_ref.rs

@@ -26,7 +26,7 @@ pub struct TreeRef<'a, L: Level> {
 }
 
 impl<'a, L: Level> TreeRef<'a, L> {
-    pub(super) fn from_suffix(data: &'a [u8]) -> culprit::Result<Self, DecodeErr> {
+    pub(super) fn from_suffix(data: &'a [u8]) -> Result<Self, DecodeErr> {
         let (data, num_children) = decode_len_from_suffix::<Block>(data)?;
         assert_ne!(
             num_children, 0,

src/codec/tree_ref.rs

@@ -5,7 +5,6 @@ use std::ops::{
 };
 
 use bytes::{BufMut, Bytes};
-use culprit::Culprit;
 use either::Either;
 
 use crate::{
@@ -185,7 +184,7 @@ impl<B: Deref<Target = [u8]>> CowSplinter<B> {
     /// let cow = CowSplinter::from_bytes(bytes).unwrap();
     /// assert!(cow.contains(42));
     /// ```
-    pub fn from_bytes(data: B) -> Result<Self, Culprit<DecodeErr>> {
+    pub fn from_bytes(data: B) -> Result<Self, DecodeErr> {
         Ok(Self::Ref(SplinterRef::from_bytes(data)?))
     }
 

src/cow.rs

@@ -4,7 +4,6 @@ use std::{
 };
 
 use bytes::Bytes;
-use culprit::Culprit;
 use zerocopy::FromBytes;
 
 use crate::{
@@ -239,19 +238,19 @@ impl<B: Deref<Target = [u8]>> SplinterRef<B> {
     ///
     /// let invalid_bytes = vec![0u8; 5]; // Too short
     /// let result = SplinterRef::from_bytes(invalid_bytes);
-    /// assert!(matches!(result.unwrap_err().ctx(), DecodeErr::Length));
+    /// assert!(matches!(result.unwrap_err(), DecodeErr::Length));
     /// ```
-    pub fn from_bytes(data: B) -> culprit::Result<Self, DecodeErr> {
+    pub fn from_bytes(data: B) -> Result<Self, DecodeErr> {
         pub(crate) const SPLINTER_V1_MAGIC: [u8; 4] = [0xDA, 0xAE, 0x12, 0xDF];
         if data.len() >= 4
             && data.starts_with(&SPLINTER_V1_MAGIC)
             && !data.ends_with(&SPLINTER_V2_MAGIC)
         {
-            return Err(Culprit::new(DecodeErr::SplinterV1));
+            return Err(DecodeErr::SplinterV1);
         }
 
         if data.len() < Footer::SIZE {
-            return Err(Culprit::new(DecodeErr::Length));
+            return Err(DecodeErr::Length);
         }
         let (partitions, footer) = data.split_at(data.len() - Footer::SIZE);
         Footer::ref_from_bytes(footer)?.validate(partitions)?;

src/splinter_ref.rs

@@ -378,7 +378,7 @@ pub fn mksplinter_buf(values: &[u32]) -> BytesMut {
 #[macro_export]
 macro_rules! assert_error {
     ($expr:expr, $err:path$(, $($rest:tt),+)?) => {
-        assert_matches::assert_matches!(($expr).expect_err("expected an error").ctx(), $err $(, $($rest),+)?)
+        assert_matches::assert_matches!(($expr).expect_err("expected an error"), $err $(, $($rest),+)?)
     };
 }