Struct Range 

pub struct Range(/* private fields */);

Node-style semver range.

These ranges map mostly 1:1 to semver’s except for some internal representation details that allow some more interesting set-level operations.

For details on supported syntax, see https://github.com/npm/node-semver#advanced-range-syntax

Implementations

impl Range

pub fn parse<S: AsRef<str>>(input: S) -> Result<Self, SemverError>

Parse a range from a string.

pub fn any() -> Self

Creates a new range that matches any version.

pub fn satisfies(&self, version: &Version) -> bool

Returns true if version is satisfied by this range.

pub fn satisfies_with_prerelease( &self, version: &Version, include_prerelease: bool, ) -> bool

Returns true if version is satisfied by this range.

This behaves like Range::satisfies, but will also consider pre-release versions even if the range itself does not specify a matching pre-release.

pub fn allows_all(&self, other: &Range) -> bool

Returns true if other is a strict superset of this range.

pub fn allows_any(&self, other: &Range) -> bool

Returns true if other has overlap with this range.

pub fn intersect(&self, other: &Self) -> Option<Self>

Returns a new range that is the set-intersection between this range and other.

pub fn difference(&self, other: &Self) -> Option<Self>

Returns a new range that is the set-difference between this range and other.

pub fn max_satisfying<'v>(&self, versions: &'v [Version]) -> Option<&'v Version>

Return the highest Version in the list that satisfies the range, or None if none of them do.

use nodejs_semver::{Range, Version};

fn main() {
    let versions: Vec<_> = vec!["1.2.3", "1.2.4", "1.2.5", "1.2.6"]
        .iter()
        .map(|s| Version::parse(s).unwrap())
        .collect();
    let range = Range::parse("~1.2.3").unwrap();

    let result = range.max_satisfying(&versions);

    assert_eq!(result, Some(&Version::parse("1.2.6").unwrap()));
}

pub fn min_satisfying<'v>(&self, versions: &'v [Version]) -> Option<&'v Version>

Return the lowest Version in the list that satisfies the range, or None if none of them do.

use nodejs_semver::{Range, Version};

fn main() {
    let versions: Vec<_> = vec!["1.2.3", "1.2.4", "1.2.5", "1.2.6"]
        .iter()
        .map(|s| Version::parse(s).unwrap())
        .collect();
    let range = Range::parse("~1.2.3").unwrap();

    let result = range.min_satisfying(&versions);

    assert_eq!(result, Some(&Version::parse("1.2.3").unwrap()));
}

pub fn min_version(&self) -> Option<Version>

Return the lowest Version that can possibly match the given range.

pub fn outside( &self, version: &Version, direction: OutsideDirection, include_prerelease: bool, ) -> Result<bool, RangeError>

Return Ok(true) if the Version sits entirely outside this range in the specified direction.

direction mirrors the JavaScript implementation’s “hi/lo” flag: OutsideDirection::Higher checks whether the version is greater than the range, while OutsideDirection::Lower checks whether it is lower. Set include_prerelease to true to treat prerelease versions as satisfiable even when the range does not explicitly mention them.

Errors

Returns RangeError::MissingComparatorBounds if the range does not expose enough comparator information to perform the comparison.

Trait Implementations

impl Clone for Range

fn clone(&self) -> Range

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Range

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

Formats the value using the given formatter.

impl Display for Range

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

Formats the value using the given formatter.

impl FromStr for Range

type Err = SemverError

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 Range

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Range

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

impl StructuralPartialEq for Range