ran rustfmt

Author: cutler-scott-newrelic

src/aws_scanning.rs

@@ -53,7 +53,7 @@
 use crate::SecretScanner;
 use encoding::all::ASCII;
 use encoding::{DecoderTrap, Encoding};
-use log::{self, trace, error};
+use log::{self, error, trace};
 use s3::bucket::Bucket;
 use serde_derive::{Deserialize, Serialize};
 use simple_error::SimpleError;
@@ -87,7 +87,11 @@ impl S3Scanner {
         Self { secret_scanner }
     }
 
-    pub fn new() -> Self { Self { secret_scanner: SecretScanner::default() } }
+    pub fn new() -> Self {
+        Self {
+            secret_scanner: SecretScanner::default(),
+        }
+    }
 
     /// Takes an initialized [Bucket](https://durch.github.io/rust-s3/s3/bucket/struct.Bucket.html)
     /// object and an S3 object path in the format `s3://<path>` and returns a list of S3Finding

src/bin/ankamali_hog.rs

@@ -32,7 +32,7 @@ extern crate yup_oauth2 as oauth2;
 
 use clap::ArgMatches;
 use drive3::DriveHub;
-use log::{self, info, error};
+use log::{self, error, info};
 use oauth2::{
     ApplicationSecret, Authenticator, DefaultAuthenticatorDelegate, DiskTokenStorage, FlowType,
 };
@@ -63,7 +63,7 @@ fn main() {
         .get_matches();
     match run(&matches) {
         Ok(()) => {}
-        Err(e) => error!( "Error running command: {}", e)
+        Err(e) => error!("Error running command: {}", e),
     }
 }
 
@@ -112,6 +112,9 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
     info!("Found {} secrets", findings.len());
     match gdrive_scanner.secret_scanner.output_findings(&findings) {
         Ok(_) => Ok(()),
-        Err(err) => Err(SimpleError::with("failed to output findings", SimpleError::new(err.to_string())))
+        Err(err) => Err(SimpleError::with(
+            "failed to output findings",
+            SimpleError::new(err.to_string()),
+        )),
     }
 }

src/bin/berkshire_hog.rs

@@ -67,7 +67,7 @@ fn main() {
         .get_matches();
     match run(&matches) {
         Ok(()) => {}
-        Err(e) => error!( "Error running command: {}", e)
+        Err(e) => error!("Error running command: {}", e),
     }
 }
 
@@ -93,9 +93,7 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
     };
 
     // Initialize our S3 variables
-    let profile = arg_matches
-        .value_of("PROFILE")
-        .map(|x| x.to_string());
+    let profile = arg_matches.value_of("PROFILE").map(|x| x.to_string());
     let credentials = Credentials::new(None, None, None, profile);
     debug!(
         "credentials: {:?} {:?} {:?}",
@@ -165,6 +163,9 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
     info!("Found {} secrets", findings.len());
     match s3scanner.secret_scanner.output_findings(&findings) {
         Ok(_) => Ok(()),
-        Err(err) => Err(SimpleError::with("failed to output findings", SimpleError::new(err.to_string())))
+        Err(err) => Err(SimpleError::with(
+            "failed to output findings",
+            SimpleError::new(err.to_string()),
+        )),
     }
 }

src/bin/choctaw_hog.rs

@@ -41,12 +41,12 @@ extern crate chrono;
 extern crate encoding;
 
 use clap::ArgMatches;
-use log::{self, info, error};
+use log::{self, error, info};
 use simple_error::SimpleError;
 use std::str;
 use tempdir::TempDir;
 
-use rusty_hogs::git_scanning::{GitScanner};
+use rusty_hogs::git_scanning::GitScanner;
 use rusty_hogs::{SecretScanner, SecretScannerBuilder};
 
 /// Main entry function that uses the [clap crate](https://docs.rs/clap/2.33.0/clap/)
@@ -75,7 +75,7 @@ fn main() {
     .get_matches();
     match run(&matches) {
         Ok(()) => {}
-        Err(e) => error!( "Error running command: {}", e)
+        Err(e) => error!("Error running command: {}", e),
     }
 }
 
@@ -93,8 +93,14 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
     let since_commit = arg_matches.value_of("SINCECOMMIT");
     let until_commit = arg_matches.value_of("UNTILCOMMIT");
     let recent_days: Option<u32> = match value_t!(arg_matches.value_of("RECENTDAYS"), u32) {
-        Ok(d) => { if d == 0 { None } else { Some(d) } },
-        Err(_e) => None
+        Ok(d) => {
+            if d == 0 {
+                None
+            } else {
+                Some(d)
+            }
+        }
+        Err(_e) => None,
     };
 
     // Get Git objects
@@ -111,12 +117,15 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
         httpsuser,
         httpspass,
     );
-    let findings = git_scanner.perform_scan(None, since_commit, until_commit, recent_days) ;
+    let findings = git_scanner.perform_scan(None, since_commit, until_commit, recent_days);
 
     // Output the results
     info!("Found {} secrets", findings.len());
     match git_scanner.secret_scanner.output_findings(&findings) {
         Ok(_) => Ok(()),
-        Err(err) => Err(SimpleError::with("failed to output findings", SimpleError::new(err.to_string())))
+        Err(err) => Err(SimpleError::with(
+            "failed to output findings",
+            SimpleError::new(err.to_string()),
+        )),
     }
 }

src/bin/duroc_hog.rs

@@ -35,20 +35,20 @@ extern crate chrono;
 extern crate encoding;
 
 use clap::ArgMatches;
-use log::{self, debug, info, error};
+use log::{self, debug, error, info};
 use serde::{Deserialize, Serialize};
 use simple_error::SimpleError;
 use std::fs::File;
 use std::io::{Cursor, Read};
 use std::path::{Path, PathBuf};
 use std::{io, str};
-use walkdir::{WalkDir};
+use walkdir::WalkDir;
 
 use encoding::all::ASCII;
 use encoding::{DecoderTrap, Encoding};
+use path_clean::PathClean;
 use rusty_hogs::{SecretScanner, SecretScannerBuilder};
 use std::collections::HashSet;
-use path_clean::PathClean;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone, Default)]
 /// `serde_json` object that represents a single found secret - finding
@@ -87,7 +87,7 @@ fn main() {
         .get_matches();
     match run(&matches) {
         Ok(()) => {}
-        Err(e) => error!( "Error running command: {}", e)
+        Err(e) => error!("Error running command: {}", e),
     }
 }
 
@@ -116,7 +116,13 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
     let mut output: HashSet<FileFinding> = HashSet::new();
 
     if Path::is_dir(fspath) {
-        output.extend(scan_dir(fspath, output_file, &secret_scanner, recursive, unzip));
+        output.extend(scan_dir(
+            fspath,
+            output_file,
+            &secret_scanner,
+            recursive,
+            unzip,
+        ));
     } else {
         let f = File::open(fspath).unwrap();
         output.extend(scan_file(fspath, &secret_scanner, f, "", unzip));
@@ -125,7 +131,10 @@ fn run(arg_matches: &ArgMatches) -> Result<(), SimpleError> {
     info!("Found {} secrets", output.len());
     match secret_scanner.output_findings(&output) {
         Ok(_) => Ok(()),
-        Err(err) => Err(SimpleError::with("failed to output findings", SimpleError::new(err.to_string())))
+        Err(err) => Err(SimpleError::with(
+            "failed to output findings",
+            SimpleError::new(err.to_string()),
+        )),
     }
 }
 
@@ -155,24 +164,36 @@ fn scan_dir(
     output
 }
 
-fn recursive_dir_scan<C>(fspath: &Path, output_file: &Path, mut closure: C) where C: FnMut(&Path) {
+fn recursive_dir_scan<C>(fspath: &Path, output_file: &Path, mut closure: C)
+where
+    C: FnMut(&Path),
+{
     for entry in WalkDir::new(fspath).into_iter().filter_map(|e| e.ok()) {
         if entry.file_type().is_file() && &PathBuf::from(entry.path()).clean() != output_file {
             closure(&entry.path());
         }
     }
 }
 
-fn flat_dir_scan<C>(fspath: &Path, output_file: &Path, mut closure: C) where C: FnMut(&Path) {
+fn flat_dir_scan<C>(fspath: &Path, output_file: &Path, mut closure: C)
+where
+    C: FnMut(&Path),
+{
     let dir_contents: Vec<PathBuf> = fspath
-            .read_dir()
-            .expect("read_dir call failed")
-            .filter_map(|e| e.ok())
-            .filter(|e| e.file_type().unwrap().is_file())
-            .map(|e| e.path())
-            .inspect(|e| debug!("clean path: {:?}, output_file: {:?}", &e.clean(), output_file))
-            .filter(|e| e.clean() != output_file)
-            .collect();
+        .read_dir()
+        .expect("read_dir call failed")
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_type().unwrap().is_file())
+        .map(|e| e.path())
+        .inspect(|e| {
+            debug!(
+                "clean path: {:?}, output_file: {:?}",
+                &e.clean(),
+                output_file
+            )
+        })
+        .filter(|e| e.clean() != output_file)
+        .collect();
     debug!("dir_contents: {:?}", dir_contents);
 
     for file_path in dir_contents {
@@ -204,7 +225,10 @@ fn scan_file<R: Read + io::Seek>(
             // and moving it (inefficient) *but* that means we can recursively decompress
             let mut innerdata: Vec<u8> = Vec::new();
             let read_result = innerfile.read_to_end(&mut innerdata);
-            if read_result.is_err() { info!("read error within ZIP file"); continue; }
+            if read_result.is_err() {
+                info!("read error within ZIP file");
+                continue;
+            }
             let new_reader = Cursor::new(innerdata);
             let mut inner_findings = scan_file(
                 innerfile.sanitized_name().as_path(),
@@ -226,7 +250,10 @@ fn scan_file<R: Read + io::Seek>(
             let mut inner_entry = entry_result.unwrap();
             let mut innerdata: Vec<u8> = Vec::new();
             let read_result = inner_entry.read_to_end(&mut innerdata);
-            if read_result.is_err() { info!("read error within TAR file"); continue; }
+            if read_result.is_err() {
+                info!("read error within TAR file");
+                continue;
+            }
             let new_reader = Cursor::new(innerdata);
             let mut inner_findings = scan_file(
                 inner_entry.path().unwrap().as_ref(),
@@ -245,21 +272,18 @@ fn scan_file<R: Read + io::Seek>(
         let mut decompressor = flate2::read::GzDecoder::new(reader);
         let mut innerdata: Vec<u8> = Vec::new();
         let read_result = decompressor.read_to_end(&mut innerdata);
-        if read_result.is_err() { info!("read error within ZIP file"); return findings; }
+        if read_result.is_err() {
+            info!("read error within ZIP file");
+            return findings;
+        }
         let new_reader = Cursor::new(innerdata);
         let mut tempstring = String::from(file_path.file_stem().unwrap().to_str().unwrap());
         if ext.to_ascii_lowercase() == "tgz" {
             tempstring.push_str(".tar");
         }
         let inner_path: &Path = Path::new(&tempstring);
         info!("gunzip inner path: {:?}", inner_path);
-        let mut inner_findings = scan_file(
-            inner_path,
-            ss,
-            new_reader,
-            &path_string,
-            unzip,
-        );
+        let mut inner_findings = scan_file(inner_path, ss, new_reader, &path_string, unzip);
         for d in inner_findings.drain() {
             info!("FileFinding: {:?}", d);
             findings.insert(d);
@@ -268,7 +292,9 @@ fn scan_file<R: Read + io::Seek>(
     } else {
         let mut data = Vec::new();
         let read_result = reader.read_to_end(&mut data);
-        if read_result.is_err() { info!("read error for file {}", path_string); }
+        if read_result.is_err() {
+            info!("read error for file {}", path_string);
+        }
         scan_bytes(data, ss, path_string)
     }
 }
@@ -309,23 +335,17 @@ fn scan_bytes(input: Vec<u8>, ss: &SecretScanner, path: String) -> HashSet<FileF
 #[cfg(test)]
 mod tests {
     use super::*;
+    use escargot::CargoBuild;
     use std::io::Result;
-    use std::process::Output;
     use std::io::Write;
+    use std::process::Output;
     use tempfile::{NamedTempFile, TempDir};
-    use escargot::CargoBuild;
 
     fn run_command_in_dir(dir: &TempDir, command: &str, args: &[&str]) -> Result<Output> {
         let dir_path = dir.path().to_str().unwrap();
-        let binary = CargoBuild::new()
-            .bin(command)
-            .run()
-            .unwrap();
-
-        binary.command()
-            .current_dir(dir_path)
-            .args(args)
-            .output()
+        let binary = CargoBuild::new().bin(command).run().unwrap();
+
+        binary.command().current_dir(dir_path).args(args).output()
     }
 
     fn write_temp_file(dir: &TempDir, filename: &str, contents: &str) {
@@ -346,7 +366,11 @@ mod tests {
     fn does_not_scan_output_file() {
         let temp_dir = TempDir::new().unwrap();
 
-        write_temp_file(&temp_dir, "insecure-file.txt", "My email is username@mail.com");
+        write_temp_file(
+            &temp_dir,
+            "insecure-file.txt",
+            "My email is username@mail.com",
+        );
 
         let cmd_args = ["-o", "output_file.txt", "."];
 
@@ -374,13 +398,20 @@ mod tests {
         }
         "#;
         write!(allowlist_temp_file, "{}", json).unwrap();
-        write_temp_file(&temp_dir, "insecure-file.txt", "My email is username@mail.com");
+        write_temp_file(
+            &temp_dir,
+            "insecure-file.txt",
+            "My email is username@mail.com",
+        );
 
-        let cmd_args = ["--allowlist", allowlist_temp_file.path().to_str().unwrap(), "."];
+        let cmd_args = [
+            "--allowlist",
+            allowlist_temp_file.path().to_str().unwrap(),
+            ".",
+        ];
 
         let output = run_command_in_dir(&temp_dir, "duroc_hog", &cmd_args).unwrap();
 
         assert_eq!("[]\n", str::from_utf8(&output.stdout).unwrap());
-
     }
-}
+}