Merge pull request #27 from thedodd/23-workspaces-and-multi-project

Handle multi-project & workspace contexts.

Author: thedodd

CHANGELOG.md

@@ -3,6 +3,10 @@ changelog
 
 ## Unreleased
 
+## 0.3.0
+### added
+- Handle multi-project & workspace contexts. Thank you @oli-obk for developing [cargo_metadata](https://github.com/oli-obk/cargo_metadata).
+
 ## 0.2.0
 ### changed
 - All CLI output has been improved using console & indicatif. Builds, asset pipelines, and the like are using a progress spinner along with messages. All in all this provides a much more clean CLI output experience.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "trunk"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2018"
 description = "Build, bundle & ship your Rust WASM application to the web."
 license = "MIT/Apache-2.0"
@@ -14,6 +14,7 @@ keywords = ["wasm", "bundler", "web", "build-tool", "compiler"]
 anyhow = "1.0.32"
 async-process = "0.1.1"
 async-std = { version="1.6.3", features=["attributes", "unstable"] }
+cargo_metadata = "0.11.1"
 console = "0.12.0"
 futures = "0.3.5"
 indicatif = "0.15.0"

Cargo.toml

@@ -8,13 +8,11 @@ use anyhow::{anyhow, bail, ensure, Result};
 use async_process::{Command, Stdio};
 use async_std::fs;
 use async_std::task::{spawn, spawn_blocking, JoinHandle};
+use cargo_metadata::{MetadataCommand, Metadata, Package};
 use console::Emoji;
 use futures::stream::{FuturesUnordered, StreamExt};
 use indicatif::ProgressBar;
 use nipper::Document;
-use serde::{Serialize, Deserialize};
-
-use crate::common::get_cwd;
 
 const TRUNK_ID: &str = "__trunk-id";
 const HREF_ATTR: &str = "href";
@@ -27,7 +25,7 @@ const HREF_ATTR: &str = "href";
 /// build routines can be cleanly abstracted away form any specific CLI endpoints.
 pub struct BuildSystem {
     /// The `Cargo.toml` manifest of the app being built.
-    manifest: CargoManifest,
+    manifest: CargoMetadata,
     /// The path to the source HTML document from which the output `index.html` will be built.
     target_html_path: Arc<PathBuf>,
     /// The parent directory of `target_html_path`.
@@ -56,16 +54,13 @@ impl BuildSystem {
     ///
     /// Reducing the number of assumptions here should help us to stay flexible when adding new
     /// commands, rafctoring and the like.
-    pub async fn new(manifest: CargoManifest, target_html_path: PathBuf, release: bool, dist: PathBuf, public_url: String) -> Result<Self> {
+    pub async fn new(manifest: CargoMetadata, target_html_path: PathBuf, release: bool, dist: PathBuf, public_url: String) -> Result<Self> {
         let mode_segment = if release { "release" } else { "debug" };
-        let cwd = std::env::current_dir().map_err(|_| anyhow!("failed to determine current working directory"))?;
-        let app_target_wasm = cwd
-            .join("target")
+        let app_target_wasm = manifest.metadata.target_directory
             .join("wasm32-unknown-unknown")
             .join(mode_segment)
             .join(format!("{}.wasm", &manifest.package.name));
-        let bindgen_out = cwd
-            .join("target")
+        let bindgen_out = manifest.metadata.target_directory
             .join("wasm-bindgen")
             .join(mode_segment);
         let target_html_path = target_html_path.canonicalize()
@@ -452,34 +447,43 @@ struct WasmBindgenOutput {
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
-/// A model of the Cargo.toml `package` section.
-#[derive(Serialize, Deserialize)]
-pub struct CargoPackage {
-    /// The name of the crate.
+/// A wrapper around the cargo project's metadata.
+pub struct CargoMetadata {
+    /// The metadata parsed from the cargo project.
+    pub metadata: Metadata,
+    /// The metadata package info on this package.
+    pub package: Package,
+    /// The name of the cargo project's build output file.
     pub name: String,
-    /// The version of the crate.
-    pub version: String,
-}
-
-/// A model of the parts of a `Cargo.toml` file which we actually care about.
-#[derive(Serialize, Deserialize)]
-pub struct CargoManifest {
-    /// The package section of `Cargo.toml`.
-    pub package: CargoPackage,
 }
 
-impl CargoManifest {
-    /// Read the `Cargo.toml` manifest in the CWD.
-    pub async fn read_cwd_manifest() -> Result<Self> {
-        let manifest_path = get_cwd().await?.join("Cargo.toml");
-        let manifest_raw = fs::read_to_string(&manifest_path).await
-            .map_err(|err| anyhow!("error reading Cargo.toml file: {}", err))?;
-        let mut manifest: Self = toml::from_str(&manifest_raw)
-            .map_err(|err| anyhow!("error parsing Cargo.toml: {}", err))?;
-
-        // Update the package name to match what its output name will be.
-        manifest.package.name = manifest.package.name.replace("-", "_");
+impl CargoMetadata {
+    /// Get the project's cargo metadata of the CWD, or of the project specified by the given manifest path.
+    pub async fn new(manifest: &Option<PathBuf>) -> Result<Self> {
+        // Fetch the cargo project's metadata.
+        let mut cmd = MetadataCommand::new();
+        if let Some(manifest) = manifest.as_ref() {
+            cmd.manifest_path(manifest);
+        }
+        let metadata = spawn_blocking(move || {
+            cmd.exec()
+        }).await?;
+
+        // Get a handle to this project's package info.
+        let resolve = match metadata.resolve.as_ref() {
+            Some(resolve) => resolve,
+            None => bail!("missing package info from cargo project metadata"),
+        };
+        let pkgid = match resolve.root.as_ref() {
+            Some(pkgid) => pkgid,
+            None => bail!("package id missing while processing cargo metadata"),
+        };
+        let package = match metadata.packages.iter().find(|pkg| &pkg.id == pkgid) {
+            Some(package) => package.clone(),
+            None => bail!("error finding package info in cargo metadata"),
+        };
+        let name = package.name.replace("-", "_");
 
-        Ok(manifest)
+        Ok(Self{metadata, package, name})
     }
 }

src/build.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use anyhow::Result;
 use structopt::StructOpt;
 
-use crate::build::{BuildSystem, CargoManifest};
+use crate::build::{BuildSystem, CargoMetadata};
 use crate::common::parse_public_url;
 
 /// Build the Rust WASM app and all of its assets.
@@ -23,11 +23,14 @@ pub struct Build {
     /// The public URL from which assets are to be served.
     #[structopt(long, default_value="/", parse(from_str=parse_public_url))]
     public_url: String,
+    /// Path to Cargo.toml.
+    #[structopt(long="manifest-path", parse(from_os_str))]
+    manifest: Option<PathBuf>,
 }
 
 impl Build {
     pub async fn run(self) -> Result<()> {
-        let manifest = CargoManifest::read_cwd_manifest().await?;
+        let manifest = CargoMetadata::new(&self.manifest).await?;
         let mut system = BuildSystem::new(
             manifest, self.target.clone(), self.release,
             self.dist.clone(), self.public_url.clone(),

src/cmd/build.rs

@@ -22,7 +22,7 @@ pub struct Serve {
     target: PathBuf,
 
     /// The port to serve on.
-    #[structopt(short, long, default_value="8080")]
+    #[structopt(long, default_value="8080")]
     port: u16,
     /// Build in release mode.
     #[structopt(long)]
@@ -39,14 +39,18 @@ pub struct Serve {
     /// Open a browser tab once the initial build is complete.
     #[structopt(long)]
     open: bool,
+    /// Path to Cargo.toml.
+    #[structopt(long="manifest-path", parse(from_os_str))]
+    manifest: Option<PathBuf>,
 }
 
 impl Serve {
     pub async fn run(self) -> Result<()> {
         let (target, release, dist, public_url, ignore) = (
-            self.target.clone(), self.release, self.dist.clone(), self.public_url.clone(), self.ignore.clone().unwrap_or_default(),
+            self.target.clone(), self.release, self.dist.clone(),
+            self.public_url.clone(), self.ignore.clone().unwrap_or_default(),
         );
-        let mut watcher = WatchSystem::new(target, release, dist, public_url, ignore).await?;
+        let mut watcher = WatchSystem::new(target, release, dist, public_url, ignore, self.manifest.clone()).await?;
         watcher.build().await;
         let progress = watcher.get_progress_handle();
 

src/cmd/serve.rs

@@ -26,11 +26,17 @@ pub struct Watch {
     /// Additional paths to ignore.
     #[structopt(short, long, parse(from_os_str))]
     ignore: Option<Vec<PathBuf>>,
+    /// Path to Cargo.toml.
+    #[structopt(long="manifest-path", parse(from_os_str))]
+    manifest: Option<PathBuf>,
 }
 
 impl Watch {
     pub async fn run(self) -> Result<()> {
-        let mut system = WatchSystem::new(self.target, self.release, self.dist, self.public_url, self.ignore.unwrap_or_default()).await?;
+        let mut system = WatchSystem::new(
+            self.target, self.release, self.dist, self.public_url,
+            self.ignore.unwrap_or_default(), self.manifest,
+        ).await?;
         system.build().await;
         system.run().await;
         Ok(())

src/cmd/watch.rs

@@ -11,7 +11,7 @@ use indicatif::ProgressBar;
 use notify::{Watcher, RecursiveMode, watcher};
 
 use crate::common::get_cwd;
-use crate::build::{BuildSystem, CargoManifest};
+use crate::build::{BuildSystem, CargoMetadata};
 
 /// A watch system wrapping a build system and a watcher.
 pub struct WatchSystem {
@@ -22,7 +22,10 @@ pub struct WatchSystem {
 
 impl WatchSystem {
     /// Create a new instance.
-    pub async fn new(target: PathBuf, release: bool, dist: PathBuf, public_url: String, ignore: Vec<PathBuf>) -> Result<Self> {
+    pub async fn new(
+        target: PathBuf, release: bool, dist: PathBuf, public_url: String,
+        ignore: Vec<PathBuf>, manifest: Option<PathBuf>,
+    ) -> Result<Self> {
         // Process ignore list.
         let cwd = get_cwd().await?;
         let mut ignore = ignore.into_iter().try_fold(vec![], |mut acc, path| -> Result<Vec<PathBuf>> {
@@ -33,7 +36,7 @@ impl WatchSystem {
         ignore.append(&mut vec![cwd.join("target"), cwd.join(&dist)]);
 
         // Perform an initial build.
-        let manifest = CargoManifest::read_cwd_manifest().await?;
+        let manifest = CargoMetadata::new(&manifest).await?;
         let build = BuildSystem::new(manifest, target, release, dist, public_url).await?;
         let progress = build.get_progress_handle();