move Bound to database crate

Author: s7tya

collector/src/lib.rs

@@ -1,8 +1,6 @@
-use chrono::NaiveDate;
 pub use database::{Commit, PatchName, QueryLabel};
 use serde::Deserialize;
 use std::cmp::PartialOrd;
-use std::fmt;
 use std::process::{self, Command};
 
 pub mod api;
@@ -23,94 +21,6 @@ use std::time::{Duration, Instant};
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Deserialize)]
 pub struct DeltaTime(#[serde(with = "round_float")] pub f64);
 
-/// The bound for finding an artifact
-///
-/// This can either be the upper or lower bound.
-/// In the case of commits or tags this is an exact bound, but for dates
-/// it's a best effort (i.e., if the bound is a date but there are no artifacts
-/// for that date, we'll find the artifact that most closely matches).
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub enum Bound {
-    /// An unverified git commit (in sha form) or a tag of a commit (e.g., "1.53.0")
-    Commit(String),
-    /// A date in time
-    Date(NaiveDate),
-    /// No bound
-    #[default]
-    None,
-}
-
-impl Bound {
-    /// Tests whether `self` matches commit when searching from the left
-    pub fn left_match(&self, commit: &Commit) -> bool {
-        match self {
-            Bound::Commit(sha) => commit.sha == **sha,
-            Bound::Date(date) => commit.is_master() && commit.date.0.naive_utc().date() >= *date,
-            Bound::None => {
-                let last_month = chrono::Utc::now().date_naive() - chrono::Duration::days(30);
-                commit.is_master() && last_month <= commit.date.0.naive_utc().date()
-            }
-        }
-    }
-
-    /// Tests whether `self` matches commit when searching from the right
-    pub fn right_match(&self, commit: &Commit) -> bool {
-        match self {
-            Bound::Commit(sha) => commit.sha == **sha,
-            Bound::Date(date) => commit.is_master() && commit.date.0.date_naive() <= *date,
-            Bound::None => commit.is_master(),
-        }
-    }
-}
-
-impl serde::Serialize for Bound {
-    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        let s = match *self {
-            Bound::Commit(ref s) => s.clone(),
-            Bound::Date(ref date) => date.format("%Y-%m-%d").to_string(),
-            Bound::None => String::new(),
-        };
-        serializer.serialize_str(&s)
-    }
-}
-
-impl<'de> Deserialize<'de> for Bound {
-    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Bound, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        struct BoundVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for BoundVisitor {
-            type Value = Bound;
-
-            fn visit_str<E>(self, value: &str) -> ::std::result::Result<Bound, E>
-            where
-                E: serde::de::Error,
-            {
-                if value.is_empty() {
-                    return Ok(Bound::None);
-                }
-
-                let bound = value
-                    .parse::<chrono::NaiveDate>()
-                    .map(Bound::Date)
-                    .unwrap_or(Bound::Commit(value.to_string()));
-                Ok(bound)
-            }
-
-            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                f.write_str("either a YYYY-mm-dd date or a collection ID (usually commit hash)")
-            }
-        }
-
-        deserializer.deserialize_str(BoundVisitor)
-    }
-}
-
 pub fn null_means_nan<'de, D>(deserializer: D) -> ::std::result::Result<f64, D::Error>
 where
     D: serde::de::Deserializer<'de>,

database/src/lib.rs

@@ -9,6 +9,7 @@ use std::ops::{Add, Sub};
 use std::time::Duration;
 
 pub mod pool;
+pub mod selector;
 
 pub use pool::{Connection, Pool};
 

database/src/selector.rs

@@ -0,0 +1,94 @@
+use std::fmt;
+
+use chrono::NaiveDate;
+use serde::Deserialize;
+
+use crate::Commit;
+
+/// The bound for finding an artifact
+///
+/// This can either be the upper or lower bound.
+/// In the case of commits or tags this is an exact bound, but for dates
+/// it's a best effort (i.e., if the bound is a date but there are no artifacts
+/// for that date, we'll find the artifact that most closely matches).
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub enum Bound {
+    /// An unverified git commit (in sha form) or a tag of a commit (e.g., "1.53.0")
+    Commit(String),
+    /// A date in time
+    Date(NaiveDate),
+    /// No bound
+    #[default]
+    None,
+}
+
+impl Bound {
+    /// Tests whether `self` matches commit when searching from the left
+    pub fn left_match(&self, commit: &Commit) -> bool {
+        match self {
+            Bound::Commit(sha) => commit.sha == **sha,
+            Bound::Date(date) => commit.is_master() && commit.date.0.naive_utc().date() >= *date,
+            Bound::None => {
+                let last_month = chrono::Utc::now().date_naive() - chrono::Duration::days(30);
+                commit.is_master() && last_month <= commit.date.0.naive_utc().date()
+            }
+        }
+    }
+
+    /// Tests whether `self` matches commit when searching from the right
+    pub fn right_match(&self, commit: &Commit) -> bool {
+        match self {
+            Bound::Commit(sha) => commit.sha == **sha,
+            Bound::Date(date) => commit.is_master() && commit.date.0.date_naive() <= *date,
+            Bound::None => commit.is_master(),
+        }
+    }
+}
+
+impl serde::Serialize for Bound {
+    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        let s = match *self {
+            Bound::Commit(ref s) => s.clone(),
+            Bound::Date(ref date) => date.format("%Y-%m-%d").to_string(),
+            Bound::None => String::new(),
+        };
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for Bound {
+    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Bound, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        struct BoundVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for BoundVisitor {
+            type Value = Bound;
+
+            fn visit_str<E>(self, value: &str) -> ::std::result::Result<Bound, E>
+            where
+                E: serde::de::Error,
+            {
+                if value.is_empty() {
+                    return Ok(Bound::None);
+                }
+
+                let bound = value
+                    .parse::<chrono::NaiveDate>()
+                    .map(Bound::Date)
+                    .unwrap_or(Bound::Commit(value.to_string()));
+                Ok(bound)
+            }
+
+            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("either a YYYY-mm-dd date or a collection ID (usually commit hash)")
+            }
+        }
+
+        deserializer.deserialize_str(BoundVisitor)
+    }
+}

site/src/api.rs

@@ -81,7 +81,7 @@ pub mod dashboard {
 
 pub mod graph {
     use super::graphs::{GraphKind, Series};
-    use collector::Bound;
+    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -102,7 +102,7 @@ pub mod graph {
 }
 
 pub mod graphs {
-    use collector::Bound;
+    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
     use std::collections::{HashMap, HashSet};
 
@@ -147,7 +147,7 @@ pub mod graphs {
 pub mod detail_graphs {
     use crate::api::graphs::{GraphKind, Series};
     use crate::api::vec_from_comma_separated;
-    use collector::Bound;
+    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -170,7 +170,7 @@ pub mod detail_graphs {
 }
 
 pub mod detail_sections {
-    use collector::Bound;
+    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -207,7 +207,7 @@ pub mod detail_sections {
 pub mod runtime_detail_graphs {
     use crate::api::graphs::{GraphKind, Series};
     use crate::api::vec_from_comma_separated;
-    use collector::Bound;
+    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -228,7 +228,7 @@ pub mod runtime_detail_graphs {
 }
 
 pub mod bootstrap {
-    use collector::Bound;
+    use database::selector::Bound;
     use hashbrown::HashMap;
     use serde::{Deserialize, Serialize};
 
@@ -253,8 +253,7 @@ pub mod bootstrap {
 pub mod comparison {
     use crate::benchmark_metadata::ProfileMetadata;
     use crate::comparison::Metric;
-    use collector::Bound;
-    use database::Date;
+    use database::{selector::Bound, Date};
     use serde::{Deserialize, Serialize};
     use std::collections::HashMap;
 
@@ -596,7 +595,7 @@ pub mod github {
 
 pub mod triage {
     use crate::comparison::Metric;
-    use collector::Bound;
+    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, Clone, Serialize, Deserialize)]

site/src/comparison.rs

@@ -11,14 +11,13 @@ use crate::selector::{
 };
 
 use collector::compile::benchmark::category::Category;
-use collector::Bound;
 use serde::{Deserialize, Serialize};
 
 use crate::api::comparison::CompileBenchmarkMetadata;
 use crate::benchmark_metadata::get_compile_benchmarks_metadata;
 use crate::server::comparison::StatComparison;
 use collector::compile::benchmark::ArtifactType;
-use database::{CodegenBackend, CommitType, CompileBenchmark};
+use database::{selector::Bound, CodegenBackend, CommitType, CompileBenchmark};
 use serde::de::IntoDeserializer;
 use std::cmp;
 use std::collections::{HashMap, HashSet};

site/src/github/comparison_summary.rs

@@ -4,6 +4,7 @@ use crate::comparison::{
 };
 use crate::load::SiteCtxt;
 
+use database::selector::Bound;
 use database::{ArtifactId, QueuedCommit};
 
 use crate::github::{COMMENT_MARK_ROLLUP, COMMENT_MARK_TEMPORARY, RUST_REPO_GITHUB_API_URL};
@@ -132,8 +133,8 @@ async fn calculate_metric_comparison(
     metric: Metric,
 ) -> Result<ArtifactComparison, String> {
     match crate::comparison::compare(
-        collector::Bound::Commit(commit.parent_sha.clone()),
-        collector::Bound::Commit(commit.sha.clone()),
+        Bound::Commit(commit.parent_sha.clone()),
+        Bound::Commit(commit.sha.clone()),
         metric,
         ctxt,
     )

site/src/load.rs

@@ -6,6 +6,7 @@ use std::time::Instant;
 
 use arc_swap::{ArcSwap, Guard};
 use chrono::{Duration, Utc};
+use database::selector::Bound;
 use lazy_static::lazy_static;
 use log::error;
 use parking_lot::Mutex;
@@ -15,7 +16,7 @@ use serde::{Deserialize, Serialize};
 use crate::db;
 use crate::self_profile::SelfProfileCache;
 use collector::compile::benchmark::category::Category;
-use collector::{Bound, MasterCommit};
+use collector::MasterCommit;
 use database::Pool;
 pub use database::{ArtifactId, Benchmark, Commit};
 use database::{CommitType, Date};

site/src/request_handlers/graph.rs

@@ -1,8 +1,6 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use collector::Bound;
-
 use crate::api::detail_sections::CompilationSections;
 use crate::api::graphs::GraphKind;
 use crate::api::{detail_graphs, detail_sections, graphs, runtime_detail_graphs, ServerResult};
@@ -14,6 +12,8 @@ use crate::selector::{
 };
 use crate::self_profile::get_or_download_self_profile;
 
+use database::selector::Bound;
+
 /// Returns data for before/after graphs when comparing a single test result comparison
 /// for a compile-time benchmark.
 pub async fn handle_compile_detail_graphs(

site/src/selector.rs

@@ -25,8 +25,7 @@ use crate::db::{ArtifactId, Profile, Scenario};
 use crate::interpolate::Interpolate;
 use crate::load::SiteCtxt;
 
-use collector::Bound;
-use database::{Benchmark, CodegenBackend, Commit, Connection, Index, Lookup};
+use database::{selector::Bound, Benchmark, CodegenBackend, Commit, Connection, Index, Lookup};
 
 use crate::comparison::Metric;
 use async_trait::async_trait;