[rustc.git] / vendor / semver-0.10.0 / src / version_req.rs

// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT\r
// file at the top-level directory of this distribution and at\r
// http://rust-lang.org/COPYRIGHT.\r
//\r
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\r
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\r
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\r
// option. This file may not be copied, modified, or distributed\r
// except according to those terms.\r
\r
use std::error::Error;\r
use std::fmt;\r
use std::str;\r
\r
use semver_parser;\r
use version::Identifier;\r
use Version;\r
\r
#[cfg(feature = "serde")]\r
use serde::de::{self, Deserialize, Deserializer, Visitor};\r
#[cfg(feature = "serde")]\r
use serde::ser::{Serialize, Serializer};\r
\r
use self::Op::{Compatible, Ex, Gt, GtEq, Lt, LtEq, Tilde, Wildcard};\r
use self::ReqParseError::*;\r
use self::WildcardVersion::{Major, Minor, Patch};\r
\r
/// A `VersionReq` is a struct containing a list of predicates that can apply to ranges of version\r
/// numbers. Matching operations can then be done with the `VersionReq` against a particular\r
/// version to see if it satisfies some or all of the constraints.\r
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]\r
#[cfg_attr(feature = "diesel", derive(AsExpression, FromSqlRow))]\r
#[cfg_attr(feature = "diesel", sql_type = "diesel::sql_types::Text")]\r
pub struct VersionReq {\r
    predicates: Vec<Predicate>,\r
}\r
\r
impl From<semver_parser::range::VersionReq> for VersionReq {\r
    fn from(other: semver_parser::range::VersionReq) -> VersionReq {\r
        VersionReq {\r
            predicates: other.predicates.into_iter().map(From::from).collect(),\r
        }\r
    }\r
}\r
\r
#[cfg(feature = "serde")]\r
impl Serialize for VersionReq {\r
    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>\r
    where\r
        S: Serializer,\r
    {\r
        // Serialize VersionReq as a string.\r
        serializer.collect_str(self)\r
    }\r
}\r
\r
#[cfg(feature = "serde")]\r
impl<'de> Deserialize<'de> for VersionReq {\r
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>\r
    where\r
        D: Deserializer<'de>,\r
    {\r
        struct VersionReqVisitor;\r
\r
        /// Deserialize `VersionReq` from a string.\r
        impl<'de> Visitor<'de> for VersionReqVisitor {\r
            type Value = VersionReq;\r
\r
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\r
                formatter.write_str("a SemVer version requirement as a string")\r
            }\r
\r
            fn visit_str<E>(self, v: &str) -> ::std::result::Result<Self::Value, E>\r
            where\r
                E: de::Error,\r
            {\r
                VersionReq::parse(v).map_err(de::Error::custom)\r
            }\r
        }\r
\r
        deserializer.deserialize_str(VersionReqVisitor)\r
    }\r
}\r
\r
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]\r
enum WildcardVersion {\r
    Major,\r
    Minor,\r
    Patch,\r
}\r
\r
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]\r
enum Op {\r
    Ex,                        // Exact\r
    Gt,                        // Greater than\r
    GtEq,                      // Greater than or equal to\r
    Lt,                        // Less than\r
    LtEq,                      // Less than or equal to\r
    Tilde,                     // e.g. ~1.0.0\r
    Compatible,                // compatible by definition of semver, indicated by ^\r
    Wildcard(WildcardVersion), // x.y.*, x.*, *\r
}\r
\r
impl From<semver_parser::range::Op> for Op {\r
    fn from(other: semver_parser::range::Op) -> Op {\r
        use semver_parser::range;\r
        match other {\r
            range::Op::Ex => Op::Ex,\r
            range::Op::Gt => Op::Gt,\r
            range::Op::GtEq => Op::GtEq,\r
            range::Op::Lt => Op::Lt,\r
            range::Op::LtEq => Op::LtEq,\r
            range::Op::Tilde => Op::Tilde,\r
            range::Op::Compatible => Op::Compatible,\r
            range::Op::Wildcard(version) => match version {\r
                range::WildcardVersion::Major => Op::Wildcard(WildcardVersion::Major),\r
                range::WildcardVersion::Minor => Op::Wildcard(WildcardVersion::Minor),\r
                range::WildcardVersion::Patch => Op::Wildcard(WildcardVersion::Patch),\r
            },\r
        }\r
    }\r
}\r
\r
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]\r
struct Predicate {\r
    op: Op,\r
    major: u64,\r
    minor: Option<u64>,\r
    patch: Option<u64>,\r
    pre: Vec<Identifier>,\r
}\r
\r
impl From<semver_parser::range::Predicate> for Predicate {\r
    fn from(other: semver_parser::range::Predicate) -> Predicate {\r
        Predicate {\r
            op: From::from(other.op),\r
            major: other.major,\r
            minor: other.minor,\r
            patch: other.patch,\r
            pre: other.pre.into_iter().map(From::from).collect(),\r
        }\r
    }\r
}\r
\r
/// A `ReqParseError` is returned from methods which parse a string into a [`VersionReq`]. Each\r
/// enumeration is one of the possible errors that can occur.\r
/// [`VersionReq`]: struct.VersionReq.html\r
#[derive(Clone, Debug, PartialEq)]\r
pub enum ReqParseError {\r
    /// The given version requirement is invalid.\r
    InvalidVersionRequirement,\r
    /// You have already provided an operation, such as `=`, `~`, or `^`. Only use one.\r
    OpAlreadySet,\r
    /// The sigil you have written is not correct.\r
    InvalidSigil,\r
    /// All components of a version must be numeric.\r
    VersionComponentsMustBeNumeric,\r
    /// There was an error parsing an identifier.\r
    InvalidIdentifier,\r
    /// At least a major version is required.\r
    MajorVersionRequired,\r
    /// An unimplemented version requirement.\r
    UnimplementedVersionRequirement,\r
    /// This form of requirement is deprecated.\r
    DeprecatedVersionRequirement(VersionReq),\r
}\r
\r
impl fmt::Display for ReqParseError {\r
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
        let msg = match self {\r
            InvalidVersionRequirement => "the given version requirement is invalid",\r
            OpAlreadySet => {\r
                "you have already provided an operation, such as =, ~, or ^; only use one"\r
            }\r
            InvalidSigil => "the sigil you have written is not correct",\r
            VersionComponentsMustBeNumeric => "version components must be numeric",\r
            InvalidIdentifier => "invalid identifier",\r
            MajorVersionRequired => "at least a major version number is required",\r
            UnimplementedVersionRequirement => {\r
                "the given version requirement is not implemented, yet"\r
            }\r
            DeprecatedVersionRequirement(_) => "This requirement is deprecated",\r
        };\r
        msg.fmt(f)\r
    }\r
}\r
\r
impl Error for ReqParseError {}\r
\r
impl From<String> for ReqParseError {\r
    fn from(other: String) -> ReqParseError {\r
        match &*other {\r
            "Null is not a valid VersionReq" => ReqParseError::InvalidVersionRequirement,\r
            "VersionReq did not parse properly." => ReqParseError::OpAlreadySet,\r
            _ => ReqParseError::InvalidVersionRequirement,\r
        }\r
    }\r
}\r
\r
impl VersionReq {\r
    /// `any()` is a factory method which creates a `VersionReq` with no constraints. In other\r
    /// words, any version will match against it.\r
    ///\r
    /// # Examples\r
    ///\r
    /// ```\r
    /// use semver::VersionReq;\r
    ///\r
    /// let anything = VersionReq::any();\r
    /// ```\r
    pub fn any() -> VersionReq {\r
        VersionReq { predicates: vec![] }\r
    }\r
\r
    /// `parse()` is the main constructor of a `VersionReq`. It takes a string like `"^1.2.3"`\r
    /// and turns it into a `VersionReq` that matches that particular constraint.\r
    ///\r
    /// A `Result` is returned which contains a [`ReqParseError`] if there was a problem parsing the\r
    /// `VersionReq`.\r
    /// [`ReqParseError`]: enum.ReqParseError.html\r
    ///\r
    /// # Examples\r
    ///\r
    /// ```\r
    /// use semver::VersionReq;\r
    ///\r
    /// let version = VersionReq::parse("=1.2.3");\r
    /// let version = VersionReq::parse(">1.2.3");\r
    /// let version = VersionReq::parse("<1.2.3");\r
    /// let version = VersionReq::parse("~1.2.3");\r
    /// let version = VersionReq::parse("^1.2.3");\r
    /// let version = VersionReq::parse("1.2.3"); // synonym for ^1.2.3\r
    /// let version = VersionReq::parse("<=1.2.3");\r
    /// let version = VersionReq::parse(">=1.2.3");\r
    /// ```\r
    ///\r
    /// This example demonstrates error handling, and will panic.\r
    ///\r
    /// ```should_panic\r
    /// use semver::VersionReq;\r
    ///\r
    /// let version = match VersionReq::parse("not a version") {\r
    ///     Ok(version) => version,\r
    ///     Err(e) => panic!("There was a problem parsing: {}", e),\r
    /// };\r
    /// ```\r
    ///\r
    /// # Errors\r
    ///\r
    /// Returns an error variant if the input could not be parsed as a semver requirement.\r
    ///\r
    /// Examples of common error causes are as follows:\r
    ///\r
    /// * `\0` - an invalid version requirement is used.\r
    /// * `>= >= 1.2.3` - multiple operations are used. Only use one.\r
    /// * `>== 1.2.3` - an invalid operation is used.\r
    /// * `a.0.0` - version components are not numeric.\r
    /// * `1.2.3-` - an invalid identifier is present.\r
    /// * `>=` - major version was not specified. At least a major version is required.\r
    /// * `0.2*` - deprecated requirement syntax. Equivalent would be `0.2.*`.\r
    ///\r
    /// You may also encounter an `UnimplementedVersionRequirement` error, which indicates that a\r
    /// given requirement syntax is not yet implemented in this crate.\r
    pub fn parse(input: &str) -> Result<VersionReq, ReqParseError> {\r
        let res = semver_parser::range::parse(input);\r
\r
        if let Ok(v) = res {\r
            return Ok(From::from(v));\r
        }\r
\r
        match VersionReq::parse_deprecated(input) {\r
            Some(v) => Err(ReqParseError::DeprecatedVersionRequirement(v)),\r
            None => Err(From::from(res.err().unwrap())),\r
        }\r
    }\r
\r
    fn parse_deprecated(version: &str) -> Option<VersionReq> {\r
        match version {\r
            ".*" => Some(VersionReq::any()),\r
            "0.1.0." => Some(VersionReq::parse("0.1.0").unwrap()),\r
            "0.3.1.3" => Some(VersionReq::parse("0.3.13").unwrap()),\r
            "0.2*" => Some(VersionReq::parse("0.2.*").unwrap()),\r
            "*.0" => Some(VersionReq::any()),\r
            _ => None,\r
        }\r
    }\r
\r
    /// `exact()` is a factory method which creates a `VersionReq` with one exact constraint.\r
    ///\r
    /// # Examples\r
    ///\r
    /// ```\r
    /// use semver::VersionReq;\r
    /// use semver::Version;\r
    ///\r
    /// let version = Version { major: 1, minor: 1, patch: 1, pre: vec![], build: vec![] };\r
    /// let exact = VersionReq::exact(&version);\r
    /// ```\r
    pub fn exact(version: &Version) -> VersionReq {\r
        VersionReq {\r
            predicates: vec![Predicate::exact(version)],\r
        }\r
    }\r
\r
    /// `matches()` matches a given [`Version`] against this `VersionReq`.\r
    /// [`Version`]: struct.Version.html\r
    ///\r
    /// # Examples\r
    ///\r
    /// ```\r
    /// use semver::VersionReq;\r
    /// use semver::Version;\r
    ///\r
    /// let version = Version { major: 1, minor: 1, patch: 1, pre: vec![], build: vec![] };\r
    /// let exact = VersionReq::exact(&version);\r
    ///\r
    /// assert!(exact.matches(&version));\r
    /// ```\r
    pub fn matches(&self, version: &Version) -> bool {\r
        // no predicates means anything matches\r
        if self.predicates.is_empty() {\r
            return true;\r
        }\r
\r
        self.predicates.iter().all(|p| p.matches(version))\r
            && self\r
                .predicates\r
                .iter()\r
                .any(|p| p.pre_tag_is_compatible(version))\r
    }\r
\r
    /// `is_exact()` returns `true` if there is exactly one version which could match this\r
    /// `VersionReq`. If `false` is returned, it is possible that there may still only be exactly\r
    /// one version which could match this `VersionReq`. This function is intended do allow\r
    /// short-circuiting more complex logic where being able to handle only the possibility of a\r
    /// single exact version may be cheaper.\r
    ///\r
    /// # Examples\r
    ///\r
    /// ```\r
    /// use semver::ReqParseError;\r
    /// use semver::VersionReq;\r
    ///\r
    /// fn use_is_exact() -> Result<(), ReqParseError> {\r
    ///   assert!(VersionReq::parse("=1.0.0")?.is_exact());\r
    ///   assert!(!VersionReq::parse("=1.0")?.is_exact());\r
    ///   assert!(!VersionReq::parse(">=1.0.0")?.is_exact());\r
    ///   Ok(())\r
    /// }\r
    ///\r
    /// use_is_exact().unwrap();\r
    /// ```\r
    pub fn is_exact(&self) -> bool {\r
        if let [predicate] = self.predicates.as_slice() {\r
            predicate.has_exactly_one_match()\r
        } else {\r
            false\r
        }\r
    }\r
}\r
\r
impl str::FromStr for VersionReq {\r
    type Err = ReqParseError;\r
\r
    fn from_str(s: &str) -> Result<VersionReq, ReqParseError> {\r
        VersionReq::parse(s)\r
    }\r
}\r
\r
impl Predicate {\r
    fn exact(version: &Version) -> Predicate {\r
        Predicate {\r
            op: Ex,\r
            major: version.major,\r
            minor: Some(version.minor),\r
            patch: Some(version.patch),\r
            pre: version.pre.clone(),\r
        }\r
    }\r
\r
    /// `matches()` takes a `Version` and determines if it matches this particular `Predicate`.\r
    pub fn matches(&self, ver: &Version) -> bool {\r
        match self.op {\r
            Ex => self.matches_exact(ver),\r
            Gt => self.matches_greater(ver),\r
            GtEq => self.matches_exact(ver) || self.matches_greater(ver),\r
            Lt => !self.matches_exact(ver) && !self.matches_greater(ver),\r
            LtEq => !self.matches_greater(ver),\r
            Tilde => self.matches_tilde(ver),\r
            Compatible => self.is_compatible(ver),\r
            Wildcard(_) => self.matches_wildcard(ver),\r
        }\r
    }\r
\r
    fn matches_exact(&self, ver: &Version) -> bool {\r
        if self.major != ver.major {\r
            return false;\r
        }\r
\r
        match self.minor {\r
            Some(minor) => {\r
                if minor != ver.minor {\r
                    return false;\r
                }\r
            }\r
            None => return true,\r
        }\r
\r
        match self.patch {\r
            Some(patch) => {\r
                if patch != ver.patch {\r
                    return false;\r
                }\r
            }\r
            None => return true,\r
        }\r
\r
        if self.pre != ver.pre {\r
            return false;\r
        }\r
\r
        true\r
    }\r
\r
    // https://docs.npmjs.com/misc/semver#prerelease-tags\r
    fn pre_tag_is_compatible(&self, ver: &Version) -> bool {\r
        // If a version has a prerelease tag (for example, 1.2.3-alpha.3) then it will\r
        // only be\r
        // allowed to satisfy comparator sets if at least one comparator with the same\r
        // [major,\r
        // minor, patch] tuple also has a prerelease tag.\r
        !ver.is_prerelease()\r
            || (self.major == ver.major\r
                && self.minor == Some(ver.minor)\r
                && self.patch == Some(ver.patch)\r
                && !self.pre.is_empty())\r
    }\r
\r
    fn matches_greater(&self, ver: &Version) -> bool {\r
        if self.major != ver.major {\r
            return ver.major > self.major;\r
        }\r
\r
        match self.minor {\r
            Some(minor) => {\r
                if minor != ver.minor {\r
                    return ver.minor > minor;\r
                }\r
            }\r
            None => return false,\r
        }\r
\r
        match self.patch {\r
            Some(patch) => {\r
                if patch != ver.patch {\r
                    return ver.patch > patch;\r
                }\r
            }\r
            None => return false,\r
        }\r
\r
        if !self.pre.is_empty() {\r
            return ver.pre.is_empty() || ver.pre > self.pre;\r
        }\r
\r
        false\r
    }\r
\r
    // see https://www.npmjs.com/package/semver for behavior\r
    fn matches_tilde(&self, ver: &Version) -> bool {\r
        let minor = match self.minor {\r
            Some(n) => n,\r
            None => return self.major == ver.major,\r
        };\r
\r
        match self.patch {\r
            Some(patch) => {\r
                self.major == ver.major\r
                    && minor == ver.minor\r
                    && (ver.patch > patch || (ver.patch == patch && self.pre_is_compatible(ver)))\r
            }\r
            None => self.major == ver.major && minor == ver.minor,\r
        }\r
    }\r
\r
    // see https://www.npmjs.com/package/semver for behavior\r
    fn is_compatible(&self, ver: &Version) -> bool {\r
        if self.major != ver.major {\r
            return false;\r
        }\r
\r
        let minor = match self.minor {\r
            Some(n) => n,\r
            None => return self.major == ver.major,\r
        };\r
\r
        match self.patch {\r
            Some(patch) => {\r
                if self.major == 0 {\r
                    if minor == 0 {\r
                        ver.minor == minor && ver.patch == patch && self.pre_is_compatible(ver)\r
                    } else {\r
                        ver.minor == minor\r
                            && (ver.patch > patch\r
                                || (ver.patch == patch && self.pre_is_compatible(ver)))\r
                    }\r
                } else {\r
                    ver.minor > minor\r
                        || (ver.minor == minor\r
                            && (ver.patch > patch\r
                                || (ver.patch == patch && self.pre_is_compatible(ver))))\r
                }\r
            }\r
            None => {\r
                if self.major == 0 {\r
                    ver.minor == minor\r
                } else {\r
                    ver.minor >= minor\r
                }\r
            }\r
        }\r
    }\r
\r
    fn pre_is_compatible(&self, ver: &Version) -> bool {\r
        ver.pre.is_empty() || ver.pre >= self.pre\r
    }\r
\r
    // see https://www.npmjs.com/package/semver for behavior\r
    fn matches_wildcard(&self, ver: &Version) -> bool {\r
        match self.op {\r
            Wildcard(Major) => true,\r
            Wildcard(Minor) => self.major == ver.major,\r
            Wildcard(Patch) => {\r
                match self.minor {\r
                    Some(minor) => self.major == ver.major && minor == ver.minor,\r
                    None => {\r
                        // minor and patch version astericks mean match on major\r
                        self.major == ver.major\r
                    }\r
                }\r
            }\r
            _ => false, // unreachable\r
        }\r
    }\r
\r
    fn has_exactly_one_match(&self) -> bool {\r
        self.op == Ex && self.minor.is_some() && self.patch.is_some()\r
    }\r
}\r
\r
impl fmt::Display for VersionReq {\r
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\r
        if self.predicates.is_empty() {\r
            write!(fmt, "*")?;\r
        } else {\r
            for (i, ref pred) in self.predicates.iter().enumerate() {\r
                if i == 0 {\r
                    write!(fmt, "{}", pred)?;\r
                } else {\r
                    write!(fmt, ", {}", pred)?;\r
                }\r
            }\r
        }\r
\r
        Ok(())\r
    }\r
}\r
\r
impl fmt::Display for Predicate {\r
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\r
        match self.op {\r
            Wildcard(Major) => write!(fmt, "*")?,\r
            Wildcard(Minor) => write!(fmt, "{}.*", self.major)?,\r
            Wildcard(Patch) => {\r
                if let Some(minor) = self.minor {\r
                    write!(fmt, "{}.{}.*", self.major, minor)?\r
                } else {\r
                    write!(fmt, "{}.*.*", self.major)?\r
                }\r
            }\r
            _ => {\r
                write!(fmt, "{}{}", self.op, self.major)?;\r
\r
                if let Some(v) = self.minor {\r
                    write!(fmt, ".{}", v)?;\r
                }\r
\r
                if let Some(v) = self.patch {\r
                    write!(fmt, ".{}", v)?;\r
                }\r
\r
                if !self.pre.is_empty() {\r
                    write!(fmt, "-")?;\r
                    for (i, x) in self.pre.iter().enumerate() {\r
                        if i != 0 {\r
                            write!(fmt, ".")?\r
                        }\r
                        write!(fmt, "{}", x)?;\r
                    }\r
                }\r
            }\r
        }\r
\r
        Ok(())\r
    }\r
}\r
\r
impl fmt::Display for Op {\r
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\r
        match *self {\r
            Ex => write!(fmt, "=")?,\r
            Gt => write!(fmt, ">")?,\r
            GtEq => write!(fmt, ">=")?,\r
            Lt => write!(fmt, "<")?,\r
            LtEq => write!(fmt, "<=")?,\r
            Tilde => write!(fmt, "~")?,\r
            Compatible => write!(fmt, "^")?,\r
            // gets handled specially in Predicate::fmt\r
            Wildcard(_) => write!(fmt, "")?,\r
        }\r
        Ok(())\r
    }\r
}\r
\r
#[cfg(test)]\r
mod test {\r
    use super::super::version::Version;\r
    use super::{Op, VersionReq};\r
    use std::hash::{Hash, Hasher};\r
\r
    fn req(s: &str) -> VersionReq {\r
        VersionReq::parse(s).unwrap()\r
    }\r
\r
    fn version(s: &str) -> Version {\r
        match Version::parse(s) {\r
            Ok(v) => v,\r
            Err(e) => panic!("`{}` is not a valid version. Reason: {:?}", s, e),\r
        }\r
    }\r
\r
    fn assert_match(req: &VersionReq, vers: &[&str]) {\r
        for ver in vers.iter() {\r
            assert!(req.matches(&version(*ver)), "did not match {}", ver);\r
        }\r
    }\r
\r
    fn assert_not_match(req: &VersionReq, vers: &[&str]) {\r
        for ver in vers.iter() {\r
            assert!(!req.matches(&version(*ver)), "matched {}", ver);\r
        }\r
    }\r
\r
    fn calculate_hash<T: Hash>(t: T) -> u64 {\r
        use std::collections::hash_map::DefaultHasher;\r
\r
        let mut s = DefaultHasher::new();\r
        t.hash(&mut s);\r
        s.finish()\r
    }\r
\r
    #[test]\r
    fn test_parsing_default() {\r
        let r = req("1.0.0");\r
\r
        assert_eq!(r.to_string(), "^1.0.0".to_string());\r
\r
        assert_match(&r, &["1.0.0", "1.0.1"]);\r
        assert_not_match(&r, &["0.9.9", "0.10.0", "0.1.0"]);\r
    }\r
\r
    #[test]\r
    fn test_parsing_exact() {\r
        let r = req("=1.0.0");\r
\r
        assert!(r.to_string() == "=1.0.0".to_string());\r
        assert_eq!(r.to_string(), "=1.0.0".to_string());\r
\r
        assert_match(&r, &["1.0.0"]);\r
        assert_not_match(&r, &["1.0.1", "0.9.9", "0.10.0", "0.1.0", "1.0.0-pre"]);\r
\r
        let r = req("=0.9.0");\r
\r
        assert_eq!(r.to_string(), "=0.9.0".to_string());\r
\r
        assert_match(&r, &["0.9.0"]);\r
        assert_not_match(&r, &["0.9.1", "1.9.0", "0.0.9"]);\r
\r
        let r = req("=0.1.0-beta2.a");\r
\r
        assert_eq!(r.to_string(), "=0.1.0-beta2.a".to_string());\r
\r
        assert_match(&r, &["0.1.0-beta2.a"]);\r
        assert_not_match(&r, &["0.9.1", "0.1.0", "0.1.1-beta2.a", "0.1.0-beta2"]);\r
    }\r
\r
    #[test]\r
    fn test_parse_metadata_see_issue_88_see_issue_88() {\r
        for op in &[\r
            Op::Compatible,\r
            Op::Ex,\r
            Op::Gt,\r
            Op::GtEq,\r
            Op::Lt,\r
            Op::LtEq,\r
            Op::Tilde,\r
        ] {\r
            req(&format!("{} 1.2.3+meta", op));\r
        }\r
    }\r
\r
    #[test]\r
    pub fn test_parsing_greater_than() {\r
        let r = req(">= 1.0.0");\r
\r
        assert_eq!(r.to_string(), ">=1.0.0".to_string());\r
\r
        assert_match(&r, &["1.0.0", "2.0.0"]);\r
        assert_not_match(&r, &["0.1.0", "0.0.1", "1.0.0-pre", "2.0.0-pre"]);\r
\r
        let r = req(">= 2.1.0-alpha2");\r
\r
        assert_match(&r, &["2.1.0-alpha2", "2.1.0-alpha3", "2.1.0", "3.0.0"]);\r
        assert_not_match(\r
            &r,\r
            &["2.0.0", "2.1.0-alpha1", "2.0.0-alpha2", "3.0.0-alpha2"],\r
        );\r
    }\r
\r
    #[test]\r
    pub fn test_parsing_less_than() {\r
        let r = req("< 1.0.0");\r
\r
        assert_eq!(r.to_string(), "<1.0.0".to_string());\r
\r
        assert_match(&r, &["0.1.0", "0.0.1"]);\r
        assert_not_match(&r, &["1.0.0", "1.0.0-beta", "1.0.1", "0.9.9-alpha"]);\r
\r
        let r = req("<= 2.1.0-alpha2");\r
\r
        assert_match(&r, &["2.1.0-alpha2", "2.1.0-alpha1", "2.0.0", "1.0.0"]);\r
        assert_not_match(\r
            &r,\r
            &["2.1.0", "2.2.0-alpha1", "2.0.0-alpha2", "1.0.0-alpha2"],\r
        );\r
    }\r
\r
    #[test]\r
    pub fn test_multiple() {\r
        let r = req("> 0.0.9, <= 2.5.3");\r
        assert_eq!(r.to_string(), ">0.0.9, <=2.5.3".to_string());\r
        assert_match(&r, &["0.0.10", "1.0.0", "2.5.3"]);\r
        assert_not_match(&r, &["0.0.8", "2.5.4"]);\r
\r
        let r = req("0.3.0, 0.4.0");\r
        assert_eq!(r.to_string(), "^0.3.0, ^0.4.0".to_string());\r
        assert_not_match(&r, &["0.0.8", "0.3.0", "0.4.0"]);\r
\r
        let r = req("<= 0.2.0, >= 0.5.0");\r
        assert_eq!(r.to_string(), "<=0.2.0, >=0.5.0".to_string());\r
        assert_not_match(&r, &["0.0.8", "0.3.0", "0.5.1"]);\r
\r
        let r = req("0.1.0, 0.1.4, 0.1.6");\r
        assert_eq!(r.to_string(), "^0.1.0, ^0.1.4, ^0.1.6".to_string());\r
        assert_match(&r, &["0.1.6", "0.1.9"]);\r
        assert_not_match(&r, &["0.1.0", "0.1.4", "0.2.0"]);\r
\r
        assert!(VersionReq::parse("> 0.1.0,").is_err());\r
        assert!(VersionReq::parse("> 0.3.0, ,").is_err());\r
\r
        let r = req(">=0.5.1-alpha3, <0.6");\r
        assert_eq!(r.to_string(), ">=0.5.1-alpha3, <0.6".to_string());\r
        assert_match(\r
            &r,\r
            &[\r
                "0.5.1-alpha3",\r
                "0.5.1-alpha4",\r
                "0.5.1-beta",\r
                "0.5.1",\r
                "0.5.5",\r
            ],\r
        );\r
        assert_not_match(\r
            &r,\r
            &["0.5.1-alpha1", "0.5.2-alpha3", "0.5.5-pre", "0.5.0-pre"],\r
        );\r
        assert_not_match(&r, &["0.6.0", "0.6.0-pre"]);\r
    }\r
\r
    #[test]\r
    pub fn test_parsing_tilde() {\r
        let r = req("~1");\r
        assert_match(&r, &["1.0.0", "1.0.1", "1.1.1"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "0.0.9"]);\r
\r
        let r = req("~1.2");\r
        assert_match(&r, &["1.2.0", "1.2.1"]);\r
        assert_not_match(&r, &["1.1.1", "1.3.0", "0.0.9"]);\r
\r
        let r = req("~1.2.2");\r
        assert_match(&r, &["1.2.2", "1.2.4"]);\r
        assert_not_match(&r, &["1.2.1", "1.9.0", "1.0.9", "2.0.1", "0.1.3"]);\r
\r
        let r = req("~1.2.3-beta.2");\r
        assert_match(&r, &["1.2.3", "1.2.4", "1.2.3-beta.2", "1.2.3-beta.4"]);\r
        assert_not_match(&r, &["1.3.3", "1.1.4", "1.2.3-beta.1", "1.2.4-beta.2"]);\r
    }\r
\r
    #[test]\r
    pub fn test_parsing_compatible() {\r
        let r = req("^1");\r
        assert_match(&r, &["1.1.2", "1.1.0", "1.2.1", "1.0.1"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "0.1.4"]);\r
        assert_not_match(&r, &["1.0.0-beta1", "0.1.0-alpha", "1.0.1-pre"]);\r
\r
        let r = req("^1.1");\r
        assert_match(&r, &["1.1.2", "1.1.0", "1.2.1"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "1.0.1", "0.1.4"]);\r
\r
        let r = req("^1.1.2");\r
        assert_match(&r, &["1.1.2", "1.1.4", "1.2.1"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.0.1"]);\r
        assert_not_match(&r, &["1.1.2-alpha1", "1.1.3-alpha1", "2.9.0-alpha1"]);\r
\r
        let r = req("^0.1.2");\r
        assert_match(&r, &["0.1.2", "0.1.4"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.0.1"]);\r
        assert_not_match(&r, &["0.1.2-beta", "0.1.3-alpha", "0.2.0-pre"]);\r
\r
        let r = req("^0.5.1-alpha3");\r
        assert_match(\r
            &r,\r
            &[\r
                "0.5.1-alpha3",\r
                "0.5.1-alpha4",\r
                "0.5.1-beta",\r
                "0.5.1",\r
                "0.5.5",\r
            ],\r
        );\r
        assert_not_match(\r
            &r,\r
            &[\r
                "0.5.1-alpha1",\r
                "0.5.2-alpha3",\r
                "0.5.5-pre",\r
                "0.5.0-pre",\r
                "0.6.0",\r
            ],\r
        );\r
\r
        let r = req("^0.0.2");\r
        assert_match(&r, &["0.0.2"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.0.1", "0.1.4"]);\r
\r
        let r = req("^0.0");\r
        assert_match(&r, &["0.0.2", "0.0.0"]);\r
        assert_not_match(&r, &["0.9.1", "2.9.0", "1.1.1", "0.1.4"]);\r
\r
        let r = req("^0");\r
        assert_match(&r, &["0.9.1", "0.0.2", "0.0.0"]);\r
        assert_not_match(&r, &["2.9.0", "1.1.1"]);\r
\r
        let r = req("^1.4.2-beta.5");\r
        assert_match(\r
            &r,\r
            &["1.4.2", "1.4.3", "1.4.2-beta.5", "1.4.2-beta.6", "1.4.2-c"],\r
        );\r
        assert_not_match(\r
            &r,\r
            &[\r
                "0.9.9",\r
                "2.0.0",\r
                "1.4.2-alpha",\r
                "1.4.2-beta.4",\r
                "1.4.3-beta.5",\r
            ],\r
        );\r
    }\r
\r
    #[test]\r
    pub fn test_parsing_wildcard() {\r
        let r = req("");\r
        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);\r
        assert_not_match(&r, &[]);\r
        let r = req("*");\r
        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);\r
        assert_not_match(&r, &[]);\r
        let r = req("x");\r
        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);\r
        assert_not_match(&r, &[]);\r
        let r = req("X");\r
        assert_match(&r, &["0.9.1", "2.9.0", "0.0.9", "1.0.1", "1.1.1"]);\r
        assert_not_match(&r, &[]);\r
\r
        let r = req("1.*");\r
        assert_match(&r, &["1.2.0", "1.2.1", "1.1.1", "1.3.0"]);\r
        assert_not_match(&r, &["0.0.9"]);\r
        let r = req("1.x");\r
        assert_match(&r, &["1.2.0", "1.2.1", "1.1.1", "1.3.0"]);\r
        assert_not_match(&r, &["0.0.9"]);\r
        let r = req("1.X");\r
        assert_match(&r, &["1.2.0", "1.2.1", "1.1.1", "1.3.0"]);\r
        assert_not_match(&r, &["0.0.9"]);\r
\r
        let r = req("1.2.*");\r
        assert_match(&r, &["1.2.0", "1.2.2", "1.2.4"]);\r
        assert_not_match(&r, &["1.9.0", "1.0.9", "2.0.1", "0.1.3"]);\r
        let r = req("1.2.x");\r
        assert_match(&r, &["1.2.0", "1.2.2", "1.2.4"]);\r
        assert_not_match(&r, &["1.9.0", "1.0.9", "2.0.1", "0.1.3"]);\r
        let r = req("1.2.X");\r
        assert_match(&r, &["1.2.0", "1.2.2", "1.2.4"]);\r
        assert_not_match(&r, &["1.9.0", "1.0.9", "2.0.1", "0.1.3"]);\r
    }\r
\r
    #[test]\r
    pub fn test_any() {\r
        let r = VersionReq::any();\r
        assert_match(&r, &["0.0.1", "0.1.0", "1.0.0"]);\r
    }\r
\r
    #[test]\r
    pub fn test_pre() {\r
        let r = req("=2.1.1-really.0");\r
        assert_match(&r, &["2.1.1-really.0"]);\r
    }\r
\r
    // #[test]\r
    // pub fn test_parse_errors() {\r
    //    assert_eq!(Err(InvalidVersionRequirement), VersionReq::parse("\0"));\r
    //    assert_eq!(Err(OpAlreadySet), VersionReq::parse(">= >= 0.0.2"));\r
    //    assert_eq!(Err(InvalidSigil), VersionReq::parse(">== 0.0.2"));\r
    //    assert_eq!(Err(VersionComponentsMustBeNumeric),\r
    //               VersionReq::parse("a.0.0"));\r
    //    assert_eq!(Err(InvalidIdentifier), VersionReq::parse("1.0.0-"));\r
    //    assert_eq!(Err(MajorVersionRequired), VersionReq::parse(">="));\r
    // }\r
\r
    #[test]\r
    pub fn test_from_str() {\r
        assert_eq!(\r
            "1.0.0".parse::<VersionReq>().unwrap().to_string(),\r
            "^1.0.0".to_string()\r
        );\r
        assert_eq!(\r
            "=1.0.0".parse::<VersionReq>().unwrap().to_string(),\r
            "=1.0.0".to_string()\r
        );\r
        assert_eq!(\r
            "~1".parse::<VersionReq>().unwrap().to_string(),\r
            "~1".to_string()\r
        );\r
        assert_eq!(\r
            "~1.2".parse::<VersionReq>().unwrap().to_string(),\r
            "~1.2".to_string()\r
        );\r
        assert_eq!(\r
            "^1".parse::<VersionReq>().unwrap().to_string(),\r
            "^1".to_string()\r
        );\r
        assert_eq!(\r
            "^1.1".parse::<VersionReq>().unwrap().to_string(),\r
            "^1.1".to_string()\r
        );\r
        assert_eq!(\r
            "*".parse::<VersionReq>().unwrap().to_string(),\r
            "*".to_string()\r
        );\r
        assert_eq!(\r
            "1.*".parse::<VersionReq>().unwrap().to_string(),\r
            "1.*".to_string()\r
        );\r
        assert_eq!(\r
            "< 1.0.0".parse::<VersionReq>().unwrap().to_string(),\r
            "<1.0.0".to_string()\r
        );\r
    }\r
\r
    // #[test]\r
    // pub fn test_from_str_errors() {\r
    //    assert_eq!(Err(InvalidVersionRequirement), "\0".parse::<VersionReq>());\r
    //    assert_eq!(Err(OpAlreadySet), ">= >= 0.0.2".parse::<VersionReq>());\r
    //    assert_eq!(Err(InvalidSigil), ">== 0.0.2".parse::<VersionReq>());\r
    //    assert_eq!(Err(VersionComponentsMustBeNumeric),\r
    //               "a.0.0".parse::<VersionReq>());\r
    //    assert_eq!(Err(InvalidIdentifier), "1.0.0-".parse::<VersionReq>());\r
    //    assert_eq!(Err(MajorVersionRequired), ">=".parse::<VersionReq>());\r
    // }\r
\r
    #[test]\r
    fn test_cargo3202() {\r
        let v = "0.*.*".parse::<VersionReq>().unwrap();\r
        assert_eq!("0.*.*", format!("{}", v.predicates[0]));\r
\r
        let v = "0.0.*".parse::<VersionReq>().unwrap();\r
        assert_eq!("0.0.*", format!("{}", v.predicates[0]));\r
\r
        let r = req("0.*.*");\r
        assert_match(&r, &["0.5.0"]);\r
    }\r
\r
    #[test]\r
    fn test_eq_hash() {\r
        assert!(req("^1") == req("^1"));\r
        assert!(calculate_hash(req("^1")) == calculate_hash(req("^1")));\r
        assert!(req("^1") != req("^2"));\r
    }\r
\r
    #[test]\r
    fn test_ordering() {\r
        assert!(req("=1") < req("*"));\r
        assert!(req(">1") < req("*"));\r
        assert!(req(">=1") < req("*"));\r
        assert!(req("<1") < req("*"));\r
        assert!(req("<=1") < req("*"));\r
        assert!(req("~1") < req("*"));\r
        assert!(req("^1") < req("*"));\r
        assert!(req("*") == req("*"));\r
    }\r
\r
    #[test]\r
    fn is_exact() {\r
        assert!(req("=1.0.0").is_exact());\r
        assert!(req("=1.0.0-alpha").is_exact());\r
\r
        assert!(!req("=1").is_exact());\r
        assert!(!req(">=1.0.0").is_exact());\r
        assert!(!req(">=1.0.0, <2.0.0").is_exact());\r
    }\r
}\r