quickcfg 0.6.3

Do basic configuration of a system, declaratively and quickly.
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

use crate::{
    environment as e, system::SystemInput, template::Template, unit::SystemUnit, FileSystem,
};
use anyhow::{bail, Error};
use std::fmt;
use std::fs;

system_struct! {
    #[doc = "Builds one unit for every directory and file that needs to be copied."]
    CopyDir {
        #[doc="Where to copy from."]
        pub from: Template,
        #[doc="Where to copy to."]
        pub to: Template,
        #[serde(default)]
        #[doc="If we should treat files as templates."]
        pub templates: bool,
    }
}

impl CopyDir {
    system_defaults!(translate);

    /// Copy one directory to another.
    pub fn apply<E>(&self, input: SystemInput<E>) -> Result<Vec<SystemUnit>, Error>
    where
        E: Copy + e::Environment,
    {
        let SystemInput {
            root,
            base_dirs,
            facts,
            environment,
            file_system,
            ..
        } = input;

        let mut units = Vec::new();

        let from = match self.from.as_path(root, base_dirs, facts, environment)? {
            Some(from) => from,
            None => return Ok(units),
        };

        // resolve destination, if unspecified defaults to relative current directory.
        let to = match self.to.as_path(root, base_dirs, facts, environment)? {
            Some(to) => to,
            None => return Ok(units),
        };

        for e in ignore::WalkBuilder::new(&from).hidden(false).build() {
            let e = e?;
            let from_path = e.path();
            let to_path = to.join(from_path.strip_prefix(&from)?);

            let from = from_path.symlink_metadata()?;
            let to = FileSystem::try_open_meta(&to_path)?;

            let source_type = from.file_type();

            if source_type.is_symlink() {
                let link = fs::read_link(from_path)?;
                units.extend(file_system.symlink(&to_path, link, to.as_ref())?);
                continue;
            }

            if source_type.is_dir() {
                if FileSystem::should_create_dir(&to_path, to.as_ref())? {
                    units.extend(file_system.create_dir_all(&to_path)?);
                }

                continue;
            }

            if source_type.is_file() {
                units.extend(file_system.copy_file(
                    from_path,
                    from,
                    &to_path,
                    to.as_ref(),
                    self.templates,
                )?);
                continue;
            }

            bail!(
                "Cannot handle file with metadata `{:?}`: {}",
                from,
                from_path.display()
            );
        }

        Ok(units)
    }
}

impl fmt::Display for CopyDir {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "copy directory from `{}` to `{}`", self.from, self.to)
    }
}