lux-cli 0.38.0

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

use std::collections::HashMap;

use clap::Args;
use itertools::Itertools;
use lux_lib::{
    config::Config, lockfile::LocalPackage, lua_version::LuaVersion, package::PackageVersion,
    progress::MultiProgress, remote_package_db::RemotePackageDB, workspace::Workspace,
};
use miette::{IntoDiagnostic, Result};
use text_trees::{FormatCharacters, StringTreeNode, TreeFormatting};

use crate::{args::OutputFormat, workspace::sync_dependencies_if_locked};

#[derive(Args)]
pub struct Outdated {
    #[arg(long, default_value = "text", value_enum, ignore_case = true)]
    output_format: OutputFormat,
}

/// List rocks that are outdated
/// If in a project, this lists rocks in the project tree
pub async fn outdated(outdated_data: Outdated, config: Config) -> Result<()> {
    let progress = MultiProgress::new(&config);
    let bar = progress.map(MultiProgress::new_bar);
    let workspace = Workspace::current()?;
    let tree = match &workspace {
        Some(project) => {
            // Make sure dependencies are synced if in a project
            sync_dependencies_if_locked(project, MultiProgress::new_arc(&config), &config).await?;
            project.tree(&config)?
        }
        None => {
            let lua_version = LuaVersion::from(&config)?.clone();
            config.user_tree(lua_version)?
        }
    };

    let package_db = RemotePackageDB::from_config(&config, &bar).await?;

    bar.map(|b| b.set_message("🔎 Checking for outdated rocks...".to_string()));

    // NOTE: This will display all installed versions and each possible upgrade.
    // However, this should also take into account dependency constraints made by other rocks.
    // This will naturally occur with lockfiles and should be accounted for directly in the
    // `has_update` function.
    let rock_list = tree.as_rock_list()?;
    let rock_list = rock_list
        .iter()
        .map(|rock| {
            rock.to_package()
                .has_update(&package_db)
                .map(|mb_version| mb_version.map(|version| (rock, version)))
        })
        .filter_map_ok(|mb_tuple| mb_tuple)
        .try_collect::<_, Vec<(&LocalPackage, PackageVersion)>, _>()?;

    let rock_list = rock_list
        .iter()
        .sorted_by_key(|(rock, _)| rock.name().to_owned())
        .into_group_map_by(|(rock, _)| rock.name().to_owned());

    bar.map(|b| b.finish_and_clear());

    match outdated_data.output_format {
        OutputFormat::Json => {
            let jsonified_rock_list = rock_list
                .iter()
                .map(|(key, values)| {
                    (
                        key,
                        values
                            .iter()
                            .map(|(k, v)| (k.version().to_string(), v.to_string()))
                            .collect::<HashMap<_, _>>(),
                    )
                })
                .collect::<HashMap<_, _>>();

            println!(
                "{}",
                serde_json::to_string(&jsonified_rock_list).into_diagnostic()?
            );
        }
        OutputFormat::Text => {
            let formatting = TreeFormatting::dir_tree(FormatCharacters::box_chars());

            for (rock_name, updates) in rock_list {
                let mut tree = StringTreeNode::new(rock_name.to_string());

                for (rock, latest_version) in updates {
                    tree.push(format!("{} => {}", rock.version(), latest_version));
                }

                println!(
                    "{}",
                    tree.to_string_with_format(&formatting).into_diagnostic()?
                );
            }
        }
    }

    Ok(())
}