scryfall-client 0.1.0

an wrapper for the scryfall API
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

use crate::cache::cache_iterator::CacheIterator;
use crate::cache::io_cache::IoCache;
use crate::card::Card;
use crate::client::{get_unix_time, Client};
use crate::search_builder;
use crate::search_builder::SearchBuilderTrait;
use eyre::Result;
use std::path::PathBuf;
use std::time::Duration;

pub mod cache_iterator;
mod io_cache;

#[derive(Debug)]
pub struct ScryfallCache {
    io: IoCache,
    expiration: Duration,
    query: String,
}

impl ScryfallCache {
    pub fn new() -> Self {
        Self::new_options(CacheOptions::default())
    }

    pub async fn check(&self) -> Result<()> {
        if match self.io.get_meta()? {
            None => true,
            Some(meta) => meta.download_time + self.expiration.as_millis() > get_unix_time(),
        } {
            let result = Client.search(&self.query).await?;
            self.io.add(result)?;
        };
        Ok(())
    }

    pub fn new_options(options: CacheOptions) -> Self {
        let (path, expiration, query) = options.unpack();
        Self {
            io: IoCache::new(path).unwrap(),
            expiration,
            query,
        }
    }

    pub async fn get_card_by_name<S: ToString>(&self, name: S) -> Result<Option<Card>> {
        self.check().await?;
        self.io.get(name)
    }

    pub async fn iter<'a>(&'a self) -> Result<CacheIterator<'a>> {
        self.check().await?;
        Ok(CacheIterator {
            inner: &self,
            inner_iter: self.io.get_all()?,
        })
    }

    pub fn delete(self) -> Result<()> {
        self.io.delete()
    }
}

#[derive(Debug, Clone)]
pub struct CacheOptions {
    location: Box<PathBuf>,
    expiration: Duration,
    query: String,
}

impl CacheOptions {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn unpack(self) -> (Box<PathBuf>, Duration, String) {
        (self.location, self.expiration, self.query)
    }

    pub fn location(mut self, path: PathBuf) -> Self {
        self.location = Box::new(path);
        self
    }

    pub fn expiration(mut self, time: Duration) -> Self {
        self.expiration = time;
        self
    }

    pub fn query<S: ToString>(mut self, query: S) -> Self {
        self.query = query.to_string();
        self
    }
}

impl Default for CacheOptions {
    fn default() -> Self {
        Self {
            location: Box::new(std::env::current_dir().unwrap().join("__scryfall_cache")),
            expiration: Duration::from_secs(60 * 60 * 24),
            query: search_builder::Builder::all_cards().stringify(),
        }
    }
}