feat: only include dependencies that aren't restricted on a target

This may not be good enough. We'll see.

Sponsored-by: pep.foundation

1 files changed, 23 insertions, 9 deletions

diff --git a/src/main.rs b/src/main.rs
index c069ae9..edb8712 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,7 @@
 use anyhow::anyhow;
 use cargo_metadata::{CargoOpt, MetadataCommand};
 use clap::Parser;
-use log::{trace, debug, error, info};
+use log::{debug, error, info, trace};
 use semver::{Version, VersionReq};
 use std::collections::HashMap;
 use std::fmt;
@@ -24,24 +24,28 @@ fn fallible_main() -> anyhow::Result<()> {
 
     info!("load dependencies with version requirements");
     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"));
 
     if args.all_features {
         metadata.features(CargoOpt::AllFeatures);
     } else if !args.features.is_empty() {
         metadata.features(CargoOpt::NoDefaultFeatures);
-        metadata.features(CargoOpt::SomeFeatures(args.features.clone()));
+        metadata.features(CargoOpt::SomeFeatures(args.features));
     };
 
+    info!("run cargo command: {:?}", metadata.cargo_command());
     let metadata = metadata.exec()?;
 
     let mut dependencies: HashMap<String, VersionReq> = HashMap::new();
     for package in metadata.packages {
         for dep in &package.dependencies {
-            trace!("package {} dep {:?}", package.name, dep);
-            let name = canonicalize_crate_name(&dep.name);
-            trace!("dependency on {} {}", name, dep.req);
-            dependencies.insert(name, dep.req.clone());
+            if dep.target.is_none() {
+                trace!("package {} platform {:?}", package.name, dep.target);
+                let name = canonicalize_crate_name(&dep.name);
+                trace!("dependency on {} {}", name, dep.req);
+                dependencies.insert(name, dep.req.clone());
+            }
         }
     }
     info!("found {} dependencies", dependencies.len());
@@ -52,14 +56,20 @@ fn fallible_main() -> anyhow::Result<()> {
         debug!("consider {}, version {} required", name, req);
         if let Some(c) = packaged.get(name) {
             if !req.matches(&c.version) {
-                info!("crate {} is packaged, but version doesn't satisfy {}", c.orig_name, c.version);
+                info!(
+                    "crate {} is packaged, but version doesn't satisfy {}",
+                    c.orig_name, c.version
+                );
                 problems.push(Problem::MissingVersion(
                     c.orig_name.clone(),
                     req.clone(),
                     c.version.clone(),
                 ));
             } else {
-                info!("crate {} is packaged and version satisfies {}", c.orig_name, c.version);
+                info!(
+                    "crate {} is packaged and version satisfies {}",
+                    c.orig_name, c.version
+                );
             }
         } else {
             info!("crate {} is not packaged at all", name);
@@ -193,7 +203,11 @@ impl fmt::Display for Problem {
         match self {
             Self::MissingCrate(name, req) => write!(f, "missing-entirely {} {}", name, req),
             Self::MissingVersion(name, req, got) => {
-                write!(f, "missing-version: crate {} want {} got {}", name, req, got)
+                write!(
+                    f,
+                    "missing-version: crate {} want {} got {}",
+                    name, req, got
+                )
             }
         }
     }