Merge branch 'refactor/code-quality' of https://github.com/danieleades/rust-base64 into danieleades-refactor/code-quality

Author: marshallpierce

README.md

@@ -13,8 +13,6 @@ This library's goals are to be *correct* and *fast*. It's thoroughly tested and
 ## Example
 
 ```rust
-extern crate base64;
-
 use base64::{encode, decode};
 
 fn main() {

benches/benchmarks.rs

@@ -1,7 +1,5 @@
-extern crate base64;
 #[macro_use]
 extern crate criterion;
-extern crate rand;
 
 use base64::display;
 use base64::{

examples/base64.rs

@@ -15,16 +15,16 @@ enum Alphabet {
 
 impl Default for Alphabet {
     fn default() -> Self {
-        Alphabet::Standard
+        Self::Standard
     }
 }
 
 impl FromStr for Alphabet {
     type Err = String;
-    fn from_str(s: &str) -> Result<Alphabet, String> {
+    fn from_str(s: &str) -> Result<Self, String> {
         match s {
-            "standard" => Ok(Alphabet::Standard),
-            "urlsafe" => Ok(Alphabet::UrlSafe),
+            "standard" => Ok(Self::Standard),
+            "urlsafe" => Ok(Self::UrlSafe),
             _ => Err(format!("alphabet '{}' unrecognized", s)),
         }
     }

fuzz/fuzzers/decode_random.rs

@@ -1,6 +1,5 @@
 #![no_main]
 #[macro_use] extern crate libfuzzer_sys;
-extern crate base64;
 
 use base64::*;
 

fuzz/fuzzers/roundtrip.rs

@@ -1,6 +1,5 @@
 #![no_main]
 #[macro_use] extern crate libfuzzer_sys;
-extern crate base64;
 
 use base64::engine::DEFAULT_ENGINE;
 

fuzz/fuzzers/roundtrip_no_pad.rs

@@ -1,6 +1,5 @@
 #![no_main]
 #[macro_use] extern crate libfuzzer_sys;
-extern crate base64;
 use base64::engine::fast_portable;
 
 fuzz_target!(|data: &[u8]| {

fuzz/fuzzers/roundtrip_random_config.rs

@@ -1,6 +1,5 @@
 #![no_main]
 #[macro_use] extern crate libfuzzer_sys;
-extern crate base64;
 
 use base64::*;
 

fuzz/fuzzers/utils.rs

@@ -1,8 +1,3 @@
-extern crate base64;
-extern crate rand;
-extern crate rand_pcg;
-extern crate ring;
-
 use base64::{alphabet, engine::fast_portable};
 use self::rand::{Rng, SeedableRng};
 use self::rand_pcg::Pcg32;

src/alphabet.rs

@@ -27,7 +27,7 @@ pub struct Alphabet {
 impl Alphabet {
     /// Performs no checks so that it can be const.
     /// Used only for known-valid strings.
-    const fn from_str_unchecked(alphabet: &str) -> Alphabet {
+    const fn from_str_unchecked(alphabet: &str) -> Self {
         let mut symbols = [0_u8; ALPHABET_SIZE];
         let source_bytes = alphabet.as_bytes();
 
@@ -38,7 +38,7 @@ impl Alphabet {
             index += 1;
         }
 
-        Alphabet { symbols }
+        Self { symbols }
     }
 
     /// Create an `Alphabet` from a string of 64 unique printable ASCII bytes.
@@ -97,7 +97,7 @@ impl convert::TryFrom<&str> for Alphabet {
     type Error = ParseAlphabetError;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        Alphabet::from_str(value)
+        Self::from_str(value)
     }
 }
 
@@ -117,10 +117,10 @@ pub enum ParseAlphabetError {
 impl fmt::Display for ParseAlphabetError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ParseAlphabetError::InvalidLength => write!(f, "Invalid length - must be 64 bytes"),
-            ParseAlphabetError::DuplicatedByte(b) => write!(f, "Duplicated byte: {:#04x}", b),
-            ParseAlphabetError::UnprintableByte(b) => write!(f, "Unprintable byte: {:#04x}", b),
-            ParseAlphabetError::ReservedByte(b) => write!(f, "Reserved byte: {:#04x}", b),
+            Self::InvalidLength => write!(f, "Invalid length - must be 64 bytes"),
+            Self::DuplicatedByte(b) => write!(f, "Duplicated byte: {:#04x}", b),
+            Self::UnprintableByte(b) => write!(f, "Unprintable byte: {:#04x}", b),
+            Self::ReservedByte(b) => write!(f, "Reserved byte: {:#04x}", b),
         }
     }
 }
@@ -238,6 +238,6 @@ mod tests {
             STANDARD,
             Alphabet::try_from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
                 .unwrap()
-        )
+        );
     }
 }

src/chunked_encoder.rs

@@ -201,14 +201,13 @@ pub mod tests {
 
     fn chunked_encode_str(bytes: &[u8], config: FastPortableConfig) -> String {
         let mut s = String::new();
-        {
-            let mut sink = StringSink::from(&mut s);
-            let engine = FastPortable::from(&STANDARD, config);
-            let encoder = ChunkedEncoder::from(&engine);
-            encoder.encode(bytes, &mut sink).unwrap();
-        }
 
-        return s;
+        let mut sink = StringSink::from(&mut s);
+        let engine = FastPortable::from(&STANDARD, config);
+        let encoder = ChunkedEncoder::from(&engine);
+        encoder.encode(bytes, &mut sink).unwrap();
+
+        s
     }
 
     // An abstraction around sinks so that we can have tests that easily to any sink implementation
@@ -222,10 +221,8 @@ pub mod tests {
         fn encode_to_string<E: Engine>(&self, engine: &E, bytes: &[u8]) -> String {
             let encoder = ChunkedEncoder::from(engine);
             let mut s = String::new();
-            {
-                let mut sink = StringSink::from(&mut s);
-                encoder.encode(bytes, &mut sink).unwrap();
-            }
+            let mut sink = StringSink::from(&mut s);
+            encoder.encode(bytes, &mut sink).unwrap();
 
             s
         }