emplace 1.5.3

Command-line tool to mirror installed software on multiple machines.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#[macro_use]
pub mod test_macro;

mod apt;
mod brew;
mod cargo;
mod cargo_binstall;
mod chocolatey;
mod dnf;
mod gem;
mod go;
mod guix;
mod nix;
mod npm;
mod pacman;
mod pip;
mod pip3;
mod pkg;
mod rua;
mod rustup;
mod scoop;
mod snap;
mod yay;
mod zypper;

pub use apt::Apt;
pub use brew::Brew;
pub use cargo::Cargo;
pub use cargo_binstall::CargoBinstall;
pub use chocolatey::Chocolatey;
pub use dnf::Dnf;
pub use gem::Gem;
pub use go::Go;
pub use guix::Guix;
pub use nix::Nix;
pub use npm::Npm;
pub use pacman::Pacman;
pub use pip::Pip;
pub use pip3::Pip3;
pub use pkg::Pkg;
pub use rua::Rua;
pub use rustup::Rustup;
pub use scoop::Scoop;
pub use snap::Snap;
pub use yay::Yay;
pub use zypper::Zypper;

use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use strum_macros::EnumIter;

/// Enum containing all package managers.
///
/// The actual functions are implemented in `src/package_manager_impl.rs`.
#[enum_dispatch::enum_dispatch]
#[derive(Debug, Copy, Clone, Eq, PartialEq, EnumIter, Serialize, Deserialize)]
pub enum PackageManager {
    Apt,
    Brew,
    Cargo,
    CargoBinstall,
    Chocolatey,
    Dnf,
    Gem,
    Go,
    Guix,
    Nix,
    Npm,
    Pacman,
    Pip,
    Pip3,
    Pkg,
    Rua,
    Rustup,
    Scoop,
    Snap,
    Yay,
    Zypper,
}

/// Trait that needs to be implemented for a new package manager.
#[enum_dispatch::enum_dispatch(PackageManager)]
pub trait PackageManagerTrait {
    /// A descriptive name.
    fn full_name(self) -> &'static str;

    /// The command-line word(s) to invoke the package manager.
    fn commands(self) -> Vec<&'static str>;

    /// The command-line subcommand(s) that's used to catch installing new packages.
    fn sub_commands(self) -> Vec<&'static str>;

    /// Command that's used to install new packages.
    fn install_command(self) -> &'static str;

    /// Does installing a new command need administrative permissions?
    fn needs_root(self) -> bool;

    /// Check whether a package is already installed.
    #[allow(clippy::wrong_self_convention)]
    fn is_installed(self, package: &str) -> PackageInstalledMethod;

    /// A list of known command line flags that accept an extra argument which could be the name of
    /// the package.
    fn known_flags_with_values(self) -> Vec<&'static str>;

    /// A list of command line flags that should be caught as well.
    ///
    /// This usually stays empty.
    fn capture_flags(self) -> Vec<CaptureFlag>;

    /// Flags that make a command with a subcommand that would be caught otherwise be ignored.
    fn invalidating_flags(self) -> Vec<&'static str>;
}

/// Different ways in which a set of flags can be captured.
#[derive(Debug, Copy, Clone)]
pub enum CaptureFlag {
    /// A single flag argument without a value.
    Single(&'static str),
    /// A flag argument with a set value.
    SetValue(&'static str, &'static str),
    /// A flag argument with a single dynamic value.
    DynamicValue(&'static str),
}

/// The way a package is checked if it's installed.
pub enum PackageInstalledMethod {
    /// A simple command line script will check if the package is installed.
    Script(String),

    // TODO use this
    #[allow(unused)]
    /// A file or directory on the filesystem is checked for existence.
    Path(PathBuf),
}

#[cfg(test)]
mod tests {
    use crate::{
        catch,
        package_manager::{apt::Apt, PackageManager},
    };

    #[test]
    fn test_empty() {
        catch!(PackageManager::from(Apt), "no match" => ());
    }
}