npmgen-cli 0.1.2

Command-line driver for npmgen: standalone `npmgen` and the `cargo npmgen` subcommand.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use std::path::PathBuf;

use clap::Parser;
use npmgen_core::{DEFAULT_DRIVER, DEFAULT_MANIFEST_PATH, DEFAULT_OUT, Generator};

/// Generate the npm publish tree (meta + per-platform packages) that ships a
/// prebuilt Rust binary.
#[derive(Debug, Parser)]
#[command(name = "npmgen", version, about, long_about = None)]
pub struct Cli {
    /// Manifest of the target crate.
    #[arg(long, env = "NPMGEN_MANIFEST_PATH", default_value = DEFAULT_MANIFEST_PATH)]
    manifest_path: PathBuf,

    /// Output root for the generated tree.
    #[arg(long, env = "NPMGEN_OUT", default_value = DEFAULT_OUT)]
    out: PathBuf,

    /// Workspace package to describe and build.
    #[arg(short = 'p', long, env = "NPMGEN_PACKAGE")]
    package: Option<String>,

    /// Cargo bin name shipped in platform packages.
    #[arg(long, env = "NPMGEN_BIN")]
    bin: Option<String>,

    /// Override the package version (otherwise read from Cargo.toml).
    #[arg(long = "pkg-version", env = "NPMGEN_PKG_VERSION")]
    pkg_version: Option<String>,

    /// Require the resolved version to equal `v<tag>`.
    #[arg(long, env = "NPMGEN_TAG")]
    tag: Option<String>,

    /// Assemble from existing binaries instead of building.
    #[arg(long, env = "NPMGEN_NO_BUILD")]
    no_build: bool,

    /// Build driver invoked per target (e.g. cargo, cross, cargo-zigbuild).
    #[arg(long, env = "NPMGEN_BUILDER", default_value = DEFAULT_DRIVER)]
    builder: String,

    /// Restrict to these target keys (repeatable or comma-separated).
    #[arg(long = "target", env = "NPMGEN_TARGETS", value_delimiter = ',')]
    targets: Vec<String>,
}

impl Cli {
    /// Build the configured [`Generator`] from parsed arguments.
    pub fn into_generator(self) -> Generator {
        let mut builder = Generator::builder()
            .manifest_path(self.manifest_path)
            .out(self.out)
            .no_build(self.no_build)
            .driver(self.builder)
            .targets(self.targets);
        if let Some(package) = self.package {
            builder = builder.package(package);
        }
        if let Some(bin) = self.bin {
            builder = builder.bin(bin);
        }
        if let Some(version) = self.pkg_version {
            builder = builder.version(version);
        }
        if let Some(tag) = self.tag {
            builder = builder.tag(tag);
        }
        builder.build()
    }
}