alpm-types

Types for Arch Linux Package Management.

The provided types and the traits they implement can be used in package management related applications (e.g. package manager, repository manager, special purpose parsers and file specifications, etc.) which deal with libalpm based packages.

This library strives to provide all underlying types for writing ALPM based software as a leaf-crate, so that they can be shared across applications and none of them has to implement them itself.

Examples

System

Known CPU architectures are represented by the Architecture enum. You can create members e.g. from str:

```rust use std::str::FromStr; use alpm_types::Architecture;

asserteq!(Architecture::fromstr("aarch64"), Ok(Architecture::Aarch64)); ```

Date

The date when a package has been built is represented using the BuildDate struct, which tracks this in seconds since the epoch.

Apart from creating BuildDate from i64 or str, it can also be created from DateTime<Utc>:

```rust use chrono::{DateTime, NaiveDateTime, Utc}; use alpm_types::BuildDate;

let datetime: BuildDate = DateTime::::fromutc(NaiveDateTime::fromtimestampopt(1, 0).unwrap(), Utc).into(); asserteq!(BuildDate::new(1), datetime); ```

Env

The options available in a build environment are tracked using BuildEnv:

```rust use alpm_types::BuildEnv;

let option = BuildEnv::new("foo").unwrap(); asserteq!(option.on(), true); asserteq!(option.name(), "foo"); ```

A package installed to an environment can be described using Installed:

```rust use alpm_types::Installed;

assert!(Installed::new("foo-1:1.0.0-1-any").isok()); assert!(Installed::new("foo-1:1.0.0-1-foo").iserr()); assert!(Installed::new("foo-1:1.0.0-any").is_err()); ```

The options used for packaging are tracked using PackageOption:

```rust use alpm_types::PackageOption;

let option = PackageOption::new("foo").unwrap(); asserteq!(option.on(), true); asserteq!(option.name(), "foo"); ```

Size

The compressed size of a package is represented by CompressedSize which tracks the size in bytes and can also be created from str:

```rust use alpm_types::CompressedSize; use std::str::FromStr;

asserteq!(CompressedSize::fromstr("1"), Ok(CompressedSize::new(1))); ```

The installed size of a package is represented by InstalledSize which tracks the size in bytes and can also be created from str:

```rust use alpm_types::InstalledSize; use std::str::FromStr;

asserteq!(InstalledSize::fromstr("1"), Ok(InstalledSize::new(1))); ```

Name

The name for a package is restricted to a specific set of characters. You can create Name directly or from str, which yields a Result:

```rust use std::str::FromStr; use alpm_types::{Error, Name};

asserteq!(Name::fromstr("test-123@.foo+"), Name::new("test-123@.foo+".tostring())); asserteq!(Name::fromstr(".foo"), Err(Error::InvalidName(".foo".tostring()))); ```

Path

The build directory of a package build environment can be described using BuildDir:

```rust use alpm_types::BuildDir;

let builddir = BuildDir::new("/build").unwrap(); assert_eq!("/build", format!("{}", builddir)); ```

The start directory of a package build environment can be described using StartDir:

```rust use alpm_types::StartDir;

let startdir = StartDir::new("/start").unwrap(); assert_eq!("/start", format!("{}", startdir)); ```

Pkg

The authors of packages are identified using the Packager type, which describes a User ID (name and valid email):

```rust use std::str::FromStr; use alpm_types::Packager;

let packager = Packager::new("Foobar McFooface foobar@mcfooface.org").unwrap(); asserteq!("Foobar McFooface", packager.name()); asserteq!("foobar@mcfooface.org", packager.email().to_string()); ```

Package types are distinguished using the PkgType enum. Its variants can be constructed from str:

```rust use std::str::FromStr; use alpm_types::PkgType;

asserteq!(PkgType::fromstr("pkg"), Ok(PkgType::Package)); ```

Version

The version and CPU architecture of a build tool is tracked using BuildToolVer:

```rust use alpm_types::BuildToolVer;

let buildtoolver = BuildToolVer::new("1.0.0-1-any").unwrap();

assert_eq!("1.0.0-1-any", format!("{}", buildtoolver)); ```

Schemas of compound types (e.g. those used to describe .BUILDINFO or .PKGINFO files) need a schema version to version their features. This is what SchemaVersion is for:

```rust use std::str::FromStr; use alpm_types::SchemaVersion;

let version = SchemaVersion::new("1.0.0").unwrap();

assert_eq!("1.0.0", format!("{}", version)); ```

The handling of package versions is covered by the Version type (which consists of an optional Epoch, Pkgver and an optional Pkgrel). Its vercmp() method implementation is compatible with that of libalpm/pacman's vercmp.

```rust use std::str::FromStr; use alpm_types::Version;

let version = Version::new("1.0.0").unwrap();

assert_eq!("1.0.0", format!("{}", version));

let versiona = Version::new("1.0.0").unwrap(); let versionb = Version::new("1.1.0").unwrap();

asserteq!(Version::vercmp(&versiona, &version_b), -1);

// create a Version that is guaranteed to have a Pkgrel assert!(Version::withpkgrel("1.0.0-1").isok()); assert!(Version::withpkgrel("1.0.0").iserr()); ```

Contributing

Please refer to the contribution guidelines to learn how to contribute to this project.

License

This project is licensed under the terms of the LGPL-3.0-or-later.