Introduce Clippy pedantic and nursery

This commit adds new Clippy directives.
Most lints have been applied, mostly affecting formatting or control
flow.

`find` function was skipped because it may be replaced with a
non-recursive version (#80).

dotenv/Cargo.toml

@@ -9,12 +9,13 @@ authors = [
   "Sean Griffin <[email protected]>",
   "Adam Sharp <[email protected]>",
   "Arpad Borsos <[email protected]>",
-  "Allan Zhang <[email protected]>",
+  "Allan Zhang <[email protected]>",
 ]
 description = "A well-maintained fork of the dotenv crate"
 homepage = "https://github.com/allan2/dotenvy"
 readme = "README.md"
 keywords = ["dotenv", "env", "environment", "settings", "config"]
+categories = ["configuration"]
 license = "MIT"
 repository = "https://github.com/allan2/dotenvy"
 edition = "2018"

dotenv/src/errors.rs

@@ -1,7 +1,4 @@
-use std::env;
-use std::error;
-use std::fmt;
-use std::io;
+use std::{env, error, fmt, io};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -14,8 +11,9 @@ pub enum Error {
 }
 
 impl Error {
+    #[must_use]
     pub fn not_found(&self) -> bool {
-        if let Error::Io(ref io_error) = *self {
+        if let Self::Io(ref io_error) = *self {
             return io_error.kind() == io::ErrorKind::NotFound;
         }
         false
@@ -25,8 +23,8 @@ impl Error {
 impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match self {
-            Error::Io(err) => Some(err),
-            Error::EnvVar(err) => Some(err),
+            Self::Io(err) => Some(err),
+            Self::EnvVar(err) => Some(err),
             _ => None,
         }
     }
@@ -35,22 +33,19 @@ impl error::Error for Error {
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Error::Io(err) => write!(fmt, "{}", err),
-            Error::EnvVar(err) => write!(fmt, "{}", err),
-            Error::LineParse(line, error_index) => write!(
+            Self::Io(e) => write!(fmt, "{e}"),
+            Self::EnvVar(e) => write!(fmt, "{e}"),
+            Self::LineParse(line, index) => write!(
                 fmt,
-                "Error parsing line: '{}', error at line index: {}",
-                line, error_index
+                "Error parsing line: '{line}', error at line index: {index}",
             ),
         }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use std::env;
     use std::error::Error as StdError;
-    use std::io;
 
     use super::*;
 

dotenv/src/find.rs

@@ -1,8 +1,11 @@
-use std::fs::File;
-use std::path::{Path, PathBuf};
-use std::{env, fs, io};
-
-use crate::errors::*;
+use std::{
+    env,
+    fs::{self, File},
+    io,
+    path::{Path, PathBuf},
+};
+
+use crate::errors::{Error, Result};
 use crate::iter::Iter;
 
 pub struct Finder<'a> {
@@ -16,7 +19,7 @@ impl<'a> Finder<'a> {
         }
     }
 
-    pub fn filename(mut self, filename: &'a Path) -> Self {
+    pub const fn filename(mut self, filename: &'a Path) -> Self {
         self.filename = filename;
         self
     }

dotenv/src/iter.rs

@@ -1,19 +1,21 @@
-use std::collections::HashMap;
-use std::env;
-use std::io::prelude::*;
-use std::io::BufReader;
-
-use crate::errors::*;
-use crate::parse;
+use crate::{
+    errors::{Error, Result},
+    parse,
+};
+use std::{
+    collections::HashMap,
+    env,
+    io::{BufRead, BufReader, Read},
+};
 
 pub struct Iter<R> {
     lines: QuotedLines<BufReader<R>>,
     substitution_data: HashMap<String, Option<String>>,
 }
 
 impl<R: Read> Iter<R> {
-    pub fn new(reader: R) -> Iter<R> {
-        Iter {
+    pub fn new(reader: R) -> Self {
+        Self {
             lines: QuotedLines {
                 buf: BufReader::new(reader),
             },
@@ -133,13 +135,13 @@ impl<B: BufRead> Iterator for QuotedLines<B> {
         loop {
             buf_pos = buf.len();
             match self.buf.read_line(&mut buf) {
-                Ok(0) => match cur_state {
-                    ParseState::Complete => return None,
-                    _ => {
-                        let len = buf.len();
-                        return Some(Err(Error::LineParse(buf, len)));
+                Ok(0) => {
+                    if matches!(cur_state, ParseState::Complete) {
+                        return None;
                     }
-                },
+                    let len = buf.len();
+                    return Some(Err(Error::LineParse(buf, len)));
+                }
                 Ok(_n) => {
                     // Skip lines which start with a # before iteration
                     // This optimizes parsing a bit.

dotenv/src/lib.rs

@@ -1,3 +1,6 @@
+#![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::cargo)]
+#![allow(clippy::missing_errors_doc)]
+
 //! [`dotenv`]: https://crates.io/crates/dotenv
 //! A well-maintained fork of the [`dotenv`] crate
 //!
@@ -209,7 +212,6 @@ pub fn from_filename_override<P: AsRef<Path>>(filename: P) -> Result<PathBuf> {
 /// #     Ok(())
 /// # }
 /// ```
-
 pub fn from_filename_iter<P: AsRef<Path>>(filename: P) -> Result<Iter<File>> {
     let (_, iter) = Finder::new().filename(filename.as_ref()).find()?;
     Ok(iter)

dotenv/src/parse.rs

@@ -1,7 +1,7 @@
-use std::collections::HashMap;
-use std::env;
+#![allow(clippy::module_name_repetitions)]
 
-use crate::errors::*;
+use crate::errors::{Error, Result};
+use std::{collections::HashMap, env};
 
 // for readability's sake
 pub type ParsedLine = Result<Option<(String, String)>>;
@@ -120,10 +120,7 @@ enum SubstitutionMode {
     EscapedBlock,
 }
 
-fn parse_value(
-    input: &str,
-    substitution_data: &mut HashMap<String, Option<String>>,
-) -> Result<String> {
+fn parse_value(input: &str, substitution_data: &HashMap<String, Option<String>>) -> Result<String> {
     let mut strong_quote = false; // '
     let mut weak_quote = false; // "
     let mut escaped = false;
@@ -145,9 +142,8 @@ fn parse_value(
                 continue;
             } else if c == '#' {
                 break;
-            } else {
-                return Err(Error::LineParse(input.to_owned(), index));
             }
+            return Err(Error::LineParse(input.to_owned(), index));
         } else if escaped {
             //TODO I tried handling literal \r but various issues
             //imo not worth worrying about until there's a use case
@@ -258,7 +254,7 @@ fn parse_value(
 }
 
 fn apply_substitution(
-    substitution_data: &mut HashMap<String, Option<String>>,
+    substitution_data: &HashMap<String, Option<String>>,
     substitution_name: &str,
     output: &mut String,
 ) {

dotenv_codegen/Cargo.toml

@@ -10,10 +10,11 @@ authors = [
   "Mike Piccolo <[email protected]>",
   "Alice Maz <[email protected]>",
   "Sean Griffin <[email protected]>",
-  "Allan Zhang <[email protected]>",
+  "Allan Zhang <[email protected]>",
 ]
 readme = "README.md"
 keywords = ["dotenv", "env", "environment", "settings", "config"]
+categories = ["configuration"]
 license = "MIT"
 homepage = "https://github.com/allan2/dotenvy"
 repository = "https://github.com/allan2/dotenvy"