ffizer 2.13.9

ffizer is a files and folders initializer / generator. It creates or updates any kind (or part) of project from template(s)
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

mod ignore_cfg;
mod import_cfg;
mod script_cfg;
mod template_cfg;
mod template_composite;
mod transform_values;
mod variable_cfg;

pub(crate) use import_cfg::*;
pub(crate) use template_cfg::*;
pub(crate) use template_composite::*;
pub(crate) use transform_values::*;
pub(crate) use variable_cfg::*;

use crate::Result;
use crate::path_pattern::PathPattern;
use crate::scripts::Script;
use crate::source_loc::SourceLoc;
use crate::source_uri::SourceUri;
use crate::timeline::FFIZER_DATASTORE_DIRNAME;
use std::path::PathBuf;
use std::str::FromStr;

const TEMPLATE_CFG_FILENAME: &str = ".ffizer.yaml";
pub const TEMPLATE_SAMPLES_DIRNAME: &str = ".ffizer.samples.d";
const DEFAULTS_IGNORE: [&str; 3] = [
    TEMPLATE_CFG_FILENAME,
    FFIZER_DATASTORE_DIRNAME,
    TEMPLATE_SAMPLES_DIRNAME,
];

impl template_cfg::TemplateCfg {
    pub(crate) fn find_ignores(&self) -> Result<Vec<PathPattern>> {
        let trim_chars: &[_] = &['\r', '\n', ' ', '\t', '"', '\''];
        let mut ignores = self
            .ignores
            .iter()
            .map(|v| v.trim_matches(trim_chars))
            .filter(|v| !v.is_empty())
            .map(PathPattern::from_str)
            .collect::<Result<Vec<PathPattern>>>()?;
        ignores.extend(
            DEFAULTS_IGNORE
                .iter()
                .map(|x| PathPattern::from_str(x))
                .collect::<Result<Vec<PathPattern>>>()?,
        );
        Ok(ignores)
    }

    pub(crate) fn find_scripts(&self) -> Result<Vec<Script>> {
        Ok(self
            .scripts
            .iter()
            .map(|v| Script {
                message: v.message.clone().filter(|x| !x.is_empty()),
                cmd: v.cmd.clone().filter(|x| !x.is_empty()),
                default_confirm_answer: v
                    .default_confirm_answer
                    .clone()
                    .map(|x| x.parse::<bool>().unwrap_or(false))
                    .unwrap_or_default(),
            })
            .collect())
    }

    pub(crate) fn find_sourcelocs(&self) -> Result<Vec<SourceLoc>> {
        self.imports
            .iter()
            .map(|v| {
                let uri = SourceUri::from_str(v.uri.as_str())?;
                let subfolder = v.subfolder.as_ref().map(|x| PathBuf::from(x.as_str()));
                let rev = v.rev.clone();
                Ok(SourceLoc {
                    uri,
                    rev,
                    subfolder,
                })
            })
            .collect()
    }
}

pub fn provide_json_schema() -> Result<String> {
    let schema = schemars::schema_for!(template_cfg::TemplateCfg);
    Ok(serde_json::to_string_pretty(&schema)?)
}