lazin 1.0.2

Primarily a dotfiles manager
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
117
118
119
120
121
122
123
124
125
126
127
128

use std::{
    fs::{self, OpenOptions},
    io::{ErrorKind, Write},
    path::Path,
};

use lazin_error::{Context, LazinResult};

use crate::error::LazinError;

const LAZIN_DEFAULT_WORKSPACE_FILE: &str = "workspace.toml";
const LAZIN_DEFAULT_MODULE_FILE: &str = "modules.toml";

const LAZIN_DEFAULT_WORKSPACE: &str = r#"#workspace_name = [
#   "module1",
#   "module2",
#]
"#;

const LAZIN_DEFAULT_MODULE: &str = r#"#[my_module]
#config = {
#    encrypt = false, # When setting to false, recipient field is optional
#}
#source_file="/.config/my_program/source_file"
#source_dir="/.config/source_dir"
#"more/specific/path/to/source_file"="/.config/my_program/source_file"
#source_file_with_attributes = {
#    path = "/.config/my_program/source_file_with_attributes",
#    config = {
#        encrypt = true # override module level encrypt
#        recipient = "gpg-recipient"
#    }
#}
"#;

enum WriteFileState {
    Written,
    Skipped,
}

fn try_write_file(base_dir: &Path, filename: &str, data: &[u8]) -> LazinResult<WriteFileState> {
    let mut write_state = WriteFileState::Written;

    let new_file = OpenOptions::new()
        .create_new(true)
        .write(true)
        .open(base_dir.to_path_buf().join(filename));

    if let Ok(mut file) = new_file {
        file.write_all(data).context("Failed to write file")?;
    } else if let Err(e) = new_file {
        match e.kind() {
            ErrorKind::AlreadyExists => write_state = WriteFileState::Skipped,
            _ => return Err(LazinError::Io(e)).context("File write error"),
        }
    }

    Ok(write_state)
}

pub fn init_directory(directory: &Path) -> LazinResult<()> {
    fs::create_dir_all(directory).context("Failed to create directories")
}

pub fn init_default_config(base_dir: &Path) -> LazinResult<()> {
    let lazin_default_workspace = try_write_file(
        base_dir,
        LAZIN_DEFAULT_WORKSPACE_FILE,
        LAZIN_DEFAULT_WORKSPACE.as_bytes(),
    )?;
    match lazin_default_workspace {
        WriteFileState::Written => (),
        WriteFileState::Skipped => lazin_logger::info!(
            "Skipped writing {} file. File already exists.",
            LAZIN_DEFAULT_WORKSPACE_FILE
        ),
    }

    let lazin_default_module = try_write_file(
        base_dir,
        LAZIN_DEFAULT_MODULE_FILE,
        LAZIN_DEFAULT_MODULE.as_bytes(),
    )?;
    match lazin_default_module {
        WriteFileState::Written => (),
        WriteFileState::Skipped => lazin_logger::info!(
            "Skipped writing {} file. File already exists.",
            LAZIN_DEFAULT_MODULE_FILE
        ),
    }

    Ok(())
}

#[cfg(test)]
mod test {
    use std::fs;

    use crate::{
        filesystem::init::{init_default_config, init_directory},
        test::filesystem::tmp::TempDir,
    };

    #[test]
    fn temp_default_config() {
        let temp_dir = TempDir::new();
        init_default_config(temp_dir.path()).expect("initialized config file examples")
    }

    #[test]
    fn temp_init_directory() {
        let temp_dir = TempDir::new();
        init_directory(temp_dir.path()).expect("initialized temp directory");
        assert!(
            fs::metadata(temp_dir.path())
                .expect("valid metadata")
                .is_dir()
        );
    }

    #[test]
    fn temp_init_directory_nested() {
        let temp_dir = TempDir::new();
        let temp_dir = temp_dir.path().join("child1").join("child2");
        init_directory(&temp_dir).expect("initialized temp directory");
        assert!(fs::metadata(&temp_dir).expect("valid metadata").is_dir());
    }
}