code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/version_check-0.9.5/README.md

@@ -1,80 +0,0 @@
-# version\_check
-
-[![Build Status](https://github.com/SergioBenitez/version_check/workflows/CI/badge.svg)](https://github.com/SergioBenitez/version_check/actions)
-[![Current Crates.io Version](https://img.shields.io/crates/v/version_check.svg)](https://crates.io/crates/version_check)
-[![rustdocs on docs.rs](https://docs.rs/version_check/badge.svg)](https://docs.rs/version_check)
-
-This tiny crate checks that the running or installed `rustc` meets some version
-requirements. The version is queried by calling the Rust compiler with
-`--version`. The path to the compiler is determined first via the `RUSTC`
-environment variable. If it is not set, then `rustc` is used. If that fails, no
-determination is made, and calls return `None`.
-
-## Usage
-
-Add to your `Cargo.toml` file, typically as a build dependency:
-
-```toml
-[build-dependencies]
-version_check = "0.9"
-```
-
-`version_check` is compatible and compiles with Rust 1.0.0 and beyond.
-
-## Examples
-
-Set a `cfg` flag in `build.rs` if the running compiler was determined to be
-at least version `1.13.0`:
-
-```rust
-extern crate version_check as rustc;
-
-if rustc::is_min_version("1.13.0").unwrap_or(false) {
-    println!("cargo:rustc-cfg=question_mark_operator");
-}
-```
-
-Check that the running compiler was released on or after `2018-12-18`:
-
-```rust
-extern crate version_check as rustc;
-
-match rustc::is_min_date("2018-12-18") {
-    Some(true) => "Yep! It's recent!",
-    Some(false) => "No, it's older.",
-    None => "Couldn't determine the rustc version."
-};
-```
-
-Check that the running compiler supports feature flags:
-
-```rust
-extern crate version_check as rustc;
-
-match rustc::is_feature_flaggable() {
-    Some(true) => "Yes! It's a dev or nightly release!",
-    Some(false) => "No, it's stable or beta.",
-    None => "Couldn't determine the rustc version."
-};
-```
-
-See the [rustdocs](https://docs.rs/version_check) for more examples and complete
-documentation.
-
-## Alternatives
-
-This crate is dead simple with no dependencies. If you need something more and
-don't care about panicking if the version cannot be obtained, or if you don't
-mind adding dependencies, see [rustc_version]. If you'd instead prefer a feature
-detection library that works by dynamically invoking `rustc` with a
-representative code sample, see [autocfg].
-
-[rustc_version]: https://crates.io/crates/rustc_version
-[autocfg]: https://crates.io/crates/autocfg
-
-## License
-
-`version_check` is licensed under either of the following, at your option:
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT License ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

data/ext/cargo-vendor/version_check-0.9.5/src/channel.rs

@@ -1,195 +0,0 @@
-use std::fmt;
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-enum Kind {
-    Dev,
-    Nightly,
-    Beta,
-    Stable,
-}
-
-/// Release channel: "dev", "nightly", "beta", or "stable".
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub struct Channel(Kind);
-
-impl Channel {
-    /// Reads the release channel of the running compiler. If it cannot be
-    /// determined (see the [top-level documentation](crate)), returns `None`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// match Channel::read() {
-    ///     Some(c) => format!("The channel is: {}", c),
-    ///     None => format!("Failed to read the release channel.")
-    /// };
-    /// ```
-    pub fn read() -> Option<Channel> {
-        ::get_version_and_date()
-            .and_then(|(version, _)| version)
-            .and_then(|version| Channel::parse(&version))
-    }
-
-    /// Parse a Rust release channel from a Rust release version string (of the
-    /// form `major[.minor[.patch[-channel]]]`). Returns `None` if `version` is
-    /// not a valid Rust version string.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// let dev = Channel::parse("1.3.0-dev").unwrap();
-    /// assert!(dev.is_dev());
-    ///
-    /// let nightly = Channel::parse("1.42.2-nightly").unwrap();
-    /// assert!(nightly.is_nightly());
-    ///
-    /// let beta = Channel::parse("1.32.0-beta").unwrap();
-    /// assert!(beta.is_beta());
-    ///
-    /// let stable = Channel::parse("1.4.0").unwrap();
-    /// assert!(stable.is_stable());
-    /// ```
-    pub fn parse(version: &str) -> Option<Channel> {
-        let version = version.trim();
-        if version.contains("-dev") || version == "dev" {
-            Some(Channel(Kind::Dev))
-        } else if version.contains("-nightly") || version == "nightly" {
-            Some(Channel(Kind::Nightly))
-        } else if version.contains("-beta") || version == "beta" {
-            Some(Channel(Kind::Beta))
-        } else if !version.contains("-") {
-            Some(Channel(Kind::Stable))
-        } else {
-            None
-        }
-    }
-
-    /// Returns the name of the release channel.
-    fn as_str(&self) -> &'static str {
-        match self.0 {
-            Kind::Dev => "dev",
-            Kind::Beta => "beta",
-            Kind::Nightly => "nightly",
-            Kind::Stable => "stable",
-        }
-    }
-
-    /// Returns `true` if this channel supports feature flags. In other words,
-    /// returns `true` if the channel is either `dev` or `nightly`.
-    ///
-    /// **Please see the note on [feature detection](crate#feature-detection).**
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// let dev = Channel::parse("1.3.0-dev").unwrap();
-    /// assert!(dev.supports_features());
-    ///
-    /// let nightly = Channel::parse("1.42.2-nightly").unwrap();
-    /// assert!(nightly.supports_features());
-    ///
-    /// let beta = Channel::parse("1.32.0-beta").unwrap();
-    /// assert!(!beta.supports_features());
-    ///
-    /// let stable = Channel::parse("1.4.0").unwrap();
-    /// assert!(!stable.supports_features());
-    /// ```
-    pub fn supports_features(&self) -> bool {
-        match self.0 {
-            Kind::Dev | Kind::Nightly => true,
-            Kind::Beta | Kind::Stable => false
-        }
-    }
-
-    /// Returns `true` if this channel is `dev` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// let dev = Channel::parse("1.3.0-dev").unwrap();
-    /// assert!(dev.is_dev());
-    ///
-    /// let stable = Channel::parse("1.0.0").unwrap();
-    /// assert!(!stable.is_dev());
-    /// ```
-    pub fn is_dev(&self) -> bool {
-        match self.0 {
-            Kind::Dev => true,
-            _ => false
-        }
-    }
-
-    /// Returns `true` if this channel is `nightly` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// let nightly = Channel::parse("1.3.0-nightly").unwrap();
-    /// assert!(nightly.is_nightly());
-    ///
-    /// let stable = Channel::parse("1.0.0").unwrap();
-    /// assert!(!stable.is_nightly());
-    /// ```
-    pub fn is_nightly(&self) -> bool {
-        match self.0 {
-            Kind::Nightly => true,
-            _ => false
-        }
-    }
-
-    /// Returns `true` if this channel is `beta` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// let beta = Channel::parse("1.3.0-beta").unwrap();
-    /// assert!(beta.is_beta());
-    ///
-    /// let stable = Channel::parse("1.0.0").unwrap();
-    /// assert!(!stable.is_beta());
-    /// ```
-    pub fn is_beta(&self) -> bool {
-        match self.0 {
-            Kind::Beta => true,
-            _ => false
-        }
-    }
-
-    /// Returns `true` if this channel is `stable` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Channel;
-    ///
-    /// let stable = Channel::parse("1.0.0").unwrap();
-    /// assert!(stable.is_stable());
-    ///
-    /// let beta = Channel::parse("1.3.0-beta").unwrap();
-    /// assert!(!beta.is_stable());
-    /// ```
-    pub fn is_stable(&self) -> bool {
-        match self.0 {
-            Kind::Stable => true,
-            _ => false
-        }
-    }
-}
-
-impl fmt::Display for Channel {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}

data/ext/cargo-vendor/version_check-0.9.5/src/date.rs

@@ -1,203 +0,0 @@
-use std::fmt;
-
-/// Release date including year, month, and day.
-// Internal storage is: y[31..9] | m[8..5] | d[5...0].
-#[derive(Debug, PartialEq, Eq, Copy, Clone, PartialOrd, Ord)]
-pub struct Date(u32);
-
-impl Date {
-    /// Reads the release date of the running compiler. If it cannot be
-    /// determined (see the [top-level documentation](crate)), returns `None`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Date;
-    ///
-    /// match Date::read() {
-    ///     Some(d) => format!("The release date is: {}", d),
-    ///     None => format!("Failed to read the release date.")
-    /// };
-    /// ```
-    pub fn read() -> Option<Date> {
-        ::get_version_and_date()
-            .and_then(|(_, date)| date)
-            .and_then(|date| Date::parse(&date))
-    }
-
-    /// Parse a release date of the form `%Y-%m-%d`. Returns `None` if `date` is
-    /// not in `%Y-%m-%d` format.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Date;
-    ///
-    /// let date = Date::parse("2016-04-20").unwrap();
-    ///
-    /// assert!(date.at_least("2016-01-10"));
-    /// assert!(date.at_most("2016-04-20"));
-    /// assert!(date.exactly("2016-04-20"));
-    ///
-    /// assert!(Date::parse("2021-12-31").unwrap().exactly("2021-12-31"));
-    ///
-    /// assert!(Date::parse("March 13, 2018").is_none());
-    /// assert!(Date::parse("1-2-3-4-5").is_none());
-    /// assert!(Date::parse("2020-300-23120").is_none());
-    /// assert!(Date::parse("2020-12-12 1").is_none());
-    /// assert!(Date::parse("2020-10").is_none());
-    /// assert!(Date::parse("2020").is_none());
-    /// ```
-    pub fn parse(date: &str) -> Option<Date> {
-        let mut ymd = [0u16; 3];
-        for (i, split) in date.split('-').map(|s| s.parse::<u16>()).enumerate() {
-            ymd[i] = match (i, split) {
-                (3, _) | (_, Err(_)) => return None,
-                (_, Ok(v)) => v,
-            };
-        }
-
-        let (year, month, day) = (ymd[0], ymd[1], ymd[2]);
-        if year == 0 || month == 0 || month > 12 || day == 0 || day > 31 {
-            return None;
-        }
-
-        Some(Date::from_ymd(year, month as u8, day as u8))
-    }
-
-    /// Creates a `Date` from `(year, month, day)` date components.
-    ///
-    /// Does not check the validity of `year`, `month`, or `day`, but `year` is
-    /// truncated to 23 bits (% 8,388,608), `month` to 4 bits (% 16), and `day`
-    /// to 5 bits (% 32).
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Date;
-    ///
-    /// assert!(Date::from_ymd(2021, 7, 30).exactly("2021-07-30"));
-    /// assert!(Date::from_ymd(2010, 3, 23).exactly("2010-03-23"));
-    /// assert!(Date::from_ymd(2090, 1, 31).exactly("2090-01-31"));
-    ///
-    /// // Truncation: 33 % 32 == 0x21 & 0x1F == 1.
-    /// assert!(Date::from_ymd(2090, 1, 33).exactly("2090-01-01"));
-    /// ```
-    pub fn from_ymd(year: u16, month: u8, day: u8) -> Date {
-        let year = (year as u32) << 9;
-        let month = ((month as u32) & 0xF) << 5;
-        let day = (day as u32) & 0x1F;
-        Date(year | month | day)
-    }
-
-    /// Return the original (YYYY, MM, DD).
-    fn to_ymd(&self) -> (u16, u8, u8) {
-        let y = self.0 >> 9;
-        let m = (self.0 >> 5) & 0xF;
-        let d = self.0 & 0x1F;
-        (y as u16, m as u8, d as u8)
-    }
-
-    /// Returns `true` if `self` occurs on or after `date`.
-    ///
-    /// If `date` occurs before `self`, or if `date` is not in `%Y-%m-%d`
-    /// format, returns `false`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Date;
-    ///
-    /// let date = Date::parse("2020-01-01").unwrap();
-    ///
-    /// assert!(date.at_least("2019-12-31"));
-    /// assert!(date.at_least("2020-01-01"));
-    /// assert!(date.at_least("2014-04-31"));
-    ///
-    /// assert!(!date.at_least("2020-01-02"));
-    /// assert!(!date.at_least("2024-08-18"));
-    /// ```
-    pub fn at_least(&self, date: &str) -> bool {
-        Date::parse(date)
-            .map(|date| self >= &date)
-            .unwrap_or(false)
-    }
-
-    /// Returns `true` if `self` occurs on or before `date`.
-    ///
-    /// If `date` occurs after `self`, or if `date` is not in `%Y-%m-%d`
-    /// format, returns `false`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Date;
-    ///
-    /// let date = Date::parse("2020-01-01").unwrap();
-    ///
-    /// assert!(date.at_most("2020-01-01"));
-    /// assert!(date.at_most("2020-01-02"));
-    /// assert!(date.at_most("2024-08-18"));
-    ///
-    /// assert!(!date.at_most("2019-12-31"));
-    /// assert!(!date.at_most("2014-04-31"));
-    /// ```
-    pub fn at_most(&self, date: &str) -> bool {
-        Date::parse(date)
-            .map(|date| self <= &date)
-            .unwrap_or(false)
-    }
-
-    /// Returns `true` if `self` occurs exactly on `date`.
-    ///
-    /// If `date` is not exactly `self`, or if `date` is not in `%Y-%m-%d`
-    /// format, returns `false`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use version_check::Date;
-    ///
-    /// let date = Date::parse("2020-01-01").unwrap();
-    ///
-    /// assert!(date.exactly("2020-01-01"));
-    ///
-    /// assert!(!date.exactly("2019-12-31"));
-    /// assert!(!date.exactly("2014-04-31"));
-    /// assert!(!date.exactly("2020-01-02"));
-    /// assert!(!date.exactly("2024-08-18"));
-    /// ```
-    pub fn exactly(&self, date: &str) -> bool {
-        Date::parse(date)
-            .map(|date| self == &date)
-            .unwrap_or(false)
-    }
-}
-
-impl fmt::Display for Date {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let (y, m, d) = self.to_ymd();
-        write!(f, "{}-{:02}-{:02}", y, m, d)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Date;
-
-    macro_rules! reflexive_display {
-        ($string:expr) => (
-            assert_eq!(Date::parse($string).unwrap().to_string(), $string);
-        )
-    }
-
-    #[test]
-    fn display() {
-        reflexive_display!("2019-05-08");
-        reflexive_display!("2000-01-01");
-        reflexive_display!("2000-12-31");
-        reflexive_display!("2090-12-31");
-        reflexive_display!("1999-02-19");
-        reflexive_display!("9999-12-31");
-    }
-}