chronicle 0.1.0

write your chronicle from command line
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

use anyhow::{Result, bail};
use serde::{Serialize, Deserialize};

use std::collections::HashMap;
use std::fs::{self, File};
use std::io::{self, Read, Write};
use std::path::PathBuf;

#[derive(Default, Serialize, Deserialize)]
pub struct ChronicleConfig {
    pub stores: Vec<String>,
    pub reverse: Option<bool>,
    pub date: Option<String>,
    pub time: Option<String>,
}

impl ChronicleConfig {
    pub fn new(store: &str) -> Self {
        Self {
            stores: vec![store.to_string()],
            ..Default::default()
        }
    }
}

fn reverse_default() -> bool { true }
fn date_default() -> String { String::from("%Y-%m-%d") }
fn time_default() -> String { String::from("%H:%M") }

#[derive(Default, Serialize, Deserialize)]
pub struct Config {
    pub editor: String,
    #[serde(default = "reverse_default")]
    pub reverse: bool,
    #[serde(default = "date_default")]
    pub date: String,
    #[serde(default = "time_default")]
    pub time: String,
    pub chronicle: HashMap<String, ChronicleConfig>,
}

impl Config {
    pub fn new() -> Self {
        Self {
            reverse: reverse_default(),
            date: date_default(),
            time: time_default(),
            ..Default::default()
        }
    }

    pub fn exists(&self, name: &str) -> bool {
        self.chronicle.contains_key(name)
    }
}

pub fn dir() -> PathBuf {
    home::home_dir().unwrap().join(".chronicle")
}

pub fn backup_dir() -> PathBuf {
    dir().join("backup~")
}

pub fn config_path() -> PathBuf {
    dir().join("config.toml")
}

pub fn draft_path(name: &str) -> PathBuf {
    dir().join(name)
}

fn init_config() -> Result<()> {
    let d = dir();
    fs::create_dir_all(&d)?;
    let p = config_path();
    let mut f = File::create(&p)?;

    let c = Config::new();
    let b = toml::to_vec(&c)?;
    f.write_all(&b)?;
    Ok(())
}

pub fn read_config() -> Result<Config> {
    let p = config_path();
    let f = File::open(&p).or_else(|err| {
        match err.kind() {
            io::ErrorKind::NotFound => {
                init_config().and_then(|()| {
                    File::open(&p)
                        .map_err(|e| e.into())
                })
            },
            _ => Err(anyhow::Error::from(err))
        }
    });

    if let Err(e) = f {
        bail!(e);
    }

    let mut f = f?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;

    toml::from_str(&s)
        .map_err(|e| e.into())
}

pub fn write_config(cfg: &mut Config) -> Result<()> {
    let p = config_path();
    let b = toml::to_vec(cfg)?;
    fs::write(&p, &b)?;
    Ok(())
}