dotbak 0.3.5

Manage and backup dotfiles with ease!
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

pub mod files;
mod tests;

use crate::errors::{config::ConfigError, io::IoError, Result};
use serde::{Deserialize, Serialize};
use std::path::Path;
use std::{fs, path::PathBuf};

use self::files::FilesConfig;

/// The configuration that Dotbak uses to run.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Config {
    /// The location of the configuration file. This is a temporary value that will be overwritten
    /// later when loading in `Config::load_config`, so it is not serialized.
    #[serde(skip)]
    pub path: PathBuf,

    /// The URL for the remote git repository. This is the URL that will be used to clone the
    /// repository if it doesn't exist, and to push and pull changes to and from the repository.
    /// Also, incase the local repository is deleted or corrupted, this URL will be used to clone
    /// the repository again.
    pub repository_url: Option<String>,

    /// The configuration for the `Files` struct. This is a list of files and folders that will be
    /// managed by Dotbak.
    #[serde(default)]
    pub files: FilesConfig,
}

impl Default for Config {
    /// The default configuration for Dotbak.
    fn default() -> Self {
        Config {
            path: PathBuf::new(), // This is a temporary value that will be overwritten later.
            repository_url: None, // No default value.
            files: FilesConfig::default(),
        }
    }
}

/// Public API for the configuration.
impl Config {
    /// Loads the config file from the given path. If the path doesn't exist, it will return an error.
    pub fn load_config<P>(path: P) -> Result<Self>
    where
        P: AsRef<Path>,
    {
        let path = path.as_ref();
        let mut config: Config;

        if !path.exists() {
            return Err(ConfigError::NotFound {
                path: path.to_path_buf(),
            }
            .into());
        }

        let config_str = fs::read_to_string(path).map_err(|err| IoError::Read {
            source: err,
            path: path.to_path_buf(),
        })?;

        config = toml::from_str(&config_str)?;

        // IMPORTANT: This is the only place where the path is set.
        config.path = path.to_path_buf();

        Ok(config)
    }

    /// Saves the config file to the given path. If the path doesn't exist, it will return an error.
    pub fn save_config(&self) -> Result<()> {
        if !self.path.exists() {
            return Err(ConfigError::NotFound {
                path: self.path.to_path_buf(),
            }
            .into());
        }

        let config_str = toml::to_string_pretty(self)?;
        fs::write(&self.path, config_str).map_err(|err| IoError::Write {
            source: err,
            path: self.path.to_path_buf(),
        })?;

        Ok(())
    }

    /// Creates a new config file at the given path. If the path already exists, it will return an error.
    pub fn create_config<P>(path: P) -> Result<Self>
    where
        P: AsRef<Path>,
    {
        let path: &Path = path.as_ref();

        if path.exists() {
            return Err(ConfigError::AlreadyExists {
                path: path.to_path_buf(),
            }
            .into());
        } else {
            // Create the file if it doesn't exist.
            fs::create_dir_all(path.parent().unwrap()).map_err(|err| IoError::Create {
                source: err,
                path: path.to_path_buf(),
            })?;

            // Create the file.
            fs::File::create(path).map_err(|err| IoError::Create {
                source: err,
                path: path.to_path_buf(),
            })?;
        }

        let mut config = Config::default();
        let config_str = toml::to_string(&config)?;

        fs::write(path, config_str).map_err(|err| IoError::Write {
            source: err,
            path: path.to_path_buf(),
        })?;

        // IMPORTANT: This is the only place where the path is set.
        config.path = path.to_path_buf();

        Ok(config)
    }

    /// Deletes the config file at the given path. If the path doesn't exist, it will return an error.
    pub fn delete_config(self) -> Result<()> {
        if !self.path.exists() {
            return Err(ConfigError::NotFound { path: self.path }.into());
        }

        fs::remove_file(&self.path).map_err(|err| IoError::Write {
            source: err,
            path: self.path,
        })?;

        Ok(())
    }
}