Enum Source 

pub enum Source {
    File {
        filename: Option<PathBuf>,
        location: PathBuf,
    },
    SourceUrl {
        filename: Option<PathBuf>,
        source_url: SourceUrl,
    },
}

Represents the location that a source file should be retrieved from

It can be either a local file (next to the PKGBUILD) or a URL.

Variants

File

A local file source.

The location must be a pure file name, without any path components (/). Hence, the file must be located directly next to the PKGBUILD.

Fields

filename: Option<PathBuf>

The optional destination file name.

location: PathBuf

The source file name.

SourceUrl

A URL source.

Fields

filename: Option<PathBuf>

The optional destination file name.

source_url: SourceUrl

The source URL.

Implementations

impl Source

pub fn filename(&self) -> Option<&PathBuf>

Returns the filename of the source if it is set.

Trait Implementations

impl Clone for Source

fn clone(&self) -> Source

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Source

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Source

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Source

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

Formats the value using the given formatter.

impl FromStr for Source

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

Creates a Source from a string slice.

It is either a filename (in the same directory as the PKGBUILD) or a url, optionally prefixed by a destination file name (separated by ::).

Delegates to Source::parser_until.

Errors

Returns an error if Source::parser_until fails.

Examples

use std::{path::Path, str::FromStr};

use alpm_types::Source;
use url::Url;


// Parse from a string that represents a remote file link.
let source = Source::from_str("foopkg-1.2.3.tar.gz::https://example.com/download")?;
let Source::SourceUrl {
    source_url,
    filename,
} = source
else {
    panic!()
};

assert_eq!(filename.unwrap(), Path::new("foopkg-1.2.3.tar.gz"));
assert_eq!(source_url.url.inner().host_str(), Some("example.com"));
assert_eq!(source_url.to_string(), "https://example.com/download");

// Parse from a string that represents a local file.
let source = Source::from_str("renamed-source.tar.gz::test.tar.gz")?;
let Source::File { location, filename } = source else {
    panic!()
};
assert_eq!(location, Path::new("test.tar.gz"));
assert_eq!(filename.unwrap(), Path::new("renamed-source.tar.gz"));

type Err = Error

The associated error which can be returned from parsing.

impl ParserUntil for Source

For Source, we only define a ParserUntil trait and not the AlpmParser trait, as we don’t provide the Url type parser ourselves. Hence, the indicator for its supposed “end” must be provided by the caller of the parser.

fn parser_until<'a, P>( delimiter: P, ) -> impl Parser<&'a str, Self, ErrMode<ContextError>>

where P: Parser<&'a str, &'a str, ErrMode<ContextError>>,

Returns a [Parser] that parses Self until the given delimiter parser matches.

fn parser_until_eof(input: &mut &str) -> Result<Self, ErrMode<ContextError>>

Returns a [Parser] that parses an entire input.

fn parser_until_line_ending( input: &mut &str, ) -> Result<Self, ErrMode<ContextError>>

Returns a [Parser] that parses until the end of line or [eof].

impl PartialEq for Source

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Source

impl StructuralPartialEq for Source