Load all crates in the graph, honor the "publish" flag to prevent publishing examples/tests.

4 files changed, 114 insertions, 38 deletions

diff --git a/release/src/build.rs b/release/src/build.rs
index d1abb2aa1..7c777d36c 100644
--- a/release/src/build.rs
+++ b/release/src/build.rs
@@ -34,6 +34,10 @@ pub(crate) fn build(ctx: &crate::Context, crate_name: Option<&str>) -> Result<()
                 args_builder = args_builder.features(&config.features);
             }
 
+            if let Some(ref artifact_dir) = config.artifact_dir {
+                args_builder = args_builder.artifact_dir(artifact_dir);
+            }
+
             batch_builder.add_command(args_builder.build());
         }
     }
diff --git a/release/src/cargo.rs b/release/src/cargo.rs
index 0b28458e9..826a3a8b2 100644
--- a/release/src/cargo.rs
+++ b/release/src/cargo.rs
@@ -149,6 +149,15 @@ impl CargoArgsBuilder {
     }
 
     #[must_use]
+    pub fn artifact_dir<S>(mut self, artifact_dir: S) -> Self
+    where
+        S: Into<String>,
+    {
+        self.args.push(format!("--artifact-dir={}", artifact_dir.into()));
+        self
+    }
+
+    #[must_use]
     pub fn arg<S>(mut self, arg: S) -> Self
     where
         S: Into<String>,
diff --git a/release/src/main.rs b/release/src/main.rs
index b1bc17255..5605ca332 100644
--- a/release/src/main.rs
+++ b/release/src/main.rs
@@ -3,7 +3,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command as ProcessCommand;
 
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, bail, Result};
 use clap::{Parser, Subcommand};
 use log::info;
 use petgraph::graph::{Graph, NodeIndex};
@@ -13,6 +13,25 @@ use simple_logger::SimpleLogger;
 use toml_edit::{DocumentMut, Item, Value};
 use types::*;
 
+fn check_publish_dependencies(ctx: &Context) -> Result<()> {
+    for krate in ctx.crates.values() {
+        if krate.publish {
+            for dep_name in &krate.dependencies {
+                if let Some(dep_crate) = ctx.crates.get(dep_name) {
+                    if !dep_crate.publish {
+                        return Err(anyhow!(
+                            "Publishable crate '{}' depends on non-publishable crate '{}'. This is not allowed.",
+                            krate.name,
+                            dep_name
+                        ));
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
 mod build;
 mod cargo;
 mod semver_check;
@@ -56,7 +75,7 @@ enum Command {
     },
     /// SemverCheck
     SemverCheck {
-        /// Crate to check. Will traverse that crate an it's dependents. If not specified checks all crates.
+        /// Specific crate name to check
         #[arg(value_name = "CRATE")]
         crate_name: String,
     },
@@ -120,53 +139,72 @@ fn update_versions(to_update: &Crate, dep: &CrateId, new_version: &str) -> Resul
 }
 
 fn list_crates(root: &PathBuf) -> Result<BTreeMap<CrateId, Crate>> {
-    let d = std::fs::read_dir(root)?;
     let mut crates = BTreeMap::new();
+    discover_crates(root, &mut crates)?;
+    Ok(crates)
+}
+
+fn discover_crates(dir: &PathBuf, crates: &mut BTreeMap<CrateId, Crate>) -> Result<()> {
+    let d = std::fs::read_dir(dir)?;
     for c in d {
         let entry = c?;
         if entry.file_type()?.is_dir() {
-            let path = root.join(entry.path());
-            let entry = path.join("Cargo.toml");
-            if entry.exists() {
-                let content = fs::read_to_string(&entry)?;
-                let parsed: ParsedCrate = toml::from_str(&content)?;
-                let id = parsed.package.name;
+            let path = dir.join(entry.path());
+            let cargo_toml = path.join("Cargo.toml");
 
-                let metadata = &parsed.package.metadata.embassy;
+            if cargo_toml.exists() {
+                let content = fs::read_to_string(&cargo_toml)?;
 
-                if metadata.skip {
-                    continue;
-                }
+                // Try to parse as a crate, skip if it's a workspace
+                let parsed: Result<ParsedCrate, _> = toml::from_str(&content);
+                if let Ok(parsed) = parsed {
+                    let id = parsed.package.name;
 
-                let mut dependencies = Vec::new();
-                for (k, _) in parsed.dependencies {
-                    if k.starts_with("embassy-") {
-                        dependencies.push(k);
+                    let metadata = &parsed.package.metadata.embassy;
+
+                    if metadata.skip {
+                        continue;
                     }
-                }
 
-                let mut configs = metadata.build.clone();
-                if configs.is_empty() {
-                    configs.push(BuildConfig {
-                        features: vec![],
-                        target: None,
-                    })
-                }
+                    let mut dependencies = Vec::new();
+                    for (k, _) in parsed.dependencies {
+                        if k.starts_with("embassy-") {
+                            dependencies.push(k);
+                        }
+                    }
+
+                    let mut configs = metadata.build.clone();
+                    if configs.is_empty() {
+                        configs.push(BuildConfig {
+                            features: vec![],
+                            target: None,
+                            artifact_dir: None,
+                        })
+                    }
 
-                crates.insert(
-                    id.clone(),
-                    Crate {
-                        name: id,
-                        version: parsed.package.version,
-                        path,
-                        dependencies,
-                        configs,
-                    },
-                );
+                    crates.insert(
+                        id.clone(),
+                        Crate {
+                            name: id,
+                            version: parsed.package.version,
+                            path,
+                            dependencies,
+                            configs,
+                            publish: parsed.package.publish,
+                        },
+                    );
+                }
+            } else {
+                // Recursively search subdirectories, but only for examples, tests, and docs
+                let file_name = entry.file_name();
+                let dir_name = file_name.to_string_lossy();
+                if dir_name == "examples" || dir_name == "tests" || dir_name == "docs" {
+                    discover_crates(&path, crates)?;
+                }
             }
         }
     }
-    Ok(crates)
+    Ok(())
 }
 
 fn build_graph(crates: &BTreeMap<CrateId, Crate>) -> (Graph<CrateId, ()>, HashMap<CrateId, NodeIndex>) {
@@ -214,12 +252,17 @@ fn load_context(args: &Args) -> Result<Context> {
     let crates = list_crates(&root)?;
     let (graph, indices) = build_graph(&crates);
 
-    Ok(Context {
+    let ctx = Context {
         root,
         crates,
         graph,
         indices,
-    })
+    };
+
+    // Check for publish dependency conflicts
+    check_publish_dependencies(&ctx)?;
+
+    Ok(ctx)
 }
 
 fn main() -> Result<()> {
@@ -274,10 +317,21 @@ fn main() -> Result<()> {
         }
         Command::SemverCheck { crate_name } => {
             let c = ctx.crates.get(&crate_name).unwrap();
+            if !c.publish {
+                bail!("Cannot run semver-check on non-publishable crate '{}'", crate_name);
+            }
             check_semver(&c)?;
         }
         Command::PrepareRelease { crate_name } => {
             let start = ctx.indices.get(&crate_name).expect("unable to find crate in tree");
+
+            // Check if the target crate is publishable
+            let start_weight = ctx.graph.node_weight(*start).unwrap();
+            let start_crate = ctx.crates.get(start_weight).unwrap();
+            if !start_crate.publish {
+                bail!("Cannot prepare release for non-publishable crate '{}'", crate_name);
+            }
+
             let mut rgraph = ctx.graph.clone();
             rgraph.reverse();
 
diff --git a/release/src/types.rs b/release/src/types.rs
index c5b774977..4d9d440d8 100644
--- a/release/src/types.rs
+++ b/release/src/types.rs
@@ -13,10 +13,16 @@ pub struct ParsedCrate {
 pub struct ParsedPackage {
     pub name: String,
     pub version: String,
+    #[serde(default = "default_publish")]
+    pub publish: bool,
     #[serde(default)]
     pub metadata: Metadata,
 }
 
+fn default_publish() -> bool {
+    true
+}
+
 #[derive(Debug, Deserialize, Default)]
 pub struct Metadata {
     #[serde(default)]
@@ -36,6 +42,8 @@ pub struct BuildConfig {
     #[serde(default)]
     pub features: Vec<String>,
     pub target: Option<String>,
+    #[serde(rename = "artifact-dir")]
+    pub artifact_dir: Option<String>,
 }
 
 pub type CrateId = String;
@@ -47,4 +55,5 @@ pub struct Crate {
     pub path: PathBuf,
     pub dependencies: Vec<CrateId>,
     pub configs: Vec<BuildConfig>,
+    pub publish: bool,
 }