zoi-install 1.24.1

Advanced Package Manager & Environment Orchestrator
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

use anyhow::{Result, anyhow};
use zoi_core::types;

pub fn create_manifest(
    pkg: &types::Package,
    reason: types::InstallReason,
    installed_dependencies: Vec<String>,
    install_method: Option<String>,
    installed_files: Vec<String>,
    registry_handle: &str,
    repo_type: String,
    chosen_options: &[String],
    chosen_optionals: &[String],
    sub_package: Option<String>,
) -> Result<types::InstallManifest> {
    let platform = zoi_core::utils::get_platform().unwrap_or_default();

    let mut installed_dependencies = installed_dependencies;
    installed_dependencies.sort();

    let mut installed_files = installed_files;
    installed_files.sort();

    let mut chosen_options = chosen_options.to_vec();
    chosen_options.sort();

    let mut chosen_optionals = chosen_optionals.to_vec();
    chosen_optionals.sort();

    let mut bins = pkg.bins.clone();
    if let Some(ref mut b) = bins {
        b.sort();
    }

    let mut conflicts = pkg.conflicts.clone();
    if let Some(ref mut c) = conflicts {
        c.sort();
    }

    let mut replaces = pkg.replaces.clone();
    if let Some(ref mut r) = replaces {
        r.sort();
    }

    let mut provides = pkg.provides.clone();
    if let Some(ref mut p) = provides {
        p.sort();
    }

    let mut backup = pkg.backup.clone();
    if let Some(ref mut b) = backup {
        b.sort();
    }

    let mut dependencies_v2 = pkg.dependencies.clone().map(types::to_dependencies_v2);
    if let Some(ref mut deps) = dependencies_v2 {
        deps.runtime.sort();
        for b in &mut deps.build {
            b.packages.sort();
        }
    }

    let mut completions = pkg.completions.clone();
    if let Some(ref mut c) = completions {
        c.sort_by(|a, a2| {
            a.shell
                .cmp(&a2.shell)
                .then_with(|| a.filename.cmp(&a2.filename))
        });
    }

    Ok(types::InstallManifest {
        name: pkg.name.clone(),
        version: pkg.version.clone().ok_or_else(|| {
            anyhow!(
                "Version should be resolved but was missing for package '{}'",
                pkg.name
            )
        })?,
        epoch: pkg.epoch,
        revision: pkg.revision.clone(),
        sub_package,
        repo: pkg.repo.clone(),
        repo_type,
        registry_handle: registry_handle.to_string(),
        package_type: pkg.package_type,
        description: pkg.description.clone(),
        reason,
        scope: pkg.scope,
        bins,
        conflicts,
        replaces,
        provides,
        backup,
        installed_dependencies,
        dependencies_v2,
        chosen_options,
        chosen_optionals,
        install_method,
        platform,
        service: pkg.service.clone(),
        installed_files,
        installed_size: pkg.installed_size,
        sandbox: pkg.sandbox.clone(),
        completions,
    })
}