cargo clippy --fix

Author: hschimke

src/aztec/DecoderTest.rs

@@ -77,8 +77,7 @@ fn test_high_level_decode_string(expectedString: &str, b: &str) {
     assert_eq!(
         expectedString,
         decoder::highLevelDecode(&toBooleanArray(&bits)).expect("highLevelDecode Failed"),
-        "highLevelDecode() failed for input bits: {}",
-        b
+        "highLevelDecode() failed for input bits: {b}"
     );
 }
 

src/aztec/DetectorTest.rs

@@ -64,7 +64,7 @@ fn test_error_in_parameter_locator_compact() {
 #[test]
 fn test_error_in_parameter_locator_not_compact() {
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz";
-    test_error_in_parameter_locator(&format!("{}{}{}", alphabet, alphabet, alphabet));
+    test_error_in_parameter_locator(&format!("{alphabet}{alphabet}{alphabet}"));
 }
 
 #[test]
@@ -165,7 +165,7 @@ fn test_error_in_parameter_locator(data: &str) {
                     if let Exceptions::NotFoundException(_msg) = res {
                         // all ok
                     } else {
-                        panic!("Only Exceptions::NotFoundException allowed, got {}", res);
+                        panic!("Only Exceptions::NotFoundException allowed, got {res}");
                     }
                 } else {
                     let r = Detector::new(&make_larger(&copy, 3)).detect(false);

src/aztec/EncoderTest.rs

@@ -617,7 +617,7 @@ fn testBorderCompact4CaseFailed() {
     // be error correction
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     // encodes as 26 * 5 * 4 = 520 bits of data
-    let alphabet4 = format!("{}{}{}{}", alphabet, alphabet, alphabet, alphabet);
+    let alphabet4 = format!("{alphabet}{alphabet}{alphabet}{alphabet}");
     aztec_encoder::encode(&alphabet4, 0, -4).expect("encode");
 }
 
@@ -627,7 +627,7 @@ fn testBorderCompact4Case() {
     // be error correction
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     // encodes as 26 * 5 * 4 = 520 bits of data
-    let alphabet4 = format!("{}{}{}{}", alphabet, alphabet, alphabet, alphabet);
+    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 = aztec_encoder::encode(&alphabet4, 0, aztec_encoder::DEFAULT_AZTEC_LAYERS)
@@ -658,7 +658,7 @@ fn testEncode(data: &str, compact: bool, layers: u32, expected: &str) {
 
     // let mut xored = BitMatrix::parse_strings(&stripSpace(expected), "X ", "  ").expect("should parse");
     // xored.xor(matrix).expect("should xor");
-    assert_eq!(expected, matrix.to_string(), "encode({}) failed", data);
+    assert_eq!(expected, matrix.to_string(), "encode({data}) failed");
 }
 
 fn testEncodeDecode(data: &str, compact: bool, layers: u32) {
@@ -814,8 +814,7 @@ fn testStuffBits(wordSize: usize, bits: &str, expected: &str) {
     assert_eq!(
         stripSpace(expected),
         stripSpace(&stuffed.to_string()),
-        "stuffBits() failed for input string: {}",
-        bits
+        "stuffBits() failed for input string: {bits}"
     );
 }
 
@@ -838,8 +837,7 @@ fn testHighLevelEncodeStringUtf8(s: &str, expectedBits: &str) {
     assert_eq!(
         stripSpace(expectedBits),
         receivedBits,
-        "highLevelEncode() failed for input string: {}",
-        s
+        "highLevelEncode() failed for input string: {s}"
     );
 }
 
@@ -856,8 +854,7 @@ fn testHighLevelEncodeString(s: &str, expectedBits: &str) {
     assert_eq!(
         stripSpace(expectedBits),
         receivedBits,
-        "highLevelEncode() failed for input string: {}",
-        s
+        "highLevelEncode() failed for input string: {s}"
     );
     assert_eq!(
         s,
@@ -888,7 +885,6 @@ fn testHighLevelEncodeStringCount(s: &str, expectedReceivedBits: u32) {
     // );
     assert_eq!(
         expectedReceivedBits as usize, receivedBitCount,
-        "highLevelEncode() failed for input string: {} with byte count ({}!={})",
-        s, expectedReceivedBits, receivedBitCount
+        "highLevelEncode() failed for input string: {s} with byte count ({expectedReceivedBits}!={receivedBitCount})"
     );
 }

src/aztec/aztec_writer.rs

@@ -107,8 +107,7 @@ fn encode(
 ) -> Result<BitMatrix, Exceptions> {
     if format != BarcodeFormat::AZTEC {
         return Err(Exceptions::IllegalArgumentException(Some(format!(
-            "can only encode AZTEC, but got {:?}",
-            format
+            "can only encode AZTEC, but got {format:?}"
         ))));
     }
     let aztec = if let Some(cset) = charset {

src/aztec/decoder.rs

@@ -350,8 +350,7 @@ fn correct_bits(
     let num_codewords = rawbits.len() / codeword_size;
     if num_codewords < num_data_codewords as usize {
         return Err(Exceptions::FormatException(Some(format!(
-            "numCodewords {}< numDataCodewords{}",
-            num_codewords, num_data_codewords
+            "numCodewords {num_codewords}< numDataCodewords{num_data_codewords}"
         ))));
     }
     let mut offset = rawbits.len() % codeword_size;

src/aztec/encoder/aztec_encoder.rs

@@ -53,7 +53,7 @@ pub const WORD_SIZE: [u32; 33] = [
 pub fn encode_simple(data: &str) -> Result<AztecCode, Exceptions> {
     let Ok(bytes) = encoding::all::ISO_8859_1
         .encode(data, encoding::EncoderTrap::Replace) else {
-            return Err(Exceptions::IllegalArgumentException(Some(format!("'{}' cannot be encoded as ISO_8859_1", data))));
+            return Err(Exceptions::IllegalArgumentException(Some(format!("'{data}' cannot be encoded as ISO_8859_1"))));
         };
     encode_bytes_simple(&bytes)
 }
@@ -76,8 +76,7 @@ pub fn encode(
         encode_bytes(&bytes, minECCPercent, userSpecifiedLayers)
     } else {
         Err(Exceptions::IllegalArgumentException(Some(format!(
-            "'{}' cannot be encoded as ISO_8859_1",
-            data
+            "'{data}' cannot be encoded as ISO_8859_1"
         ))))
     }
 }
@@ -104,8 +103,7 @@ pub fn encode_with_charset(
         encode_bytes_with_charset(&bytes, minECCPercent, userSpecifiedLayers, charset)
     } else {
         Err(Exceptions::IllegalArgumentException(Some(format!(
-            "'{}' cannot be encoded as ISO_8859_1",
-            data
+            "'{data}' cannot be encoded as ISO_8859_1"
         ))))
     }
 }
@@ -181,8 +179,7 @@ pub fn encode_bytes_with_charset(
             })
         {
             return Err(Exceptions::IllegalArgumentException(Some(format!(
-                "Illegal value {} for layers",
-                user_specified_layers
+                "Illegal value {user_specified_layers} for layers"
             ))));
         }
         total_bits_in_layer_var = total_bits_in_layer(layers, compact);
@@ -498,8 +495,7 @@ fn getGF(wordSize: usize) -> Result<GenericGFRef, Exceptions> {
         10 => Ok(get_predefined_genericgf(PredefinedGenericGF::AztecData10)),
         12 => Ok(get_predefined_genericgf(PredefinedGenericGF::AztecData12)),
         _ => Err(Exceptions::IllegalArgumentException(Some(format!(
-            "Unsupported word size {}",
-            wordSize
+            "Unsupported word size {wordSize}"
         )))),
     }
     // switch (wordSize) {

src/aztec/encoder/state.rs

@@ -86,7 +86,7 @@ impl State {
             // throw new IllegalArgumentException("ECI code must be between 0 and 999999");
         } else {
             let eci_digits = encoding::all::ISO_8859_1
-                .encode(&format!("{}", eci), encoding::EncoderTrap::Strict)
+                .encode(&format!("{eci}"), encoding::EncoderTrap::Strict)
                 .unwrap();
             // let eciDigits = Integer.toString(eci).getBytes(StandardCharsets.ISO_8859_1);
             token.add(eci_digits.len() as i32, 3); // 1-6: number of ECI digits

src/client/result/AddressBookAUResultParser.rs

@@ -89,7 +89,7 @@ fn matchMultipleValuePrefix(prefix: &str, rawText: &str) -> Vec<String> {
     for i in 1..=3 {
         // for (int i = 1; i <= 3; i++) {
         let value = ResultParser::matchSinglePrefixedField(
-            &format!("{}{}:", prefix, i),
+            &format!("{prefix}{i}:"),
             rawText,
             '\r',
             true,

src/client/result/BizcardResultParser.rs

@@ -123,6 +123,6 @@ fn buildName(firstName: &str, lastName: &str) -> String {
     } else if lastName.is_empty() {
         firstName.to_owned()
     } else {
-        format!("{} {}", firstName, lastName)
+        format!("{firstName} {lastName}")
     }
 }

src/client/result/CalendarParsedResult.rs

@@ -196,8 +196,7 @@ impl CalendarParsedRXingResult {
             return match Utc.datetime_from_str(&when, "%Y%m%dT%H%M%SZ") {
                 Ok(dtm) => Ok(dtm.with_timezone(&Utc).timestamp()),
                 Err(e) => Err(Exceptions::ParseException(Some(format!(
-                    "couldn't parse string: {}",
-                    e
+                    "couldn't parse string: {e}"
                 )))),
             };
             // let dtm = DateTime::parse_from_str(&when, "%Y%m%dT%H%M%S").unwrap().with_timezone(&Utc);
@@ -219,16 +218,14 @@ impl CalendarParsedRXingResult {
                 Ok(time_zone) => time_zone,
                 Err(e) => {
                     return Err(Exceptions::ParseException(Some(format!(
-                        "couldn't parse timezone '{}': {}",
-                        tz_part, e
+                        "couldn't parse timezone '{tz_part}': {e}"
                     ))))
                 }
             };
             return match Utc.datetime_from_str(time_part, "%Y%m%dT%H%M%S") {
                 Ok(dtm) => Ok(dtm.with_timezone(&tz_parsed).timestamp()),
                 Err(e) => Err(Exceptions::ParseException(Some(format!(
-                    "couldn't parse string: {}",
-                    e
+                    "couldn't parse string: {e}"
                 )))),
             };
         }
@@ -238,8 +235,7 @@ impl CalendarParsedRXingResult {
             return match Utc.datetime_from_str(&when, "%Y%m%dT%H%M%S") {
                 Ok(dtm) => Ok(dtm.timestamp()),
                 Err(e) => Err(Exceptions::ParseException(Some(format!(
-                    "couldn't parse local time: {}",
-                    e
+                    "couldn't parse local time: {e}"
                 )))),
             };
         }
@@ -300,8 +296,7 @@ impl CalendarParsedRXingResult {
             Ok(dtm.timestamp())
         } else {
             Err(Exceptions::ParseException(Some(format!(
-                "Couldn't parse {}",
-                dateTimeString
+                "Couldn't parse {dateTimeString}"
             ))))
         }
         // DateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss", Locale.ENGLISH);

src/client/result/ExpandedProductParsedResultTestCase.rs

@@ -78,7 +78,7 @@ fn testRSSExpanded() {
                     let ev = epr_res.getUncommonAIs().get(k).unwrap();
                     assert_eq!(v, ev);
                 } else {
-                    panic!("key not found {}", k)
+                    panic!("key not found {k}")
                 }
             }
             // assert_eq!(&uncommonAIs, epr_res.getUncommonAIs());

src/client/result/TelParsedResultTestCase.rs

@@ -49,7 +49,7 @@ fn doTest(contents: &str, number: &str, title: &str) {
     if let ParsedClientResult::TelResult(telRXingResult) = result {
         assert_eq!(number, telRXingResult.getNumber());
         assert_eq!(title, telRXingResult.getTitle());
-        assert_eq!(format!("tel:{}", number), telRXingResult.getTelURI());
+        assert_eq!(format!("tel:{number}"), telRXingResult.getTelURI());
     } else {
         panic!("wrong return type, expected TelResult");
     }

src/client/result/TelResultParser.rs

@@ -36,7 +36,7 @@ pub fn parse(theRXingResult: &crate::RXingResult) -> Option<ParsedClientResult>
     }
     // Normalize "TEL:" to "tel:"
     let telURI = if let Some(stripped) = rawText.strip_prefix("TEL:") {
-        format!("tel:{}", stripped)
+        format!("tel:{stripped}")
     } else {
         rawText.clone()
     };

src/client/result/VCardResultParser.rs

@@ -182,7 +182,7 @@ pub fn matchVCardPrefixedField(
 
     // At start or after newline, match prefix, followed by optional metadata
     // (led by ;) ultimately ending in colon
-    let matcher_primary = Regex::new(&format!("(?:^|\\n)(?i:{})(?:;([^:]*))?:", prefix)).unwrap();
+    let matcher_primary = Regex::new(&format!("(?:^|\\n)(?i:{prefix})(?:;([^:]*))?:")).unwrap();
     // let matcher_primary = Regex::new(&format!("(?:^|\n){}(.*)", prefix)).unwrap();
 
     //let lower_case_raw_text = rawText.to_lowercase();

src/client/result/VEventResultParser.rs

@@ -134,7 +134,7 @@ fn matchSingleVCardPrefixedField(prefix: &str, rawText: &str) -> String {
                 "".to_owned()
             };
             let root_time = values.last().unwrap().clone();
-            format!("{}{}", root_time, tz_mod)
+            format!("{root_time}{tz_mod}")
         }
     } else {
         "".to_owned()

src/common/BitArrayTestCase.rs

@@ -45,12 +45,12 @@ fn test_get_next_set1() {
     let array = BitArray::with_size(32);
     for i in 0..array.getSize() {
         // for (int i = 0; i < array.getSize(); i++) {
-        assert_eq!(32, array.getNextSet(i), "{}", i);
+        assert_eq!(32, array.getNextSet(i), "{i}");
     }
     let array = BitArray::with_size(33);
     for i in 0..array.getSize() {
         // for (int i = 0; i < array.getSize(); i++) {
-        assert_eq!(33, array.getNextSet(i), "{}", i);
+        assert_eq!(33, array.getNextSet(i), "{i}");
     }
 }
 
@@ -60,13 +60,13 @@ fn test_get_next_set2() {
     array.set(31);
     for i in 0..array.getSize() {
         // for (int i = 0; i < array.getSize(); i++) {
-        assert_eq!(if i <= 31 { 31 } else { 33 }, array.getNextSet(i), "{}", i);
+        assert_eq!(if i <= 31 { 31 } else { 33 }, array.getNextSet(i), "{i}");
     }
     array = BitArray::with_size(33);
     array.set(32);
     for i in 0..array.getSize() {
         // for (int i = 0; i < array.getSize(); i++) {
-        assert_eq!(32, array.getNextSet(i), "{}", i);
+        assert_eq!(32, array.getNextSet(i), "{i}");
     }
 }
 
@@ -85,7 +85,7 @@ fn test_get_next_set3() {
         } else {
             expected = 63;
         }
-        assert_eq!(expected, array.getNextSet(i), "{}", i);
+        assert_eq!(expected, array.getNextSet(i), "{i}");
     }
 }
 
@@ -104,7 +104,7 @@ fn test_get_next_set4() {
         } else {
             expected = 63;
         }
-        assert_eq!(expected, array.getNextSet(i), "{}", i);
+        assert_eq!(expected, array.getNextSet(i), "{i}");
     }
 }
 

src/common/bit_array.rs

@@ -393,7 +393,7 @@ impl fmt::Display for BitArray {
             }
             _str.push_str(if self.get(i) { "X" } else { "." });
         }
-        write!(f, "{}", _str)
+        write!(f, "{_str}")
     }
 }
 

src/common/bit_matrix_test_case.rs

@@ -367,7 +367,7 @@ fn test_rotate_180(width: u32, height: u32) {
         // for (int y = 0; y < height; y++) {
         for x in 0..width {
             // for (int x = 0; x < width; x++) {
-            assert_eq!(expected.get(x, y), input.get(x, y), "({},{})", x, y);
+            assert_eq!(expected.get(x, y), input.get(x, y), "({x},{y})");
         }
     }
 }

src/common/eci_string_builder.rs

@@ -94,7 +94,7 @@ impl ECIStringBuilder {
      * @param value int to append as a string
      */
     pub fn append(&mut self, value: i32) {
-        self.append_string(&format!("{}", value));
+        self.append_string(&format!("{value}"));
     }
 
     /**