Remove unneeded PathBuf usage

diff --git a/src/calculate.rs b/src/calculate.rs
index dc059b260d0d3e28188523e1cb4f04be04b6fc2e..59395d3c6b5544969c41bab22d67efdeb0fb6b42 100644 (file)
--- a/src/calculate.rs
+++ b/src/calculate.rs
@@ -8,7 +8,7 @@ use crypto::sha2::Sha256;
 use std::error::Error;
 use std::fs::File;
 use std::io::prelude::*;
 use std::error::Error;
 use std::fs::File;
 use std::io::prelude::*;

-use std::path::PathBuf;
+use std::path::Path;

 use std::sync::Arc;
 use std::thread;
 use std::thread::JoinHandle;
 use std::sync::Arc;
 use std::thread;
 use std::thread::JoinHandle;


@@ -16,7 +16,7 @@ use std::thread::JoinHandle;
 pub type CalculateResult = Result<Vec<(Algorithm, Vec<u8>)>, Box<dyn Error>>;
 
 /// For a given path to the input (may be "-" for STDIN), try to obtain a reader for the data within it.
 pub type CalculateResult = Result<Vec<(Algorithm, Vec<u8>)>, Box<dyn Error>>;
 
 /// For a given path to the input (may be "-" for STDIN), try to obtain a reader for the data within it.

-pub fn get_input_reader(input: &PathBuf) -> Result<Box<dyn Read>, String> {
+pub fn get_input_reader(input: &Path) -> Result<Box<dyn Read>, String> {

     if input.to_str() == Some("-") {
         // Special case: standard input
         return Ok(Box::new(std::io::stdin()));
     if input.to_str() == Some("-") {
         // Special case: standard input
         return Ok(Box::new(std::io::stdin()));

diff --git a/src/display.rs b/src/display.rs
index a4c011c760e6cea3a879dfce92138c03eb3bad82..2cc940adca4d8883274ec1663c13d6a89d3b3b2a 100644 (file)
--- a/src/display.rs
+++ b/src/display.rs
@@ -1,5 +1,4 @@
 use super::{Algorithm, CandidateHash, Hash, MatchLevel, MessageLevel, VerificationSource};
 use super::{Algorithm, CandidateHash, Hash, MatchLevel, MessageLevel, VerificationSource};

-use std::borrow::Borrow;

 use std::error::Error;
 use std::io::Write;
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 use std::error::Error;
 use std::io::Write;
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};


@@ -74,7 +73,7 @@ fn write_source(
         VerificationSource::Clipboard => {
             writeln!(&mut stdout, "pasted from clipboard")?;
         }
         VerificationSource::Clipboard => {
             writeln!(&mut stdout, "pasted from clipboard")?;
         }

-        VerificationSource::RawFile(raw_path) => match raw_path.to_string_lossy().borrow() {
+        VerificationSource::RawFile(raw_path) => match raw_path.as_str() {

             "-" => {
                 writeln!(&mut stdout, "from standard input")?;
             }
             "-" => {
                 writeln!(&mut stdout, "from standard input")?;
             }


@@ -82,25 +81,23 @@ fn write_source(
                 writeln!(&mut stdout, "from file '{}' containing raw hash", path)?;
             }
         },
                 writeln!(&mut stdout, "from file '{}' containing raw hash", path)?;
             }
         },

-        VerificationSource::DigestsFile(digest_path) => {
-            match digest_path.to_string_lossy().borrow() {
-                "-" => {
-                    writeln!(
-                        &mut stdout,
-                        "'{}' from digests on standard input",
-                        candidate_filename.as_ref().unwrap()
-                    )?;
-                }
-                path => {
-                    writeln!(
-                        &mut stdout,
-                        "'{}' in digests file '{}'",
-                        candidate_filename.as_ref().unwrap(),
-                        path
-                    )?;
-                }
+        VerificationSource::DigestsFile(digest_path) => match digest_path.as_str() {
+            "-" => {
+                writeln!(
+                    &mut stdout,
+                    "'{}' from digests on standard input",
+                    candidate_filename.as_ref().unwrap()
+                )?;

             }
             }

-        }
+            path => {
+                writeln!(
+                    &mut stdout,
+                    "'{}' in digests file '{}'",
+                    candidate_filename.as_ref().unwrap(),
+                    path
+                )?;
+            }
+        },

     }
     stdout.reset()?;
     Ok(())
     }
     stdout.reset()?;
     Ok(())

diff --git a/src/main.rs b/src/main.rs
index 2c7e1899dbbf4fab3f72f60ba79570bd86fc6c6d..fd965dac05a1576b4f380cf596eff66559db779d 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,5 @@
 use std::error::Error;
 use std::error::Error;

-use std::path::PathBuf;
+use std::path::{Path, PathBuf};

 use std::process;
 use structopt::StructOpt;
 
 use std::process;
 use structopt::StructOpt;
 


@@ -75,8 +75,8 @@ impl Algorithm {
 pub enum VerificationSource {
     CommandArgument,
     Clipboard,
 pub enum VerificationSource {
     CommandArgument,
     Clipboard,

-    RawFile(PathBuf),
-    DigestsFile(PathBuf),
+    RawFile(String),
+    DigestsFile(String),

 }
 
 /// A complete standalone hash result
 }
 
 /// A complete standalone hash result


@@ -87,7 +87,7 @@ pub struct Hash {
 }
 
 impl Hash {
 }
 
 impl Hash {

-    pub fn new(alg: Algorithm, bytes: Vec<u8>, path: &PathBuf) -> Self {
+    pub fn new(alg: Algorithm, bytes: Vec<u8>, path: &Path) -> Self {

         // Taking the filename component should always work?
         // If not, just fall back to the full path
         let filename = match path.file_name() {
         // Taking the filename component should always work?
         // If not, just fall back to the full path
         let filename = match path.file_name() {


@@ -155,7 +155,7 @@ fn main() {
 fn hashgood() -> Result<(), Box<dyn Error>> {
     let opt = get_verified_options()?;
     let candidates = verify::get_candidate_hashes(&opt)?;
 fn hashgood() -> Result<(), Box<dyn Error>> {
     let opt = get_verified_options()?;
     let candidates = verify::get_candidate_hashes(&opt)?;

-    let input = calculate::get_input_reader(&opt.input)?;
+    let input = calculate::get_input_reader(opt.input.as_path())?;

     if let Some(c) = candidates {
         // If we have a candidate hash of a particular type, use that specific algorithm
         let hashes = calculate::create_digests(&[c.alg], input)?;
     if let Some(c) = candidates {
         // If we have a candidate hash of a particular type, use that specific algorithm
         let hashes = calculate::create_digests(&[c.alg], input)?;

diff --git a/src/verify.rs b/src/verify.rs
index 8f0807444614e8b91ddca1914f3348aebb4116dd..25e565f7abebfdf2540d9de42e83f26b80d7d06d 100644 (file)
--- a/src/verify.rs
+++ b/src/verify.rs
@@ -8,7 +8,7 @@ use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::io::BufReader;
 use std::io;
 use std::io::prelude::*;
 use std::io::BufReader;

-use std::path::PathBuf;
+use std::path::Path;

 
 /// Calculate a list of candidate hashes based on the options specified.
 /// If no hash options have been specified returns None.
 
 /// Calculate a list of candidate hashes based on the options specified.
 /// If no hash options have been specified returns None.


@@ -74,7 +74,7 @@ fn get_from_clipboard() -> Result<CandidateHashes, String> {
 }
 
 /// Generate a candidate hash from the digests file specified (could be "-" for STDIN), or throw an error.
 }
 
 /// Generate a candidate hash from the digests file specified (could be "-" for STDIN), or throw an error.

-fn get_from_file(path: &PathBuf) -> Result<CandidateHashes, String> {
+fn get_from_file(path: &Path) -> Result<CandidateHashes, String> {

     // Get a reader for either standard input or the chosen path
     let reader: Box<dyn Read> = if path.to_str() == Some("-") {
         Box::new(std::io::stdin())
     // Get a reader for either standard input or the chosen path
     let reader: Box<dyn Read> = if path.to_str() == Some("-") {
         Box::new(std::io::stdin())


@@ -129,11 +129,11 @@ fn try_parse_hash(s: &str) -> Option<(Algorithm, Vec<u8>)> {
     Some((alg, bytes))
 }
 
     Some((alg, bytes))
 }
 

-fn read_raw_candidate_from_file(line: &str, path: &PathBuf) -> Option<CandidateHashes> {
+fn read_raw_candidate_from_file(line: &str, path: &Path) -> Option<CandidateHashes> {

     let (alg, bytes) = try_parse_hash(line)?;
     Some(CandidateHashes {
         alg,
     let (alg, bytes) = try_parse_hash(line)?;
     Some(CandidateHashes {
         alg,

-        source: VerificationSource::RawFile(path.clone()),
+        source: VerificationSource::RawFile(path.to_string_lossy().to_string()),

         hashes: vec![CandidateHash {
             bytes,
             filename: None,
         hashes: vec![CandidateHash {
             bytes,
             filename: None,


@@ -141,7 +141,7 @@ fn read_raw_candidate_from_file(line: &str, path: &PathBuf) -> Option<CandidateH
     })
 }
 
     })
 }
 

-fn read_coreutils_digests_from_file<I, S>(lines: I, path: &PathBuf) -> Option<CandidateHashes>
+fn read_coreutils_digests_from_file<I, S>(lines: I, path: &Path) -> Option<CandidateHashes>

 where
     I: Iterator<Item = io::Result<S>>,
     S: AsRef<str>,
 where
     I: Iterator<Item = io::Result<S>>,
     S: AsRef<str>,


@@ -207,7 +207,7 @@ where
     // Otherwise all is well and we can return our results
     Some(CandidateHashes {
         alg,
     // Otherwise all is well and we can return our results
     Some(CandidateHashes {
         alg,

-        source: VerificationSource::DigestsFile(path.clone()),
+        source: VerificationSource::DigestsFile(path.to_string_lossy().to_string()),

         hashes,
     })
 }
         hashes,
     })
 }


@@ -288,7 +288,7 @@ mod tests {
 
     #[test]
     fn test_read_raw_inputs() {
 
     #[test]
     fn test_read_raw_inputs() {

-        let example_path: PathBuf = "some_file".into();
+        let example_path = Path::new("some_file");

         let valid_md5 = "d229da563da18fe5d58cd95a6467d584";
         let valid_sha1 = "b314c7ebb7d599944981908b7f3ed33a30e78f3a";
         let valid_sha1_2 = valid_sha1.to_uppercase();
         let valid_md5 = "d229da563da18fe5d58cd95a6467d584";
         let valid_sha1 = "b314c7ebb7d599944981908b7f3ed33a30e78f3a";
         let valid_sha1_2 = valid_sha1.to_uppercase();


@@ -341,7 +341,7 @@ mod tests {
 
         fe6c26d485a3573a1cb0ad0682f5105325a1905f  shasums";
         let lines = shasums.lines().map(|l| std::io::Result::Ok(l));
 
         fe6c26d485a3573a1cb0ad0682f5105325a1905f  shasums";
         let lines = shasums.lines().map(|l| std::io::Result::Ok(l));

-        let path = PathBuf::from("SHASUMS");
+        let path = Path::new("SHASUMS");

         let candidates = read_coreutils_digests_from_file(lines, &path);
 
         assert_eq!(
         let candidates = read_coreutils_digests_from_file(lines, &path);
 
         assert_eq!(


@@ -362,7 +362,7 @@ mod tests {
                         filename: Some("shasums".to_owned()),
                     }
                 ],
                         filename: Some("shasums".to_owned()),
                     }
                 ],

-                source: VerificationSource::DigestsFile(path),
+                source: VerificationSource::DigestsFile(path.to_string_lossy().to_string()),

             })
         );
     }
             })
         );
     }


@@ -376,7 +376,7 @@ mod tests {
         for digest in [no_format, invalid_format, extra_space] {
             let lines = digest.lines().map(|l| std::io::Result::Ok(l));
             assert!(
         for digest in [no_format, invalid_format, extra_space] {
             let lines = digest.lines().map(|l| std::io::Result::Ok(l));
             assert!(

-                read_coreutils_digests_from_file(lines, &PathBuf::from("SHASUMS")).is_none(),
+                read_coreutils_digests_from_file(lines, Path::new("SHASUMS")).is_none(),

                 "Should be invalid digest: {:?}",
                 digest
             );
                 "Should be invalid digest: {:?}",
                 digest
             );