Merge pull request marshallpierce#186 from marshallpierce/danieleades-refactor/code-quality

Danieleades refactor/code quality

Author: marshallpierce

.circleci/config.yml

@@ -53,6 +53,15 @@ jobs:
           command: |
             rustup component add rustfmt
             cargo fmt -- --check
+      - run:
+          name: Check clippy lints
+          # we only care about stable clippy -- nightly clippy is a bit wild
+          command: |
+            if [[ '<< parameters.toolchain_override >>' == 'stable' ]]
+            then
+              rustup component add clippy
+              cargo clippy --all-targets
+            fi
       - run:
           name: Build all targets
           command: cargo build --all-targets

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::{

clippy.toml

@@ -0,0 +1 @@
+msrv = "1.47.0"

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/roundtrip_no_pad.rs

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

fuzz/fuzzers/utils.rs

@@ -1,4 +1,3 @@
-extern crate base64;
 extern crate rand;
 extern crate rand_pcg;
 extern crate ring;

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
         }

src/decode.rs

@@ -30,11 +30,9 @@ pub enum DecodeError {
 impl fmt::Display for DecodeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            DecodeError::InvalidByte(index, byte) => {
-                write!(f, "Invalid byte {}, offset {}.", byte, index)
-            }
-            DecodeError::InvalidLength => write!(f, "Encoded text cannot have a 6-bit remainder."),
-            DecodeError::InvalidLastSymbol(index, byte) => {
+            Self::InvalidByte(index, byte) => write!(f, "Invalid byte {}, offset {}.", byte, index),
+            Self::InvalidLength => write!(f, "Encoded text cannot have a 6-bit remainder."),
+            Self::InvalidLastSymbol(index, byte) => {
                 write!(f, "Invalid last symbol {}, offset {}.", byte, index)
             }
         }
@@ -45,9 +43,9 @@ impl fmt::Display for DecodeError {
 impl error::Error for DecodeError {
     fn description(&self) -> &str {
         match *self {
-            DecodeError::InvalidByte(_, _) => "invalid byte",
-            DecodeError::InvalidLength => "invalid length",
-            DecodeError::InvalidLastSymbol(_, _) => "invalid last symbol",
+            Self::InvalidByte(_, _) => "invalid byte",
+            Self::InvalidLength => "invalid length",
+            Self::InvalidLastSymbol(_, _) => "invalid last symbol",
         }
     }
 
@@ -62,12 +60,8 @@ impl error::Error for DecodeError {
 ///# Example
 ///
 ///```rust
-///extern crate base64;
-///
-///fn main() {
-///    let bytes = base64::decode("aGVsbG8gd29ybGQ=").unwrap();
-///    println!("{:?}", bytes);
-///}
+/// let bytes = base64::decode("aGVsbG8gd29ybGQ=").unwrap();
+/// println!("{:?}", bytes);
 ///```
 #[cfg(any(feature = "alloc", feature = "std", test))]
 pub fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError> {
@@ -80,9 +74,6 @@ pub fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError> {
 ///# Example
 ///
 ///```rust
-///extern crate base64;
-///
-///fn main() {
 ///    let bytes = base64::decode_engine(
 ///        "aGVsbG8gd29ybGR+Cg==",
 ///        &base64::engine::DEFAULT_ENGINE,
@@ -98,7 +89,6 @@ pub fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError> {
 ///
 ///    ).unwrap();
 ///    println!("{:?}", bytes_url);
-///}
 ///```
 #[cfg(any(feature = "alloc", feature = "std", test))]
 pub fn decode_engine<E: Engine, T: AsRef<[u8]>>(
@@ -117,8 +107,6 @@ pub fn decode_engine<E: Engine, T: AsRef<[u8]>>(
 ///# Example
 ///
 ///```rust
-///extern crate base64;
-///
 ///const URL_SAFE_ENGINE: base64::engine::fast_portable::FastPortable =
 ///    base64::engine::fast_portable::FastPortable::from(
 ///        &base64::alphabet::URL_SAFE,
@@ -162,11 +150,8 @@ pub fn decode_engine_vec<E: Engine, T: AsRef<[u8]>>(
         .expect("Overflow when calculating output buffer length");
     buffer.resize(total_len_estimate, 0);
 
-    let bytes_written;
-    {
-        let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
-        bytes_written = engine.decode(input_bytes, buffer_slice, estimate)?;
-    }
+    let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
+    let bytes_written = engine.decode(input_bytes, buffer_slice, estimate)?;
 
     buffer.truncate(starting_output_len + bytes_written);