macro_files 0.1.0

Macro consuming JSON like data structures to create directories and files at runtime.
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
102
103
104

use std::collections::HashSet;
use std::path::{Path, PathBuf};

#[test]
fn temp() {
    let project_name = String::from("Rust project");
    let adr_directory = "adr";
    let adr_template = ["# NUMBER. TITLE", "", "Date: DATE"].join("\n");
    fn license() -> &'static str {
        "MIT"
    }
    fn markdown(name: &str) -> String {
        format!("{}.md", name)
    }

    let dir = macro_files::create_temp!({
        ["long", "path"].join("/"): {
            markdown("README"): format!("# {}", project_name),
            "docs": {
                markdown("README"): "# Documentation",
                "assets": {},
                "examples": {}
            },
            adr_directory: {
                "templates": {
                    markdown("template"): adr_template,
                }
            },
            "LICENSE": license(),
            ".adr-dir": adr_directory,
        },
        "other": {
            "not-create-1": false,
            "not-create-2": null,
            ".gitkeep": true,
            "path/as/file-name": "file path",
            "path": {
                "file": "existing path"
            }
        },
    })
    .unwrap();

    let expected = HashSet::from([
        Entry::dir("long"),
        Entry::dir("long/path"),
        Entry::file("long/path/README.md", "# Rust project"),
        Entry::dir("long/path/docs"),
        Entry::file("long/path/docs/README.md", "# Documentation"),
        Entry::dir("long/path/docs/assets"),
        Entry::dir("long/path/docs/examples"),
        Entry::dir("long/path/adr"),
        Entry::dir("long/path/adr/templates"),
        Entry::file(
            "long/path/adr/templates/template.md",
            "# NUMBER. TITLE\n\nDate: DATE",
        ),
        Entry::file("long/path/LICENSE", "MIT"),
        Entry::file("long/path/.adr-dir", "adr"),
        Entry::dir("other"),
        Entry::file("other/.gitkeep", ""),
        Entry::dir("other/path"),
        Entry::dir("other/path/as"),
        Entry::file("other/path/as/file-name", "file path"),
        Entry::file("other/path/file", "existing path"),
    ]);
    assert_eq!(get_entries(dir.path(), &PathBuf::default()), expected);
}

#[derive(Hash, PartialEq, Eq, Debug)]
enum Entry {
    Dir(PathBuf),
    File(PathBuf, Vec<u8>),
}

impl Entry {
    fn dir(path: &str) -> Entry {
        Entry::Dir(path.into())
    }

    fn file(path: &str, contents: &str) -> Entry {
        Entry::File(path.into(), contents.into())
    }
}

fn get_entries(path: &Path, relative_path: &Path) -> HashSet<Entry> {
    let mut entries = HashSet::new();
    for entry in path.read_dir().unwrap() {
        let entry_path = entry.unwrap().path();
        let relative_path = relative_path.join(entry_path.strip_prefix(path).unwrap());
        if entry_path.is_dir() {
            entries.insert(Entry::Dir(relative_path.clone()));
            for entry in get_entries(&entry_path, &relative_path) {
                entries.insert(entry);
            }
        } else if entry_path.is_file() {
            entries.insert(Entry::File(
                relative_path,
                std::fs::read(entry_path).unwrap(),
            ));
        }
    }
    entries
}