lux-cli 0.37.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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::path::{Path, PathBuf};

use clap::Args;
use emmylua_check::OutputDestination;
use itertools::Itertools;
use lux_lib::{config::Config, progress::MultiProgress, workspace::Workspace};
use miette::{miette, Result};

use crate::{
    args::OutputFormat,
    utils::path::{classify_path, PathTarget},
    workspace::{sync_dependencies_if_locked, sync_test_dependencies_if_locked},
};

#[derive(Args)]
pub struct Check {
    /// Path to a workspace, directory, or Lua file to check. Defaults to the current workspace.
    #[arg(long)]
    path: Option<PathBuf>,
    /// Comma-separated list of ignore patterns.
    /// Patterns must follow glob syntax.
    /// Lux will automatically add top-level ignored project files.
    #[arg(short, long, value_delimiter = ',')]
    ignore: Option<Vec<String>>,

    /// The output format.
    #[arg(long, default_value = "text", value_enum, ignore_case = true)]
    output_format: OutputFormat,

    /// Output destination.{n}
    /// (stdout or a file path, only used when the output format is json).
    #[arg(long, default_value = "stdout")]
    output: OutputDestination,

    /// Treat warnings as errors.
    #[arg(long)]
    warnings_as_errors: bool,
}

impl From<OutputFormat> for emmylua_check::OutputFormat {
    fn from(value: OutputFormat) -> Self {
        match value {
            OutputFormat::Json => emmylua_check::OutputFormat::Json,
            OutputFormat::Text => emmylua_check::OutputFormat::Text,
        }
    }
}

pub async fn check(args: Check, config: Config) -> Result<()> {
    let target = match args.path.as_deref() {
        None => PathTarget::Workspace(Box::new(Workspace::current_or_err()?)),
        Some(path) => classify_path(path)?,
    };

    let (workspace_dirs, rc_files) = match target {
        PathTarget::Workspace(workspace) => {
            let progress = MultiProgress::new_arc(&config);
            sync_dependencies_if_locked(&workspace, progress.clone(), &config).await?;
            sync_test_dependencies_if_locked(&workspace, progress, &config).await?;

            let dirs = workspace
                .members()
                .iter()
                .map(|project| project.root())
                .flat_map(|project_root| {
                    vec![
                        project_root.join("src"),
                        project_root.join("lua"),
                        // For now, we don't include tests
                        // because they require LLS_Addons definitions for busted

                        // project_root.join("test"),
                        // project_root.join("tests"),
                        // project_root.join("spec"),
                    ]
                })
                .filter(|dir| dir.is_dir())
                .collect_vec();

            let luarc_path = workspace.luarc_path(&config);

            let rc = if luarc_path.is_file() {
                Some(vec![luarc_path])
            } else {
                None
            };

            (dirs, rc)
        }
        PathTarget::Directory(dir) => {
            let rc = resolve_rc_files(&dir, &config)?;
            (vec![dir], rc)
        }
        PathTarget::File(file) => {
            let root = file
                .parent()
                .unwrap_or_else(|| Path::new("."))
                .to_path_buf();

            let rc = resolve_rc_files(&root, &config)?;
            (vec![root], rc)
        }
    };

    if workspace_dirs.is_empty() {
        println!("Nothing to check!");
        return Ok(());
    }

    let emmylua_check_args = emmylua_check::CmdArgs {
        config: rc_files,
        workspace: workspace_dirs,
        ignore: args.ignore,
        output_format: args.output_format.into(),
        output: args.output,
        warnings_as_errors: args.warnings_as_errors,
        verbose: config.verbose(),
    };

    emmylua_check::run_check(emmylua_check_args)
        .await
        .map_err(|err| miette!("{err}"))?;
    Ok(())
}

fn resolve_rc_files(root: &Path, config: &Config) -> Result<Option<Vec<PathBuf>>> {
    let rc_path = match Workspace::from(root)? {
        Some(workspace) => workspace.luarc_path(config),
        None => root.join(".luarc.json"),
    };

    if rc_path.is_file() {
        Ok(Some(vec![rc_path]))
    } else {
        Ok(None)
    }
}