Merge remote-tracking branch 'origin/master' into ben-auto-bump

Author: gnunicorn

Cargo.lock

@@ -18,8 +18,7 @@ path = "src/main.rs"
 
 [features]
 default = []
-gen-readme = ["cargo-readme", "sha1"]
-
+gen-readme = ["cargo-readme","lazy_static","sha1"]
 
 [dependencies]
 structopt = "0.3.9"
@@ -42,4 +41,5 @@ git2 = "0.13.10"
 
 # Optional dependencies
 cargo-readme = { version="3.2", optional = true }
-sha1 = { version="0.6", optional = true }
+lazy_static = { version = "1.4", optional = true }
+sha1 = { version="0.6", optional = true }

Cargo.toml

@@ -158,4 +158,4 @@ _You are using the tooling and want to be mentioned here–[create an issue](htt
 
 This Software is released under the [GNU General Public License (GPL) 3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).
 
-This, as any other software, is build on the shoulders of giants. In particular, this uses `cargo` internally and draws heavily on the knowledge established by [cargo publish-all](https://torkleyy.gitlab.io/cargo-publish-all/) and [cargo hack](https://github.com/taiki-e/cargo-hack).
+This, as any other software, is build on the shoulders of giants. In particular, this uses `cargo` internally and draws heavily on the knowledge established by [cargo publish-all](https://gitlab.com/torkleyy/cargo-publish-all) and [cargo hack](https://github.com/taiki-e/cargo-hack).

Readme.md

@@ -411,7 +411,7 @@ fn make_pkg_predicate(args: PackageSelectOptions) -> Result<Box<dyn Fn(&Package)
                 return false;
             }
             let name = p.name();
-            if skip.iter().find(|r| r.is_match(&name)).is_some() {
+            if skip.iter().any(|r| r.is_match(&name)) {
                 return false;
             }
             if p.version().is_prerelease() {
@@ -453,7 +453,7 @@ pub fn run(args: Opt) -> Result<(), Box<dyn Error>> {
         fs::canonicalize(path)?
     };
 
-    let maybe_patch = |shouldnt_patch, predicate: &Box<dyn Fn(&Package) -> bool>| {
+    let maybe_patch = |shouldnt_patch, predicate: &dyn Fn(&Package) -> bool| {
         if shouldnt_patch {
             return Ok(());
         }
@@ -498,15 +498,13 @@ pub fn run(args: Opt) -> Result<(), Box<dyn Error>> {
             value,
             pkg_opts,
         } => {
-            if name == "name".to_owned() {
+            if name == "name" {
                 return Err("To change the name please use the rename command!".into());
             }
             let predicate = make_pkg_predicate(pkg_opts)?;
             let type_value = {
-                if &value == "true" {
-                    Value::from(true)
-                } else if &value == "false" {
-                    Value::from(true)
+                if let Ok(v) = bool::from_str(&value) {
+                    Value::from(v)
                 } else if let Ok(v) = i64::from_str(&value) {
                     Value::from(v)
                 } else {
@@ -735,7 +733,7 @@ pub fn run(args: Opt) -> Result<(), Box<dyn Error>> {
                 .map_err(|e| format!("Reading workspace {:?} failed: {:}", root_manifest, e))?;
             let packages = commands::packages_to_release(&ws, predicate)?;
 
-            commands::gen_all_readme(&packages, &ws, readme_mode)
+            commands::gen_all_readme(packages, &ws, readme_mode)
         }
         Command::EmDragons {
             dry_run,

src/cli.rs

@@ -82,7 +82,7 @@ fn run_check(
     // package has a workspace we can still build our new crate.
     let (src, new_pkg) = {
         let id = SourceId::for_path(&dst)?;
-        let mut src = PathSource::new(&dst, id.clone(), ws.config());
+        let mut src = PathSource::new(&dst, id, ws.config());
         let new_pkg = src.root_package()?;
 
         // inject our local builds
@@ -147,7 +147,7 @@ fn run_check(
     Ok(())
 }
 
-fn check_dependencies<'a>(package: &'a Package) -> Result<(), String> {
+fn check_dependencies(package: &Package) -> Result<(), String> {
     let git_deps = package
         .dependencies()
         .iter()
@@ -163,18 +163,18 @@ fn check_dependencies<'a>(package: &'a Package) -> Result<(), String> {
 
 // ensure metadata is set
 // https://doc.rust-lang.org/cargo/reference/publishing.html#before-publishing-a-new-crate
-fn check_metadata<'a>(metadata: &'a ManifestMetadata) -> Result<(), String> {
+fn check_metadata(metadata: &ManifestMetadata) -> Result<(), String> {
     let mut bad_fields = Vec::new();
-    if metadata.authors.len() == 0 {
+    if metadata.authors.is_empty() {
         bad_fields.push("authors is empty")
     }
-    match metadata.description {
-        Some(ref s) if s.len() == 0 => bad_fields.push("description is empty"),
+    match metadata.description.as_deref() {
+        Some("") => bad_fields.push("description is empty"),
         None => bad_fields.push("description is missing"),
         _ => {}
     }
-    match metadata.repository {
-        Some(ref s) if s.len() == 0 => bad_fields.push("repository is empty"),
+    match metadata.repository.as_deref() {
+        Some("") => bad_fields.push("repository is empty"),
         None => bad_fields.push("repository is missing"),
         _ => {}
     }
@@ -184,7 +184,7 @@ fn check_metadata<'a>(metadata: &'a ManifestMetadata) -> Result<(), String> {
         _ => bad_fields.push("Neither license nor license_file is provided"),
     }
 
-    if bad_fields.len() == 0 {
+    if bad_fields.is_empty() {
         Ok(())
     } else {
         Err(bad_fields.join("; "))
@@ -202,8 +202,8 @@ fn check_readme<'a>(_ws: &Workspace<'a>, _pkg: &Package) -> Result<(), String> {
     unreachable!()
 }
 
-pub fn check<'a, 'r>(
-    packages: &Vec<Package>,
+pub fn check<'a>(
+    packages: &[Package],
     ws: &Workspace<'a>,
     build: bool,
     check_readme: bool,
@@ -253,12 +253,11 @@ pub fn check<'a, 'r>(
         res
     });
 
-    let errors_count = errors.iter().map(|s| error!("{:#?}", s)).count();
-
+    errors.iter().for_each(|s| error!("{:#?}", s));
     if errors.len() > 0 {
         return Err(format!(
             "Soft checkes failed with {} errors (see above)",
-            errors_count
+            errors.len()
         )
         .into());
     }
@@ -276,12 +275,11 @@ pub fn check<'a, 'r>(
             res
         });
 
-        let errors_count = errors.iter().map(|s| error!("{:#?}", s)).count();
-
+        errors.iter().for_each(|s| error!("{:#?}", s));
         if errors.len() > 0 {
             return Err(format!(
                 "{} readme file(s) need to be updated (see above).",
-                errors_count
+                errors.len()
             )
             .into());
         }
@@ -298,21 +296,18 @@ pub fn check<'a, 'r>(
             .map_err(|e| format!("{:}", e))?;
         match package(&pkg_ws, &opts) {
             Ok(Some(rw_lock)) => Ok((pkg_ws, rw_lock)),
-            Ok(None) => Err(format!("Failure packing {:}", pkg.name()).into()),
-            Err(e) => Err(format!("Failure packing {:}: {}", pkg.name(), e).into()),
+            Ok(None) => Err(format!("Failure packing {:}", pkg.name())),
+            Err(e) => Err(format!("Failure packing {:}: {}", pkg.name(), e)),
         }
     });
 
-    let (errors, successes): (Vec<_>, Vec<_>) =
-        builds.partition(|r: &Result<(Workspace<'_>, FileLock), String>| r.is_err());
+    let (errors, successes): (Vec<_>, Vec<_>) = builds.partition(Result::is_err);
 
-    let errors_count = errors
-        .iter()
-        .map(|r| r.as_ref().map_err(|e| error!("{:#?}", e)))
-        .count();
-
-    if errors_count > 0 {
-        return Err(format!("Packing failed with {} errors (see above)", errors_count).into());
+    for e in errors.iter().filter_map(|res| res.as_ref().err()) {
+        error!("{:#?}", e);
+    }
+    if errors.len() > 0 {
+        return Err(format!("Packing failed with {} errors (see above)", errors.len()).into());
     };
 
     let build_mode = if build {