muffy 0.3.18

The static website validator
Documentation 
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

mod fjall;
mod memory;
mod moka;
mod sled;
mod utility;

pub use self::{fjall::FjallCache, memory::MemoryCache, moka::MokaCache, sled::SledCache};
use alloc::sync::Arc;
use async_trait::async_trait;
use core::{
    error::Error,
    fmt::{self, Display, Formatter},
};
use serde::{Deserialize, Serialize};

/// A cache.
///
/// Every operation against the cache is transactional.
#[async_trait]
pub trait Cache<T: Clone>: Send + Sync {
    /// Gets a value.
    async fn get(&self, key: &str) -> Result<Option<T>, CacheError>;

    /// Gets a cached value.
    ///
    /// If a cached value is not found, it awaits the given future and sets its
    /// resulting value into the cache and returns the value.
    async fn get_with<'a>(
        &self,
        key: String,
        future: Box<dyn Future<Output = T> + Send + 'a>,
    ) -> Result<T, CacheError>;

    /// Sets a value.
    async fn set(&self, key: String, value: T) -> Result<(), CacheError>;

    /// Removes a cached value corresponding to the given key.
    async fn remove(&self, key: &str) -> Result<(), CacheError>;
}

#[async_trait]
impl<T: Clone + Send + Sync + 'static, C: Cache<T> + ?Sized> Cache<T> for Arc<C> {
    async fn get(&self, key: &str) -> Result<Option<T>, CacheError> {
        (**self).get(key).await
    }

    async fn get_with<'a>(
        &self,
        key: String,
        future: Box<dyn Future<Output = T> + Send + 'a>,
    ) -> Result<T, CacheError> {
        (**self).get_with(key, future).await
    }

    async fn set(&self, key: String, value: T) -> Result<(), CacheError> {
        (**self).set(key, value).await
    }

    async fn remove(&self, key: &str) -> Result<(), CacheError> {
        (**self).remove(key).await
    }
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum CacheError {
    Bitcode(Arc<str>),
    Fjall(Arc<str>),
    Sled(Arc<str>),
}

impl Error for CacheError {}

impl Display for CacheError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Bitcode(error) => write!(formatter, "{error}"),
            Self::Fjall(error) => write!(formatter, "{error}"),
            Self::Sled(error) => write!(formatter, "{error}"),
        }
    }
}

impl From<bitcode::Error> for CacheError {
    fn from(error: bitcode::Error) -> Self {
        Self::Bitcode(error.to_string().into())
    }
}

impl From<::fjall::Error> for CacheError {
    fn from(error: ::fjall::Error) -> Self {
        Self::Fjall(error.to_string().into())
    }
}

impl From<::sled::Error> for CacheError {
    fn from(error: ::sled::Error) -> Self {
        Self::Sled(error.to_string().into())
    }
}

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

    #[tokio::test]
    async fn get_or_set_with_shared_cache() {
        let cache = Arc::new(MemoryCache::new(1 << 10));

        assert_eq!(
            cache
                .get_with("key".into(), Box::new(async { 42 }))
                .await
                .unwrap(),
            42,
        );
        assert_eq!(
            cache
                .get_with("key".into(), Box::new(async { 0 }))
                .await
                .unwrap(),
            42,
        );
    }

    #[tokio::test]
    async fn set_with_shared_cache() {
        let cache = Arc::new(MemoryCache::new(1 << 10));

        cache.set("key".into(), 42).await.unwrap();

        assert_eq!(cache.get("key").await.unwrap(), Some(42));
    }

    #[tokio::test]
    async fn remove_with_shared_cache() {
        let cache = Arc::new(MemoryCache::new(1 << 10));

        cache
            .get_with("key".into(), Box::new(async { 42 }))
            .await
            .unwrap();
        cache.remove("key").await.unwrap();

        assert_eq!(
            cache
                .get_with("key".into(), Box::new(async { 0 }))
                .await
                .unwrap(),
            0,
        );
    }
}