dotpatina 1.6.0

dotpatina is a rust application for managing system dotfiles and configuration
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

//! [PatinaFile] and related functionality

use std::path::PathBuf;

use serde::{Deserialize, Serialize};

/// A [PatinaFile] describes a template file and its target output path.
#[derive(Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct PatinaFile {
    /// An optional list of tags for this patina file. This allows subsets of files to be specified from the command line
    #[serde(default)]
    pub tags: Vec<String>,

    /// The path to the template file
    pub template: PathBuf,

    /// The path to the garget output file
    pub target: PathBuf,

    /// When true, the template file's permissions are copied to the target file after writing.
    /// Useful for executable scripts.
    #[serde(default)]
    pub preserve_permissions: bool,

    /// When true, templating is disabled for this PatinaFile. The file is simply copied from `template` to `target`.
    #[serde(default)]
    pub disable_templating: bool,
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::*;

    impl PatinaFile {
        pub fn new<P: AsRef<Path>>(template: P, target: P) -> PatinaFile {
            let template = template.as_ref().to_path_buf();
            let target = target.as_ref().to_path_buf();
            PatinaFile {
                template,
                target,
                tags: vec![],
                preserve_permissions: false,
                disable_templating: false,
            }
        }

        pub fn new_with_tags<P: AsRef<Path>>(
            template: P,
            target: P,
            tags: Vec<&str>,
        ) -> PatinaFile {
            let mut result = PatinaFile::new(template, target);
            result.tags = tags.iter().map(|s| s.to_string()).collect();
            result
        }
    }

    #[test]
    fn test_patina_file_new() {
        let patina_file = PatinaFile::new("template.txt", "target.txt");

        assert_eq!(PathBuf::from("template.txt"), patina_file.template);
        assert_eq!(PathBuf::from("target.txt"), patina_file.target);
        assert!(patina_file.tags.is_empty());
    }

    #[test]
    fn test_patina_file_with_tags() {
        let patina_file =
            PatinaFile::new_with_tags("template.txt", "target.txt", vec!["aaa", "bbb", "ccc"]);

        assert_eq!(PathBuf::from("template.txt"), patina_file.template);
        assert_eq!(PathBuf::from("target.txt"), patina_file.target);
        assert_eq!(patina_file.tags.len(), 3);
        assert_eq!(patina_file.tags[0], "aaa");
        assert_eq!(patina_file.tags[1], "bbb");
        assert_eq!(patina_file.tags[2], "ccc");
    }
}