move TimedLruCache to util module

src/client/cache.rs

@@ -1,12 +1,10 @@
 use std::sync::Arc;
 
-use crate::cache::TimedLruCache;
-
 use mime::Mime;
 use reqwest::header::HeaderMap;
 use url::Url;
 
-use crate::{Error, Result};
+use crate::{util::TimedLruCache, Error, Result};
 
 pub type ResponseCache = TimedLruCache<Url, Response>;
 

src/filter/full_text.rs

@@ -7,10 +7,10 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
-use crate::cache::TimedLruCache;
 use crate::client::{self, Client};
 use crate::feed::{Feed, Post};
 use crate::html::convert_relative_url;
+use crate::util::TimedLruCache;
 use crate::{ConfigError, Error, Result};
 
 use super::html::{KeepElement, KeepElementConfig};

src/main.rs

@@ -1,4 +1,3 @@
-mod cache;
 mod cli;
 mod client;
 mod config;

src/util.rs

@@ -77,3 +77,51 @@ impl<'a, T> Iterator for SingleOrVecIter<'a, T> {
     }
   }
 }
+
+use std::{
+  hash::Hash,
+  num::NonZeroUsize,
+  sync::RwLock,
+  time::{Duration, Instant},
+};
+
+use lru::LruCache;
+
+pub struct Timed<T> {
+  value: T,
+  created: Instant,
+}
+
+pub struct TimedLruCache<K: Hash + Eq, V: Clone> {
+  map: RwLock<LruCache<K, Timed<V>>>,
+  timeout: Duration,
+}
+
+impl<K: Hash + Eq, V: Clone> TimedLruCache<K, V> {
+  pub fn new(max_entries: usize, timeout: Duration) -> Self {
+    let max_entries = max_entries.try_into().unwrap_or(NonZeroUsize::MIN);
+    Self {
+      map: RwLock::new(LruCache::new(max_entries)),
+      timeout,
+    }
+  }
+
+  pub fn get_cached(&self, key: &K) -> Option<V> {
+    let mut map = self.map.write().ok()?;
+    let entry = map.get(key)?;
+    if entry.created.elapsed() > self.timeout {
+      map.pop(key);
+      return None;
+    }
+    Some(entry.value.clone())
+  }
+
+  pub fn insert(&self, key: K, value: V) -> Option<()> {
+    let timed = Timed {
+      value,
+      created: Instant::now(),
+    };
+    self.map.write().ok()?.push(key, timed);
+    Some(())
+  }
+}