Struct pep440::Version

pub struct Version {
    pub epoch: u32,
    pub release: Vec<u32>,
    pub pre: Option<PreRelease>,
    pub post: Option<u32>,
    pub dev: Option<u32>,
    pub local: Vec<LocalVersion>,
}

Represents a version parsed as a PEP440-compliant version string.

Several things to note:

• All integer values are stored as u32. This is somewhat arbitrary, but based on the fact that PEP440 defines no specification for these numbers, beyond the fact that they are positive (thus our use of unsigned).

• The release component (i.e., the 1.2.3 of v1.2.3rc0.post0.dev1+123) is stored as a vector of u32 integers. This allows for easier ordering comparison later.

• The pre component, if it exists, is stored as a PreRelease, which allows for all of the valid pre-release identifiers that PEP440 specifies. These are a (alpha), b (beta), and rc (release candidate).

• The local component is stored as a vector of LocalVersion components. This is because the “local” version is allowed to contain both numeric and string pieces, and we need to be able to account for both.

Fields

epoch: u32

release: Vec<u32>

pre: Option<PreRelease>

post: Option<u32>

dev: Option<u32>

local: Vec<LocalVersion>

Implementations

impl Version

pub fn is_canonical(input: &str) -> bool

Returns true if the given version is in its canonical form, false if not.

pub fn parse(input: &str) -> Option<Version>

Attempt to parse the given input string as a PEP440-compliant version string. By default, we base this on the same regex that is given at the bottom of the PEP440 specification. Release labels (alpha, a, rc, dev, post, etc.) are case-insensitive.

pub fn epoch_str(&self) -> String

Returns the normalized form of the epoch for the version. This will either be a number followed by a !, or the empty string.

let ver = Version::parse("1!2.3.4rc0").unwrap();
assert_eq!(ver.epoch_str(), "1!".to_string());

let ver = Version::parse("2.3.4rc0").unwrap();
assert_eq!(ver.epoch_str(), "".to_string());

pub fn release_str(&self) -> String

Returns the normalized form of the release for the version. This will be the release component of the input, but with leading zeros removed from each segment.

let ver = Version::parse("2.3.4post3.dev6").unwrap();
assert_eq!(ver.release_str(), "2.3.4".to_string());

let ver = Version::parse("v002.03.000004post3.dev6").unwrap();
assert_eq!(ver.release_str(), "2.3.4".to_string());

pub fn pre_str(&self) -> String

Returns the normalized form of the pre-release field for the version. If no pre-release is given, the empty string will be returned.

Non-canonical strings will be turned into canonical ones. For example, alpha3 will be turned into a3, and preview9 will be turned into rc9.

let ver = Version::parse("2.3.4c4.post3.dev6").unwrap();
assert_eq!(ver.pre_str(), "rc4".to_string());

let ver = Version::parse("2.3.4.alpha8").unwrap();
assert_eq!(ver.pre_str(), "a8".to_string());

let ver = Version::parse("2.3.4").unwrap();
assert_eq!(ver.pre_str(), "".to_string());

pub fn post_str(&self) -> String

Returns the normalized form of the post-release field for the version. If no post-release is given, the empty string will be returned.

If a string is returned, it includes a leading . which is required in normalized renditions of a version.

let ver = Version::parse("2.3.4c4.post3.dev6").unwrap();
assert_eq!(ver.post_str(), ".post3".to_string());

let ver = Version::parse("2.3.4-3.dev6").unwrap();
assert_eq!(ver.post_str(), ".post3".to_string());

let ver = Version::parse("2.3.4.alpha8").unwrap();
assert_eq!(ver.post_str(), "".to_string());

pub fn dev_str(&self) -> String

Returns the normalized form of the dev-release field for the version. If no dev-release is given, the empty string will be returned.

If a string is returned, it includes a leading . which is required in normalized renditions of a version.

let ver = Version::parse("2.3.4c4.post3.dev6").unwrap();
assert_eq!(ver.dev_str(), ".dev6".to_string());

let ver = Version::parse("2.3.4.alpha8").unwrap();
assert_eq!(ver.dev_str(), "".to_string());

pub fn local_str(&self) -> String

Returns the normalized form of the local field for the version. If no local component is given, the empty string will be returned.

If a string is returned, it includes a leading + which is required in normalized renditions of a version.

let ver = Version::parse("2.3.4c4.post3.dev6+123.foo_deb-3").unwrap();
assert_eq!(ver.local_str(), "+123.foo.deb.3".to_string());

let ver = Version::parse("2.3.4.alpha8").unwrap();
assert_eq!(ver.local_str(), "".to_string());

pub fn public_str(&self) -> String

Returns public portion of the version in normalized form.

This is equivalent to all components except the “local” portion of the version.

let ver = Version::parse("2.3.4c4.post3.dev6+123.foo_deb-3").unwrap();
assert_eq!(ver.public_str(), "2.3.4rc4.post3.dev6".to_string());

pub fn normalize(&self) -> String

Returns the normalized form of the version by combining all of the segments in their normalized form as returned by the *_str() methods defined above.

This method is also used to implement Display for Version and the result will be identical.

let ver = Version::parse("v2.3.4c4.post3.dev6+1.f-3").unwrap();
assert_eq!(ver.normalize(), "2.3.4rc4.post3.dev6+1.f.3".to_string());

Trait Implementations

impl Clone for Version

fn clone(&self) -> Version

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Version

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

Formats the value using the given formatter.

impl Display for Version

This implementation is returns the normalized version of the version. It is equivalent to calling normalize() on the version.

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

let ver = Version::parse("v2.3.4c4.post3.dev6+1.f-3").unwrap();
assert_eq!(format!("{}", ver), ver.normalize());

impl FromStr for Version

type Err = Error

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for Version

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for Version

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Version> for Version

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Version> for Version

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

let ver1 = Version::parse("v2.3.4c4.post3.dev6+1.f-3").unwrap();
let ver2 = Version::parse("v2.3.4pre4.post3.dev6+1.f-3").unwrap();
assert_eq!(ver1.partial_cmp(&ver2), Some(Ordering::Equal))

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Version