Struct Install 

pub struct Install { /* private fields */ }

One package to install with this machine’s package manager: the command, the question that shows it and the handoff that runs it.

Made by Install::package, which looks for pacman, apt-get, dnf, zypper, apk and brew on PATH in that order and takes the first. The command is the manager’s own install command with sudo in front when the application does not run as root, such as sudo pacman -S --needed libarchive; no “yes” flag is added, so the manager shows its own question and the person answers it.

use std::path::PathBuf;

use qframe::install::{Install, Manager};

// A machine with `apt-get` and nothing else, the application not running as root.
let lookup = |program: &str| (program == "apt-get").then(|| PathBuf::from("/usr/bin/apt-get"));
let install = Install::package_with("libarchive", lookup, false)
    .expect("a package manager")
    .name_for(Manager::Apt, "libarchive-tools");
assert_eq!(install.manager(), Manager::Apt);
assert_eq!(install.command_line(), "sudo apt-get install libarchive-tools");

Implementations

impl Install

pub fn package(name: &str) -> Option<Install>

The package name with this machine’s package manager, found on PATH; None when there is none, or when name cannot be a package name (empty, starting with -, or holding a space or a control character).

Homebrew is passed over when the application runs as root, since it refuses to run so.

pub fn package_with( name: &str, lookup: impl Fn(&str) -> Option<PathBuf>, root: bool, ) -> Option<Install>

Install::package with the search given: lookup says where a program is, or None when it is not installed, and root whether the application runs as root. For tests, and for an application that decides itself where programs are.

pub fn name_for(self, manager: Manager, name: &str) -> Self

Uses name instead when the package manager is manager, for a package that is called differently there: libarchive on Arch is libarchive-tools on Debian. Nothing changes on other managers, nor when name cannot be a package name.

pub fn manager(&self) -> Manager

The package manager that installs the package.

pub fn name(&self) -> &str

The package’s name for this manager.

pub fn program(&self) -> Vec<OsString>

The command’s words, the program first: ["sudo", "pacman", "-S", "--needed", "libarchive"].

pub fn command_line(&self) -> String

The command as the person reads it: sudo pacman -S --needed libarchive. The words need no quoting, since a package name holds no space.

pub fn confirm<Msg>(&self, on_yes: Msg) -> Confirm<Msg>

The question to ask before installing: which package, the exact command line, and that the package manager may ask for a password. The confirm button reads Install and sends on_yes; Cancel, Esc and the close mark install nothing. Add on_cancel for a message when the person declines.

The text comes from quvyta.install.title, quvyta.install.runs, quvyta.install.asks and quvyta.install.confirm in the active language.

pub fn handoff<Msg: Send + 'static>( &self, on_finish: impl FnOnce(HandoffOutcome) -> Msg + Send + 'static, ) -> Handoff<Msg>

The handoff that runs the command: the terminal is the package manager’s until it ends, with a line saying what is being installed (quvyta.install.notice) above its output, and a key press awaited afterwards so its last lines can be read. on_finish receives how it ended; an exit code other than zero means the package was not installed.

Return it only after the person agreed to confirm.

Trait Implementations

impl Clone for Install

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Install

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Install

impl PartialEq for Install

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Install