Provide workspace manifest path in Subcommand (#24)

Especially with the new `[workspace.package]` values, `cargo-apk` would
like to know the path of the workspace that was found for the requested
package, so that `cargo-apk` can scan it for values to inherit.

Author: MarijnS95

src/manifest.rs

@@ -2,7 +2,7 @@ use crate::error::{Error, Result};
 use serde::Deserialize;
 use std::path::Path;
 
-#[derive(Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize)]
 pub struct Manifest {
     pub workspace: Option<Workspace>,
     pub package: Option<Package>,
@@ -15,12 +15,12 @@ impl Manifest {
     }
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize)]
 pub struct Workspace {
     pub members: Vec<String>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize)]
 pub struct Package {
     pub name: String,
 }

src/subcommand.rs

@@ -10,6 +10,7 @@ use std::path::{Path, PathBuf};
 pub struct Subcommand {
     args: Args,
     package: String,
+    workspace_manifest: Option<PathBuf>,
     manifest: PathBuf,
     target_dir: PathBuf,
     host_triple: String,
@@ -57,14 +58,18 @@ impl Subcommand {
         // or contains the given `--manifest-path` as member.
         let workspace_manifest = utils::find_workspace(&search_path)?;
 
-        let (manifest_path, package) =
-            if let Some((workspace_manifest_path, workspace)) = &workspace_manifest {
-                // If a workspace was found, find packages relative to it
-                utils::find_package_in_workspace(workspace_manifest_path, workspace, package)?
-            } else {
-                // Otherwise scan up the directories
-                utils::find_package(&search_path, package)?
-            };
+        let (manifest_path, manifest) = if let Some((workspace_manifest_path, workspace)) =
+            &workspace_manifest
+        {
+            // If a workspace was found, find packages relative to it
+            utils::find_package_manifest_in_workspace(workspace_manifest_path, workspace, package)?
+        } else {
+            // Otherwise scan up the directories
+            utils::find_package_manifest(&search_path, package)?
+        };
+
+        // The manifest is known to contain a package at this point
+        let package = &manifest.package.as_ref().unwrap().name;
 
         let root_dir = manifest_path.parent().unwrap();
 
@@ -127,7 +132,8 @@ impl Subcommand {
         let profile = args.profile();
         Ok(Self {
             args,
-            package,
+            package: package.clone(),
+            workspace_manifest: workspace_manifest.map(|(path, _)| path),
             manifest: manifest_path,
             target_dir,
             host_triple,
@@ -145,6 +151,10 @@ impl Subcommand {
         &self.package
     }
 
+    pub fn workspace_manifest(&self) -> Option<&Path> {
+        self.workspace_manifest.as_deref()
+    }
+
     pub fn manifest(&self) -> &Path {
         &self.manifest
     }

src/utils.rs

@@ -19,32 +19,32 @@ pub fn list_rust_files(dir: &Path) -> Result<Vec<String>> {
     Ok(files)
 }
 
-fn match_package_name(manifest: &Manifest, name: Option<&str>) -> Option<String> {
+fn match_package_name(manifest: &Manifest, name: Option<&str>) -> bool {
     if let Some(p) = &manifest.package {
         if let Some(name) = name {
             if name == p.name {
-                return Some(p.name.clone());
+                return true;
             }
         } else {
-            return Some(p.name.clone());
+            return true;
         }
     }
 
-    None
+    false
 }
 
 /// Tries to find a package by the given `name` in the [workspace root] or member
 /// of the given [workspace] [`Manifest`].
 ///
-/// When a workspace is not detected, call [`find_package()`] instead.
+/// When a workspace is not detected, call [`find_package_manifest()`] instead.
 ///
 /// [workspace root]: https://doc.rust-lang.org/cargo/reference/workspaces.html#root-package
 /// [workspace]: https://doc.rust-lang.org/cargo/reference/workspaces.html#workspaces
-pub fn find_package_in_workspace(
+pub fn find_package_manifest_in_workspace(
     workspace_manifest_path: &Path,
     workspace_manifest: &Manifest,
     name: Option<&str>,
-) -> Result<(PathBuf, String)> {
+) -> Result<(PathBuf, Manifest)> {
     let workspace = workspace_manifest
         .workspace
         .as_ref()
@@ -57,8 +57,11 @@ pub fn find_package_in_workspace(
     let name = name.ok_or(Error::MultiplePackagesNotSupported)?;
 
     // Check if the workspace manifest also contains a [package]
-    if let Some(package) = match_package_name(workspace_manifest, Some(name)) {
-        return Ok((workspace_manifest_path.to_owned(), package));
+    if match_package_name(workspace_manifest, Some(name)) {
+        return Ok((
+            workspace_manifest_path.to_owned(),
+            workspace_manifest.clone(),
+        ));
     }
 
     // Check all member packages inside the workspace
@@ -73,8 +76,8 @@ pub fn find_package_in_workspace(
                 return Err(Error::UnexpectedWorkspace(manifest_path));
             }
 
-            if let Some(package) = match_package_name(&manifest, Some(name)) {
-                return Ok((manifest_path, package));
+            if match_package_name(&manifest, Some(name)) {
+                return Ok((manifest_path, manifest));
             }
         }
     }
@@ -84,9 +87,9 @@ pub fn find_package_in_workspace(
 
 /// Recursively walk up the directories until finding a `Cargo.toml`
 ///
-/// When a workspace has been detected, [`find_package_in_workspace()`] to find packages
+/// When a workspace has been detected, [`find_package_manifest_in_workspace()`] to find packages
 /// instead (that are members of the given workspace).
-pub fn find_package(path: &Path, name: Option<&str>) -> Result<(PathBuf, String)> {
+pub fn find_package_manifest(path: &Path, name: Option<&str>) -> Result<(PathBuf, Manifest)> {
     let path = dunce::canonicalize(path).map_err(|e| Error::Io(path.to_owned(), e))?;
     for manifest_path in path
         .ancestors()
@@ -100,8 +103,8 @@ pub fn find_package(path: &Path, name: Option<&str>) -> Result<(PathBuf, String)
             return Err(Error::UnexpectedWorkspace(manifest_path));
         }
 
-        if let Some(package) = match_package_name(&manifest, name) {
-            return Ok((manifest_path, package));
+        if match_package_name(&manifest, name) {
+            return Ok((manifest_path, manifest));
         }
     }
     Err(Error::ManifestNotFound)