1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Availability evaluation tools.

use chrono::NaiveDate;
use manifest::Manifest;
use std::borrow::Borrow;
use std::collections::{HashMap, HashSet};

type PackageName = String;
type TargetTripple = String;
type DatesSet = HashSet<NaiveDate>;
type PackagesAvailability = HashMap<PackageName, DatesSet>;

/// Data about packages availability in rust builds.
#[derive(Debug, Default)]
pub struct AvailabilityData {
    data: HashMap<TargetTripple, PackagesAvailability>,
}

impl AvailabilityData {
    /// Adds an availability data from a given [`Manifest`].
    pub fn add_manifest(&mut self, manifest: Manifest) {
        for (package_name, info) in manifest.packages {
            for (target_tripple, target_info) in info.targets {
                let package_set = self
                    .data
                    .entry(target_tripple.clone())
                    .or_default()
                    .entry(package_name.clone())
                    .or_default();
                if target_info.available {
                    package_set.insert(manifest.date);
                }
            }
        }
    }

    /// Adds multiple [`Manifest`]s at once.
    pub fn add_manifests(&mut self, manifests: impl IntoIterator<Item = Manifest>) {
        manifests
            .into_iter()
            .for_each(|manifest| self.add_manifest(manifest));
    }

    /// Gets a list of targets that have been extracted from manifest files except for the '*'
    /// target.
    pub fn get_available_targets(&self) -> HashSet<&'_ str> {
        self.data
            .keys()
            .filter(|target| target != &"*")
            .map(AsRef::as_ref)
            .collect()
    }

    /// Returns all available packages throughout all the targets and all the times.
    pub fn get_available_packages<'a>(&'a self) -> HashSet<&'a str> {
        self.data
            .iter()
            .flat_map(|(_, per_target)| per_target.keys())
            .map(AsRef::as_ref)
            .collect()
    }

    /// Makes an iterator that maps given dates to `true` or `false`, depending on whether or not the
    /// given package is available on a given moment.
    ///
    /// Availability is checked against the specified target and against the `*` target.
    pub fn get_availability_row<I>(&self, target: &str, pkg: &str, dates: I) -> Vec<bool>
    where
        I: IntoIterator,
        I::Item: Borrow<NaiveDate>,
    {
        let available_on_target = self.data.get(target).and_then(|packages| packages.get(pkg));
        let available_on_wildcard = self.data.get("*").and_then(|packages| packages.get(pkg));
        let available_dates: HashSet<&NaiveDate> =
            match (available_on_target, available_on_wildcard) {
                (Some(x), Some(y)) => x.union(y).collect(),
                (Some(x), None) | (None, Some(x)) => x.iter().collect(),
                (None, None) => HashSet::new(),
            };
        dates
            .into_iter()
            .map(|date| available_dates.contains(date.borrow()))
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use manifest::Manifest;
    use toml;

    #[test]
    fn check() {
        let data = r#"date = "2018-09-03"
[pkg.rust-src.target."*"]
available = true
[pkg.ahaha.target.lol]
available = true
"#;
        let parsed_manifest: Manifest = toml::from_str(data).unwrap();
        let mut availability: AvailabilityData = Default::default();
        availability.add_manifest(parsed_manifest);
        let all_packages = availability.get_available_packages();
        assert_eq!(2, all_packages.len());
        assert!(all_packages.contains("rust-src"));
        assert!(all_packages.contains("ahaha"));

        let all_targets = availability.get_available_targets();
        // The *wildcard* target is ignored here.
        assert_eq!(1, all_targets.len());
        assert!(all_targets.contains("lol"));

        let package_exists = availability.get_availability_row(
            "*",
            "rust-src",
            vec![NaiveDate::from_ymd(2018, 9, 3)],
        );
        assert_eq!(vec!(true), package_exists);
        let package_exists = availability.get_availability_row(
            "lol",
            "rust-src",
            vec![NaiveDate::from_ymd(2018, 9, 3)],
        );
        assert_eq!(vec!(true), package_exists);
        let package_exists = availability.get_availability_row(
            "lol",
            "ahaha",
            vec![NaiveDate::from_ymd(2018, 9, 3)],
        );
        assert_eq!(vec!(true), package_exists);
    }
}