refactor

Sponsored-by: pep.foundation

1 files changed, 65 insertions, 51 deletions

diff --git a/src/main.rs b/src/main.rs
index f527163..671a1d6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,5 @@
 use anyhow::anyhow;
-use cargo_metadata::{CargoOpt, DependencyKind, MetadataCommand};
+use cargo_metadata::{CargoOpt, DependencyKind, Metadata, MetadataCommand};
 use clap::Parser;
 use log::{debug, error, info, trace};
 use semver::{Version, VersionReq};
@@ -23,6 +23,25 @@ fn fallible_main() -> anyhow::Result<()> {
     let packaged = Crates::from_file(&args.packaged)?;
 
     info!("load dependencies with version requirements");
+    let metadata = load_cargo_metadata(&args)?;
+
+    let dependencies = collect_dependencies(&metadata);
+    info!("found {} dependencies", dependencies.len());
+
+    info!("find dependencies that are not packaged");
+    let problems = find_problems(&packaged, &dependencies);
+    let count = problems.len();
+
+    if count == 0 {
+        info!("all good");
+        Ok(())
+    } else {
+        report_problems(problems);
+        Err(anyhow!("there were {} missing dependencies", count))
+    }
+}
+
+fn load_cargo_metadata(args: &Args) -> anyhow::Result<Metadata> {
     let mut metadata = MetadataCommand::new();
     metadata.other_options(vec!["--filter-platform=x86_64-unknown-linux-gnu".into()]);
     metadata.manifest_path(&args.dirname.join("Cargo.toml"));
@@ -31,14 +50,16 @@ fn fallible_main() -> anyhow::Result<()> {
         metadata.features(CargoOpt::AllFeatures);
     } else if !args.features.is_empty() {
         metadata.features(CargoOpt::NoDefaultFeatures);
-        metadata.features(CargoOpt::SomeFeatures(args.features));
+        metadata.features(CargoOpt::SomeFeatures(args.features.clone()));
     };
 
     info!("run cargo command: {:?}", metadata.cargo_command());
-    let metadata = metadata.exec()?;
+    Ok(metadata.exec()?)
+}
 
+fn collect_dependencies(metadata: &Metadata) -> HashMap<String, VersionReq> {
     let mut dependencies: HashMap<String, VersionReq> = HashMap::new();
-    for package in metadata.packages {
+    for package in metadata.packages.iter() {
         for dep in &package.dependencies {
             if dep.target.is_none()
                 && matches!(dep.kind, DependencyKind::Build | DependencyKind::Normal)
@@ -50,9 +71,10 @@ fn fallible_main() -> anyhow::Result<()> {
             }
         }
     }
-    info!("found {} dependencies", dependencies.len());
+    dependencies
+}
 
-    info!("find dependencies that are not packaged");
+fn find_problems(packaged: &Crates, dependencies: &HashMap<String, VersionReq>) -> Vec<Problem> {
     let mut problems = Problems::default();
     for (name, req) in dependencies.iter() {
         debug!("consider {}, version {} required", name, req);
@@ -81,55 +103,47 @@ fn fallible_main() -> anyhow::Result<()> {
             }));
         }
     }
+    problems.to_vec()
+}
 
-    let mut problems = problems.to_vec();
-    if problems.is_empty() {
-        info!("all good");
-        Ok(())
-    } else {
-        problems.sort_by_key(|p| match p {
-            Problem::MissingCrate(x) => x.name.clone(),
-            Problem::MissingVersion(x) => x.name.clone(),
-        });
-
-        let versions: Vec<&MissingVersion> = problems
-            .iter()
-            .filter_map(|p| match p {
-                Problem::MissingVersion(x) => Some(x),
-                _ => None,
-            })
-            .collect();
-
-        let crates: Vec<&MissingCrate> = problems
-            .iter()
-            .filter_map(|p| match p {
-                Problem::MissingCrate(x) => Some(x),
-                _ => None,
-            })
-            .collect();
-
-        let got_versions = !versions.is_empty();
-        if got_versions {
-            let table = Table::new(versions).with(Style::modern());
-            println!("Table: Packaged version is not what is required");
-            println!();
-            println!("{}", table.to_string());
-        }
+fn report_problems(mut problems: Vec<Problem>) {
+    problems.sort_by_key(|p| match p {
+        Problem::MissingCrate(x) => x.name.clone(),
+        Problem::MissingVersion(x) => x.name.clone(),
+    });
+
+    let versions: Vec<&MissingVersion> = problems
+        .iter()
+        .filter_map(|p| match p {
+            Problem::MissingVersion(x) => Some(x),
+            _ => None,
+        })
+        .collect();
+
+    let crates: Vec<&MissingCrate> = problems
+        .iter()
+        .filter_map(|p| match p {
+            Problem::MissingCrate(x) => Some(x),
+            _ => None,
+        })
+        .collect();
+
+    let got_versions = !versions.is_empty();
+    if got_versions {
+        let table = Table::new(versions).with(Style::modern());
+        println!("Table: Packaged version is not what is required");
+        println!();
+        println!("{}", table.to_string());
+    }
 
-        if !crates.is_empty() {
-            if got_versions {
-                println!();
-            }
-            let table = Table::new(crates).with(Style::modern());
-            println!("Table: Required crate is not packaged at all");
+    if !crates.is_empty() {
+        if got_versions {
             println!();
-            println!("{}", table.to_string());
         }
-
-        Err(anyhow!(
-            "there were {} missing dependencies",
-            problems.len()
-        ))
+        let table = Table::new(crates).with(Style::modern());
+        println!("Table: Required crate is not packaged at all");
+        println!();
+        println!("{}", table.to_string());
     }
 }