upstream-rs 2.4.1

Fetch package updates directly from the source.
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

use clap::ValueEnum;
use serde::{Deserialize, Serialize};
use std::fmt;
use std::str::FromStr;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ValueEnum)]
pub enum Filetype {
    AppImage,
    MacApp,
    MacDmg,
    Archive,
    Compressed,
    Binary,
    WinExe,
    Checksum,
    Auto, // select automatically
}

impl fmt::Display for Filetype {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            Filetype::AppImage => "AppImage",
            Filetype::MacApp => "Mac app bundle",
            Filetype::MacDmg => "macOS disk image",
            Filetype::Archive => "Compressed archive",
            Filetype::Compressed => "Compressed file",
            Filetype::Binary => "Binary",
            Filetype::WinExe => "Windows executable",
            Filetype::Checksum => "Checksum",
            Filetype::Auto => "Auto",
        };

        write!(f, "{s}")
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ValueEnum)]
pub enum Channel {
    Stable,
    Preview,
    Nightly,
}

impl fmt::Display for Channel {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Channel::Stable => write!(f, "Stable"),
            Channel::Preview => write!(f, "Preview"),
            Channel::Nightly => write!(f, "Nightly"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ValueEnum)]
pub enum TrustMode {
    None,
    BestEffort,
    Checksum,
    Signature,
    All,
}

impl fmt::Display for TrustMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            TrustMode::None => "none",
            TrustMode::BestEffort => "best-effort",
            TrustMode::Checksum => "checksum",
            TrustMode::Signature => "signature",
            TrustMode::All => "all",
        };
        write!(f, "{s}")
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum Provider {
    Github,
    Gitlab,
    Gitea,
    WebScraper,
    Direct,
}

impl FromStr for Provider {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "github" => Ok(Provider::Github),
            "gitlab" => Ok(Provider::Gitlab),
            "gitea" => Ok(Provider::Gitea),
            "scraper" => Ok(Provider::WebScraper),
            "direct" => Ok(Provider::Direct),
            _ => Err(format!("Unknown provider: {}", s)),
        }
    }
}

impl std::fmt::Display for Provider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Provider::Github => write!(f, "github"),
            Provider::Gitlab => write!(f, "gitlab"),
            Provider::Gitea => write!(f, "gitea"),
            Provider::WebScraper => write!(f, "scraper"),
            Provider::Direct => write!(f, "direct"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum CompressionLevel {
    None,
    Low,
    #[default]
    High,
}