knott 0.1.17

Fast Rust package manager helper for Arch Linux repos and the AUR
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

use crate::aur::AurClient;
use crate::cli::Options;
use crate::localdb::LocalDb;
use crate::output;
use crate::pacman::Toolchain;
use crate::version::vercmp;
use anyhow::Result;
use std::cmp::Ordering;

pub async fn print_foreign(options: &Options, tools: &Toolchain) -> Result<i32> {
    let names = tools.foreign_names().await.unwrap_or_default();

    if options.quiet {
        for name in &names {
            output::inline_line(name);
        }
        return Ok(0);
    }

    let local = LocalDb::load_default().unwrap_or_else(|_| LocalDb::empty());
    for name in &names {
        if let Some(pkg) = local.get(name) {
            output::line(format!(
                "{} {}",
                output::inline(&pkg.name),
                output::inline(&pkg.version)
            ));
        } else {
            output::inline_line(name);
        }
    }

    Ok(0)
}

pub async fn print_aur_updates(
    options: &Options,
    tools: &Toolchain,
    aur: &AurClient,
) -> Result<i32> {
    let updates = aur_updates(options, tools, aur).await?;

    for update in &updates {
        if options.quiet {
            output::inline_line(&update.name);
        } else {
            output::line(format!(
                "{} {} -> {}",
                output::inline(&update.name),
                output::inline(&update.local_version),
                output::inline(&update.aur_version)
            ));
        }
    }

    Ok(0)
}

pub async fn aur_update_targets(
    options: &Options,
    tools: &Toolchain,
    aur: &AurClient,
) -> Result<Vec<String>> {
    Ok(aur_updates(options, tools, aur)
        .await?
        .into_iter()
        .map(|update| update.name)
        .collect())
}

#[derive(Debug, Clone)]
struct AurUpdate {
    name: String,
    local_version: String,
    aur_version: String,
}

async fn aur_updates(
    options: &Options,
    tools: &Toolchain,
    aur: &AurClient,
) -> Result<Vec<AurUpdate>> {
    let local = LocalDb::load_default().unwrap_or_else(|_| LocalDb::empty());
    let mut names = tools.foreign_names().await.unwrap_or_else(|_| {
        local
            .packages()
            .map(|pkg| pkg.name.clone())
            .collect::<Vec<_>>()
    });
    names.sort();
    names.dedup();

    if let Some(limit) = options.limit {
        names.truncate(limit);
    }

    let aur_packages = aur.info(&names).await?;
    let mut updates = Vec::new();

    for pkg in aur_packages {
        let Some(local_pkg) = local.get(&pkg.name) else {
            continue;
        };

        if vercmp(&local_pkg.version, &pkg.version) == Ordering::Less {
            updates.push(AurUpdate {
                name: pkg.name,
                local_version: local_pkg.version.clone(),
                aur_version: pkg.version,
            });
        }
    }

    Ok(updates)
}