Merge NoopCache and FsCache

Author: Mark-Simulacrum

Cargo.lock

@@ -13,7 +13,6 @@ edition = "2018"
 [dependencies]
 chrono = { version = "0.4.6", features = [ "serde" ] }
 derive_more = "0.14.0"
-either = "1.5.0"
 thiserror = "1"
 log = "0.4.5"
 reqwest = { version = "0.10.0", features = ["blocking"] }

library/Cargo.toml

@@ -2,55 +2,14 @@
 
 use crate::{manifest::Manifest, Error};
 use chrono::NaiveDate;
-use either::Either;
 use std::{
     fs,
     path::{Path, PathBuf},
 };
 
-/// A cache trait.
-pub trait Cache {
-    /// Tries to load a manifest from a cached file.
-    fn get(&self, day: NaiveDate) -> Option<Manifest>;
-
-    /// Stores a manifest to the disk.
-    fn store(&self, manifest: &Manifest);
-}
-
-impl<L, R> Cache for Either<L, R>
-where
-    L: Cache,
-    R: Cache,
-{
-    fn get(&self, day: NaiveDate) -> Option<Manifest> {
-        match self {
-            Either::Left(x) => x.get(day),
-            Either::Right(x) => x.get(day),
-        }
-    }
-
-    fn store(&self, manifest: &Manifest) {
-        match self {
-            Either::Left(x) => x.store(manifest),
-            Either::Right(x) => x.store(manifest),
-        }
-    }
-}
-
-/// A cache that does nothing.
-pub struct NoopCache {}
-
-impl Cache for NoopCache {
-    fn get(&self, _day: NaiveDate) -> Option<Manifest> {
-        None
-    }
-
-    fn store(&self, _manifest: &Manifest) {}
-}
-
 /// A cache that stores manifests on a file system.
 pub struct FsCache {
-    storage_path: PathBuf,
+    storage_path: Option<PathBuf>,
 }
 
 impl FsCache {
@@ -63,18 +22,29 @@ impl FsCache {
             fs::create_dir_all(path).map_err(|e| (e, format!("creating path {:?}", path)))?;
         }
         Ok(FsCache {
-            storage_path: path.into(),
+            storage_path: Some(path.into()),
         })
     }
 
+    /// Initializes a no-op cache.
+    pub fn noop() -> Self {
+        FsCache { storage_path: None }
+    }
+
     fn make_file_name(&self, day: NaiveDate) -> PathBuf {
         self.storage_path
+            .as_ref()
+            .unwrap()
             .join(day.format("%Y-%m-%d.toml").to_string())
     }
 }
 
-impl Cache for FsCache {
-    fn get(&self, day: NaiveDate) -> Option<Manifest> {
+impl FsCache {
+    pub(crate) fn get(&self, day: NaiveDate) -> Option<Manifest> {
+        if self.storage_path.is_none() {
+            return None;
+        }
+
         let file_name = self.make_file_name(day);
         if !file_name.exists() {
             log::debug!("File {:?} doesn't exist", file_name);
@@ -85,7 +55,11 @@ impl Cache for FsCache {
             .ok()
     }
 
-    fn store(&self, manifest: &Manifest) {
+    pub(crate) fn store(&self, manifest: &Manifest) {
+        if self.storage_path.is_none() {
+            return;
+        }
+
         let file_name = self.make_file_name(manifest.date);
         match manifest.save_to_file(&file_name) {
             Ok(_) => log::debug!("Manifest stored at {:?}", file_name),

library/src/cache.rs

@@ -1,6 +1,6 @@
 use super::skip_errors::SkipMissingExt;
 use crate::{
-    cache::{Cache, NoopCache},
+    cache::FsCache,
     manifest::Manifest,
     source::{DefaultSource, SourceInfo},
     Error,
@@ -9,10 +9,10 @@ use chrono::{Duration, NaiveDate};
 use std::{io, iter};
 
 /// Manifests downloader and parser.
-pub struct Downloader<S, C = NoopCache> {
+pub struct Downloader<S> {
     client: reqwest::blocking::Client,
     source: S,
-    cache: C,
+    cache: FsCache,
     skip_missing_days: usize,
 }
 
@@ -29,19 +29,18 @@ impl<S> Downloader<S> {
         Downloader {
             client: reqwest::blocking::Client::new(),
             source,
-            cache: NoopCache {},
+            cache: FsCache::noop(),
             skip_missing_days: 0,
         }
     }
 }
 
-impl<S, C> Downloader<S, C>
+impl<S> Downloader<S>
 where
     S: SourceInfo,
-    C: Cache,
 {
     /// Sets a cache for the downloader. By default a [`NoopCache`] is used.
-    pub fn set_cache<NewCache: Cache>(self, c: NewCache) -> Downloader<S, NewCache> {
+    pub fn set_cache(self, c: FsCache) -> Downloader<S> {
         Downloader {
             client: self.client,
             source: self.source,
@@ -55,7 +54,7 @@ where
     /// Please not that this setting only affects the [`get_last_manifests`] method.
     ///
     /// Off (zero) by default.
-    pub fn skip_missing_days(self, skip: usize) -> Downloader<S, C> {
+    pub fn skip_missing_days(self, skip: usize) -> Downloader<S> {
         Downloader {
             client: self.client,
             source: self.source,

library/src/downloader.rs

@@ -6,7 +6,6 @@ edition = "2018"
 
 [dependencies]
 chrono = "0.4.6"
-either = "1.5.0"
 anyhow = "1"
 handlebars = "1.0.3"
 itertools = "0.8.0"

web/Cargo.toml

@@ -3,15 +3,10 @@ mod tiers_table;
 
 use anyhow::Context;
 use chrono::{NaiveDate, Utc};
-use either::Either;
 use handlebars::{handlebars_helper, Handlebars};
 use itertools::{Itertools, Position};
 use opts::Config;
-use rustup_available_packages::{
-    cache::{FsCache, NoopCache},
-    table::Table,
-    AvailabilityData, Downloader,
-};
+use rustup_available_packages::{cache::FsCache, table::Table, AvailabilityData, Downloader};
 use serde::Serialize;
 use std::{
     fmt::Display,
@@ -187,9 +182,9 @@ fn main() -> anyhow::Result<()> {
 
     let mut data: AvailabilityData = Default::default();
     let cache = if let Some(cache_path) = config.cache_path.as_ref() {
-        Either::Left(FsCache::new(cache_path).with_context(|| "Can't initialize cache")?)
+        FsCache::new(cache_path).with_context(|| "Can't initialize cache")?
     } else {
-        Either::Right(NoopCache {})
+        FsCache::noop()
     };
     let downloader = Downloader::with_default_source(&config.channel)
         .set_cache(cache)