wasmtime 12.0.1 → 13.0.0

data/ext/cargo-vendor/humantime-2.1.0/src/duration.rs

@@ -1,456 +0,0 @@
-use std::error::Error as StdError;
-use std::fmt;
-use std::str::Chars;
-use std::time::Duration;
-
-/// Error parsing human-friendly duration
-#[derive(Debug, PartialEq, Clone)]
-pub enum Error {
-    /// Invalid character during parsing
-    ///
-    /// More specifically anything that is not alphanumeric is prohibited
-    ///
-    /// The field is an byte offset of the character in the string.
-    InvalidCharacter(usize),
-    /// Non-numeric value where number is expected
-    ///
-    /// This usually means that either time unit is broken into words,
-    /// e.g. `m sec` instead of `msec`, or just number is omitted,
-    /// for example `2 hours min` instead of `2 hours 1 min`
-    ///
-    /// The field is an byte offset of the errorneous character
-    /// in the string.
-    NumberExpected(usize),
-    /// Unit in the number is not one of allowed units
-    ///
-    /// See documentation of `parse_duration` for the list of supported
-    /// time units.
-    ///
-    /// The two fields are start and end (exclusive) of the slice from
-    /// the original string, containing errorneous value
-    UnknownUnit {
-        /// Start of the invalid unit inside the original string
-        start: usize,
-        /// End of the invalid unit inside the original string
-        end: usize,
-        /// The unit verbatim
-        unit: String,
-        /// A number associated with the unit
-        value: u64,
-    },
-    /// The numeric value is too large
-    ///
-    /// Usually this means value is too large to be useful. If user writes
-    /// data in subsecond units, then the maximum is about 3k years. When
-    /// using seconds, or larger units, the limit is even larger.
-    NumberOverflow,
-    /// The value was an empty string (or consists only whitespace)
-    Empty,
-}
-
-impl StdError for Error {}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Error::InvalidCharacter(offset) => write!(f, "invalid character at {}", offset),
-            Error::NumberExpected(offset) => write!(f, "expected number at {}", offset),
-            Error::UnknownUnit { unit, value, .. } if &unit == &"" => {
-                write!(f,
-                    "time unit needed, for example {0}sec or {0}ms",
-                    value,
-                )
-            }
-            Error::UnknownUnit { unit, .. } => {
-                write!(
-                    f,
-                    "unknown time unit {:?}, \
-                    supported units: ns, us, ms, sec, min, hours, days, \
-                    weeks, months, years (and few variations)",
-                    unit
-                )
-            }
-            Error::NumberOverflow => write!(f, "number is too large"),
-            Error::Empty => write!(f, "value was empty"),
-        }
-    }
-}
-
-/// A wrapper type that allows you to Display a Duration
-#[derive(Debug, Clone)]
-pub struct FormattedDuration(Duration);
-
-trait OverflowOp: Sized {
-    fn mul(self, other: Self) -> Result<Self, Error>;
-    fn add(self, other: Self) -> Result<Self, Error>;
-}
-
-impl OverflowOp for u64 {
-    fn mul(self, other: Self) -> Result<Self, Error> {
-        self.checked_mul(other).ok_or(Error::NumberOverflow)
-    }
-    fn add(self, other: Self) -> Result<Self, Error> {
-        self.checked_add(other).ok_or(Error::NumberOverflow)
-    }
-}
-
-struct Parser<'a> {
-    iter: Chars<'a>,
-    src: &'a str,
-    current: (u64, u64),
-}
-
-impl<'a> Parser<'a> {
-    fn off(&self) -> usize {
-        self.src.len() - self.iter.as_str().len()
-    }
-
-    fn parse_first_char(&mut self) -> Result<Option<u64>, Error> {
-        let off = self.off();
-        for c in self.iter.by_ref() {
-            match c {
-                '0'..='9' => {
-                    return Ok(Some(c as u64 - '0' as u64));
-                }
-                c if c.is_whitespace() => continue,
-                _ => {
-                    return Err(Error::NumberExpected(off));
-                }
-            }
-        }
-        Ok(None)
-    }
-    fn parse_unit(&mut self, n: u64, start: usize, end: usize)
-        -> Result<(), Error>
-    {
-        let (mut sec, nsec) = match &self.src[start..end] {
-            "nanos" | "nsec" | "ns" => (0u64, n),
-            "usec" | "us" => (0u64, n.mul(1000)?),
-            "millis" | "msec" | "ms" => (0u64, n.mul(1_000_000)?),
-            "seconds" | "second" | "secs" | "sec" | "s" => (n, 0),
-            "minutes" | "minute" | "min" | "mins" | "m"
-            => (n.mul(60)?, 0),
-            "hours" | "hour" | "hr" | "hrs" | "h" => (n.mul(3600)?, 0),
-            "days" | "day" | "d" => (n.mul(86400)?, 0),
-            "weeks" | "week" | "w" => (n.mul(86400*7)?, 0),
-            "months" | "month" | "M" => (n.mul(2_630_016)?, 0), // 30.44d
-            "years" | "year" | "y" => (n.mul(31_557_600)?, 0), // 365.25d
-            _ => {
-                return Err(Error::UnknownUnit {
-                    start, end,
-                    unit: self.src[start..end].to_string(),
-                    value: n,
-                });
-            }
-        };
-        let mut nsec = self.current.1.add(nsec)?;
-        if nsec > 1_000_000_000 {
-            sec = sec.add(nsec / 1_000_000_000)?;
-            nsec %= 1_000_000_000;
-        }
-        sec = self.current.0.add(sec)?;
-        self.current = (sec, nsec);
-        Ok(())
-    }
-
-    fn parse(mut self) -> Result<Duration, Error> {
-        let mut n = self.parse_first_char()?.ok_or(Error::Empty)?;
-        'outer: loop {
-            let mut off = self.off();
-            while let Some(c) = self.iter.next() {
-                match c {
-                    '0'..='9' => {
-                        n = n.checked_mul(10)
-                            .and_then(|x| x.checked_add(c as u64 - '0' as u64))
-                            .ok_or(Error::NumberOverflow)?;
-                    }
-                    c if c.is_whitespace() => {}
-                    'a'..='z' | 'A'..='Z' => {
-                        break;
-                    }
-                    _ => {
-                        return Err(Error::InvalidCharacter(off));
-                    }
-                }
-                off = self.off();
-            }
-            let start = off;
-            let mut off = self.off();
-            while let Some(c) = self.iter.next() {
-                match c {
-                    '0'..='9' => {
-                        self.parse_unit(n, start, off)?;
-                        n = c as u64 - '0' as u64;
-                        continue 'outer;
-                    }
-                    c if c.is_whitespace() => break,
-                    'a'..='z' | 'A'..='Z' => {}
-                    _ => {
-                        return Err(Error::InvalidCharacter(off));
-                    }
-                }
-                off = self.off();
-            }
-            self.parse_unit(n, start, off)?;
-            n = match self.parse_first_char()? {
-                Some(n) => n,
-                None => return Ok(
-                    Duration::new(self.current.0, self.current.1 as u32)),
-            };
-        }
-    }
-
-}
-
-/// Parse duration object `1hour 12min 5s`
-///
-/// The duration object is a concatenation of time spans. Where each time
-/// span is an integer number and a suffix. Supported suffixes:
-///
-/// * `nsec`, `ns` -- nanoseconds
-/// * `usec`, `us` -- microseconds
-/// * `msec`, `ms` -- milliseconds
-/// * `seconds`, `second`, `sec`, `s`
-/// * `minutes`, `minute`, `min`, `m`
-/// * `hours`, `hour`, `hr`, `h`
-/// * `days`, `day`, `d`
-/// * `weeks`, `week`, `w`
-/// * `months`, `month`, `M` -- defined as 30.44 days
-/// * `years`, `year`, `y` -- defined as 365.25 days
-///
-/// # Examples
-///
-/// ```
-/// use std::time::Duration;
-/// use humantime::parse_duration;
-///
-/// assert_eq!(parse_duration("2h 37min"), Ok(Duration::new(9420, 0)));
-/// assert_eq!(parse_duration("32ms"), Ok(Duration::new(0, 32_000_000)));
-/// ```
-pub fn parse_duration(s: &str) -> Result<Duration, Error> {
-    Parser {
-        iter: s.chars(),
-        src: s,
-        current: (0, 0),
-    }.parse()
-}
-
-/// Formats duration into a human-readable string
-///
-/// Note: this format is guaranteed to have same value when using
-/// parse_duration, but we can change some details of the exact composition
-/// of the value.
-///
-/// # Examples
-///
-/// ```
-/// use std::time::Duration;
-/// use humantime::format_duration;
-///
-/// let val1 = Duration::new(9420, 0);
-/// assert_eq!(format_duration(val1).to_string(), "2h 37m");
-/// let val2 = Duration::new(0, 32_000_000);
-/// assert_eq!(format_duration(val2).to_string(), "32ms");
-/// ```
-pub fn format_duration(val: Duration) -> FormattedDuration {
-    FormattedDuration(val)
-}
-
-fn item_plural(f: &mut fmt::Formatter, started: &mut bool,
-    name: &str, value: u64)
-    -> fmt::Result
-{
-    if value > 0 {
-        if *started {
-            f.write_str(" ")?;
-        }
-        write!(f, "{}{}", value, name)?;
-        if value > 1 {
-            f.write_str("s")?;
-        }
-        *started = true;
-    }
-    Ok(())
-}
-fn item(f: &mut fmt::Formatter, started: &mut bool, name: &str, value: u32)
-    -> fmt::Result
-{
-    if value > 0 {
-        if *started {
-            f.write_str(" ")?;
-        }
-        write!(f, "{}{}", value, name)?;
-        *started = true;
-    }
-    Ok(())
-}
-
-impl FormattedDuration {
-    /// Returns a reference to the [`Duration`][] that is being formatted.
-    pub fn get_ref(&self) -> &Duration {
-        &self.0
-    }
-}
-
-impl fmt::Display for FormattedDuration {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let secs = self.0.as_secs();
-        let nanos = self.0.subsec_nanos();
-
-        if secs == 0 && nanos == 0 {
-            f.write_str("0s")?;
-            return Ok(());
-        }
-
-        let years = secs / 31_557_600;  // 365.25d
-        let ydays = secs % 31_557_600;
-        let months = ydays / 2_630_016;  // 30.44d
-        let mdays = ydays % 2_630_016;
-        let days = mdays / 86400;
-        let day_secs = mdays % 86400;
-        let hours = day_secs / 3600;
-        let minutes = day_secs % 3600 / 60;
-        let seconds = day_secs % 60;
-
-        let millis = nanos / 1_000_000;
-        let micros = nanos / 1000 % 1000;
-        let nanosec = nanos % 1000;
-
-        let ref mut started = false;
-        item_plural(f, started, "year", years)?;
-        item_plural(f, started, "month", months)?;
-        item_plural(f, started, "day", days)?;
-        item(f, started, "h", hours as u32)?;
-        item(f, started, "m", minutes as u32)?;
-        item(f, started, "s", seconds as u32)?;
-        item(f, started, "ms", millis)?;
-        item(f, started, "us", micros)?;
-        item(f, started, "ns", nanosec)?;
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::time::Duration;
-
-    use rand::Rng;
-
-    use super::{parse_duration, format_duration};
-    use super::Error;
-
-    #[test]
-    #[allow(clippy::cognitive_complexity)]
-    fn test_units() {
-        assert_eq!(parse_duration("17nsec"), Ok(Duration::new(0, 17)));
-        assert_eq!(parse_duration("17nanos"), Ok(Duration::new(0, 17)));
-        assert_eq!(parse_duration("33ns"), Ok(Duration::new(0, 33)));
-        assert_eq!(parse_duration("3usec"), Ok(Duration::new(0, 3000)));
-        assert_eq!(parse_duration("78us"), Ok(Duration::new(0, 78000)));
-        assert_eq!(parse_duration("31msec"), Ok(Duration::new(0, 31_000_000)));
-        assert_eq!(parse_duration("31millis"), Ok(Duration::new(0, 31_000_000)));
-        assert_eq!(parse_duration("6ms"), Ok(Duration::new(0, 6_000_000)));
-        assert_eq!(parse_duration("3000s"), Ok(Duration::new(3000, 0)));
-        assert_eq!(parse_duration("300sec"), Ok(Duration::new(300, 0)));
-        assert_eq!(parse_duration("300secs"), Ok(Duration::new(300, 0)));
-        assert_eq!(parse_duration("50seconds"), Ok(Duration::new(50, 0)));
-        assert_eq!(parse_duration("1second"), Ok(Duration::new(1, 0)));
-        assert_eq!(parse_duration("100m"), Ok(Duration::new(6000, 0)));
-        assert_eq!(parse_duration("12min"), Ok(Duration::new(720, 0)));
-        assert_eq!(parse_duration("12mins"), Ok(Duration::new(720, 0)));
-        assert_eq!(parse_duration("1minute"), Ok(Duration::new(60, 0)));
-        assert_eq!(parse_duration("7minutes"), Ok(Duration::new(420, 0)));
-        assert_eq!(parse_duration("2h"), Ok(Duration::new(7200, 0)));
-        assert_eq!(parse_duration("7hr"), Ok(Duration::new(25200, 0)));
-        assert_eq!(parse_duration("7hrs"), Ok(Duration::new(25200, 0)));
-        assert_eq!(parse_duration("1hour"), Ok(Duration::new(3600, 0)));
-        assert_eq!(parse_duration("24hours"), Ok(Duration::new(86400, 0)));
-        assert_eq!(parse_duration("1day"), Ok(Duration::new(86400, 0)));
-        assert_eq!(parse_duration("2days"), Ok(Duration::new(172_800, 0)));
-        assert_eq!(parse_duration("365d"), Ok(Duration::new(31_536_000, 0)));
-        assert_eq!(parse_duration("1week"), Ok(Duration::new(604_800, 0)));
-        assert_eq!(parse_duration("7weeks"), Ok(Duration::new(4_233_600, 0)));
-        assert_eq!(parse_duration("52w"), Ok(Duration::new(31_449_600, 0)));
-        assert_eq!(parse_duration("1month"), Ok(Duration::new(2_630_016, 0)));
-        assert_eq!(parse_duration("3months"), Ok(Duration::new(3*2_630_016, 0)));
-        assert_eq!(parse_duration("12M"), Ok(Duration::new(31_560_192, 0)));
-        assert_eq!(parse_duration("1year"), Ok(Duration::new(31_557_600, 0)));
-        assert_eq!(parse_duration("7years"), Ok(Duration::new(7*31_557_600, 0)));
-        assert_eq!(parse_duration("17y"), Ok(Duration::new(536_479_200, 0)));
-    }
-
-    #[test]
-    fn test_combo() {
-        assert_eq!(parse_duration("20 min 17 nsec "), Ok(Duration::new(1200, 17)));
-        assert_eq!(parse_duration("2h 15m"), Ok(Duration::new(8100, 0)));
-    }
-
-    #[test]
-    fn all_86400_seconds() {
-        for second in 0..86400 {  // scan leap year and non-leap year
-            let d = Duration::new(second, 0);
-            assert_eq!(d,
-                parse_duration(&format_duration(d).to_string()).unwrap());
-        }
-    }
-
-    #[test]
-    fn random_second() {
-        for _ in 0..10000 {
-            let sec = rand::thread_rng().gen_range(0, 253_370_764_800);
-            let d = Duration::new(sec, 0);
-            assert_eq!(d,
-                parse_duration(&format_duration(d).to_string()).unwrap());
-        }
-    }
-
-    #[test]
-    fn random_any() {
-        for _ in 0..10000 {
-            let sec = rand::thread_rng().gen_range(0, 253_370_764_800);
-            let nanos = rand::thread_rng().gen_range(0, 1_000_000_000);
-            let d = Duration::new(sec, nanos);
-            assert_eq!(d,
-                parse_duration(&format_duration(d).to_string()).unwrap());
-        }
-    }
-
-    #[test]
-    fn test_overlow() {
-        // Overflow on subseconds is earlier because of how we do conversion
-        // we could fix it, but I don't see any good reason for this
-        assert_eq!(parse_duration("100000000000000000000ns"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("100000000000000000us"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("100000000000000ms"),
-            Err(Error::NumberOverflow));
-
-        assert_eq!(parse_duration("100000000000000000000s"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("10000000000000000000m"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("1000000000000000000h"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("100000000000000000d"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("10000000000000000w"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("1000000000000000M"),
-            Err(Error::NumberOverflow));
-        assert_eq!(parse_duration("10000000000000y"),
-            Err(Error::NumberOverflow));
-    }
-
-    #[test]
-    fn test_nice_error_message() {
-        assert_eq!(parse_duration("123").unwrap_err().to_string(),
-            "time unit needed, for example 123sec or 123ms");
-        assert_eq!(parse_duration("10 months 1").unwrap_err().to_string(),
-            "time unit needed, for example 1sec or 1ms");
-        assert_eq!(parse_duration("10nights").unwrap_err().to_string(),
-            "unknown time unit \"nights\", supported units: \
-            ns, us, ms, sec, min, hours, days, weeks, months, \
-            years (and few variations)");
-    }
-}

data/ext/cargo-vendor/humantime-2.1.0/src/lib.rs

@@ -1,34 +0,0 @@
-//! Human-friendly time parser and formatter
-//!
-//! Features:
-//!
-//! * Parses durations in free form like `15days 2min 2s`
-//! * Formats durations in similar form `2years 2min 12us`
-//! * Parses and formats timestamp in `rfc3339` format: `2018-01-01T12:53:00Z`
-//! * Parses timestamps in a weaker format: `2018-01-01 12:53:00`
-//!
-//! Timestamp parsing/formatting is super-fast because format is basically
-//! fixed.
-//!
-//! See [humantime-serde] for serde integration (previous crate [serde-humantime] looks unmaintained).
-//!
-//! [serde-humantime]: https://docs.rs/serde-humantime/0.1.1/serde_humantime/
-//! [humantime-serde]: https://docs.rs/humantime-serde
-
-#![forbid(unsafe_code)]
-#![warn(missing_debug_implementations)]
-#![warn(missing_docs)]
-
-mod duration;
-mod wrapper;
-mod date;
-
-pub use self::duration::{parse_duration, Error as DurationError};
-pub use self::duration::{format_duration, FormattedDuration};
-pub use self::wrapper::{Duration, Timestamp};
-pub use self::date::{parse_rfc3339, parse_rfc3339_weak, Error as TimestampError};
-pub use self::date::{
-    format_rfc3339, format_rfc3339_micros, format_rfc3339_millis, format_rfc3339_nanos,
-    format_rfc3339_seconds,
-};
-pub use self::date::{Rfc3339Timestamp};

data/ext/cargo-vendor/humantime-2.1.0/src/wrapper.rs

@@ -1,107 +0,0 @@
-use std::str::FromStr;
-use std::ops::Deref;
-use std::fmt;
-use std::time::{Duration as StdDuration, SystemTime};
-
-use crate::duration::{self, parse_duration, format_duration};
-use crate::date::{self, parse_rfc3339_weak, format_rfc3339};
-
-/// A wrapper for duration that has `FromStr` implementation
-///
-/// This is useful if you want to use it somewhere where `FromStr` is
-/// expected.
-///
-/// See `parse_duration` for the description of the format.
-///
-/// # Example
-///
-/// ```
-/// use std::time::Duration;
-/// let x: Duration;
-/// x = "12h 5min 2ns".parse::<humantime::Duration>().unwrap().into();
-/// assert_eq!(x, Duration::new(12*3600 + 5*60, 2))
-/// ```
-///
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
-pub struct Duration(StdDuration);
-
-/// A wrapper for SystemTime that has `FromStr` implementation
-///
-/// This is useful if you want to use it somewhere where `FromStr` is
-/// expected.
-///
-/// See `parse_rfc3339_weak` for the description of the format. The "weak"
-/// format is used as it's more pemissive for human input as this is the
-/// expected use of the type (e.g. command-line parsing).
-///
-/// # Example
-///
-/// ```
-/// use std::time::SystemTime;
-/// let x: SystemTime;
-/// x = "2018-02-16T00:31:37Z".parse::<humantime::Timestamp>().unwrap().into();
-/// assert_eq!(humantime::format_rfc3339(x).to_string(), "2018-02-16T00:31:37Z");
-/// ```
-///
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct Timestamp(SystemTime);
-
-impl AsRef<StdDuration> for Duration {
-    fn as_ref(&self) -> &StdDuration { &self.0 }
-}
-
-impl Deref for Duration {
-    type Target = StdDuration;
-    fn deref(&self) -> &StdDuration { &self.0 }
-}
-
-impl Into<StdDuration> for Duration {
-    fn into(self) -> StdDuration { self.0 }
-}
-
-impl From<StdDuration> for Duration {
-    fn from(dur: StdDuration) -> Duration { Duration(dur) }
-}
-
-impl FromStr for Duration {
-    type Err = duration::Error;
-    fn from_str(s: &str) -> Result<Duration, Self::Err> {
-        parse_duration(s).map(Duration)
-    }
-}
-
-impl fmt::Display for Duration {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_duration(self.0).fmt(f)
-    }
-}
-
-impl AsRef<SystemTime> for Timestamp {
-    fn as_ref(&self) -> &SystemTime { &self.0 }
-}
-
-impl Deref for Timestamp {
-    type Target = SystemTime;
-    fn deref(&self) -> &SystemTime { &self.0 }
-}
-
-impl Into<SystemTime> for Timestamp {
-    fn into(self) -> SystemTime { self.0 }
-}
-
-impl From<SystemTime> for Timestamp {
-    fn from(dur: SystemTime) -> Timestamp { Timestamp(dur) }
-}
-
-impl FromStr for Timestamp {
-    type Err = date::Error;
-    fn from_str(s: &str) -> Result<Timestamp, Self::Err> {
-        parse_rfc3339_weak(s).map(Timestamp)
-    }
-}
-
-impl fmt::Display for Timestamp {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_rfc3339(self.0).fmt(f)
-    }
-}

data/ext/cargo-vendor/humantime-2.1.0/vagga.yaml

@@ -1,92 +0,0 @@
-commands:
-
-  cargo: !Command
-    description: Run any cargo command
-    container: ubuntu
-    run: [cargo]
-
-  make: !Command
-    description: Build the library
-    container: ubuntu
-    run: [cargo, build]
-
-  test64: !Command
-    description: Test the 64bit library
-    container: ubuntu
-    environ: { RUST_BACKTRACE: 1 }
-    run: [cargo, test]
-
-  test32: !Command
-    description: Test the 32bit library
-    container: ubuntu32
-    environ: { RUST_BACKTRACE: 1 }
-    run: [cargo, test]
-
-  test: !Command
-    description: Test the 64bit library
-    container: ubuntu
-    environ: { RUST_BACKTRACE: 1 }
-    prerequisites: [test64, test32]
-    run: [echo, okay]
-
-  bench: !Command
-    description: Run benchmarks
-    container: bench
-    environ: { RUST_BACKTRACE: 1 }
-    run: [cargo, bench]
-
-  _bulk: !Command
-    description: Run `bulk` command (for version bookkeeping)
-    container: ubuntu
-    run: [bulk]
-
-containers:
-
-  ubuntu:
-    setup:
-    - !Ubuntu xenial
-    - !UbuntuUniverse
-    - !Install [ca-certificates, build-essential, vim]
-
-    - !TarInstall
-      url: "https://static.rust-lang.org/dist/rust-1.31.0-x86_64-unknown-linux-gnu.tar.gz"
-      script: "./install.sh --prefix=/usr \
-               --components=rustc,rust-std-x86_64-unknown-linux-gnu,cargo"
-    - &bulk !Tar
-      url: "https://github.com/tailhook/bulk/releases/download/v0.4.10/bulk-v0.4.10.tar.gz"
-      sha256: 481513f8a0306a9857d045497fb5b50b50a51e9ff748909ecf7d2bda1de275ab
-      path: /
-
-    environ:
-      HOME: /work/target
-      USER: pc
-
-  ubuntu32:
-    setup:
-    - !UbuntuRelease
-      codename: xenial
-      arch: i386
-    - !UbuntuUniverse
-    - !Install [ca-certificates, build-essential, vim]
-
-    - !TarInstall
-      url: "https://static.rust-lang.org/dist/rust-1.31.0-i686-unknown-linux-gnu.tar.gz"
-      script: "./install.sh --prefix=/usr \
-               --components=rustc,rust-std-i686-unknown-linux-gnu,cargo"
-
-    environ:
-      HOME: /work/target
-      USER: pc
-
-  bench:
-    setup:
-    - !Ubuntu xenial
-    - !Install [ca-certificates, wget, build-essential]
-    - !TarInstall
-      url: https://static.rust-lang.org/dist/rust-nightly-x86_64-unknown-linux-gnu.tar.gz
-      script: |
-        ./install.sh --prefix=/usr \
-          --components=rustc,rust-std-x86_64-unknown-linux-gnu,cargo
-    environ:
-      HOME: /work/target
-      USER: pc

data/ext/cargo-vendor/indexmap-1.9.3/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"1290d383adfdcd24f158a4619afb5547d633c83c0a1ab3b5c1ee0dabe4fb1f36","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"ecc269ef87fd38a1d98e30bfac9ba964a9dbd9315c3770fed98d4d7cb5882055","README.md":"f8b02aa7c20fc0f5bc13de9e9e78899ec8cdbc16c2db880a1d0bc14c25b07542","RELEASES.md":"85d9d9bc78e94df7ce90300bb94099b9ab2696d1b3f6b815c22761522878e679","benches/bench.rs":"3b2900abbc9e8a60af78b0395222ee75e86bc68519a0f38477387d1572eed397","benches/faststring.rs":"5fdd6cdb19d0557ed58f241e809a240cf8939d9e5b87a72d5f127f81ab98380b","build.rs":"558b4d0b9e9b3a44f7e1a2b69f7a7567ea721cd45cb54f4e458e850bf702f35c","src/arbitrary.rs":"bb8bda10f686abe57eef1446d3fc3fc6fb251f95629b28c20e620a4838c43db8","src/equivalent.rs":"2e6ae24ef09a09b917f4e2b0f6288f901878e42f5080f61b1bd1afdcc90aba87","src/lib.rs":"ea2cbe4f6cc2c4a75f42c9fc936503e6bee0f136c60f6811a2a9907ed8886443","src/macros.rs":"80c22f630e7f81e6fa663ca4c9e50cf5f332c8905d72d1338bd16f24eb353c2a","src/map.rs":"2e9cbfa240865cfd6b6b972bdbdb39283e6302dd2d0d72b3c2bfce4414bf5729","src/map/core.rs":"8422cd774c5db7d83cdeb0c5836c10f29caa1bee8d95b0d674b01b32e7ce80d8","src/map/core/raw.rs":"4e5fac4fecccc352268351d8b1f82b345067b5c029bba7e6ab88e8f8bc799c6a","src/mutable_keys.rs":"a919065b59000286eb11c7d46f6896bf0a1d484c9dac5e61d80bb8990c9fbedb","src/rayon/map.rs":"1a508c7c95c5d56113b851f7ce140d62ad541f1c6129352a7ec62d5bea7af4a1","src/rayon/mod.rs":"019e9379ccab57a299ab5b5a2c0efc7561b77a715a5afe8f797c7e8330c6206c","src/rayon/set.rs":"ba00e88e90fb7ab803589f99f24b595d60309e541aae3d01fdde21bff3840194","src/rustc.rs":"fe7a348c5a10a66880cb6c737593fe79d3b6de40f44ba0d7b89204aa95e14a3a","src/serde.rs":"d45ec8fb9c02594ca6f2e9b20764778b2b4193a24a52f1e233160a33efc6e683","src/serde_seq.rs":"c54a52fa607b6ccddda1e76e829778ca304c49b5f434edc5e582a5386c35d662","src/set.rs":"0a57affb623fa6b28df18cc14841e4f076cbd1da5c809635d202f865640af1ee","src/util.rs":"ab712bce71b54cf2763e6010e64bb5944d1d59ce15e2f2beffa7ceed204d6a68","tests/equivalent_trait.rs":"efe9393069e3cfc893d2c9c0343679979578e437fdb98a10baefeced027ba310","tests/macros_full_path.rs":"c33c86d7341581fdd08e2e6375a4afca507fa603540c54a3b9e51c4cd011cd71","tests/quick.rs":"1addbc6cbcb1aae5b8bde0fb0e18197d947e8f13244e4ae7ebf97bdda00eafea","tests/tests.rs":"f6dbeeb0e2950402b0e66ac52bf74c9e4197d3c5d9c0dde64a7998a2ef74d327"},"package":"bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"}