Struct aur_depends::Resolver

pub struct Resolver<'a, 'b, H = Handle> { /* private fields */ }

Resolver is the main type for resolving dependencies

Given a list of targets of either repo or AUR packages it will resolve the dependencies needed to install them.

This resolver assumes all the repo packages will be installed first, then each base is built and installed together.

aur-depends will try to solve dependnecies using the minimum ammount of AUR RPC requests.

Resolving is done via the AUR RPC. No packages are downloaded.

Example

use std::collections::HashSet;
use alpm::Alpm;
use raur::Handle;

use aur_depends::{Flags, Resolver};

let alpm = Alpm::new("/", "/var/lib/pacman")?;
let raur = Handle::default();
let mut cache = HashSet::new();
let resolver = Resolver::new(&alpm, Vec::new(), &mut cache, &raur, Flags::aur());
let actions = resolver.resolve_targets(&["discord-canary", "spotify"]).await?;

for install in &actions.install {
    println!("install: {}", install.pkg.name())
}

for build in actions.iter_build_pkgs() {
    println!("build: {}", build.pkg.name)
}

Implementations

impl<'a, 'b, E: Error + Sync + Send + 'static, H: Raur<Err = E> + Sync> Resolver<'a, 'b, H>

pub fn new(alpm: &'a Alpm, cache: &'b mut Cache, raur: &'b H, flags: Flags) -> Self

Create a new Resolver

pub fn provider_callback<F: Fn(&str, &[&str]) -> usize + 'static>(
    self,
    f: F
) -> Self

Set the provider callback

The provider callback will be called any time there is a choice of multiple AUR packages that can satisfy a dependency. This callback receives the dependency that we are trying to satisfy and a slice of package names satisfying it.

The callback returns returns the index of which package to pick.

Retuning an invalid index will cause a panic.

pub fn group_callback<F: Fn(&[Group<'a>]) -> Vec<Package<'a>> + 'static>(
    self,
    f: F
) -> Self

Set the group callback

The group callback is called whenever a group is processed. The callback recieves the group and returns a list of packages should be installed from the group;

pub fn devel_pkgs<F: Fn(&str) -> bool + 'static>(self, f: F) -> Self

Set the function for determining if a package is devel.

Devel packages are never skipped when using NEEDED.

By default, no packages are considered devel.

pub fn aur_namespace(self, enable: bool) -> Self

If enabled, causes aur/foo to mean from the AUR, instead of a repo named aur.

pub fn custom_aur_namespace(self, name: Option<String>) -> Self

Causes <name>/foo to mean from the AUR, instead of a repo named <name>.

pub fn repos(self, repos: &'a [Repo]) -> Self

Set the custom repos to use.

pub fn get_cache(&self) -> &Cache

Getter for the aur cache

pub fn get_cache_mut(&mut self) -> &mut Cache

Mut getter for the aur cache

pub async fn aur_updates(&mut self) -> Result<AurUpdates<'a>, Error>

Get which aur packages need to be updated.

Example

use std::collections::HashSet;
use alpm::Alpm;
use raur::Handle;

use aur_depends::{Flags, Resolver};

let alpm = Alpm::new("/", "/var/lib/pacman")?;
let raur = Handle::default();
let mut cache = HashSet::new();
let mut resolver = Resolver::new(&alpm, Vec::new(), &mut cache, &raur, Flags::aur_only());

let updates = resolver.aur_updates().await?;

for update in updates.updates {
    println!("update: {}: {} -> {}", update.local.name(), update.local.version(),
    update.remote.version);
}

pub async fn local_aur_updates<S: AsRef<str>>(
    &mut self,
    repos: &[S]
) -> Result<AurUpdates<'a>, Error>

Fetch updates from a list of local repos.

pub fn custom_updates(&mut self) -> Result<CustomUpdates<'a>, Error>

Fetch updates from custom repo.

pub fn local_custom_updates<S: AsRef<str>>(
    &mut self,
    repos: &[S]
) -> Result<CustomUpdates<'a>, Error>

Fetch updates from custom repo that exist in your local repo.

pub async fn resolve_targets<T: AsTarg>(
    self,
    pkgs: &[T]
) -> Result<Actions<'a>, Error>

Resolve a list of targets.

pub async fn resolve_depends<T: AsRef<str>>(
    self,
    deps: &[T],
    make_deps: &[T]
) -> Result<Actions<'a>, Error>

Resolve a list of dependencies.

Trait Implementations

impl<'a, 'b, H: Debug> Debug for Resolver<'a, 'b, H>

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

Formats the value using the given formatter.