waxpkg 0.15.9

Fast Homebrew-compatible package manager
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

use crate::cache::Cache;
use crate::cask::CaskState;
use crate::discovery::{discover_linux_system_packages, discover_manually_installed_casks};
use crate::error::Result;
use crate::install::InstallState;
use crate::lockfile::{Lockfile, LockfileCask, LockfilePackage};
use tracing::instrument;

#[instrument(skip(cache))]
pub async fn lock(cache: &Cache) -> Result<()> {
    let formulae = cache.load_formulae().await?;
    let casks = cache.load_casks().await?;

    let state = InstallState::new()?;
    state.sync_from_cellar().await?;

    let cask_state = CaskState::new()?;
    let mut installed_casks = cask_state.load().await?;

    if cfg!(target_os = "macos") {
        for (name, cask) in discover_manually_installed_casks(&casks).await? {
            installed_casks.entry(name).or_insert(cask);
        }
        cask_state.save(&installed_casks).await?;
    }

    let mut lockfile = Lockfile::new();

    let installed_packages = state.load().await?;
    for (name, pkg) in installed_packages {
        lockfile.packages.insert(
            name,
            LockfilePackage {
                version: pkg.version,
                bottle: pkg.platform,
            },
        );
    }

    for (name, cask) in installed_casks {
        lockfile.casks.insert(
            name,
            LockfileCask {
                version: cask.version,
            },
        );
    }

    if cfg!(target_os = "linux") {
        for (name, package) in discover_linux_system_packages(&formulae).await? {
            lockfile.packages.entry(name).or_insert(LockfilePackage {
                version: package.version,
                bottle: package.platform,
            });
        }
    }

    let package_count = lockfile.packages.len();
    let cask_count = lockfile.casks.len();

    if package_count == 0 && cask_count == 0 {
        println!("no packages or casks installed");
        return Ok(());
    }

    let lockfile_path = Lockfile::default_path();
    lockfile.save(&lockfile_path).await?;

    println!(
        "locked {} {} and {} {} in wax.lock",
        package_count,
        if package_count == 1 {
            "package"
        } else {
            "packages"
        },
        cask_count,
        if cask_count == 1 { "cask" } else { "casks" }
    );

    Ok(())
}