fix mutli crate setup

Author: makspll

codegen/crates/crate_feature_graph/Cargo.toml

@@ -2,10 +2,17 @@
 name = "crate_feature_graph"
 version = "0.1.0"
 edition = "2024"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+include = ["src/**", "bin/**", "Cargo.toml", "README.md", "example.png"]
 
 [lib]
 path = "src/lib.rs"
 
+[[bin]]
+name = "crate_feature_graph"
+path = "bin/main.rs"
+
 [features]
 dot_parser = ["petgraph/dot_parser"]
 serde = ["dep:serde", "dep:serde_json"]
@@ -18,6 +25,7 @@ log = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 serde = { workspace = true, features = ["derive"], optional = true }
 serde_json = { workspace = true, optional = true }
+pretty_env_logger = { workspace = true }
 
 [dev-dependencies]
 petgraph = { workspace = true, features = ["dot_parser"] }

codegen/crates/crate_feature_graph/README.md

@@ -0,0 +1,10 @@
+# Crate Feature Graph
+
+![Example output graph](./example.png)
+
+A tool for visualising feature flow in a rust workspace, from the perspective of build time features.
+
+## Features
+- Compute feature flow throughout your workspace
+- Filter out crates you don't want to see from the graph, but retain the connections
+- Output as a dot graph or if the `dot_parser` feature is disabled as a text representation

codegen/crates/crate_feature_graph/bin/main.rs

@@ -0,0 +1,75 @@
+use clap::Parser;
+use crate_feature_graph::{CrateName, Workspace, WorkspaceGraph};
+
+#[derive(Parser)]
+struct Args {
+    /// Path to the Cargo.toml of the workspace to analyze
+    #[clap(long, short, default_value = "./Cargo.toml")]
+    manifest_path: String,
+
+    /// Comma-separated list of feature names to enable for the given manifest
+    #[clap(
+        short,
+        long,
+        default_value = "",
+        use_value_delimiter = true,
+        value_delimiter = ','
+    )]
+    features: Vec<String>,
+
+    /// Whether to disable the default features of the given manifest
+    /// Defaults to true
+    #[clap(long, default_value = "false")]
+    disable_default_features: bool,
+
+    /// Only show crates in the output graph that match one of these names
+    /// Only works for dot graphs
+    /// Defaults to empty, which shows all crates
+    #[clap(long, use_value_delimiter = true, value_delimiter = ',')]
+    only_show_crates: Vec<String>,
+
+    /// The package to consider as the root of the search
+    /// The default will use the root of the workspace
+    /// The features provided will be applied to this package, unless a crate prefix is provided
+    #[clap(long)]
+    root_package: Option<String>,
+}
+
+pub fn main() -> std::io::Result<()> {
+    pretty_env_logger::init();
+    let args = Args::parse();
+
+    let metadata = cargo_metadata::MetadataCommand::new()
+        .manifest_path(&args.manifest_path)
+        .exec()
+        .expect("Failed to get cargo metadata");
+
+    let workspace = Workspace::from(&metadata);
+    let mut graph = WorkspaceGraph::from(workspace);
+
+    let root = args.root_package;
+    log::info!(
+        "Calculating features for root: {:?} with features: {:?}, default features: {}",
+        root,
+        args.features,
+        !args.disable_default_features
+    );
+
+    // TODO: allow focusing on a non-workspace root, i.e. package
+    graph
+        .calculate_enabled_features_and_dependencies_parse(args.features, root.map(CrateName::new));
+
+    #[cfg(feature = "dot_parser")]
+    let dot_graph = graph.visualise_feature_flow(args.only_show_crates)?;
+
+    #[cfg(not(feature = "dot_parser"))]
+    let dot_graph = {
+        log::warn!("Feature `dot_parser` not enabled, dumping debug print instead");
+        format!("{:?}", graph.workspace)
+    };
+
+    // dump the graph
+    println!("{dot_graph}");
+
+    Ok(())
+}

codegen/crates/crate_feature_graph/example.png

@@ -64,7 +64,7 @@ pub enum FeatureEffect {
     /// I.e. `foo=["dep:optional"]` is represented as `EnableOptionalDependency("optional")`
     EnableOptionalDependency(CrateName),
     /// I.e. `foo=["optional(?)/feature"]` is represented as `EnableFeatureInDependency("feature", "optional")`
-    /// this effect by itself does not enable the dependency, only the feature in it
+    /// this effect by itself does not enable the dependency, only the feature in it unless `enables_optionals` is true
     EnableFeatureInDependency(FeatureName, CrateName, bool),
 }
 
@@ -263,6 +263,21 @@ impl Crate {
         }
     }
 
+    /// Checks if a dependency of this crate is enabled via one of its active features
+    /// The active features must be computed first
+    pub fn optional_dependency_is_enabled(&self, dep: &CrateName) -> bool {
+        self.optional_dependencies.iter().any(|d| {
+            &d.name == dep
+                && self.active_features.as_ref().is_some_and(|f| {
+                    f.iter().any(|f| {
+                        self.features.iter().any(|feat| {
+                            feat.name == *f && feat.effects().any(|e| e.enables_crate(dep))
+                        })
+                    })
+                })
+        })
+    }
+
     /// processes the feature set, given the initially enabled features, and returns the full set of enabled features.
     /// if `enable_default` is true, the "default" feature is considered enabled initially if it exists.
     pub fn compute_active_features(
@@ -324,14 +339,28 @@ impl Crate {
                 // for default do still include the feature even if it doesn't exist
                 all_features.insert(next);
             } else {
-                error!(
-                    "Crate `{}` does not have feature `{}`. Are you using the right features?",
-                    self.name, next
-                );
+                // error!(
+                //     "Crate `{}` does not have feature `{}`. Are you using the right features?",
+                //     self.name, next
+                // );
+                // too noisy for now, figure out what's going on TODO
             }
         }
 
-        self.active_features = Some(all_features);
+        if let Some(active_features) = &self.active_features {
+            // merge, features are always additive in a workspace
+            if self.in_workspace.is_some_and(|a| a) {
+                log::trace!(
+                    "Merging active features for crate `{}`, as new path is being computed: {:?} + {:?}",
+                    self.name,
+                    active_features,
+                    all_features
+                );
+            }
+            self.active_features = Some(active_features.union(&all_features).cloned().collect());
+        } else {
+            self.active_features = Some(all_features);
+        }
     }
 }
 impl From<Package> for Crate {
@@ -526,31 +555,6 @@ impl From<&Metadata> for Workspace {
                 }
             });
 
-        let existing_package_names = workspace_crates
-            .iter()
-            .map(|c| c.name.clone())
-            .collect::<HashSet<_>>();
-
-        // also process dependency crates that are not part of the workspace
-        for dep in meta.packages.iter() {
-            for dependency in dep.dependencies.iter() {
-                let dep_name = CrateName::new(&dependency.name);
-                if !existing_package_names.contains(&dep_name) {
-                    other_crates.push(Crate {
-                        name: dep_name,
-                        features: vec![],
-                        dependencies: vec![],
-                        optional_dependencies: vec![],
-                        version: Version::new(0, 0, 0),
-                        in_workspace: Some(false),
-                        active_features: None,
-                        active_dependency_features: None,
-                        is_enabled: None,
-                    });
-                }
-            }
-        }
-
         for krate in workspace_crates.iter_mut() {
             krate.in_workspace = Some(true);
         }