Enum PackageInfoSchema

pub enum PackageInfoSchema {
    V1(SchemaVersion),
    V2(SchemaVersion),
}

An enum tracking all available PKGINFO schemas.

The schema of a PKGINFO refers to its available fields in a specific version.

Variants

V1(SchemaVersion)

V2(SchemaVersion)

Trait Implementations

impl Clone for PackageInfoSchema

fn clone(&self) -> PackageInfoSchema

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PackageInfoSchema

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

Formats the value using the given formatter.

impl Default for PackageInfoSchema

fn default() -> Self

Returns the default PackageInfoSchema variant (PackageInfoSchema::V2).

impl Display for PackageInfoSchema

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

Formats the value using the given formatter.

impl FileFormatSchema for PackageInfoSchema

fn inner(&self) -> &SchemaVersion

Returns a reference to the inner SchemaVersion.

fn derive_from_file(file: impl AsRef<Path>) -> Result<Self, Error>

where Self: Sized,

Derives a PackageInfoSchema from a PKGINFO file.

Opens the file and defers to PackageInfoSchema::derive_from_reader.

Errors

Returns an error if

• opening file for reading fails
• or deriving a PackageInfoSchema from the contents of file fails.

fn derive_from_reader(reader: impl Read) -> Result<Self, Error>

where Self: Sized,

Derives a PackageInfoSchema from PKGINFO data in a reader.

Reads the reader to string and defers to PackageInfoSchema::derive_from_str.

Errors

Returns an error if

• reading a String from reader fails
• or deriving a PackageInfoSchema from the contents of reader fails.

fn derive_from_str(s: &str) -> Result<PackageInfoSchema, Error>

Derives a PackageInfoSchema from a string slice containing PKGINFO data.

Since the PKGINFO format does not carry any version information, this function looks for the first xdata field (if any) to determine whether the input may be PKGINFOv2. If no xdata field is found, PKGINFOv1 is assumed.

Examples

use alpm_common::FileFormatSchema;
use alpm_pkginfo::PackageInfoSchema;
use alpm_types::{SchemaVersion, semver_version::Version};

let pkginfo_v2 = r#"
pkgname = example
pkgbase = example
pkgver = 1:1.0.0-1
pkgdesc = A project that does something
url = https://example.org/
builddate = 1729181726
packager = John Doe <john@example.org>
size = 181849963
arch = any
xdata = pkgtype=pkg
"#;
assert_eq!(
    PackageInfoSchema::V2(SchemaVersion::new(Version::new(2, 0, 0))),
    PackageInfoSchema::derive_from_str(pkginfo_v2)?
);

let pkginfo_v1 = r#"
pkgname = example
pkgbase = example
pkgver = 1:1.0.0-1
pkgdesc = A project that does something
url = https://example.org/
builddate = 1729181726
packager = John Doe <john@example.org>
size = 181849963
arch = any
"#;
assert_eq!(
    PackageInfoSchema::V1(SchemaVersion::new(Version::new(1, 0, 0))),
    PackageInfoSchema::derive_from_str(pkginfo_v1)?
);

Errors

Returns an error if

• the first xdata keyword is assigned an empty string,
• or the first xdata keyword does not assign “pkgtype”.

type Err = Error

The Error type to use.

impl FromStr for PackageInfoSchema

fn from_str(s: &str) -> Result<PackageInfoSchema, Self::Err>

Creates a PackageInfoSchema from string slice s.

Relies on SchemaVersion::from_str to create a corresponding PackageInfoSchema from s.

Errors

Returns an error if

• no SchemaVersion can be created from s,
• or the conversion from SchemaVersion to PackageInfoSchema fails.

type Err = Error

The associated error which can be returned from parsing.

impl MetadataFile<PackageInfoSchema> for PackageInfo

fn from_file_with_schema( file: impl AsRef<Path>, schema: Option<PackageInfoSchema>, ) -> Result<Self, Error>

Creates a PackageInfo from file, optionally validated using a PackageInfoSchema.

Opens the file and defers to PackageInfo::from_reader_with_schema.

Note

To automatically derive the PackageInfoSchema, use PackageInfo::from_file.

Examples

use std::{fs::File, io::Write};

use alpm_common::{FileFormatSchema, MetadataFile};
use alpm_pkginfo::{PackageInfo, PackageInfoSchema};
use alpm_types::{SchemaVersion, semver_version::Version};

// Prepare a file with PKGINFO data
let (file, pkginfo_data) = {
    let pkginfo_data = r#"pkgname = example
pkgbase = example
xdata = pkgtype=pkg
pkgver = 1:1.0.0-1
pkgdesc = A project that does something
url = https://example.org/
builddate = 1729181726
packager = John Doe <john@example.org>
size = 181849963
arch = any
"#;
    let pkginfo_file = tempfile::NamedTempFile::new()?;
    let mut output = File::create(&pkginfo_file)?;
    write!(output, "{}", pkginfo_data)?;
    (pkginfo_file, pkginfo_data)
};

let pkginfo = PackageInfo::from_file_with_schema(
    file.path().to_path_buf(),
    Some(PackageInfoSchema::V2(SchemaVersion::new(Version::new(
        2, 0, 0,
    )))),
)?;
assert_eq!(pkginfo.to_string(), pkginfo_data);

Errors

Returns an error if

• the file cannot be opened for reading,
• no variant of PackageInfo can be constructed from the contents of file,
• or schema is Some and the PackageInfoSchema does not match the contents of file.

fn from_reader_with_schema( reader: impl Read, schema: Option<PackageInfoSchema>, ) -> Result<Self, Error>

Creates a PackageInfo from a reader, optionally validated using a PackageInfoSchema.

Reads the reader to string and defers to PackageInfo::from_str_with_schema.

Note

To automatically derive the PackageInfoSchema, use PackageInfo::from_reader.

Examples

use std::{fs::File, io::Write};

use alpm_common::MetadataFile;
use alpm_pkginfo::{PackageInfo, PackageInfoSchema};
use alpm_types::{SchemaVersion, semver_version::Version};

// Prepare a reader with PKGINFO data
let (reader, pkginfo_data) = {
    let pkginfo_data = r#"pkgname = example
pkgbase = example
xdata = pkgtype=pkg
pkgver = 1:1.0.0-1
pkgdesc = A project that does something
url = https://example.org/
builddate = 1729181726
packager = John Doe <john@example.org>
size = 181849963
arch = any
"#;
    let pkginfo_file = tempfile::NamedTempFile::new()?;
    let mut output = File::create(&pkginfo_file)?;
    write!(output, "{}", pkginfo_data)?;
    (File::open(&pkginfo_file.path())?, pkginfo_data)
};

let pkginfo = PackageInfo::from_reader_with_schema(
    reader,
    Some(PackageInfoSchema::V2(SchemaVersion::new(Version::new(
        2, 0, 0,
    )))),
)?;
assert_eq!(pkginfo.to_string(), pkginfo_data);

Errors

Returns an error if

• the reader cannot be read to string,
• no variant of PackageInfo can be constructed from the contents of the reader,
• or schema is Some and the PackageInfoSchema does not match the contents of the reader.

fn from_str_with_schema( s: &str, schema: Option<PackageInfoSchema>, ) -> Result<Self, Error>

Creates a PackageInfo from string slice, optionally validated using a PackageInfoSchema.

If schema is None attempts to detect the PackageInfoSchema from s. Attempts to create a PackageInfo variant that corresponds to the PackageInfoSchema.

Note

To automatically derive the PackageInfoSchema, use PackageInfo::from_str.

Examples

use std::{fs::File, io::Write};

use alpm_common::MetadataFile;
use alpm_pkginfo::{PackageInfo, PackageInfoSchema};
use alpm_types::{SchemaVersion, semver_version::Version};

let pkginfo_v2_data = r#"pkgname = example
pkgbase = example
xdata = pkgtype=pkg
pkgver = 1:1.0.0-1
pkgdesc = A project that does something
url = https://example.org/
builddate = 1729181726
packager = John Doe <john@example.org>
size = 181849963
arch = any
"#;

let pkginfo_v2 = PackageInfo::from_str_with_schema(
    pkginfo_v2_data,
    Some(PackageInfoSchema::V2(SchemaVersion::new(Version::new(
        2, 0, 0,
    )))),
)?;
assert_eq!(pkginfo_v2.to_string(), pkginfo_v2_data);

let pkginfo_v1_data = r#"pkgname = example
pkgbase = example
pkgver = 1:1.0.0-1
pkgdesc = A project that does something
url = https://example.org/
builddate = 1729181726
packager = John Doe <john@example.org>
size = 181849963
arch = any
"#;

let pkginfo_v1 = PackageInfo::from_str_with_schema(
    pkginfo_v1_data,
    Some(PackageInfoSchema::V1(SchemaVersion::new(Version::new(
        1, 0, 0,
    )))),
)?;
assert_eq!(pkginfo_v1.to_string(), pkginfo_v1_data);

Errors

Returns an error if

• schema is Some and the specified variant of PackageInfo cannot be constructed from s,
• schema is None and
  • a PackageInfoSchema cannot be derived from s,
  • or the detected variant of PackageInfo cannot be constructed from s.

type Err = Error

The Error type to use.

fn from_file(file: impl AsRef<Path>) -> Result<Self, Self::Err>

where Self: Sized,

Creates Self from file.

fn from_stdin() -> Result<Self, Self::Err>

where Self: Sized,

Creates Self from stdin.

fn from_stdin_with_schema(schema: Option<T>) -> Result<Self, Self::Err>

where Self: Sized,

Creates Self from stdin, optionally validated by a schema.

fn from_reader(reader: impl Read) -> Result<Self, Self::Err>

where Self: Sized,

Creates Self from a Read implementer.

impl PartialEq for PackageInfoSchema

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<SchemaVersion> for PackageInfoSchema

fn try_from(value: SchemaVersion) -> Result<Self, Self::Error>

Converts a SchemaVersion to a PackageInfoSchema.

Errors

Returns an error if the SchemaVersion’s inner Version does not provide a major version that corresponds to a PackageInfoSchema variant.

type Error = Error

The type returned in the event of a conversion error.

impl Eq for PackageInfoSchema

impl StructuralPartialEq for PackageInfoSchema