apply just all +stable clippy --fix

Author: hdhoang

cli/src/crawl.rs

@@ -41,9 +41,9 @@ pub fn crawl(
             Err(error) => {
                 if let IgnoreError::WithPath { path, err } = error {
                     FileResult::from_error(&path.to_string_lossy(), err)
-                        .print_as(&output_format, true);
+                        .print_as(output_format, true);
                 } else {
-                    FileResult::from_error("", error).print_as(&output_format, false);
+                    FileResult::from_error("", error).print_as(output_format, false);
                 }
                 None
             }
@@ -58,10 +58,10 @@ pub fn crawl(
                     let data = TextData::new(&content);
                     let idres = identify_data(&store, &data, false, false);
                     let fileres = FileResult::from_identification_result(&path_lossy, &idres);
-                    fileres.print_as(&output_format, true);
+                    fileres.print_as(output_format, true);
                 }
                 Err(err) => {
-                    FileResult::from_error(&path_lossy, err).print_as(&output_format, true);
+                    FileResult::from_error(&path_lossy, err).print_as(output_format, true);
                 }
             };
         });

cli/src/formats.rs

@@ -49,7 +49,7 @@ impl<'a> FileResult<'a> {
         result: &'a Result<CLIIdentification, Error>,
     ) -> FileResult<'a> {
         match result {
-            Ok(id) => FileResult::Ok { path, result: &id },
+            Ok(id) => FileResult::Ok { path, result: id },
             Err(e) => FileResult::Err {
                 path,
                 error: format!("{}", e),

cli/src/identify.rs

@@ -47,7 +47,7 @@ pub fn identify(
         let idres = identify_data(&store, &content.into(), optimize, want_diff);
         let file_lossy = filename.to_string_lossy();
         let fileres = FileResult::from_identification_result(&file_lossy, &idres);
-        fileres.print_as(&output_format, false);
+        fileres.print_as(output_format, false);
 
         return idres.map(|_| ());
     }
@@ -69,14 +69,14 @@ pub fn identify(
                     path: &buf,
                     error: format!("Input error: {}", e),
                 };
-                fileres.print_as(&output_format, false);
+                fileres.print_as(output_format, false);
                 continue;
             }
         };
 
         let idres = identify_data(&store, &content.into(), optimize, want_diff);
         let fileres = FileResult::from_identification_result(&buf, &idres);
-        fileres.print_as(&output_format, false);
+        fileres.print_as(output_format, false);
     }
 
     Ok(())
@@ -113,7 +113,7 @@ pub fn identify_data(
             .map(|cr| CLIContainedResult {
                 score: cr.score,
                 license: CLIIdentifiedLicense {
-                    aliases: store.aliases(&cr.license.name).unwrap().clone(),
+                    aliases: store.aliases(cr.license.name).unwrap().clone(),
                     name: cr.license.name.to_owned(),
                     kind: cr.license.kind,
                 },
@@ -125,13 +125,13 @@ pub fn identify_data(
     // include the overall license if present
     if let Some(license) = result.license {
         output.license = Some(CLIIdentifiedLicense {
-            aliases: store.aliases(&license.name).unwrap().clone(),
+            aliases: store.aliases(license.name).unwrap().clone(),
             name: license.name.to_owned(),
             kind: license.kind,
         });
 
         if want_diff {
-            diff_result(&text_data, &license.data);
+            diff_result(text_data, license.data);
         }
 
         return Ok(output);
@@ -140,7 +140,7 @@ pub fn identify_data(
     // not a good enough match overall, but maybe inside
     if !output.containing.is_empty() {
         if want_diff {
-            diff_result(&text_data, &result.containing[0].license.data);
+            diff_result(text_data, result.containing[0].license.data);
         }
         return Ok(output);
     }

cli/tests/cli.rs

@@ -1,7 +1,7 @@
 // Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use serde_json;
+
 
 use std::path::PathBuf;
 use std::process::Command;

src/license.rs

@@ -311,23 +311,23 @@ mod tests {
 
         let (optimized, _) = sample.optimize_bounds(&license);
         println!("{:?}", optimized.lines_view);
-        println!("{:?}", optimized.lines_normalized.clone());
+        println!("{:?}", optimized.lines_normalized);
         assert_eq!((0, 3), optimized.lines_view);
 
         // add more to the string, try again (avoid int trunc screwups)
         let sample_text = format!("{}\none more line", sample_text);
         let sample = TextData::from(sample_text.as_str());
         let (optimized, _) = sample.optimize_bounds(&license);
         println!("{:?}", optimized.lines_view);
-        println!("{:?}", optimized.lines_normalized.clone());
+        println!("{:?}", optimized.lines_normalized);
         assert_eq!((0, 3), optimized.lines_view);
 
         // add to the beginning too
         let sample_text = format!("some content\nat\n\nthe beginning\n{}", sample_text);
         let sample = TextData::from(sample_text.as_str());
         let (optimized, _) = sample.optimize_bounds(&license);
         println!("{:?}", optimized.lines_view);
-        println!("{:?}", optimized.lines_normalized.clone());
+        println!("{:?}", optimized.lines_normalized);
         // end bounds at 7 and 8 have the same score, since they're empty lines (not
         // counted). askalono is not smart enough to trim this as close as it
         // can.

src/strategy.rs

@@ -386,7 +386,7 @@ impl<'a> ScanStrategy<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use env_logger;
+    
 
     #[test]
     fn can_construct() {
@@ -411,7 +411,7 @@ mod tests {
         let result = strategy.scan(&test_data).unwrap();
         assert!(
             result.score > 0.5,
-            format!("score must meet threshold; was {}", result.score)
+            "score must meet threshold; was {}", result.score
         );
         assert_eq!(
             result.license.expect("result has a license").name,
@@ -471,8 +471,8 @@ mod tests {
         // inspect the array and ensure we got both licenses
         let mut found1 = 0;
         let mut found2 = 0;
-        for (_, ref contained) in result.containing.iter().enumerate() {
-            match contained.license.name.as_ref() {
+        for (_, contained) in result.containing.iter().enumerate() {
+            match contained.license.name {
                 "license-1" => {
                     assert!(contained.score > 0.5, "license-1 score meets threshold");
                     found1 += 1;
@@ -516,8 +516,8 @@ mod tests {
         // inspect the array and ensure we got both licenses
         let mut found1 = 0;
         let mut found2 = 0;
-        for (_, ref contained) in result.containing.iter().enumerate() {
-            match contained.license.name.as_ref() {
+        for (_, contained) in result.containing.iter().enumerate() {
+            match contained.license.name {
                 "license-1" => {
                     assert!(contained.score > 0.5, "license-1 score meets threshold");
                     found1 += 1;

tests/introspection.rs

@@ -11,8 +11,6 @@
 // express or implied. See the License for the specific language governing
 // permissions and limitations under the License.
 
-use askalono;
-
 mod common;
 
 use std::fs::File;
@@ -38,7 +36,7 @@ fn self_apache_header() {
     assert_eq!(askalono::LicenseType::Header, matched.license_type);
 
     // now try to find the bounds of the license header
-    let (optimized, _) = text_data.optimize_bounds(&matched.data);
+    let (optimized, _) = text_data.optimize_bounds(matched.data);
 
     // the license is from (0-indexed) lines 3 thru 12 of this file, excluding
     // that copyright statement on line 1.

tests/real_world.rs

@@ -30,7 +30,7 @@ fn real_world_licenses() {
                 let test_name = &parts[0];
                 let confidence = f32::from_str(parts[1]).unwrap();
 
-                assert_license(&store, &file_path, &test_name, &license_id, confidence);
+                assert_license(&store, &file_path, test_name, &license_id, confidence);
             }
         }
     }

tests/store_sanity.rs

@@ -11,7 +11,7 @@ use askalono::TextData;
 #[test]
 fn store_loads() {
     let store = common::load_store();
-    assert!(store.len() > 0, "store should have licenses");
+    assert!(!store.is_empty(), "store should have licenses");
 }
 
 #[test]
@@ -26,7 +26,7 @@ fn self_licenses() {
         "MPL-2.0",
     ] {
         let mut f = File::open(format!("{}/{}.txt", common::SPDX_TEXT, license))
-            .expect(&format!("couldn't open license file '{}'", license));
+            .unwrap_or_else(|_| panic!("couldn't open license file '{}'", license));
         let mut text = String::new();
         f.read_to_string(&mut text).unwrap();
         let text_data: TextData = text.into();