Clean up legacy code and improve QR code tests

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 resolver = "3"
 
 [workspace.package]
-version = "0.0.7"
+version = "0.0.8"
 
 [profile.release]
 codegen-units = 1

rxing-reader/src/binarizer.rs

@@ -25,12 +25,12 @@ use crate::{LuminanceSource, common::BitMatrix};
 pub trait Binarizer {
     type Source: LuminanceSource;
 
-    fn get_luminance_source(&self) -> &Self::Source;
+    fn luminance_source(&self) -> &Self::Source;
 
     /// Converts the image to a black/white matrix for QR detection.
     /// Returns the image bits, where `true` means black.
     /// Returns an error if the image cannot be binarized into a matrix.
-    fn get_black_matrix(&self) -> Result<&BitMatrix>;
+    fn black_matrix(&self) -> Result<&BitMatrix>;
 
-    fn get_black_matrix_mut(&mut self) -> Result<&mut BitMatrix>;
+    fn black_matrix_mut(&mut self) -> Result<&mut BitMatrix>;
 }

rxing-reader/src/binary_bitmap.rs

@@ -34,15 +34,15 @@ impl<B: Binarizer> BinaryBitmap<B> {
 
     /// Returns the mutable image matrix, where `true` means black.
     /// Returns an error if the image cannot be binarized into a matrix.
-    pub fn get_black_matrix_mut(&mut self) -> Result<&mut BitMatrix> {
-        self.binarizer.get_black_matrix_mut()
+    pub fn black_matrix_mut(&mut self) -> Result<&mut BitMatrix> {
+        self.binarizer.black_matrix_mut()
     }
 
     /// Converts the image to a black/white matrix for QR detection.
     /// Returns the image matrix, where `true` means black.
     /// Returns an error if the image cannot be binarized into a matrix.
-    pub fn get_black_matrix(&self) -> Result<&BitMatrix> {
-        self.binarizer.get_black_matrix()
+    pub fn black_matrix(&self) -> Result<&BitMatrix> {
+        self.binarizer.black_matrix()
     }
 
     /// Apply a 3×3 morphological close to the cached BitMatrix: dilate (set
@@ -52,7 +52,7 @@ impl<B: Binarizer> BinaryBitmap<B> {
     /// photos (cf. zxing-cpp's `tryDenoise`). The 1-pixel border is left
     /// unchanged. No-op if the matrix is smaller than 3×3.
     pub fn close(&mut self) -> Result<()> {
-        let matrix = self.get_black_matrix_mut()?;
+        let matrix = self.black_matrix_mut()?;
         let (w, h) = (matrix.width(), matrix.height());
         if w < 3 || h < 3 {
             return Ok(());
@@ -84,7 +84,7 @@ fn sum_filter_3x3<F: Fn(u8) -> bool>(input: &BitMatrix, output: &mut BitMatrix,
 
 impl<B: Binarizer> fmt::Display for BinaryBitmap<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.binarizer.get_black_matrix() {
+        match self.binarizer.black_matrix() {
             Ok(matrix) => write!(f, "{matrix:?}"),
             Err(_) => write!(f, "<unavailable>"),
         }

rxing-reader/src/common/bit_array.rs

@@ -61,11 +61,17 @@ impl BitArray {
         }
     }
 
-    pub fn get_size(&self) -> usize {
+    #[must_use]
+    pub fn len(&self) -> usize {
         self.bits.len()
     }
 
-    pub fn get_size_in_bytes(&self) -> usize {
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.bits.is_empty()
+    }
+
+    pub fn byte_len(&self) -> usize {
         self.bits.len().div_ceil(8)
     }
 
@@ -90,7 +96,7 @@ impl BitArray {
         self.bits.set(i, !v);
     }
 
-    pub fn get_next_set(&self, from: usize) -> usize {
+    pub fn next_set(&self, from: usize) -> usize {
         let size = self.bits.len();
         if from >= size {
             return size;
@@ -101,7 +107,7 @@ impl BitArray {
             .unwrap_or(size)
     }
 
-    pub fn get_next_unset(&self, from: usize) -> usize {
+    pub fn next_unset(&self, from: usize) -> usize {
         let size = self.bits.len();
         if from >= size {
             return size;
@@ -124,7 +130,7 @@ impl BitArray {
             return Err(Error::InvalidArgument {
                 message: format!(
                     "set_range: start={start}, end={end} out of range for bit array of length {len}"
-                ),
+                ).into(),
             }
             .into());
         }
@@ -145,7 +151,7 @@ impl BitArray {
             return Err(Error::InvalidArgument {
                 message: format!(
                     "is_range: start={start}, end={end} out of range for bit array of length {len}"
-                ),
+                ).into(),
             }
             .into());
         }
@@ -165,7 +171,7 @@ impl BitArray {
     pub fn append_bits(&mut self, value: BaseType, num_bits: usize) -> Result<()> {
         if num_bits > BASE_BITS {
             return Err(Error::InvalidArgument {
-                message: format!("num bits must be between 0 and {}", BaseType::BITS),
+                message: format!("num bits must be between 0 and {}", BaseType::BITS).into(),
             }
             .into());
         }
@@ -190,7 +196,7 @@ impl BitArray {
                     "xor: bit array sizes differ (self={}, other={})",
                     self.bits.len(),
                     other.bits.len(),
-                ),
+                ).into(),
             }
             .into());
         }
@@ -214,7 +220,7 @@ impl BitArray {
         }
     }
 
-    pub fn get_bit_array(&self) -> &[BaseType] {
+    pub fn words(&self) -> &[BaseType] {
         self.bits.as_raw_slice()
     }
 
@@ -251,8 +257,8 @@ impl From<BitArray> for Vec<u8> {
 
 impl From<&BitArray> for Vec<u8> {
     fn from(value: &BitArray) -> Self {
-        let mut array = vec![0; value.get_size_in_bytes()];
-        value.to_bytes(0, &mut array, 0, value.get_size_in_bytes());
+        let mut array = vec![0; value.byte_len()];
+        value.to_bytes(0, &mut array, 0, value.byte_len());
         array
     }
 }
@@ -358,7 +364,7 @@ mod tests {
         let bytes = [0b1000_0001, 0b0101_1010, 0];
         let bits = BitArray::from(bytes.to_vec());
 
-        assert_eq!(bits.get_size(), bytes.len() * 8);
+        assert_eq!(bits.len(), bytes.len() * 8);
         assert_eq!(Vec::<u8>::from(bits), bytes);
     }
 
@@ -368,6 +374,6 @@ mod tests {
 
         bits.set_bulk(5, 0b101);
 
-        assert_eq!(bits.get_bit_array()[0], 0b101);
+        assert_eq!(bits.words()[0], 0b101);
     }
 }