Crate aur

aur

aur is a package for interacting with the Arch User Repository RPC API.

It supports client trait implementations for both asynchronous hyper and synchronous reqwest.

Installation

Add the following to your Cargo.toml:

[dependencies]
aur = "~0.1"

And the following to your main.rs or lib.rs:

extern crate aur;

There are two features: hyper-support and reqwest-support. hyper-support is enabled by default. To enable reqwest-support, instead depend on aur like so:

[dependencies.aur]
default-features = false
features = ["reqwest-support"]
version = "~0.1"

Examples

Asynchronously request information for the rust-nightly package:

mod inner {
extern crate aur;
extern crate hyper;
extern crate hyper_tls;
extern crate tokio;

use aur::bridge::hyper::AurRequester;
use hyper::Client;
use hyper::net::HttpsConnector;
use hyper_tls::NativeTlsClient;

let connector = HttpsConnector::new(4);
let client = Client::builder().build(connector);

let done = client.aur_search(Some("rust-nightly"), None).map(|search| {
    assert!(search.result_count >= 2);
}).map_err(|why| {
    println!("Error getting rust-nightly info: {:?}", why);
});

tokio::run(done);

Synchronously request information for the rust-nightly package:

extern crate aur;
extern crate reqwest;

use aur::bridge::reqwest::AurRequester;
use reqwest::Client;

let client = Client::new();

let info = client.aur_info(&["rust-nightly"])?;

match info.results.first() {
    Some(package) => {
        if let Some(ref maintainer) = package.maintainer {
            println!("The package is maintained by: {}", maintainer);
        } else {
            println!("The package has no maintainer");
        }
    },
    None => {
        println!("No package found!");
    },
}

License

ISC.

Re-exports

pub use self::bridge::hyper::AurRequester as AurHyperRequester;

Modules

bridge

Bridge implementations for HTTP client libraries.

model

Models mapping the API.

Enums

Error

Enum encompassing the library’s possible returned errors.

Type Definitions

Result

Standard result type for asynchronous functions throughout the library.