Support autobins and target renaming [lib] and [[bin]]

Author: MarijnS95

Cargo.toml

@@ -6,6 +6,15 @@ edition = "2018"
 description = "Library for creating cargo subcommands."
 repository = "https://github.com/dvc94ch/cargo-subcommand"
 license = "ISC"
+# autobins = false
+
+[lib]
+name = "cargo_subcommand"
+# name = "foo"
+
+[[bin]]
+name = "cargo-subcommand"
+path = "src/main.rs"
 
 [features]
 default = ["clap"]

README.md

@@ -1,5 +1,6 @@
-# cargo-subcommand library for building subcommands
-Is used by `cargo-ndk` and `cargo-flutter`.
+# `cargo-subcommand` library for building subcommands
+
+Is used by [`cargo-apk`](https://crates.io/crates/cargo-apk) and `cargo-flutter`.
 
 # License
 Copyright 2020 David Craven <david@craven.ch>

src/args.rs

@@ -130,4 +130,13 @@ impl Args {
             Profile::Dev
         }
     }
+
+    /// Returns [`true`] when one or more target selection options are active.
+    /// This is generally used to deduce whether to default to binary and
+    /// library targets, in accordance with [`cargo build`].
+    ///
+    /// [`cargo build`]: https://doc.rust-lang.org/cargo/commands/cargo-build.html#target-selection
+    pub fn specific_target_selected(&self) -> bool {
+        self.lib || self.bins || self.examples || !self.bin.is_empty() || !self.example.is_empty()
+    }
 }

src/artifact.rs

@@ -6,15 +6,6 @@ pub enum Artifact {
     Example(String),
 }
 
-impl AsRef<Path> for Artifact {
-    fn as_ref(&self) -> &Path {
-        Path::new(match self {
-            Self::Root(_) => "",
-            Self::Example(_) => "examples",
-        })
-    }
-}
-
 impl Artifact {
     pub fn name(&self) -> &str {
         match self {
@@ -23,6 +14,13 @@ impl Artifact {
         }
     }
 
+    pub fn build_dir(&self) -> &'static Path {
+        Path::new(match self {
+            Self::Root(_) => "",
+            Self::Example(_) => "examples",
+        })
+    }
+
     pub fn file_name(&self, ty: CrateType, target: &str) -> String {
         match ty {
             CrateType::Bin => {

src/manifest.rs

@@ -6,6 +6,9 @@ use std::path::Path;
 pub struct Manifest {
     pub workspace: Option<Workspace>,
     pub package: Option<Package>,
+    pub lib: Option<Lib>,
+    #[serde(default, rename = "bin")]
+    pub bins: Vec<Bin>,
 }
 
 impl Manifest {
@@ -20,7 +23,23 @@ pub struct Workspace {
     pub members: Vec<String>,
 }
 
+const fn default_true() -> bool {
+    true
+}
+
 #[derive(Debug, Deserialize)]
 pub struct Package {
     pub name: String,
+    #[serde(default = "default_true")]
+    pub autobins: bool,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Lib {
+    pub name: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Bin {
+    pub name: String,
 }

src/subcommand.rs

@@ -1,6 +1,7 @@
 use crate::args::Args;
 use crate::artifact::{Artifact, CrateType};
 use crate::error::Error;
+use crate::manifest::Manifest;
 use crate::profile::Profile;
 use crate::{utils, LocalizedConfig};
 use std::io::BufRead;
@@ -35,6 +36,7 @@ impl Subcommand {
             "`--exclude` is not supported yet by `cargo-subcommand`"
         );
         let (manifest_path, package) = utils::find_package(
+            // TODO: This must be the path to the package already!
             &args
                 .manifest_path
                 .clone()
@@ -50,6 +52,8 @@ impl Subcommand {
             config.set_env_vars().unwrap();
         }
 
+        let parsed_manifest = Manifest::parse_from_toml(&manifest_path)?;
+
         let target_dir = args
             .target_dir
             .clone()
@@ -75,6 +79,8 @@ impl Subcommand {
                 .join(utils::get_target_dir_name(config.as_deref()).unwrap())
         });
 
+        // https://doc.rust-lang.org/cargo/reference/cargo-targets.html#target-auto-discovery
+
         let mut artifacts = vec![];
         if args.examples {
             for file in utils::list_rust_files(&root_dir.join("examples"))? {
@@ -85,17 +91,41 @@ impl Subcommand {
                 artifacts.push(Artifact::Example(example.into()));
             }
         }
-        if args.bins {
-            for file in utils::list_rust_files(&root_dir.join("src").join("bin"))? {
-                artifacts.push(Artifact::Root(file));
+
+        let specific_target_selected = args.specific_target_selected();
+
+        // https://doc.rust-lang.org/cargo/reference/cargo-targets.html#binaries
+        if args.bins || !specific_target_selected {
+            // Parse all autobins
+            if parsed_manifest.package.map_or(true, |p| p.autobins) {
+                // TODO: Autobins can still be "configured" through [[bin]] in the manifest
+                // and should then NOT end up in the artifacts list twice!
+                // We should effectively merge those lists here.
+                for file in utils::list_rust_files(&root_dir.join("src").join("bin"))? {
+                    artifacts.push(Artifact::Root(file));
+                }
+                if root_dir.join("src/main.rs").is_file() {
+                    artifacts.push(Artifact::Root(package.clone()));
+                }
+            }
+
+            // Add all explicitly configured binaries
+            for bin in parsed_manifest.bins {
+                artifacts.push(Artifact::Root(bin.name.clone()));
             }
         } else {
+            // TODO: Use info from the above if body to validate that these bins exist?
             for bin in &args.bin {
-                artifacts.push(Artifact::Root(bin.into()));
+                artifacts.push(Artifact::Root(bin.clone()));
             }
         }
-        if artifacts.is_empty() {
-            artifacts.push(Artifact::Root(package.clone()));
+        if args.lib || !specific_target_selected {
+            // Add the one and only library target, if it exists
+            let name = parsed_manifest
+                .lib
+                .and_then(|lib| lib.name)
+                .unwrap_or_else(|| package.clone());
+            artifacts.push(Artifact::Root(name));
         }
         let host_triple = Command::new("rustc")
             .arg("-vV")
@@ -178,6 +208,8 @@ impl Subcommand {
     ) -> PathBuf {
         let triple = target.unwrap_or_else(|| self.host_triple());
         let file_name = artifact.file_name(crate_type, triple);
-        self.build_dir(target).join(artifact).join(file_name)
+        self.build_dir(target)
+            .join(artifact.build_dir())
+            .join(file_name)
     }
 }

src/utils.rs

@@ -40,7 +40,7 @@ pub fn find_package(path: &Path, name: Option<&str>) -> Result<(PathBuf, String)
     for manifest_path in path
         .ancestors()
         .map(|dir| dir.join("Cargo.toml"))
-        .filter(|dir| dir.exists())
+        .filter(|manifest| manifest.exists())
     {
         let manifest = Manifest::parse_from_toml(&manifest_path)?;
         if let Some(p) = manifest.package.as_ref() {