Refactor linting implementation to utility function

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

3 files changed, 80 insertions, 123 deletions

diff --git a/src/commands/build.rs b/src/commands/build.rs
index ff026f2..9970cf7 100644
--- a/src/commands/build.rs
+++ b/src/commands/build.rs
@@ -13,7 +13,7 @@ use diesel::ExpressionMethods;
 use diesel::PgConnection;
 use diesel::QueryDsl;
 use diesel::RunQueryDsl;
-use log::{debug, error, info, warn, trace};
+use log::{debug, info, warn, trace};
 use tokio::stream::StreamExt;
 use tokio::sync::RwLock;
 
@@ -27,7 +27,6 @@ use crate::log::LogItem;
 use crate::orchestrator::OrchestratorSetup;
 use crate::package::PackageName;
 use crate::package::PackageVersion;
-use crate::package::ScriptBuilder;
 use crate::package::Shebang;
 use crate::package::Tree;
 use crate::repository::Repository;
@@ -197,69 +196,13 @@ pub async fn build(repo_root: &Path,
         warn!("No script linting will be performed!");
     } else {
         if let Some(linter) = crate::ui::find_linter_command(repo_root, config)? {
-            let shebang = Shebang::from(config.shebang().clone());
-
             let all_packages = tree.all_packages();
             let bar = progressbars.bar();
             bar.set_length(all_packages.len() as u64);
             bar.set_message("Linting package scripts...");
 
-            let lint_results = all_packages
-                .into_iter()
-                .map(|pkg| {
-                    let shebang = shebang.clone();
-                    let bar = bar.clone();
-                    let linter = &linter; // rebind because of borrowing semantics
-                    async move {
-                        trace!("Linting script of {} {} with '{}'", pkg.name(), pkg.version(), linter.display());
-                        let cmd = tokio::process::Command::new(linter);
-                        let script = ScriptBuilder::new(&shebang)
-                            .build(pkg, config.available_phases(), *config.strict_script_interpolation())?;
-
-                        let (status, stdout, stderr) = script.lint(cmd).await?;
-                        bar.inc(1);
-                        Ok((pkg.name().clone(), pkg.version().clone(), status, stdout, stderr))
-                    }
-                })
-                .collect::<futures::stream::FuturesUnordered<_>>()
-                .collect::<Result<Vec<_>>>()
-                .await?
-                .into_iter()
-                .map(|tpl| {
-                    let pkg_name = tpl.0;
-                    let pkg_vers = tpl.1;
-                    let status = tpl.2;
-                    let stdout = tpl.3;
-                    let stderr = tpl.4;
-
-                    if status.success() {
-                        info!("Linting {pkg_name} {pkg_vers} script (exit {status}):\nstdout:\n{stdout}\n\nstderr:\n\n{stderr}",
-                            pkg_name = pkg_name,
-                            pkg_vers = pkg_vers,
-                            status = status,
-                            stdout = stdout,
-                            stderr = stderr);
-                        true
-                    } else {
-                        error!("Linting {pkg_name} {pkg_vers} errored ({status}):\n\nstdout:\n{stdout}\n\nstderr:\n{stderr}\n\n",
-                            pkg_name = pkg_name,
-                            pkg_vers = pkg_vers,
-                            status = status,
-                            stdout = stdout,
-                            stderr = stderr
-                        );
-                        false
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            let lint_ok = lint_results.iter().all(|b| *b);
-            if !lint_ok {
-                bar.finish_with_message("Linting errored");
-                return Err(anyhow!("Linting was not successful"))
-            } else {
-                bar.finish_with_message(&format!("Finished linting {} package scripts", lint_results.len()));
-            }
+            let iter = all_packages.into_iter();
+            let _ = crate::commands::util::lint_packages(iter, &linter, config, bar).await?;
         } else {
             warn!("No linter set in configuration, no script linting will be performed!");
         }
diff --git a/src/commands/lint.rs b/src/commands/lint.rs
index 03e69e8..0414e02 100644
--- a/src/commands/lint.rs
+++ b/src/commands/lint.rs
@@ -3,86 +3,26 @@ use std::path::Path;
 use anyhow::anyhow;
 use anyhow::Result;
 use clap::ArgMatches;
-use log::{error, info, trace};
-use tokio::stream::StreamExt;
 
 use crate::config::*;
-use crate::package::Shebang;
 use crate::repository::Repository;
 use crate::package::PackageName;
 use crate::package::PackageVersionConstraint;
-use crate::package::ScriptBuilder;
 use crate::util::progress::ProgressBars;
 
 pub async fn lint(repo_path: &Path, matches: &ArgMatches, progressbars: ProgressBars, config: &Configuration, repo: Repository) -> Result<()> {
     let linter = crate::ui::find_linter_command(repo_path, config)?
         .ok_or_else(|| anyhow!("No linter command found"))?;
-    let shebang = Shebang::from(config.shebang().clone());
     let pname = matches.value_of("package_name").map(String::from).map(PackageName::from);
     let pvers = matches.value_of("package_version").map(String::from).map(PackageVersionConstraint::new).transpose()?;
 
     let bar = progressbars.bar();
     bar.set_message("Linting package scripts...");
 
-    let lint_results = repo.packages()
+    let iter = repo.packages()
         .filter(|p| pname.as_ref().map(|n| p.name() == n).unwrap_or(true))
-        .filter(|p| pvers.as_ref().map(|v| v.matches(p.version())).unwrap_or(true))
-        .map(|pkg| {
-            let shebang = shebang.clone();
-            let bar = bar.clone();
-            let linter = &linter; // rebind because of borrowing semantics
-            async move {
-                trace!("Linting script of {} {} with '{}'", pkg.name(), pkg.version(), linter.display());
-                let cmd = tokio::process::Command::new(linter);
-                let script = ScriptBuilder::new(&shebang)
-                    .build(pkg, config.available_phases(), *config.strict_script_interpolation())?;
+        .filter(|p| pvers.as_ref().map(|v| v.matches(p.version())).unwrap_or(true));
 
-                let (status, stdout, stderr) = script.lint(cmd).await?;
-                bar.inc(1);
-                Ok((pkg.name().clone(), pkg.version().clone(), status, stdout, stderr))
-            }
-        })
-        .collect::<futures::stream::FuturesUnordered<_>>()
-        .collect::<Result<Vec<_>>>()
-        .await?
-        .into_iter()
-        .map(|tpl| {
-            let pkg_name = tpl.0;
-            let pkg_vers = tpl.1;
-            let status = tpl.2;
-            let stdout = tpl.3;
-            let stderr = tpl.4;
-
-            if status.success() {
-                info!("Linting {pkg_name} {pkg_vers} script (exit {status}):\nstdout:\n{stdout}\n\nstderr:\n\n{stderr}",
-                    pkg_name = pkg_name,
-                    pkg_vers = pkg_vers,
-                    status = status,
-                    stdout = stdout,
-                    stderr = stderr
-                );
-                true
-            } else {
-                error!("Linting {pkg_name} {pkg_vers} errored ({status}):\n\nstdout:\n{stdout}\n\nstderr:\n{stderr}\n\n",
-                    pkg_name = pkg_name,
-                    pkg_vers = pkg_vers,
-                    status = status,
-                    stdout = stdout,
-                    stderr = stderr
-                );
-                false
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let lint_ok = lint_results.iter().all(|b| *b);
-
-    if !lint_ok {
-        bar.finish_with_message("Linting errored");
-        return Err(anyhow!("Linting was not successful"))
-    } else {
-        bar.finish_with_message(&format!("Finished linting {} package scripts", lint_results.len()));
-        Ok(())
-    }
+    crate::commands::util::lint_packages(iter, &linter, config, bar).await
 }
 
diff --git a/src/commands/util.rs b/src/commands/util.rs
index 9334320..28ff5ea 100644
--- a/src/commands/util.rs
+++ b/src/commands/util.rs
@@ -1,7 +1,81 @@
+use std::path::Path;
+
+use anyhow::Result;
+use anyhow::anyhow;
 use clap::ArgMatches;
+use log::{error, info, trace};
+use tokio::stream::StreamExt;
+
+use crate::config::*;
+use crate::package::Shebang;
+use crate::package::Package;
+use crate::package::ScriptBuilder;
 
 pub fn getbool(m: &ArgMatches, name: &str, cmp: &str) -> bool {
     // unwrap is safe here because clap is configured with default values
     m.values_of(name).unwrap().any(|v| v == cmp)
 }
 
+pub async fn lint_packages<'a, I>(iter: I, linter: &Path, config: &Configuration, bar: indicatif::ProgressBar) -> Result<()>
+    where I: Iterator<Item = &'a Package> + 'a
+{
+    let shebang = Shebang::from(config.shebang().clone());
+    let lint_results = iter
+        .map(|pkg| {
+            let shebang = shebang.clone();
+            let bar = bar.clone();
+            async move {
+                trace!("Linting script of {} {} with '{}'", pkg.name(), pkg.version(), linter.display());
+                let cmd = tokio::process::Command::new(linter);
+                let script = ScriptBuilder::new(&shebang)
+                    .build(pkg, config.available_phases(), *config.strict_script_interpolation())?;
+
+                let (status, stdout, stderr) = script.lint(cmd).await?;
+                bar.inc(1);
+                Ok((pkg.name().clone(), pkg.version().clone(), status, stdout, stderr))
+            }
+        })
+        .collect::<futures::stream::FuturesUnordered<_>>()
+        .collect::<Result<Vec<_>>>()
+        .await?
+        .into_iter()
+        .map(|tpl| {
+            let pkg_name = tpl.0;
+            let pkg_vers = tpl.1;
+            let status = tpl.2;
+            let stdout = tpl.3;
+            let stderr = tpl.4;
+
+            if status.success() {
+                info!("Linting {pkg_name} {pkg_vers} script (exit {status}):\nstdout:\n{stdout}\n\nstderr:\n\n{stderr}",
+                    pkg_name = pkg_name,
+                    pkg_vers = pkg_vers,
+                    status = status,
+                    stdout = stdout,
+                    stderr = stderr
+                );
+                true
+            } else {
+                error!("Linting {pkg_name} {pkg_vers} errored ({status}):\n\nstdout:\n{stdout}\n\nstderr:\n{stderr}\n\n",
+                    pkg_name = pkg_name,
+                    pkg_vers = pkg_vers,
+                    status = status,
+                    stdout = stdout,
+                    stderr = stderr
+                );
+                false
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let lint_ok = lint_results.iter().all(|b| *b);
+
+    if !lint_ok {
+        bar.finish_with_message("Linting errored");
+        return Err(anyhow!("Linting was not successful"))
+    } else {
+        bar.finish_with_message(&format!("Finished linting {} package scripts", lint_results.len()));
+        Ok(())
+    }
+}
+