readstor 0.6.0

A CLI for Apple Books annotations
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

use std::path::PathBuf;

use once_cell::sync::Lazy;

/// Defines the environment variable key used to determine whether the application is being
/// developed on or not. If so, the Apple Books databases path is bypassed and redirected to a local
/// testing/dev database.
pub const READSTOR_DEV: &str = "READSTOR_DEV";

/// Defines the environment variable key used to set the application's log level. Valid values are:
/// `error`, `warn`, `info`, `debug` and `trace`.
pub const READSTOR_LOG: &str = "READSTOR_LOG";

/// Defines the default output directory.
///
/// The full path:
/// ```plaintext
/// /users/[user]/.readstor
/// ```
pub static OUTPUT_DIRECTORY: Lazy<PathBuf> = Lazy::new(|| lib::defaults::HOME.join(".readstor"));

/// Returns a path to a temp directory to use for reading and writing data during development/testing.
///
/// Internally this returns the value of the TMPDIR environment variable if it is set, otherwise it
/// returns `/tmp`. See [`std::env::temp_dir()`] for more information.
///
/// The full path:
///
/// ```plaintext
/// [temp_dir]/readstor/[name]
/// ```
///
/// For example:
///
/// ```plaintext
/// /var/folders/58/8yrgg8897ld633zt0qg9ww680000gn/T/readstor/
/// ```
pub static TEMP_OUTPUT_DIRECTORY: Lazy<PathBuf> =
    Lazy::new(|| std::env::temp_dir().join("readstor"));

/// Defines the default template string. This is used as a fallback if the user doesn't supply a
/// templates directory.
pub static TEMPLATE: &str = include_str!(concat!(
    env!("CARGO_MANIFEST_DIR"),
    "/templates/basic/basic.jinja2"
));

/// Defines the root path to the test/mock databases.
pub static TEST_DATABASES: Lazy<PathBuf> = Lazy::new(|| {
    let mut path = lib::defaults::CRATE_ROOT.to_owned();
    path.extend(["data", "databases"].iter());
    path
});

#[cfg(test)]
pub mod testing {

    use super::*;

    #[derive(Debug, Clone, Copy)]
    pub enum MockDatabases {
        Empty,
        BooksNew,
        BooksAnnotated,
    }

    impl std::fmt::Display for MockDatabases {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                Self::Empty => write!(f, "empty"),
                Self::BooksNew => write!(f, "books-new"),
                Self::BooksAnnotated => write!(f, "books-annotated"),
            }
        }
    }

    impl From<MockDatabases> for PathBuf {
        fn from(databases: MockDatabases) -> Self {
            TEST_DATABASES.join(databases.to_string())
        }
    }

    /// Defines the root path to the mock plists.
    pub static MOCK_PLISTS: Lazy<PathBuf> = Lazy::new(|| {
        let mut path = lib::defaults::CRATE_ROOT.to_owned();
        path.extend(["data", "plists"].iter());
        path
    });

    #[derive(Debug, Clone, Copy)]
    pub enum MockPlists {
        Empty,
        BooksNew,
        BooksAnnotated,
    }

    impl std::fmt::Display for MockPlists {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                Self::Empty => write!(f, "empty"),
                Self::BooksNew => write!(f, "books-new"),
                Self::BooksAnnotated => write!(f, "books-annotated"),
            }
        }
    }

    impl From<MockPlists> for PathBuf {
        fn from(databases: MockPlists) -> Self {
            MOCK_PLISTS.join(databases.to_string())
        }
    }
}