alexandria 0.2.0

An encrypted document-oriented database with tag based query support
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

//! Directory helper to create and manage Alexandria instances

use crate::error::Result;
use std::{fs, path::PathBuf};

/// Metadata for where things are stored
pub(crate) struct Dirs {
    /// The root path, contains metadata
    root: PathBuf,
}

#[allow(unused)]
impl Dirs {
    pub(crate) fn new<P: Into<PathBuf>>(root: P) -> Self {
        Self { root: root.into() }
    }

    pub(crate) fn scaffold(&self) -> Result<()> {
        fs::create_dir_all(&self.root)?;
        fs::create_dir(self.records())?;
        fs::create_dir(self.meta())?;
        fs::create_dir(self.cache())?;
        Ok(())
    }

    /// Return the records directory in the library
    pub(crate) fn records(&self) -> PathBuf {
        self.root.join("records")
    }

    /// Return the meta directory in the library
    pub(crate) fn meta(&self) -> PathBuf {
        self.root.join("meta")
    }

    /// Return the cache directory in the library
    pub(crate) fn cache(&self) -> PathBuf {
        self.root.join("cache")
    }
}

#[test]
fn scaffold_lib() -> Result<()> {
    use std::path::Path;
    use tempfile::tempdir;

    let root = tempdir().unwrap();
    let mut offset = root.path().to_path_buf();
    offset.push("library");

    let d = Dirs::new(offset.clone());
    d.scaffold()?;

    assert!(Path::new(dbg!(&offset.join("records"))).exists());
    assert!(Path::new(dbg!(&offset.join("meta"))).exists());
    assert!(Path::new(dbg!(&offset.join("cache"))).exists());
    Ok(())
}