Enum PackageInfo 

pub enum PackageInfo {
    V1(PackageInfoV1),
    V2(PackageInfoV2),
}

A representation of the PKGINFO file format.

Tracks all available versions of the file format.

Variants

V1(PackageInfoV1)

The PKGINFOv1 file format.

V2(PackageInfoV2)

The PKGINFOv2 file format.

Trait Implementations

impl Clone for PackageInfo

fn clone(&self) -> PackageInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PackageInfo

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

Formats the value using the given formatter.

impl Display for PackageInfo

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

Formats the value using the given formatter.

impl FromStr for PackageInfo

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

Creates a PackageInfo from string slice s.

Calls PackageInfo::from_str_with_schema with schema set to None.

Errors

Returns an error if

• a PackageInfoSchema cannot be derived from s,
• or the detected variant of PackageInfo cannot be constructed from s.

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 PackageInfo

fn eq(&self, other: &PackageInfo) -> 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 Serialize for PackageInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PackageInfo