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

use crate::{Mind, Reminder, Storage};
use std::fs;
use std::fs::File;
use std::io::{self, BufReader, Write};
use std::path::PathBuf;

pub struct LocalStorage {
    mind_tasks_path: PathBuf,
    mind_reminders_path: PathBuf,
}

impl Storage for LocalStorage {
    fn init() -> io::Result<Self> {
        let local_storage = dirs::home_dir()
            .expect("failed go get home directory")
            .join(".mind");
        if !local_storage.exists() {
            fs::create_dir(&local_storage)?;
        };

        let mind_tasks_path = local_storage.join("tasks.yml");
        let default_mind = Mind::default();
        if !mind_tasks_path.exists() {
            let file = File::create(&mind_tasks_path)?;
            serde_yaml::to_writer(&file, default_mind.tasks()).expect("failed to create tasks.yml");
        };

        let mind_reminders_path = local_storage.join("reminders.yml");
        if !mind_reminders_path.exists() {
            let file = File::create(&mind_reminders_path)?;
            serde_yaml::to_writer(&file, default_mind.tasks())
                .expect("failed to create reminders.yml");
        };

        let reminder_examples_path = local_storage.join("reminder_examples.yml");
        let mut file = File::create(&reminder_examples_path)?;
        file.write_all(Reminder::examples().as_bytes())?;

        // TODO Add version compatibility logic
        let mind_version_path = local_storage.join("version");
        let mut file = File::create(&mind_version_path)?;
        file.write_all(Mind::version().as_bytes())?;

        Ok(Self {
            mind_tasks_path,
            mind_reminders_path,
        })
    }

    fn load(&self) -> io::Result<Mind> {
        let mind: Mind = Mind::from(
            serde_yaml::from_reader(BufReader::new(&File::open(&self.mind_tasks_path)?))
                .expect("invalid format"),
            serde_yaml::from_reader(BufReader::new(&File::open(&self.mind_reminders_path)?))
                .expect("invalid format"),
        );
        Ok(mind)
    }

    fn save(&self, mind: Mind) -> io::Result<()> {
        serde_yaml::to_writer(File::create(&self.mind_tasks_path)?, mind.tasks())
            .expect("failed to save file.");
        serde_yaml::to_writer(File::create(&self.mind_reminders_path)?, mind.reminders())
            .expect("failed to save file.");
        Ok(())
    }
}