Skip to content

Commit c452647

Browse files
deejayydeejayy
committed
Update formatting and clippy findings
1 parent d4aad87 commit c452647

31 files changed

Lines changed: 309 additions & 456 deletions

‎.cargo/config.toml‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
[target.x86_64-pc-windows-msvc]
2+
rustflags = ["-C", "target-feature=+crt-static"]
3+
[target.i686-pc-windows-msvc]
4+
rustflags = ["-C", "target-feature=+crt-static"]
5+
6+
[target.x86_64-unknown-linux-musl]
7+
rustflags = [
8+
"-C", "target-feature=+crt-static",
9+
"-C", "link-self-contained=yes",
10+
]

‎rustfmt.toml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
max_width = 140
2+
fn_call_width = 130

‎src/codec/base16.rs‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use data_encoding::{Encoding, HEXLOWER, HEXUPPER, HEXLOWER_PERMISSIVE, HEXUPPER_PERMISSIVE};
1+
use data_encoding::{Encoding, HEXLOWER, HEXLOWER_PERMISSIVE, HEXUPPER, HEXUPPER_PERMISSIVE};
22

33
use super::{util, Codec};
44
use crate::error::{MbaseError, Result};
@@ -17,10 +17,7 @@ fn decode_hex(input: &str, mode: Mode, strict_enc: &Encoding, lenient_enc: &Enco
1717
};
1818

1919
if to_decode.len() % 2 != 0 {
20-
return Err(MbaseError::invalid_length(
21-
crate::error::LengthConstraint::MultipleOf(2),
22-
to_decode.len()
23-
));
20+
return Err(MbaseError::invalid_length(crate::error::LengthConstraint::MultipleOf(2), to_decode.len()));
2421
}
2522

2623
let enc = match mode {
@@ -62,7 +59,7 @@ fn detect_hex(input: &str, codec_name: &str, multibase_code: char) -> DetectCand
6259
warnings.push(format!("{:.1}% non-hex characters", (1.0 - ratio) * 100.0));
6360
}
6461

65-
if input.len() % 2 != 0 {
62+
if !input.len().is_multiple_of(2) {
6663
confidence *= 0.5;
6764
warnings.push("odd length".to_string());
6865
}

‎src/codec/base32.rs‎

Lines changed: 90 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
use data_encoding::{Encoding, Specification};
22
use std::sync::OnceLock;
33

4-
use super::Codec;
54
use super::util;
5+
use super::Codec;
66
use crate::error::{MbaseError, Result};
77
use crate::types::{CaseSensitivity, CodecMeta, DetectCandidate, Mode, PaddingRule};
88

@@ -67,8 +67,7 @@ fn decode_base32(
6767
match mode {
6868
Mode::Strict => {
6969
let e = if expects_padding { pad_enc } else { enc };
70-
e.decode(cleaned.as_bytes())
71-
.map_err(|e| MbaseError::invalid_input(e.to_string()))
70+
e.decode(cleaned.as_bytes()).map_err(|e| MbaseError::invalid_input(e.to_string()))
7271
}
7372
Mode::Lenient => {
7473
let normalized = if is_lowercase {
@@ -180,59 +179,123 @@ macro_rules! impl_base32_codec {
180179
}
181180

182181
impl_base32_codec!(
183-
Base32Lower, "base32lower", &["base32", "b32"], RFC4648_LOWER, Some('b'),
184-
CaseSensitivity::Lower, PaddingRule::None, false, true,
182+
Base32Lower,
183+
"base32lower",
184+
&["base32", "b32"],
185+
RFC4648_LOWER,
186+
Some('b'),
187+
CaseSensitivity::Lower,
188+
PaddingRule::None,
189+
false,
190+
true,
185191
"RFC4648 Base32 lowercase without padding",
186-
get_base32_lower, get_base32_pad_lower
192+
get_base32_lower,
193+
get_base32_pad_lower
187194
);
188195

189196
impl_base32_codec!(
190-
Base32Upper, "base32upper", &["B32"], RFC4648_UPPER, Some('B'),
191-
CaseSensitivity::Upper, PaddingRule::None, false, false,
197+
Base32Upper,
198+
"base32upper",
199+
&["B32"],
200+
RFC4648_UPPER,
201+
Some('B'),
202+
CaseSensitivity::Upper,
203+
PaddingRule::None,
204+
false,
205+
false,
192206
"RFC4648 Base32 uppercase without padding",
193-
get_base32_upper, get_base32_pad_upper
207+
get_base32_upper,
208+
get_base32_pad_upper
194209
);
195210

196211
impl_base32_codec!(
197-
Base32PadLower, "base32padlower", &["base32pad", "b32pad"], RFC4648_LOWER, Some('c'),
198-
CaseSensitivity::Lower, PaddingRule::Required, true, true,
212+
Base32PadLower,
213+
"base32padlower",
214+
&["base32pad", "b32pad"],
215+
RFC4648_LOWER,
216+
Some('c'),
217+
CaseSensitivity::Lower,
218+
PaddingRule::Required,
219+
true,
220+
true,
199221
"RFC4648 Base32 lowercase with padding",
200-
get_base32_lower, get_base32_pad_lower
222+
get_base32_lower,
223+
get_base32_pad_lower
201224
);
202225

203226
impl_base32_codec!(
204-
Base32PadUpper, "base32padupper", &["B32PAD"], RFC4648_UPPER, Some('C'),
205-
CaseSensitivity::Upper, PaddingRule::Required, true, false,
227+
Base32PadUpper,
228+
"base32padupper",
229+
&["B32PAD"],
230+
RFC4648_UPPER,
231+
Some('C'),
232+
CaseSensitivity::Upper,
233+
PaddingRule::Required,
234+
true,
235+
false,
206236
"RFC4648 Base32 uppercase with padding",
207-
get_base32_upper, get_base32_pad_upper
237+
get_base32_upper,
238+
get_base32_pad_upper
208239
);
209240

210241
impl_base32_codec!(
211-
Base32HexLower, "base32hexlower", &["base32hex", "b32hex"], HEX_LOWER, Some('v'),
212-
CaseSensitivity::Lower, PaddingRule::None, false, true,
242+
Base32HexLower,
243+
"base32hexlower",
244+
&["base32hex", "b32hex"],
245+
HEX_LOWER,
246+
Some('v'),
247+
CaseSensitivity::Lower,
248+
PaddingRule::None,
249+
false,
250+
true,
213251
"RFC4648 Base32hex lowercase without padding",
214-
get_base32_hex_lower, get_base32_hex_pad_lower
252+
get_base32_hex_lower,
253+
get_base32_hex_pad_lower
215254
);
216255

217256
impl_base32_codec!(
218-
Base32HexUpper, "base32hexupper", &["B32HEX"], HEX_UPPER, Some('V'),
219-
CaseSensitivity::Upper, PaddingRule::None, false, false,
257+
Base32HexUpper,
258+
"base32hexupper",
259+
&["B32HEX"],
260+
HEX_UPPER,
261+
Some('V'),
262+
CaseSensitivity::Upper,
263+
PaddingRule::None,
264+
false,
265+
false,
220266
"RFC4648 Base32hex uppercase without padding",
221-
get_base32_hex_upper, get_base32_hex_pad_upper
267+
get_base32_hex_upper,
268+
get_base32_hex_pad_upper
222269
);
223270

224271
impl_base32_codec!(
225-
Base32HexPadLower, "base32hexpadlower", &["base32hexpad", "b32hexpad"], HEX_LOWER, Some('t'),
226-
CaseSensitivity::Lower, PaddingRule::Required, true, true,
272+
Base32HexPadLower,
273+
"base32hexpadlower",
274+
&["base32hexpad", "b32hexpad"],
275+
HEX_LOWER,
276+
Some('t'),
277+
CaseSensitivity::Lower,
278+
PaddingRule::Required,
279+
true,
280+
true,
227281
"RFC4648 Base32hex lowercase with padding",
228-
get_base32_hex_lower, get_base32_hex_pad_lower
282+
get_base32_hex_lower,
283+
get_base32_hex_pad_lower
229284
);
230285

231286
impl_base32_codec!(
232-
Base32HexPadUpper, "base32hexpadupper", &["B32HEXPAD"], HEX_UPPER, Some('T'),
233-
CaseSensitivity::Upper, PaddingRule::Required, true, false,
287+
Base32HexPadUpper,
288+
"base32hexpadupper",
289+
&["B32HEXPAD"],
290+
HEX_UPPER,
291+
Some('T'),
292+
CaseSensitivity::Upper,
293+
PaddingRule::Required,
294+
true,
295+
false,
234296
"RFC4648 Base32hex uppercase with padding",
235-
get_base32_hex_upper, get_base32_hex_pad_upper
297+
get_base32_hex_upper,
298+
get_base32_hex_pad_upper
236299
);
237300

238301
#[cfg(test)]

‎src/codec/base32human.rs‎

Lines changed: 13 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -50,10 +50,7 @@ fn crockford_encode(input: &[u8]) -> String {
5050
fn crockford_decode(input: &str, mode: Mode) -> Result<Vec<u8>> {
5151
let cleaned: String = match mode {
5252
Mode::Strict => input.to_string(),
53-
Mode::Lenient => input
54-
.chars()
55-
.filter(|c| !c.is_ascii_whitespace() && *c != '-')
56-
.collect(),
53+
Mode::Lenient => input.chars().filter(|c| !c.is_ascii_whitespace() && *c != '-').collect(),
5754
};
5855

5956
if cleaned.is_empty() {
@@ -83,9 +80,7 @@ fn crockford_decode(input: &str, mode: Mode) -> Result<Vec<u8>> {
8380
if bits > 0 {
8481
let remaining_bits = buffer & ((1 << bits) - 1);
8582
if remaining_bits != 0 {
86-
return Err(MbaseError::invalid_input(
87-
"crockford32 decode: non-zero padding bits"
88-
));
83+
return Err(MbaseError::invalid_input("crockford32 decode: non-zero padding bits"));
8984
}
9085
}
9186

@@ -137,22 +132,14 @@ fn crockford_char_value(ch: char, mode: Mode) -> Result<Option<u8>> {
137132
fn validate_crockford(input: &str, mode: Mode) -> Result<()> {
138133
let cleaned: String = match mode {
139134
Mode::Strict => input.to_string(),
140-
Mode::Lenient => input
141-
.chars()
142-
.filter(|c| !c.is_ascii_whitespace() && *c != '-')
143-
.collect(),
135+
Mode::Lenient => input.chars().filter(|c| !c.is_ascii_whitespace() && *c != '-').collect(),
144136
};
145137

146138
for (pos, ch) in cleaned.chars().enumerate() {
147139
let upper = ch.to_ascii_uppercase();
148140
let valid = match mode {
149141
Mode::Strict => CROCKFORD_ALPHABET.contains(upper) && ch.is_ascii_uppercase(),
150-
Mode::Lenient => {
151-
CROCKFORD_ALPHABET.contains(upper)
152-
|| upper == 'O'
153-
|| upper == 'I'
154-
|| upper == 'L'
155-
}
142+
Mode::Lenient => CROCKFORD_ALPHABET.contains(upper) || upper == 'O' || upper == 'I' || upper == 'L',
156143
};
157144
if !valid {
158145
return Err(MbaseError::InvalidCharacter { char: ch, position: pos });
@@ -225,10 +212,7 @@ impl Codec for ZBase32 {
225212
reasons.push("multibase prefix 'h' detected".to_string());
226213
}
227214

228-
let valid = input
229-
.chars()
230-
.filter(|c| ZBASE32_ALPHABET_FULL.contains(*c))
231-
.count();
215+
let valid = input.chars().filter(|c| ZBASE32_ALPHABET_FULL.contains(*c)).count();
232216
let ratio = valid as f64 / input.len() as f64;
233217

234218
if ratio == 1.0 {
@@ -343,10 +327,7 @@ mod tests {
343327

344328
#[test]
345329
fn test_crockford_decode() {
346-
assert_eq!(
347-
Crockford32.decode("91JPRV3F", Mode::Strict).unwrap(),
348-
b"Hello"
349-
);
330+
assert_eq!(Crockford32.decode("91JPRV3F", Mode::Strict).unwrap(), b"Hello");
350331
}
351332

352333
#[test]
@@ -359,30 +340,18 @@ mod tests {
359340

360341
#[test]
361342
fn test_crockford_lenient_confusables() {
362-
assert_eq!(
363-
Crockford32.decode("O1JPRV3F", Mode::Lenient).unwrap(),
364-
Crockford32.decode("01JPRV3F", Mode::Lenient).unwrap()
365-
);
366-
assert_eq!(
367-
Crockford32.decode("9IJPRV3F", Mode::Lenient).unwrap(),
368-
Crockford32.decode("91JPRV3F", Mode::Lenient).unwrap()
369-
);
343+
assert_eq!(Crockford32.decode("O1JPRV3F", Mode::Lenient).unwrap(), Crockford32.decode("01JPRV3F", Mode::Lenient).unwrap());
344+
assert_eq!(Crockford32.decode("9IJPRV3F", Mode::Lenient).unwrap(), Crockford32.decode("91JPRV3F", Mode::Lenient).unwrap());
370345
}
371346

372347
#[test]
373348
fn test_crockford_lenient_hyphens() {
374-
assert_eq!(
375-
Crockford32.decode("91JP-RV3F", Mode::Lenient).unwrap(),
376-
b"Hello"
377-
);
349+
assert_eq!(Crockford32.decode("91JP-RV3F", Mode::Lenient).unwrap(), b"Hello");
378350
}
379351

380352
#[test]
381353
fn test_crockford_lenient_lowercase() {
382-
assert_eq!(
383-
Crockford32.decode("91jprv3f", Mode::Lenient).unwrap(),
384-
b"Hello"
385-
);
354+
assert_eq!(Crockford32.decode("91jprv3f", Mode::Lenient).unwrap(), b"Hello");
386355
}
387356

388357
#[test]
@@ -393,10 +362,7 @@ mod tests {
393362
#[test]
394363
fn test_crockford_empty() {
395364
assert_eq!(Crockford32.encode(&[]).unwrap(), "");
396-
assert_eq!(
397-
Crockford32.decode("", Mode::Strict).unwrap(),
398-
Vec::<u8>::new()
399-
);
365+
assert_eq!(Crockford32.decode("", Mode::Strict).unwrap(), Vec::<u8>::new());
400366
}
401367

402368
#[test]
@@ -424,11 +390,11 @@ mod tests {
424390
// Change last char to one that would set trailing bits differently
425391
let last_val = crockford_char_value(chars[last_idx], Mode::Strict).unwrap().unwrap();
426392
let new_val = (last_val ^ 1) & 0x1f; // Flip bit 0
427-
// Find corresponding char for new_val
393+
// Find corresponding char for new_val
428394
let new_char = CROCKFORD_ALPHABET.chars().nth(new_val as usize).unwrap();
429395
chars[last_idx] = new_char;
430396
let modified: String = chars.into_iter().collect();
431-
397+
432398
let result = Crockford32.decode(&modified, Mode::Strict);
433399
assert!(result.is_err(), "should reject invalid padding bits");
434400
}

‎src/codec/base36.rs‎

Lines changed: 3 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,9 @@ fn encode_base36(input: &[u8], alphabet: &[u8]) -> String {
2525
});
2626

2727
let leading_zeros = input.iter().take_while(|&&b| b == 0).count();
28-
for _ in 0..leading_zeros {
29-
num.push(0);
30-
}
28+
num.extend(std::iter::repeat_n(0, leading_zeros));
3129

32-
num.iter()
33-
.rev()
34-
.map(|&d| alphabet[d as usize] as char)
35-
.collect()
30+
num.iter().rev().map(|&d| alphabet[d as usize] as char).collect()
3631
}
3732

3833
fn decode_base36(input: &str, mode: Mode, is_lowercase: bool) -> Result<Vec<u8>> {
@@ -286,7 +281,7 @@ mod tests {
286281
let enc1 = Base36Lower.encode(data1).unwrap();
287282
let enc2 = Base36Lower.encode(data2).unwrap();
288283
assert_ne!(enc1, enc2, "Leading zero byte should produce different encoding");
289-
284+
290285
let dec1 = Base36Lower.decode(&enc1, Mode::Strict).unwrap();
291286
let dec2 = Base36Lower.decode(&enc2, Mode::Strict).unwrap();
292287
assert_eq!(dec1, data1);

0 commit comments

Comments
 (0)