lux_lib/operations/
exec.rs

1use std::io;
2use tokio::process::Command;
3
4use crate::{
5    config::Config,
6    lua_rockspec::LuaVersionError,
7    lua_version::{LuaVersion, LuaVersionUnset},
8    operations::{BuildWorkspace, BuildWorkspaceError, Install},
9    package::{PackageReq, PackageVersionReqError},
10    path::{Paths, PathsError},
11    remote_package_db::RemotePackageDBError,
12    tree::{self, InstallTree, TreeError},
13    workspace::{Workspace, WorkspaceTreeError},
14};
15use bon::Builder;
16use itertools::Itertools;
17use miette::Diagnostic;
18use thiserror::Error;
19use which::which;
20
21use super::{InstallError, PackageInstallSpec};
22
23/// Rocks package runner, providing fine-grained control
24/// over how a package should be run.
25#[derive(Builder)]
26#[builder(start_fn = new, finish_fn(name = _exec, vis = ""))]
27pub struct Exec<'a> {
28    #[builder(start_fn)]
29    command: &'a str,
30    #[builder(start_fn)]
31    workspace: Option<&'a Workspace>,
32    #[builder(start_fn)]
33    config: &'a Config,
34
35    #[builder(field)]
36    args: Vec<String>,
37
38    disable_loader: Option<bool>,
39}
40
41impl<State: exec_builder::State> ExecBuilder<'_, State> {
42    pub fn arg(mut self, arg: impl Into<String>) -> Self {
43        self.args.push(arg.into());
44        self
45    }
46
47    pub fn args(mut self, args: impl IntoIterator<Item: Into<String>>) -> Self {
48        self.args.extend(args.into_iter().map_into());
49        self
50    }
51}
52
53impl<State> ExecBuilder<'_, State>
54where
55    State: exec_builder::State + exec_builder::IsComplete,
56{
57    pub async fn exec(self) -> Result<(), ExecError>
58    where
59        State: exec_builder::IsComplete,
60    {
61        exec(self._exec()).await
62    }
63}
64
65#[derive(Error, Debug, Diagnostic)]
66pub enum ExecError {
67    #[error("failed to run {cmd}: {source}")]
68    RunCommandFailed {
69        cmd: String,
70        source: io::Error,
71        #[help]
72        help: Option<String>,
73    },
74    #[error(
75        "{cmd} exited with non-zero exit code: {}",
76        exit_code.map(|code| code.to_string()).unwrap_or("unknown".into())
77    )]
78    #[diagnostic(help("check the command's output for errors."))]
79    RunCommandNonZeroExitCode { cmd: String, exit_code: Option<i32> },
80    #[error(transparent)]
81    #[diagnostic(transparent)]
82    LuaVersionUnset(#[from] LuaVersionUnset),
83    #[error(transparent)]
84    #[diagnostic(transparent)]
85    Tree(#[from] TreeError),
86    #[error(transparent)]
87    #[diagnostic(transparent)]
88    Paths(#[from] PathsError),
89    #[error(transparent)]
90    #[diagnostic(transparent)]
91    LuaVersionError(#[from] LuaVersionError),
92    #[error(transparent)]
93    #[diagnostic(transparent)]
94    BuildProject(#[from] BuildWorkspaceError),
95    #[error(transparent)]
96    #[diagnostic(transparent)]
97    InstallCommand(#[from] InstallCommandError),
98    #[error(transparent)]
99    #[diagnostic(transparent)]
100    WorkspaceTree(#[from] WorkspaceTreeError),
101    #[error("failed to execute '{0}':\n{1}")]
102    Io(String, io::Error),
103}
104
105#[derive(Error, Debug, Diagnostic)]
106#[error(transparent)]
107pub enum InstallCommandError {
108    InstallError(#[from] InstallError),
109    PackageVersionReqError(#[from] PackageVersionReqError),
110    RemotePackageDBError(#[from] RemotePackageDBError),
111    Tree(#[from] TreeError),
112    LuaVersionUnset(#[from] LuaVersionUnset),
113}
114
115async fn exec(run: Exec<'_>) -> Result<(), ExecError> {
116    let lua_version = run
117        .workspace
118        .map(|project| project.lua_version(run.config))
119        .transpose()?
120        .unwrap_or(LuaVersion::from(run.config)?.clone());
121
122    if let Some(project) = run.workspace {
123        BuildWorkspace::new(project, run.config)
124            .no_lock(false)
125            .only_deps(false)
126            .build()
127            .await?;
128    } else if which(run.command).is_err() {
129        install_command(run.command, run.config).await?
130    };
131
132    let user_tree = run.config.user_tree(lua_version)?;
133    let mut paths = Paths::new(&user_tree)?;
134
135    if let Some(project) = run.workspace {
136        paths.prepend(&Paths::new(&project.tree(run.config)?)?);
137    }
138
139    let lua_init = if run.disable_loader.unwrap_or(false) {
140        None
141    } else if user_tree.version().lux_lib_dir().is_none() {
142        tracing::warn!(
143            r#"lux-lua library not found.
144Cannot use the `lux.loader`.
145To suppress this warning, set the `--no-loader` option."#
146        );
147        None
148    } else {
149        Some(paths.init())
150    };
151
152    let status = match Command::new(run.command)
153        .args(run.args)
154        .env("PATH", paths.path_prepended().joined())
155        .env("LUA_INIT", lua_init.unwrap_or_default())
156        .env("LUA_PATH", paths.package_path().joined())
157        .env("LUA_CPATH", paths.package_cpath().joined())
158        .status()
159        .await
160    {
161        Ok(status) => Ok(status),
162        Err(err) => {
163            let help = if err.to_string().starts_with("No such file") {
164                Some(format!(
165                    "make sure '{}' is available on your PATH",
166                    run.command
167                ))
168            } else {
169                None
170            };
171            Err(ExecError::RunCommandFailed {
172                cmd: run.command.to_string(),
173                source: err,
174                help,
175            })
176        }
177    }?;
178    if status.success() {
179        Ok(())
180    } else {
181        Err(ExecError::RunCommandNonZeroExitCode {
182            cmd: run.command.to_string(),
183            exit_code: status.code(),
184        })
185    }
186}
187
188/// Ensure that a command is installed.
189/// This defaults to the local project tree if cwd is a project root.
190async fn install_command(command: &str, config: &Config) -> Result<(), InstallCommandError> {
191    let install_spec = PackageInstallSpec::new(
192        PackageReq::new(command.into(), None)?,
193        tree::EntryType::Entrypoint,
194    )
195    .build();
196    let tree = config.user_tree(LuaVersion::from(config)?.clone())?;
197    Install::new(config)
198        .package(install_spec)
199        .tree(tree)
200        .install()
201        .await?;
202    Ok(())
203}
lux_lib/operations/exec.rs

lux_lib/operations/
exec.rs
