fairly major reorganization and clippy cleanup

src/aztec/DetectorTest.rs

@@ -79,7 +79,8 @@ fn test_aztec_rxing_result_sample() {
 
 // Test that we can tolerate errors in the parameter locator bits
 fn test_error_in_parameter_locator(data: &str) {
-    let aztec = encoder::encoder::encode(data, 25, encoder::encoder::DEFAULT_AZTEC_LAYERS)
+    let aztec =
+        encoder::aztec_encoder::encode(data, 25, encoder::aztec_encoder::DEFAULT_AZTEC_LAYERS)
             .expect("encode should create");
     // dbg!(aztec.getMatrix().to_string());
     let mut random = rand::thread_rng(); //Random(aztec.getMatrix().hashCode());   // pseudo-random, but deterministic

src/aztec/EncoderTest.rs

@@ -28,7 +28,7 @@ use crate::{
     BarcodeFormat, EncodeHintType, EncodeHintValue, RXingResultPoint,
 };
 
-use super::{encoder::encoder, AztecWriter};
+use super::{encoder::aztec_encoder, AztecWriter};
 
 use crate::Writer;
 
@@ -180,10 +180,10 @@ fn testAztecWriter() {
     let matrix = writer
         .encode(data, &BarcodeFormat::AZTEC, 0, 0)
         .expect("matrix must exist");
-    let aztec = encoder::encode(
+    let aztec = aztec_encoder::encode(
         data,
-        encoder::DEFAULT_EC_PERCENT,
+        aztec_encoder::DEFAULT_EC_PERCENT,
-        encoder::DEFAULT_AZTEC_LAYERS,
+        aztec_encoder::DEFAULT_AZTEC_LAYERS,
     )
     .expect("encode should succeed");
     let expected_matrix = aztec.getMatrix();
@@ -599,15 +599,15 @@ fn testUserSpecifiedLayers2() {
 
 fn doTestUserSpecifiedLayers(userSpecifiedLayers: i32) {
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    let mut aztec = encoder::encode(alphabet, 25, -2).expect("should encode");
+    let mut aztec = aztec_encoder::encode(alphabet, 25, -2).expect("should encode");
     assert_eq!(2, aztec.getLayers());
     assert!(aztec.isCompact());
 
-    aztec = encoder::encode(alphabet, 25, 32).expect("should encode");
+    aztec = aztec_encoder::encode(alphabet, 25, 32).expect("should encode");
     assert_eq!(32, aztec.getLayers());
     assert!(!aztec.isCompact());
 
-    encoder::encode(alphabet, 25, userSpecifiedLayers).expect("encode");
+    aztec_encoder::encode(alphabet, 25, userSpecifiedLayers).expect("encode");
 }
 
 #[test]
@@ -618,7 +618,7 @@ fn testBorderCompact4CaseFailed() {
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     // encodes as 26 * 5 * 4 = 520 bits of data
     let alphabet4 = format!("{}{}{}{}", alphabet, alphabet, alphabet, alphabet);
-    encoder::encode(&alphabet4, 0, -4).expect("encode");
+    aztec_encoder::encode(&alphabet4, 0, -4).expect("encode");
 }
 
 #[test]
@@ -630,14 +630,14 @@ fn testBorderCompact4Case() {
     let alphabet4 = format!("{}{}{}{}", alphabet, alphabet, alphabet, alphabet);
 
     // If we just try to encode it normally, it will go to a non-compact 4 layer
-    let mut aztecCode =
+    let mut aztecCode = aztec_encoder::encode(&alphabet4, 0, aztec_encoder::DEFAULT_AZTEC_LAYERS)
-        encoder::encode(&alphabet4, 0, encoder::DEFAULT_AZTEC_LAYERS).expect("Should encode");
+        .expect("Should encode");
     assert!(!aztecCode.isCompact());
     assert_eq!(4, aztecCode.getLayers());
 
     // But shortening the string to 100 bytes (500 bits of data), compact works fine, even if we
     // include more error checking.
-    aztecCode = encoder::encode(&alphabet4[..100], 10, encoder::DEFAULT_AZTEC_LAYERS)
+    aztecCode = aztec_encoder::encode(&alphabet4[..100], 10, aztec_encoder::DEFAULT_AZTEC_LAYERS)
         .expect("should encode");
     assert!(aztecCode.isCompact());
     assert_eq!(4, aztecCode.getLayers());
@@ -646,7 +646,8 @@ fn testBorderCompact4Case() {
 // Helper routines
 
 fn testEncode(data: &str, compact: bool, layers: u32, expected: &str) {
-    let aztec = encoder::encode(data, 33, encoder::DEFAULT_AZTEC_LAYERS).expect("should encode");
+    let aztec = aztec_encoder::encode(data, 33, aztec_encoder::DEFAULT_AZTEC_LAYERS)
+        .expect("should encode");
     assert_eq!(
         compact,
         aztec.isCompact(),
@@ -661,7 +662,8 @@ fn testEncode(data: &str, compact: bool, layers: u32, expected: &str) {
 }
 
 fn testEncodeDecode(data: &str, compact: bool, layers: u32) {
-    let aztec = encoder::encode(data, 25, encoder::DEFAULT_AZTEC_LAYERS).expect("should encode");
+    let aztec = aztec_encoder::encode(data, 25, aztec_encoder::DEFAULT_AZTEC_LAYERS)
+        .expect("should encode");
     assert_eq!(
         compact,
         aztec.isCompact(),
@@ -737,8 +739,12 @@ fn testWriter(
         Some(cs) => cs,
         None => encoding::all::ISO_8859_1,
     };
-    let aztec =
+    let aztec = aztec_encoder::encode_with_charset(
-        encoder::encode_with_charset(data, ecc_percent, encoder::DEFAULT_AZTEC_LAYERS, cset)
+        data,
+        ecc_percent,
+        aztec_encoder::DEFAULT_AZTEC_LAYERS,
+        cset,
+    )
     .expect("encode should encode");
     assert_eq!(
         compact,
@@ -794,7 +800,7 @@ fn getPseudoRandom() -> rand::rngs::ThreadRng {
 }
 
 fn testModeMessageComplex(compact: bool, layers: u32, words: u32, expected: &str) {
-    let indata = encoder::generateModeMessage(compact, layers, words).expect("generate mode");
+    let indata = aztec_encoder::generateModeMessage(compact, layers, words).expect("generate mode");
     assert_eq!(
         stripSpace(expected),
         stripSpace(&indata.to_string()),
@@ -804,7 +810,7 @@ fn testModeMessageComplex(compact: bool, layers: u32, words: u32, expected: &str
 
 fn testStuffBits(wordSize: usize, bits: &str, expected: &str) {
     let indata = toBitArray(bits);
-    let stuffed = encoder::stuffBits(&indata, wordSize);
+    let stuffed = aztec_encoder::stuffBits(&indata, wordSize);
     assert_eq!(
         stripSpace(expected),
         stripSpace(&stuffed.to_string()),

src/aztec/aztec_writer.rs

@@ -23,7 +23,7 @@ use crate::{
     Writer,
 };
 
-use super::encoder::{encoder, AztecCode};
+use super::encoder::{aztec_encoder, AztecCode};
 
 /**
  * Renders an Aztec code as a {@link BitMatrix}.
@@ -51,8 +51,8 @@ impl Writer for AztecWriter {
         hints: &std::collections::HashMap<crate::EncodeHintType, crate::EncodeHintValue>,
     ) -> Result<crate::common::BitMatrix, crate::exceptions::Exceptions> {
         let mut charset = None; // Do not add any ECI code by default
-        let mut ecc_percent = encoder::DEFAULT_EC_PERCENT;
+        let mut ecc_percent = aztec_encoder::DEFAULT_EC_PERCENT;
-        let mut layers = encoder::DEFAULT_AZTEC_LAYERS;
+        let mut layers = aztec_encoder::DEFAULT_AZTEC_LAYERS;
         if hints.contains_key(&EncodeHintType::CHARACTER_SET) {
             if let EncodeHintValue::CharacterSet(cset_name) = hints
                 .get(&EncodeHintType::CHARACTER_SET)
@@ -113,9 +113,9 @@ fn encode(
     }
     let aztec = if let Some(cset) = charset {
         // dbg!(cset.name(), cset.whatwg_name());
-        encoder::encode_with_charset(contents, ecc_percent, layers, cset)?
+        aztec_encoder::encode_with_charset(contents, ecc_percent, layers, cset)?
     } else {
-        encoder::encode(contents, ecc_percent, layers)?
+        aztec_encoder::encode(contents, ecc_percent, layers)?
     };
     renderRXingResult(&aztec, width, height)
 }

src/aztec/encoder/mod.rs

@@ -5,7 +5,7 @@ mod simple_token;
 mod state;
 mod token;
 
-pub mod encoder;
+pub mod aztec_encoder;
 
 pub use aztec_code::*;
 pub use binary_shift_token::*;

src/client/result/AddressBookParsedResult.rs

@@ -100,6 +100,7 @@ impl AddressBookParsedRXingResult {
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn with_details(
         names: Vec<String>,
         nicknames: Vec<String>,

src/client/result/CalendarParsedResult.rs

@@ -97,6 +97,7 @@ impl ParsedRXingResult for CalendarParsedRXingResult {
 }
 
 impl CalendarParsedRXingResult {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         summary: String,
         startString: String,

src/client/result/ExpandedProductParsedResult.rs

@@ -73,6 +73,7 @@ impl ExpandedProductParsedRXingResult {
     pub const KILOGRAM: &'static str = "KG";
     pub const POUND: &'static str = "LB";
 
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         rawText: String,
         productID: String,

src/client/result/VINParsedResult.rs

@@ -62,6 +62,7 @@ impl ParsedRXingResult for VINParsedRXingResult {
     }
 }
 impl VINParsedRXingResult {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         vin: String,
         world_manufacturer_id: String,

src/client/result/WifiParsedResult.rs

@@ -74,6 +74,7 @@ impl WifiParsedRXingResult {
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn with_details(
         networkEncryption: String,
         ssid: String,

src/common/bit_matrix.rs

@@ -209,7 +209,6 @@ impl BitMatrix {
 
     #[inline(always)]
     fn get_offset(&self, y: u32, x: u32) -> usize {
-        
         y as usize * self.row_size + (x as usize / 32)
     }
 

src/common/detector/monochrome_rectangle_detector.rs

@@ -143,6 +143,7 @@ impl<'a> MonochromeRectangleDetector<'_> {
      * @return a {@link RXingResultPoint} encapsulating the corner that was found
      * @throws NotFoundException if such a point cannot be found
      */
+    #[allow(clippy::too_many_arguments)]
     fn findCornerFromCenter(
         &self,
         centerX: i32,

src/common/grid_sampler.rs

@@ -86,6 +86,7 @@ pub trait GridSampler {
      * @throws NotFoundException if image can't be sampled, for example, if the transformation defined
      *   by the given points is invalid or results in sampling outside the image boundaries
      */
+    #[allow(clippy::too_many_arguments)]
     fn sample_grid_detailed(
         &self,
         image: &BitMatrix,

src/common/perspective_transform.rs

@@ -36,6 +36,7 @@ pub struct PerspectiveTransform {
 }
 
 impl PerspectiveTransform {
+    #[allow(clippy::too_many_arguments)]
     fn new(
         a11: f32,
         a21: f32,
@@ -60,6 +61,7 @@ impl PerspectiveTransform {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn quadrilateralToQuadrilateral(
         x0: f32,
         y0: f32,
@@ -118,6 +120,7 @@ impl PerspectiveTransform {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn squareToQuadrilateral(
         x0: f32,
         y0: f32,
@@ -165,6 +168,7 @@ impl PerspectiveTransform {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn quadrilateralToSquare(
         x0: f32,
         y0: f32,

src/datamatrix/decoder/mod.rs

@@ -1,11 +1,11 @@
 mod bit_matrix_parser;
 mod data_block;
-mod decoder;
+mod datamatrix_decoder;
 mod version;
 
 pub use bit_matrix_parser::*;
 pub use data_block::*;
-pub use decoder::*;
+pub use datamatrix_decoder::*;
 pub use version::*;
 
 pub mod decoded_bit_stream_parser;

src/datamatrix/detector/mod.rs

@@ -1,4 +1,4 @@
+mod datamatrix_detector;
 mod datamatrix_result;
-mod detector;
+pub use datamatrix_detector::*;
 pub use datamatrix_result::*;
-pub use detector::*;

src/datamatrix/encoder/mod.rs

@@ -1,5 +1,5 @@
+mod datamatrix_encoder;
 mod default_placement;
-mod encoder;
 mod encoder_context;
 pub mod error_correction;
 pub mod high_level_encoder;
@@ -7,8 +7,8 @@ pub mod minimal_encoder;
 mod symbol_info;
 mod symbol_shape_hint;
 
+pub use datamatrix_encoder::*;
 pub use default_placement::*;
-pub use encoder::*;
 pub use encoder_context::*;
 pub use symbol_info::*;
 pub use symbol_shape_hint::*;

src/datamatrix/encoder/symbol_info.rs

@@ -93,6 +93,7 @@ impl SymbolInfo {
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn with_details(
         rectangular: bool,
         dataCapacity: u32,

src/maxicode/decoder/mod.rs

@@ -1,6 +1,6 @@
 mod bit_matrix_parser;
 pub mod decoded_bit_stream_parser;
-pub mod decoder;
+pub mod maxicode_decoder;
 
 pub use bit_matrix_parser::*;
-pub use decoder::*;
+pub use maxicode_decoder::*;

src/maxicode/maxi_code_reader.rs

@@ -20,7 +20,7 @@ use crate::{
     common::BitMatrix, BarcodeFormat, Exceptions, RXingResult, RXingResultMetadataType, Reader,
 };
 
-use super::decoder::decoder;
+use super::decoder::maxicode_decoder;
 
 /**
  * This implementation can detect and decode a MaxiCode in an image.
@@ -62,7 +62,7 @@ impl Reader for MaxiCodeReader {
         // Note that MaxiCode reader effectively always assumes PURE_BARCODE mode
         // and can't detect it in an image
         let bits = Self::extractPureBits(image.getBlackMatrix())?;
-        let decoderRXingResult = decoder::decode_with_hints(bits, hints)?;
+        let decoderRXingResult = maxicode_decoder::decode_with_hints(bits, hints)?;
         let mut result = RXingResult::new(
             decoderRXingResult.getText(),
             decoderRXingResult.getRawBytes().clone(),

src/multi/qrcode/qr_code_multi_reader.rs

@@ -53,7 +53,7 @@ impl MultipleBarcodeReader for QRCodeMultiReader {
         let detectorRXingResults = MultiDetector::new(image.getBlackMatrix()).detectMulti(hints)?;
         for detectorRXingResult in detectorRXingResults {
             let mut proc = || -> Result<(), Exceptions> {
-                let decoderRXingResult = decoder::decoder::decode_bitmatrix_with_hints(
+                let decoderRXingResult = decoder::qrcode_decoder::decode_bitmatrix_with_hints(
                     detectorRXingResult.getBits(),
                     hints,
                 )?;

src/pdf417/decoder/barcode_value.rs

@@ -50,12 +50,14 @@ impl BarcodeValue {
         let mut result = Vec::new();
         for (key, value) in &self.0 {
             // for (Entry<Integer,Integer> entry : values.entrySet()) {
-            if *value as i32 > maxConfidence {
+            match (*value as i32).cmp(&maxConfidence) {
+                std::cmp::Ordering::Greater => {
                     maxConfidence = *value as i32;
                     result.clear();
                     result.push(*key);
-            } else if *value as i32 == maxConfidence {
+                }
-                result.push(*key);
+                std::cmp::Ordering::Equal => result.push(*key),
+                std::cmp::Ordering::Less => {}
             }
         }
 

src/pdf417/decoder/pdf_417_scanning_decoder.rs

@@ -648,6 +648,7 @@ fn getStartColumn(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn detectCodeword(
     image: &BitMatrix,
     minColumn: u32,

src/pdf417/detector/mod.rs

@@ -1,4 +1,4 @@
 mod pdf_417_detector_result;
 pub use pdf_417_detector_result::*;
 
-pub mod detector;
+pub mod pdf_417_detector;

src/pdf417/pdf_417_reader.rs

@@ -23,7 +23,7 @@ use crate::{
 };
 
 use super::{
-    decoder::pdf_417_scanning_decoder, detector::detector, pdf_417_common,
+    decoder::pdf_417_scanning_decoder, detector::pdf_417_detector, pdf_417_common,
     PDF417RXingResultMetadata,
 };
 
@@ -95,7 +95,7 @@ impl PDF417Reader {
         multiple: bool,
     ) -> Result<Vec<RXingResult>, Exceptions> {
         let mut results = Vec::new(); //new ArrayList<>();
-        let detectorRXingResult = detector::detect_with_hints(image, hints, multiple)?;
+        let detectorRXingResult = pdf_417_detector::detect_with_hints(image, hints, multiple)?;
         for points in detectorRXingResult.getPoints() {
             let points_filtered = points.iter().filter_map(|e| *e).collect();
             // for (RXingResultPoint[] points : detectorRXingResult.getPoints()) {

src/planar_yuv_luminance_source.rs

@@ -153,6 +153,7 @@ pub struct PlanarYUVLuminanceSource {
 }
 
 impl PlanarYUVLuminanceSource {
+    #[allow(clippy::too_many_arguments)]
     pub fn new_with_all(
         yuv_data: Vec<u8>,
         data_width: usize,

src/qrcode/decoder/mod.rs

@@ -2,11 +2,11 @@ mod bit_matrix_parser;
 mod data_block;
 mod data_mask;
 pub mod decoded_bit_stream_parser;
-pub mod decoder;
 mod error_correction_level;
 mod format_information;
 mod mode;
 mod qr_code_decoder_meta_data;
+pub mod qrcode_decoder;
 mod version;
 
 #[cfg(test)]

src/qrcode/detector/detector_test.rs

@@ -3,7 +3,8 @@ use std::collections::HashMap;
 use crate::{
     common::{BitMatrix, DetectorRXingResult},
     qrcode::{
-        decoder::decoder, decoder::ErrorCorrectionLevel, detector::Detector, encoder::encoder,
+        decoder::qrcode_decoder, decoder::ErrorCorrectionLevel, detector::Detector,
+        encoder::qrcode_encoder,
     },
 };
 
@@ -26,8 +27,8 @@ fn test_encode_decode(value: &str) {
     for ec_level_v in 0..4 {
         let ec_level: ErrorCorrectionLevel =
             ErrorCorrectionLevel::forBits(ec_level_v).expect("must get level");
-        let qr_code =
+        let qr_code = qrcode_encoder::encode_with_hints(value, ec_level, &HashMap::new())
-            encoder::encode_with_hints(value, ec_level, &HashMap::new()).expect("must encode");
+            .expect("must encode");
         // dbg!(&qr_code.to_string());
         let byt_matrix = qr_code.getMatrix().as_ref().unwrap().clone();
         // dbg!(BitMatrix::from(byt_matrix.clone()).to_string());
@@ -35,7 +36,8 @@ fn test_encode_decode(value: &str) {
         let new_matrix: &BitMatrix = &byt_matrix.into();
         let mut detector = Detector::new(new_matrix);
         let detected_points = detector.detect().expect("must detect");
-        let decoded = decoder::decode_bitmatrix(detected_points.getBits()).expect("must decode");
+        let decoded =
+            qrcode_decoder::decode_bitmatrix(detected_points.getBits()).expect("must decode");
         assert_eq!(decoded.getText(), value);
     }
 }

src/qrcode/detector/mod.rs

@@ -1,17 +1,17 @@
 mod alignment_pattern;
 mod alignment_pattern_finder;
-mod detector;
 mod finder_pattern;
 mod finder_pattern_finder;
 mod finder_pattern_info;
+mod qrcode_detector;
 mod qrcode_detector_result;
 
 pub use alignment_pattern::*;
 pub use alignment_pattern_finder::*;
-pub use detector::*;
 pub use finder_pattern::*;
 pub use finder_pattern_finder::*;
 pub use finder_pattern_info::*;
+pub use qrcode_detector::*;
 pub use qrcode_detector_result::*;
 
 #[cfg(test)]

src/qrcode/encoder/EncoderTestCase.rs

@@ -20,7 +20,7 @@ use crate::{
     common::BitArray,
     qrcode::{
         decoder::{ErrorCorrectionLevel, Mode, Version},
-        encoder::{encoder, MinimalEncoder},
+        encoder::{qrcode_encoder, MinimalEncoder},
     },
     EncodeHintType, EncodeHintValue,
 };
@@ -42,7 +42,10 @@ fn testGetAlphanumericCode() {
     // The first ten code points are numbers.
     for i in 0..10u8 {
         // for (int i = 0; i < 10; ++i) {
-        assert_eq!(i as i8, encoder::getAlphanumericCode((b'0' + i) as u32));
+        assert_eq!(
+            i as i8,
+            qrcode_encoder::getAlphanumericCode((b'0' + i) as u32)
+        );
     }
 
     // The next 26 code points are capital alphabet letters.
@@ -50,32 +53,32 @@ fn testGetAlphanumericCode() {
         // for (int i = 10; i < 36; ++i) {
         assert_eq!(
             i as i8,
-            encoder::getAlphanumericCode((b'A' + i - 10) as u32)
+            qrcode_encoder::getAlphanumericCode((b'A' + i - 10) as u32)
         );
     }
 
     // Others are symbol letters
-    assert_eq!(36, encoder::getAlphanumericCode(b' ' as u32));
+    assert_eq!(36, qrcode_encoder::getAlphanumericCode(b' ' as u32));
-    assert_eq!(37, encoder::getAlphanumericCode(b'$' as u32));
+    assert_eq!(37, qrcode_encoder::getAlphanumericCode(b'$' as u32));
-    assert_eq!(38, encoder::getAlphanumericCode(b'%' as u32));
+    assert_eq!(38, qrcode_encoder::getAlphanumericCode(b'%' as u32));
-    assert_eq!(39, encoder::getAlphanumericCode(b'*' as u32));
+    assert_eq!(39, qrcode_encoder::getAlphanumericCode(b'*' as u32));
-    assert_eq!(40, encoder::getAlphanumericCode(b'+' as u32));
+    assert_eq!(40, qrcode_encoder::getAlphanumericCode(b'+' as u32));
-    assert_eq!(41, encoder::getAlphanumericCode(b'-' as u32));
+    assert_eq!(41, qrcode_encoder::getAlphanumericCode(b'-' as u32));
-    assert_eq!(42, encoder::getAlphanumericCode(b'.' as u32));
+    assert_eq!(42, qrcode_encoder::getAlphanumericCode(b'.' as u32));
-    assert_eq!(43, encoder::getAlphanumericCode(b'/' as u32));
+    assert_eq!(43, qrcode_encoder::getAlphanumericCode(b'/' as u32));
-    assert_eq!(44, encoder::getAlphanumericCode(b':' as u32));
+    assert_eq!(44, qrcode_encoder::getAlphanumericCode(b':' as u32));
 
     // Should return -1 for other letters;
-    assert_eq!(-1, encoder::getAlphanumericCode(b'a' as u32));
+    assert_eq!(-1, qrcode_encoder::getAlphanumericCode(b'a' as u32));
-    assert_eq!(-1, encoder::getAlphanumericCode(b'#' as u32));
+    assert_eq!(-1, qrcode_encoder::getAlphanumericCode(b'#' as u32));
-    assert_eq!(-1, encoder::getAlphanumericCode(b'\0' as u32));
+    assert_eq!(-1, qrcode_encoder::getAlphanumericCode(b'\0' as u32));
 }
 
 #[test]
 fn test_digits_only() {
     let test_data = "374833744734397449";
-    let data = encoder::encode(test_data, ErrorCorrectionLevel::H).expect("encode");
+    let data = qrcode_encoder::encode(test_data, ErrorCorrectionLevel::H).expect("encode");
-    let decode = crate::qrcode::decoder::decoder::decode_bitmatrix(
+    let decode = crate::qrcode::decoder::qrcode_decoder::decode_bitmatrix(
         &data.getMatrix().as_ref().unwrap().clone().into(),
     )
     .expect("decode");
@@ -85,18 +88,18 @@ fn test_digits_only() {
 #[test]
 fn testChooseMode() {
     // Numeric Mode::
-    assert_eq!(Mode::NUMERIC, encoder::chooseMode("0"));
+    assert_eq!(Mode::NUMERIC, qrcode_encoder::chooseMode("0"));
-    assert_eq!(Mode::NUMERIC, encoder::chooseMode("0123456789"));
+    assert_eq!(Mode::NUMERIC, qrcode_encoder::chooseMode("0123456789"));
     // Alphanumeric Mode::
-    assert_eq!(Mode::ALPHANUMERIC, encoder::chooseMode("A"));
+    assert_eq!(Mode::ALPHANUMERIC, qrcode_encoder::chooseMode("A"));
     assert_eq!(
         Mode::ALPHANUMERIC,
-        encoder::chooseMode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")
+        qrcode_encoder::chooseMode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")
     );
     // 8-bit byte Mode::
-    assert_eq!(Mode::BYTE, encoder::chooseMode("a"));
+    assert_eq!(Mode::BYTE, qrcode_encoder::chooseMode("a"));
-    assert_eq!(Mode::BYTE, encoder::chooseMode("#"));
+    assert_eq!(Mode::BYTE, qrcode_encoder::chooseMode("#"));
-    assert_eq!(Mode::BYTE, encoder::chooseMode(""));
+    assert_eq!(Mode::BYTE, qrcode_encoder::chooseMode(""));
     // Kanji Mode::  We used to use MODE_KANJI for these, but we stopped
     // doing that as we cannot distinguish Shift_JIS from other encodings
     // from data bytes alone.  See also comments in qrcode_encoder::h.
@@ -104,25 +107,25 @@ fn testChooseMode() {
     // AIUE in Hiragana in Shift_JIS
     assert_eq!(
         Mode::BYTE,
-        encoder::chooseMode(&shiftJISString(&[0x8, 0xa, 0x8, 0xa, 0x8, 0xa, 0x8, 0xa6]))
+        qrcode_encoder::chooseMode(&shiftJISString(&[0x8, 0xa, 0x8, 0xa, 0x8, 0xa, 0x8, 0xa6]))
     );
 
     // Nihon in Kanji in Shift_JIS.
     assert_eq!(
         Mode::BYTE,
-        encoder::chooseMode(&shiftJISString(&[0x9, 0xf, 0x9, 0x7b]))
+        qrcode_encoder::chooseMode(&shiftJISString(&[0x9, 0xf, 0x9, 0x7b]))
     );
 
     // Sou-Utsu-Byou in Kanji in Shift_JIS.
     assert_eq!(
         Mode::BYTE,
-        encoder::chooseMode(&shiftJISString(&[0xe, 0x4, 0x9, 0x5, 0x9, 0x61]))
+        qrcode_encoder::chooseMode(&shiftJISString(&[0xe, 0x4, 0x9, 0x5, 0x9, 0x61]))
     );
 }
 
 #[test]
 fn testEncode() {
-    let qrCode = encoder::encode("ABCDEF", ErrorCorrectionLevel::H).expect("encode");
+    let qrCode = qrcode_encoder::encode("ABCDEF", ErrorCorrectionLevel::H).expect("encode");
     let expected = r"<<
  mode: ALPHANUMERIC
  ecLevel: H
@@ -162,8 +165,8 @@ fn testEncodeWithVersion() {
         EncodeHintType::QR_VERSION,
         EncodeHintValue::QrVersion("7".to_owned()),
     );
-    let qrCode =
+    let qrCode = qrcode_encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints)
-        encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints).expect("encode");
+        .expect("encode");
     assert!(qrCode.to_string().contains(" version: 7\n"));
 }
 
@@ -175,7 +178,7 @@ fn testEncodeWithVersionTooSmall() {
         EncodeHintType::QR_VERSION,
         EncodeHintValue::QrVersion("3".to_owned()),
     );
-    encoder::encode_with_hints(
+    qrcode_encoder::encode_with_hints(
         "THISMESSAGEISTOOLONGFORAQRCODEVERSION3",
         ErrorCorrectionLevel::H,
         &hints,
@@ -190,8 +193,8 @@ fn testSimpleutf8ECI() {
         EncodeHintType::CHARACTER_SET,
         EncodeHintValue::CharacterSet("utf8".to_owned()),
     );
-    let qrCode =
+    let qrCode = qrcode_encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints)
-        encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints).expect("encode");
+        .expect("encode");
     let expected = r"<<
  mode: BYTE
  ecLevel: H
@@ -233,7 +236,8 @@ fn testEncodeKanjiMode() {
         EncodeHintValue::CharacterSet("Shift_JIS".to_owned()),
     );
     // Nihon in Kanji
-    let qrCode = encoder::encode_with_hints("\u{65e5}\u{672c}", ErrorCorrectionLevel::M, &hints)
+    let qrCode =
+        qrcode_encoder::encode_with_hints("\u{65e5}\u{672c}", ErrorCorrectionLevel::M, &hints)
             .expect("encode");
     let expected = r"<<
  mode: KANJI
@@ -277,7 +281,7 @@ fn testEncodeShiftjisNumeric() {
     );
 
     let qrCode =
-        encoder::encode_with_hints("0123", ErrorCorrectionLevel::M, &hints).expect("encode");
+        qrcode_encoder::encode_with_hints("0123", ErrorCorrectionLevel::M, &hints).expect("encode");
     let expected = r"<<
  mode: NUMERIC
  ecLevel: M
@@ -315,7 +319,8 @@ fn testEncodeGS1WithStringTypeHint() {
     let mut hints = HashMap::new();
 
     hints.insert(EncodeHintType::GS1_FORMAT, EncodeHintValue::Gs1Format(true));
-    let qrCode = encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
+    let qrCode =
+        qrcode_encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
             .expect("encode");
     verifyGS1EncodedData(&qrCode);
 }
@@ -325,7 +330,8 @@ fn testEncodeGS1WithBooleanTypeHint() {
     let mut hints = HashMap::new();
 
     hints.insert(EncodeHintType::GS1_FORMAT, EncodeHintValue::Gs1Format(true));
-    let qrCode = encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
+    let qrCode =
+        qrcode_encoder::encode_with_hints("100001%11171218", ErrorCorrectionLevel::H, &hints)
             .expect("encode");
     verifyGS1EncodedData(&qrCode);
 }
@@ -339,8 +345,8 @@ fn testDoesNotEncodeGS1WhenBooleanTypeHintExplicitlyFalse() {
         EncodeHintValue::Gs1Format(false),
     );
 
-    let qrCode =
+    let qrCode = qrcode_encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints)
-        encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints).expect("encode");
+        .expect("encode");
     verifyNotGS1EncodedData(&qrCode);
 }
 
@@ -352,8 +358,8 @@ fn testDoesNotEncodeGS1WhenStringTypeHintExplicitlyFalse() {
         EncodeHintType::GS1_FORMAT,
         EncodeHintValue::Gs1Format(false),
     );
-    let qrCode =
+    let qrCode = qrcode_encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints)
-        encoder::encode_with_hints("ABCDEF", ErrorCorrectionLevel::H, &hints).expect("encode");
+        .expect("encode");
     verifyNotGS1EncodedData(&qrCode);
 }
 
@@ -366,8 +372,8 @@ fn testGS1ModeHeaderWithECI() {
         EncodeHintValue::CharacterSet("utf8".to_owned()),
     );
     hints.insert(EncodeHintType::GS1_FORMAT, EncodeHintValue::Gs1Format(true));
-    let qrCode =
+    let qrCode = qrcode_encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints)
-        encoder::encode_with_hints("hello", ErrorCorrectionLevel::H, &hints).expect("encode");
+        .expect("encode");
     let expected = r"<<
  mode: BYTE
  ecLevel: H
@@ -403,14 +409,14 @@ fn testGS1ModeHeaderWithECI() {
 #[test]
 fn testAppendModeInfo() {
     let mut bits = BitArray::new();
-    assert!(encoder::appendModeInfo(Mode::NUMERIC, &mut bits).is_ok());
+    assert!(qrcode_encoder::appendModeInfo(Mode::NUMERIC, &mut bits).is_ok());
     assert_eq!(" ...X", bits.to_string());
 }
 
 #[test]
 fn testAppendLengthInfo() {
     let mut bits = BitArray::new();
-    encoder::appendLengthInfo(
+    qrcode_encoder::appendLengthInfo(
         1, // 1 letter (1/1).
         Version::getVersionForNumber(1).unwrap(),
         Mode::NUMERIC,
@@ -419,7 +425,7 @@ fn testAppendLengthInfo() {
     .expect("ok");
     assert_eq!(" ........ .X", bits.to_string()); // 10 bits.
     let mut bits = BitArray::new();
-    encoder::appendLengthInfo(
+    qrcode_encoder::appendLengthInfo(
         2, // 2 letters (2/1).
         Version::getVersionForNumber(10).unwrap(),
         Mode::ALPHANUMERIC,
@@ -428,7 +434,7 @@ fn testAppendLengthInfo() {
     .expect("ok");
     assert_eq!(" ........ .X.", bits.to_string()); // 11 bits.
     let mut bits = BitArray::new();
-    encoder::appendLengthInfo(
+    qrcode_encoder::appendLengthInfo(
         255, // 255 letter (255/1).
         Version::getVersionForNumber(27).unwrap(),
         Mode::BYTE,
@@ -437,7 +443,7 @@ fn testAppendLengthInfo() {
     .expect("ok");
     assert_eq!(" ........ XXXXXXXX", bits.to_string()); // 16 bits.
     let mut bits = BitArray::new();
-    encoder::appendLengthInfo(
+    qrcode_encoder::appendLengthInfo(
         512, // 512 letters (1024/2).
         Version::getVersionForNumber(40).unwrap(),
         Mode::KANJI,
@@ -452,32 +458,32 @@ fn testAppendBytes() {
     // Should use appendNumericBytes.
     // 1 = 01 = 0001 in 4 bits.
     let mut bits = BitArray::new();
-    encoder::appendBytes(
+    qrcode_encoder::appendBytes(
         "1",
         Mode::NUMERIC,
         &mut bits,
-        encoder::DEFAULT_BYTE_MODE_ENCODING,
+        qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
     )
     .expect("ok");
     assert_eq!(" ...X", bits.to_string());
     // Should use appendAlphanumericBytes.
     // A = 10 = 0xa = 001010 in 6 bits
     let mut bits = BitArray::new();
-    encoder::appendBytes(
+    qrcode_encoder::appendBytes(
         "A",
         Mode::ALPHANUMERIC,
         &mut bits,
-        encoder::DEFAULT_BYTE_MODE_ENCODING,
+        qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
     )
     .expect("ok");
     assert_eq!(" ..X.X.", bits.to_string());
     // Lower letters such as 'a' cannot be encoded in MODE_ALPHANUMERIC.
     //try {
-    if encoder::appendBytes(
+    if qrcode_encoder::appendBytes(
         "a",
         Mode::ALPHANUMERIC,
         &mut bits,
-        encoder::DEFAULT_BYTE_MODE_ENCODING,
+        qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
     )
     .is_ok()
     {
@@ -489,30 +495,30 @@ fn testAppendBytes() {
     // Should use append8BitBytes.
     // 0x61, 0x62, 0x63
     let mut bits = BitArray::new();
-    encoder::appendBytes(
+    qrcode_encoder::appendBytes(
         "abc",
         Mode::BYTE,
         &mut bits,
-        encoder::DEFAULT_BYTE_MODE_ENCODING,
+        qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
     )
     .expect("ok");
     assert_eq!(" .XX....X .XX...X. .XX...XX", bits.to_string());
     // Anything can be encoded in QRCode.MODE_8BIT_BYTE.
-    encoder::appendBytes(
+    qrcode_encoder::appendBytes(
         "\0",
         Mode::BYTE,
         &mut bits,
-        encoder::DEFAULT_BYTE_MODE_ENCODING,
+        qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
     )
     .expect("ok");
     // Should use appendKanjiBytes.
     // 0x93, 0x5f
     let mut bits = BitArray::new();
-    encoder::appendBytes(
+    qrcode_encoder::appendBytes(
         &shiftJISString(&[0x93, 0x5f]),
         Mode::KANJI,
         &mut bits,
-        encoder::DEFAULT_BYTE_MODE_ENCODING,
+        qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING,
     )
     .expect("ok");
     assert_eq!(" .XX.XX.. XXXXX", bits.to_string());
@@ -521,29 +527,29 @@ fn testAppendBytes() {
 #[test]
 fn testTerminateBits() {
     let mut v = BitArray::new();
-    encoder::terminateBits(0, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(0, &mut v).expect("terminate");
     assert_eq!("", v.to_string());
     let mut v = BitArray::new();
-    encoder::terminateBits(1, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
     assert_eq!(" ........", v.to_string());
     let mut v = BitArray::new();
     v.appendBits(0, 3).expect("terminate"); // Append 000
-    encoder::terminateBits(1, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
     assert_eq!(" ........", v.to_string());
     let mut v = BitArray::new();
     v.appendBits(0, 5).expect("terminate"); // Append 00000
-    encoder::terminateBits(1, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
     assert_eq!(" ........", v.to_string());
     let mut v = BitArray::new();
     v.appendBits(0, 8).expect("terminate"); // Append 00000000
-    encoder::terminateBits(1, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(1, &mut v).expect("terminate");
     assert_eq!(" ........", v.to_string());
     let mut v = BitArray::new();
-    encoder::terminateBits(2, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(2, &mut v).expect("terminate");
     assert_eq!(" ........ XXX.XX..", v.to_string());
     let mut v = BitArray::new();
     v.appendBits(0, 1).expect("terminate"); // Append 0
-    encoder::terminateBits(3, &mut v).expect("terminate");
+    qrcode_encoder::terminateBits(3, &mut v).expect("terminate");
     assert_eq!(" ........ XXX.XX.. ...X...X", v.to_string());
 }
 
@@ -551,43 +557,43 @@ fn testTerminateBits() {
 fn testGetNumDataBytesAndNumECBytesForBlockID() {
     // Version 1-H.
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(26, 9, 1, 0).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(26, 9, 1, 0).expect("ok");
     assert_eq!(9, numDataBytes);
     assert_eq!(17, numEcBytes);
 
     // Version 3-H.  2 blocks.
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 0).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 0).expect("ok");
     assert_eq!(13, numDataBytes);
     assert_eq!(22, numEcBytes);
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 1).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(70, 26, 2, 1).expect("ok");
     assert_eq!(13, numDataBytes);
     assert_eq!(22, numEcBytes);
 
     // Version 7-H. (4 + 1) blocks.
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 0).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 0).expect("ok");
     assert_eq!(13, numDataBytes);
     assert_eq!(26, numEcBytes);
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 4).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(196, 66, 5, 4).expect("ok");
     assert_eq!(14, numDataBytes);
     assert_eq!(26, numEcBytes);
 
     // Version 40-H. (20 + 61) blocks.
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 0).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 0).expect("ok");
     assert_eq!(15, numDataBytes);
     assert_eq!(30, numEcBytes);
 
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 20).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 20).expect("ok");
     assert_eq!(16, numDataBytes);
     assert_eq!(30, numEcBytes);
 
     let (numDataBytes, numEcBytes) =
-        encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 80).expect("ok");
+        qrcode_encoder::getNumDataBytesAndNumECBytesForBlockID(3706, 1276, 81, 80).expect("ok");
     assert_eq!(16, numDataBytes);
     assert_eq!(30, numEcBytes);
 }
@@ -600,7 +606,7 @@ fn testInterleaveWithECBytes() {
         // for (byte dataByte: dataBytes) {
         in_.appendBits(*dataByte, 8).expect("ok");
     }
-    let out = encoder::interleaveWithECBytes(&in_, 26, 9, 1).expect("encode");
+    let out = qrcode_encoder::interleaveWithECBytes(&in_, 26, 9, 1).expect("encode");
     let expected = &[
         // Data bytes.
         32, 65, 205, 69, 41, 220, 46, 128, 236, // Error correction bytes.
@@ -627,7 +633,7 @@ fn testInterleaveWithECBytes() {
         in_.appendBits(*dataByte, 8).expect("ok");
     }
 
-    let out = encoder::interleaveWithECBytes(&in_, 134, 62, 4).expect("interleave ok");
+    let out = qrcode_encoder::interleaveWithECBytes(&in_, 134, 62, 4).expect("interleave ok");
     let expected = &[
         // Data bytes.
         67, 230, 54, 55, 70, 247, 70, 71, 22, 7, 86, 87, 38, 23, 102, 103, 54, 39, 118, 119, 70, 55,
@@ -660,23 +666,23 @@ fn testInterleaveWithECBytes() {
 fn testAppendNumericBytes() {
     // 1 = 01 = 0001 in 4 bits.
     let mut bits = BitArray::new();
-    encoder::appendNumericBytes("1", &mut bits).expect("append");
+    qrcode_encoder::appendNumericBytes("1", &mut bits).expect("append");
     assert_eq!(" ...X", bits.to_string());
     // 12 = 0xc = 0001100 in 7 bits.
     let mut bits = BitArray::new();
-    encoder::appendNumericBytes("12", &mut bits).expect("append");
+    qrcode_encoder::appendNumericBytes("12", &mut bits).expect("append");
     assert_eq!(" ...XX..", bits.to_string());
     // 123 = 0x7b = 0001111011 in 10 bits.
     let mut bits = BitArray::new();
-    encoder::appendNumericBytes("123", &mut bits).expect("append");
+    qrcode_encoder::appendNumericBytes("123", &mut bits).expect("append");
     assert_eq!(" ...XXXX. XX", bits.to_string());
     // 1234 = "123" + "4" = 0001111011 + 0100
     let mut bits = BitArray::new();
-    encoder::appendNumericBytes("1234", &mut bits).expect("append");
+    qrcode_encoder::appendNumericBytes("1234", &mut bits).expect("append");
     assert_eq!(" ...XXXX. XX.X..", bits.to_string());
     // Empty.
     let mut bits = BitArray::new();
-    encoder::appendNumericBytes("", &mut bits).expect("append");
+    qrcode_encoder::appendNumericBytes("", &mut bits).expect("append");
     assert_eq!("", bits.to_string());
 }
 
@@ -684,23 +690,23 @@ fn testAppendNumericBytes() {
 fn testAppendAlphanumericBytes() {
     // A = 10 = 0xa = 001010 in 6 bits
     let mut bits = BitArray::new();
-    encoder::appendAlphanumericBytes("A", &mut bits).expect("append");
+    qrcode_encoder::appendAlphanumericBytes("A", &mut bits).expect("append");
     assert_eq!(" ..X.X.", bits.to_string());
     // AB = 10 * 45 + 11 = 461 = 0x1cd = 00111001101 in 11 bits
     let mut bits = BitArray::new();
-    encoder::appendAlphanumericBytes("AB", &mut bits).expect("append");
+    qrcode_encoder::appendAlphanumericBytes("AB", &mut bits).expect("append");
     assert_eq!(" ..XXX..X X.X", bits.to_string());
     // ABC = "AB" + "C" = 00111001101 + 001100
     let mut bits = BitArray::new();
-    encoder::appendAlphanumericBytes("ABC", &mut bits).expect("append");
+    qrcode_encoder::appendAlphanumericBytes("ABC", &mut bits).expect("append");
     assert_eq!(" ..XXX..X X.X..XX. .", bits.to_string());
     // Empty.
     let mut bits = BitArray::new();
-    encoder::appendAlphanumericBytes("", &mut bits).expect("append");
+    qrcode_encoder::appendAlphanumericBytes("", &mut bits).expect("append");
     assert_eq!("", bits.to_string());
     // Invalid data.
     // try {
-    if encoder::appendAlphanumericBytes("abc", &mut BitArray::new()).is_ok() {
+    if qrcode_encoder::appendAlphanumericBytes("abc", &mut BitArray::new()).is_ok() {
         panic!("should not be ok");
     }
     // } catch (WriterException we) {
@@ -712,12 +718,13 @@ fn testAppendAlphanumericBytes() {
 fn testAppend8BitBytes() {
     // 0x61, 0x62, 0x63
     let mut bits = BitArray::new();
-    encoder::append8BitBytes("abc", &mut bits, encoder::DEFAULT_BYTE_MODE_ENCODING)
+    qrcode_encoder::append8BitBytes("abc", &mut bits, qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING)
         .expect("append");
     assert_eq!(" .XX....X .XX...X. .XX...XX", bits.to_string());
     // Empty.
     let mut bits = BitArray::new();
-    encoder::append8BitBytes("", &mut bits, encoder::DEFAULT_BYTE_MODE_ENCODING).expect("append");
+    qrcode_encoder::append8BitBytes("", &mut bits, qrcode_encoder::DEFAULT_BYTE_MODE_ENCODING)
+        .expect("append");
     assert_eq!("", bits.to_string());
 }
 
@@ -725,9 +732,9 @@ fn testAppend8BitBytes() {
 #[test]
 fn testAppendKanjiBytes() {
     let mut bits = BitArray::new();
-    encoder::appendKanjiBytes(&shiftJISString(&[0x93, 0x5f]), &mut bits).expect("append");
+    qrcode_encoder::appendKanjiBytes(&shiftJISString(&[0x93, 0x5f]), &mut bits).expect("append");
     assert_eq!(" .XX.XX.. XXXXX", bits.to_string());
-    encoder::appendKanjiBytes(&shiftJISString(&[0xe4, 0xaa]), &mut bits).expect("append");
+    qrcode_encoder::appendKanjiBytes(&shiftJISString(&[0xe4, 0xaa]), &mut bits).expect("append");
     assert_eq!(" .XX.XX.. XXXXXXX. X.X.X.X. X.", bits.to_string());
 }
 
@@ -736,7 +743,7 @@ fn testAppendKanjiBytes() {
 #[test]
 fn testGenerateECBytes() {
     let dataBytes = &[32, 65, 205, 69, 41, 220, 46, 128, 236];
-    let ecBytes = encoder::generateECBytes(dataBytes, 17);
+    let ecBytes = qrcode_encoder::generateECBytes(dataBytes, 17);
     let expected = [
         42, 159, 74, 221, 244, 169, 239, 150, 138, 70, 237, 85, 224, 96, 74, 219, 61,
     ];
@@ -748,7 +755,7 @@ fn testGenerateECBytes() {
     let dataBytes = &[
         67, 70, 22, 38, 54, 70, 86, 102, 118, 134, 150, 166, 182, 198, 214,
     ];
-    let ecBytes = encoder::generateECBytes(dataBytes, 18);
+    let ecBytes = qrcode_encoder::generateECBytes(dataBytes, 18);
     let expected = &[
         175, 80, 155, 64, 178, 45, 214, 233, 65, 209, 12, 155, 117, 31, 140, 214, 27, 187,
     ];
@@ -759,7 +766,7 @@ fn testGenerateECBytes() {
     }
     // High-order zero coefficient case.
     let dataBytes = &[32, 49, 205, 69, 42, 20, 0, 236, 17];
-    let ecBytes = encoder::generateECBytes(dataBytes, 17);
+    let ecBytes = qrcode_encoder::generateECBytes(dataBytes, 17);
     let expected = &[
         0, 3, 130, 179, 194, 0, 55, 211, 110, 79, 98, 72, 170, 96, 211, 137, 213,
     ];
@@ -805,7 +812,7 @@ fn testBugInBitVectorNumBytes() {
         // for (int x = 0; x < 3518; x++) {
         builder.push('0');
     }
-    assert!(encoder::encode(&builder, ErrorCorrectionLevel::L).is_ok());
+    assert!(qrcode_encoder::encode(&builder, ErrorCorrectionLevel::L).is_ok());
 }
 
 #[test]

src/qrcode/encoder/minimal_encoder.rs

@@ -26,7 +26,7 @@ use crate::{
 
 use unicode_segmentation::UnicodeSegmentation;
 
-use super::encoder;
+use super::qrcode_encoder;
 
 pub enum VersionSize {
     SMALL,  //("version 1-9"),
@@ -155,7 +155,7 @@ impl MinimalEncoder {
         if let Some(version) = version {
             // compute minimal encoding for a given version
             let result = self.encodeSpecificVersion(version)?;
-            if !encoder::willFit(
+            if !qrcode_encoder::willFit(
                 result.getSize(),
                 Self::getVersion(Self::getVersionSize(result.getVersion())),
                 &self.ecLevel,
@@ -183,7 +183,8 @@ impl MinimalEncoder {
             for i in 0..3 {
                 // for (int i = 0; i < 3; i++) {
                 let size = results[i].getSize();
-                if encoder::willFit(size, versions[i], &self.ecLevel) && size < smallestSize {
+                if qrcode_encoder::willFit(size, versions[i], &self.ecLevel) && size < smallestSize
+                {
                     smallestSize = size;
                     smallestRXingResult = i as i32;
                 }
@@ -235,13 +236,13 @@ impl MinimalEncoder {
     }
 
     pub fn isDoubleByteKanji(c: &str) -> bool {
-        encoder::isOnlyDoubleByteKanji(c)
+        qrcode_encoder::isOnlyDoubleByteKanji(c)
     }
 
     pub fn isAlphanumeric(c: &str) -> bool {
         if c.len() == 1 {
             let ch = c.chars().next().unwrap();
-            encoder::getAlphanumericCode(ch as u32) != -1
+            qrcode_encoder::getAlphanumericCode(ch as u32) != -1
         } else {
             false
         }
@@ -612,6 +613,7 @@ pub struct Edge {
     _stringToEncode: Vec<String>,
 }
 impl Edge {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         mode: Mode,
         fromPosition: usize,
@@ -881,7 +883,7 @@ impl RXingResultList {
         let size = Self::internal_static_get_size(version, &list);
         // increase version if needed
         while versionNumber < upperLimit
-            && !encoder::willFit(
+            && !qrcode_encoder::willFit(
                 size,
                 Version::getVersionForNumber(versionNumber).unwrap(),
                 ecLevel,
@@ -891,7 +893,7 @@ impl RXingResultList {
         }
         // shrink version if possible
         while versionNumber > lowerLimit
-            && encoder::willFit(
+            && qrcode_encoder::willFit(
                 size,
                 Version::getVersionForNumber(versionNumber - 1).unwrap(),
                 ecLevel,
@@ -1084,7 +1086,7 @@ impl RXingResultNode {
             bits.appendBits(self.encoders.getECIValue(self.charsetEncoderIndex), 8)?;
         } else if self.characterLength > 0 {
             // append data
-            encoder::appendBytes(
+            qrcode_encoder::appendBytes(
                 // &self.stringToEncode[self.fromPosition as usize
                 //     ..(self.fromPosition + self.characterLength as usize)],
                 &(self

src/qrcode/encoder/mod.rs

@@ -1,10 +1,10 @@
 mod block_pair;
 mod byte_matrix;
-pub mod encoder;
 pub mod mask_util;
 pub mod matrix_util;
 mod minimal_encoder;
 mod qr_code;
+pub mod qrcode_encoder;
 
 pub use block_pair::*;
 pub use byte_matrix::*;

src/qrcode/qr_code_reader.rs

@@ -23,7 +23,7 @@ use crate::{
 };
 
 use super::{
-    decoder::{decoder, QRCodeDecoderMetaData},
+    decoder::{qrcode_decoder, QRCodeDecoderMetaData},
     detector::Detector,
 };
 
@@ -64,13 +64,13 @@ impl Reader for QRCodeReader {
         let mut points: Vec<RXingResultPoint>;
         if hints.contains_key(&DecodeHintType::PURE_BARCODE) {
             let bits = Self::extractPureBits(image.getBlackMatrix())?;
-            decoderRXingResult = decoder::decode_bitmatrix_with_hints(&bits, hints)?;
+            decoderRXingResult = qrcode_decoder::decode_bitmatrix_with_hints(&bits, hints)?;
             points = Vec::new();
         } else {
             let detectorRXingResult =
                 Detector::new(image.getBlackMatrix()).detect_with_hints(hints)?;
             decoderRXingResult =
-                decoder::decode_bitmatrix_with_hints(detectorRXingResult.getBits(), hints)?;
+                qrcode_decoder::decode_bitmatrix_with_hints(detectorRXingResult.getBits(), hints)?;
             points = detectorRXingResult.getPoints().clone();
         }
 

src/qrcode/qr_code_writer.rs

@@ -22,7 +22,7 @@ use crate::{
 
 use super::{
     decoder::ErrorCorrectionLevel,
-    encoder::{encoder, QRCode},
+    encoder::{qrcode_encoder, QRCode},
 };
 
 const QUIET_ZONE_SIZE: i32 = 4;
@@ -102,7 +102,7 @@ impl Writer for QRCodeWriter {
         }
         // }
 
-        let code = encoder::encode_with_hints(contents, errorCorrectionLevel, hints)?;
+        let code = qrcode_encoder::encode_with_hints(contents, errorCorrectionLevel, hints)?;
 
         Self::renderRXingResult(&code, width, height, quietZone)
     }