move Point and Interpolate to database crate

Author: s7tya

site/src/interpolate.rs renamed to database/src/interpolate.rs

@@ -10,7 +10,7 @@
 //! Given a series with some missing data `[1, 2, ?, 4]`,
 //! this iterator yields `[1, 2, 2, 4]`.
 
-use crate::db::Point;
+use crate::selector::Point;
 
 /// Whether a point has been interpolated or not
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]

database/src/lib.rs

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

database/src/selector.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use crate::{ArtifactId, ArtifactIdIter};
 
 #[derive(Debug)]
@@ -16,3 +18,60 @@ impl Iterator for StatisticSeries {
         self.artifact_ids.size_hint()
     }
 }
+
+pub trait Point {
+    type Key: fmt::Debug + PartialEq + Clone;
+
+    fn key(&self) -> &Self::Key;
+    fn set_key(&mut self, key: Self::Key);
+    fn value(&self) -> Option<f64>;
+    fn set_value(&mut self, value: f64);
+    fn interpolated(&self) -> bool;
+    fn set_interpolated(&mut self);
+}
+
+impl<T: Clone + PartialEq + fmt::Debug> Point for (T, Option<f64>) {
+    type Key = T;
+
+    fn key(&self) -> &T {
+        &self.0
+    }
+    fn set_key(&mut self, key: T) {
+        self.0 = key;
+    }
+    fn value(&self) -> Option<f64> {
+        self.1
+    }
+    fn set_value(&mut self, value: f64) {
+        self.1 = Some(value);
+    }
+    fn interpolated(&self) -> bool {
+        false
+    }
+    fn set_interpolated(&mut self) {
+        // no-op
+    }
+}
+
+impl<T: Clone + PartialEq + fmt::Debug> Point for (T, f64) {
+    type Key = T;
+
+    fn key(&self) -> &T {
+        &self.0
+    }
+    fn set_key(&mut self, key: T) {
+        self.0 = key;
+    }
+    fn value(&self) -> Option<f64> {
+        Some(self.1)
+    }
+    fn set_value(&mut self, value: f64) {
+        self.1 = value;
+    }
+    fn interpolated(&self) -> bool {
+        false
+    }
+    fn set_interpolated(&mut self) {
+        // no-op
+    }
+}

site/src/average.rs

@@ -1,4 +1,4 @@
-use crate::db::Point;
+use database::selector::Point;
 
 /// This aggregates interpolated iterators.
 ///
@@ -80,12 +80,13 @@ where
 
 #[cfg(test)]
 mod tests {
+    use database::selector::Point;
+
     use super::average;
 
     #[test]
     fn test_no_interpolation_average() {
         // Test that averaging works without interpolation.
-        use crate::db::Point;
 
         let v = vec![
             vec![("a", 0.0), ("b", 200.0)],
@@ -109,8 +110,7 @@ mod tests {
     #[test]
     fn test_interpolation_average() {
         // Test that averaging works with interpolation.
-        use crate::db::Point;
-        use crate::interpolate::{Interpolate, IsInterpolated};
+        use database::interpolate::{Interpolate, IsInterpolated};
 
         let v = vec![
             vec![("a", Some(0.0)), ("b", Some(200.0))],

site/src/db.rs

@@ -1,61 +1,2 @@
-use std::fmt;
-
 pub use crate::average::average;
 pub use database::*;
-
-pub trait Point {
-    type Key: fmt::Debug + PartialEq + Clone;
-
-    fn key(&self) -> &Self::Key;
-    fn set_key(&mut self, key: Self::Key);
-    fn value(&self) -> Option<f64>;
-    fn set_value(&mut self, value: f64);
-    fn interpolated(&self) -> bool;
-    fn set_interpolated(&mut self);
-}
-
-impl<T: Clone + PartialEq + fmt::Debug> Point for (T, Option<f64>) {
-    type Key = T;
-
-    fn key(&self) -> &T {
-        &self.0
-    }
-    fn set_key(&mut self, key: T) {
-        self.0 = key;
-    }
-    fn value(&self) -> Option<f64> {
-        self.1
-    }
-    fn set_value(&mut self, value: f64) {
-        self.1 = Some(value);
-    }
-    fn interpolated(&self) -> bool {
-        false
-    }
-    fn set_interpolated(&mut self) {
-        // no-op
-    }
-}
-
-impl<T: Clone + PartialEq + fmt::Debug> Point for (T, f64) {
-    type Key = T;
-
-    fn key(&self) -> &T {
-        &self.0
-    }
-    fn set_key(&mut self, key: T) {
-        self.0 = key;
-    }
-    fn value(&self) -> Option<f64> {
-        Some(self.1)
-    }
-    fn set_value(&mut self, value: f64) {
-        self.1 = value;
-    }
-    fn interpolated(&self) -> bool {
-        false
-    }
-    fn set_interpolated(&mut self) {
-        // no-op
-    }
-}

site/src/lib.rs

@@ -10,7 +10,6 @@ pub mod server;
 mod average;
 mod benchmark_metadata;
 mod comparison;
-mod interpolate;
 mod request_handlers;
 mod resources;
 mod selector;

site/src/request_handlers/graph.rs

@@ -7,13 +7,14 @@ use crate::api::detail_sections::CompilationSections;
 use crate::api::graphs::GraphKind;
 use crate::api::{detail_graphs, detail_sections, graphs, runtime_detail_graphs, ServerResult};
 use crate::db::{self, ArtifactId, Profile, Scenario};
-use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
 use crate::selector::{
     CompileBenchmarkQuery, CompileTestCase, RuntimeBenchmarkQuery, Selector, SeriesResponse,
 };
 use crate::self_profile::get_or_download_self_profile;
 
+use database::interpolate::IsInterpolated;
+
 /// 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

@@ -22,13 +22,13 @@
 //! there are multiple `None`s.
 
 use crate::db::{ArtifactId, Profile, Scenario};
-use crate::interpolate::Interpolate;
 use crate::load::SiteCtxt;
 
 use collector::Bound;
+use database::interpolate::Interpolate;
 use database::selector::StatisticSeries;
 use database::ArtifactIdIter;
-use database::{Benchmark, CodegenBackend, Commit, Connection, Index, Lookup};
+use database::{selector::Point, Benchmark, CodegenBackend, Commit, Connection, Index, Lookup};
 
 use crate::comparison::Metric;
 use async_trait::async_trait;
@@ -149,7 +149,7 @@ impl<TestCase, T> SeriesResponse<TestCase, T> {
     pub fn interpolate(self) -> SeriesResponse<TestCase, Interpolate<T>>
     where
         T: Iterator,
-        T::Item: crate::db::Point,
+        T::Item: Point,
     {
         self.map(|s| Interpolate::new(s))
     }