Prepare 0.3.0 release

[hashgood] / src / verify.rs

diff --git a/src/verify.rs b/src/verify.rs
index 25e565f7abebfdf2540d9de42e83f26b80d7d06d..0f2d1d88325de4e19b90da50479bd75b6fd81b52 100644 (file)
--- a/src/verify.rs
+++ b/src/verify.rs
@@ -61,15 +61,15 @@ fn get_from_clipboard() -> Result<CandidateHashes, String> {
             filename: None,
             bytes,
         };
             filename: None,
             bytes,
         };

-        return Ok(CandidateHashes {
+        Ok(CandidateHashes {

             alg,
             hashes: vec![candidate],
             source: VerificationSource::Clipboard,
             alg,
             hashes: vec![candidate],
             source: VerificationSource::Clipboard,

-        });
+        })

     }
     #[cfg(not(feature = "paste"))]
     {
     }
     #[cfg(not(feature = "paste"))]
     {

-        return Err("Paste not implemented".to_owned());
+        Err("Paste not implemented".to_owned())

     }
 }
 
     }
 }
 


@@ -96,7 +96,7 @@ fn get_from_file(path: &Path) -> Result<CandidateHashes, String> {
     let line = line.trim().to_owned();
 
     // Does our first line look like a raw hash on its own? If so, use that
     let line = line.trim().to_owned();
 
     // Does our first line look like a raw hash on its own? If so, use that

-    if let Some(candidate) = read_raw_candidate_from_file(&line, &path) {
+    if let Some(candidate) = read_raw_candidate_from_file(&line, path) {

         return Ok(candidate);
     }
 
         return Ok(candidate);
     }
 


@@ -105,7 +105,7 @@ fn get_from_file(path: &Path) -> Result<CandidateHashes, String> {
     let full_lines = vec![Ok(line)].into_iter().chain(reader.lines());
 
     // Does the entire file look like a coreutils-style digests file? (SHA1SUMS, etc.)
     let full_lines = vec![Ok(line)].into_iter().chain(reader.lines());
 
     // Does the entire file look like a coreutils-style digests file? (SHA1SUMS, etc.)

-    if let Some(candidate) = read_coreutils_digests_from_file(full_lines, &path) {
+    if let Some(candidate) = read_coreutils_digests_from_file(full_lines, path) {

         return Ok(candidate);
     }
 
         return Ok(candidate);
     }
 


@@ -148,51 +148,49 @@ where
 {
     let mut hashes = vec![];
     let mut alg: Option<Algorithm> = None;
 {
     let mut hashes = vec![];
     let mut alg: Option<Algorithm> = None;

-    for l in lines {
-        if let Ok(l) = l {
-            let l = l.as_ref().trim();
-            // Allow (ignore) blank lines
-            if l.is_empty() {
-                continue;
-            }
-            // Expected format
-            // <valid-hash><space><space-or-*><filename>
-            let (line_alg, bytes, filename) = match l
-                .find(' ')
-                .and_then(|space_pos| {
-                    // Char before filename should be space for text or * for binary
-                    match l.chars().nth(space_pos + 1) {
-                        Some(' ') | Some('*') => (l.get(..space_pos)).zip(l.get(space_pos + 2..)),
-                        _ => None,
-                    }
-                })
-                .and_then(|(maybe_hash, filename)| {
-                    // Filename should be in this position without extra whitespace
-                    if filename.trim() == filename {
-                        try_parse_hash(maybe_hash).map(|(alg, bytes)| (alg, bytes, filename))
-                    } else {
-                        None
-                    }
-                }) {
-                Some(t) => t,
-                None => {
-                    // if we have a line with content we cannot parse, this is an error
-                    return None;
+    for l in lines.flatten() {
+        let l = l.as_ref().trim();
+        // Allow (ignore) blank lines
+        if l.is_empty() {
+            continue;
+        }
+        // Expected format
+        // <valid-hash><space><space-or-*><filename>
+        let (line_alg, bytes, filename) = match l
+            .find(' ')
+            .and_then(|space_pos| {
+                // Char before filename should be space for text or * for binary
+                match l.chars().nth(space_pos + 1) {
+                    Some(' ') | Some('*') => (l.get(..space_pos)).zip(l.get(space_pos + 2..)),
+                    _ => None,

                 }
                 }

-            };
-            if alg.is_some() && alg != Some(line_alg) {
-                // Different algorithms in the same digest file are not supported
+            })
+            .and_then(|(maybe_hash, filename)| {
+                // Filename should be in this position without extra whitespace
+                if filename.trim() == filename {
+                    try_parse_hash(maybe_hash).map(|(alg, bytes)| (alg, bytes, filename))
+                } else {
+                    None
+                }
+            }) {
+            Some(t) => t,
+            None => {
+                // if we have a line with content we cannot parse, this is an error

                 return None;
                 return None;

-            } else {
-                // If we are the first line, we define the overall algorithm
-                alg = Some(line_alg);

             }
             }

-            // So far so good - create an entry for this line
-            hashes.push(CandidateHash {
-                bytes,
-                filename: Some(filename.to_owned()),
-            });
+        };
+        if alg.is_some() && alg != Some(line_alg) {
+            // Different algorithms in the same digest file are not supported
+            return None;
+        } else {
+            // If we are the first line, we define the overall algorithm
+            alg = Some(line_alg);

         }
         }

+        // So far so good - create an entry for this line
+        hashes.push(CandidateHash {
+            bytes,
+            filename: Some(filename.to_owned()),
+        });

     }
 
     // It is a failure if we got zero hashes or we somehow don't know the algorithm
     }
 
     // It is a failure if we got zero hashes or we somehow don't know the algorithm


@@ -301,28 +299,28 @@ mod tests {
         let invalid5 = "1eb85fc97224598dad1852b5d 483bbcf0aa8608790dcc657a5a2a761ae9c8c6";
 
         assert!(matches!(
         let invalid5 = "1eb85fc97224598dad1852b5d 483bbcf0aa8608790dcc657a5a2a761ae9c8c6";
 
         assert!(matches!(

-            read_raw_candidate_from_file(valid_md5, &example_path),
+            read_raw_candidate_from_file(valid_md5, example_path),

             Some(CandidateHashes {
                 alg: Algorithm::Md5,
                 ..
             })
         ));
         assert!(matches!(
             Some(CandidateHashes {
                 alg: Algorithm::Md5,
                 ..
             })
         ));
         assert!(matches!(

-            read_raw_candidate_from_file(valid_sha1, &example_path),
+            read_raw_candidate_from_file(valid_sha1, example_path),

             Some(CandidateHashes {
                 alg: Algorithm::Sha1,
                 ..
             })
         ));
         assert!(matches!(
             Some(CandidateHashes {
                 alg: Algorithm::Sha1,
                 ..
             })
         ));
         assert!(matches!(

-            read_raw_candidate_from_file(&valid_sha1_2, &example_path),
+            read_raw_candidate_from_file(&valid_sha1_2, example_path),

             Some(CandidateHashes {
                 alg: Algorithm::Sha1,
                 ..
             })
         ));
         assert!(matches!(
             Some(CandidateHashes {
                 alg: Algorithm::Sha1,
                 ..
             })
         ));
         assert!(matches!(

-            read_raw_candidate_from_file(valid_sha256, &example_path),
+            read_raw_candidate_from_file(valid_sha256, example_path),

             Some(CandidateHashes {
                 alg: Algorithm::Sha256,
                 ..
             Some(CandidateHashes {
                 alg: Algorithm::Sha256,
                 ..


@@ -330,7 +328,7 @@ mod tests {
         ));
 
         for i in &[invalid1, invalid2, invalid3, invalid4, invalid5] {
         ));
 
         for i in &[invalid1, invalid2, invalid3, invalid4, invalid5] {

-            assert!(read_raw_candidate_from_file(*i, &example_path).is_none());
+            assert!(read_raw_candidate_from_file(*i, example_path).is_none());

         }
     }
 
         }
     }
 


@@ -340,9 +338,9 @@ mod tests {
         75eb7420a9f5a260b04a3e8ad51e50f2838a17fc  lel.txt
 
         fe6c26d485a3573a1cb0ad0682f5105325a1905f  shasums";
         75eb7420a9f5a260b04a3e8ad51e50f2838a17fc  lel.txt
 
         fe6c26d485a3573a1cb0ad0682f5105325a1905f  shasums";

-        let lines = shasums.lines().map(|l| std::io::Result::Ok(l));
+        let lines = shasums.lines().map(std::io::Result::Ok);

         let path = Path::new("SHASUMS");
         let path = Path::new("SHASUMS");

-        let candidates = read_coreutils_digests_from_file(lines, &path);
+        let candidates = read_coreutils_digests_from_file(lines, path);

 
         assert_eq!(
             candidates,
 
         assert_eq!(
             candidates,


@@ -374,7 +372,7 @@ mod tests {
         let extra_space = "4b91f7a387a6edd4a7c0afb2897f1ca968c9695b   cp";
 
         for digest in [no_format, invalid_format, extra_space] {
         let extra_space = "4b91f7a387a6edd4a7c0afb2897f1ca968c9695b   cp";
 
         for digest in [no_format, invalid_format, extra_space] {

-            let lines = digest.lines().map(|l| std::io::Result::Ok(l));
+            let lines = digest.lines().map(std::io::Result::Ok);

             assert!(
                 read_coreutils_digests_from_file(lines, Path::new("SHASUMS")).is_none(),
                 "Should be invalid digest: {:?}",
             assert!(
                 read_coreutils_digests_from_file(lines, Path::new("SHASUMS")).is_none(),
                 "Should be invalid digest: {:?}",