lux-cli 0.38.1

A luxurious package manager for Lua
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

use std::path::PathBuf;

use clap::Args;
use lux_lib::{
    config::{Config, ConfigBuilder},
    operations::DistProjectBin,
    package::PackageName,
    tree::FlatDistTree,
    workspace::Workspace,
};
use miette::{IntoDiagnostic, Result};
use tempfile::tempdir;

use crate::args::OutputFormat;

#[derive(Args)]
pub struct Bin {
    /// Output path for the compiled binary.{n}
    /// Defaults to `<package>[.exe]` in the current directory.
    #[arg(short, long, visible_short_alias = 'o')]
    pub output: Option<PathBuf>,

    /// Package to compile.{n}
    /// Prioritises local projects if in a workspace.{n}
    /// If not set, lux will attempt to compile the current project.{n}
    /// Must be set in multi-project workspaces.
    #[arg(short, long, visible_short_alias = 'p')]
    package: Option<PackageName>,

    #[arg(long, default_value = "text", value_enum, ignore_case = true)]
    output_format: OutputFormat,
}

pub async fn bin(data: Bin, config: Config) -> Result<()> {
    let staging_dir = tempdir().into_diagnostic()?;
    let config = ConfigBuilder::from(config)
        .wrap_bin_scripts(Some(false))
        .user_tree(Some(staging_dir.path().to_path_buf()))
        .build()?;

    let workspace = Workspace::current_or_err()?;
    let project = match &data.package {
        None => workspace.single_member()?,
        Some(package) => workspace.select_member(package)?,
    };

    let lua_version = project.lua_version(&config)?;
    let tree = FlatDistTree::new(staging_dir.path().to_path_buf(), lua_version, &config)?;

    let out = DistProjectBin::new()
        .project(project)
        .config(&config)
        .tree(&tree)
        .maybe_output(data.output)
        .compile()
        .await
        .into_diagnostic()?;

    match data.output_format {
        OutputFormat::Json => println!("{}", serde_json::to_string(&out).into_diagnostic()?),
        OutputFormat::Text => println!("Binary written to {}", out.display()),
    }

    Ok(())
}