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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
use std::{fs, path};
use std::io::ErrorKind;
use toml;
enum PathType {
Exclude,
DoNotScan,
Okay,
}
pub struct Config {
config: toml::Value,
commands: toml::Value,
}
impl Config {
pub fn new() -> Config {
println!("Using built-in config");
Config {
config: toml::toml!{
source = "src"
build_dir = "build"
do_not_scan = []
exclude = []
file_delim = ":?"
command_delim = ":!"
commands_file = "commands.toml"
},
commands: toml::toml!{
empty = ""
}
}
}
pub fn import(config: &str) -> Config {
println!("Using found config");
let config: toml::Value = toml::from_str(config).expect("Could not load config");
let config = config.get("config").expect("Could not find \"[config]\" field");
// Attempt to read commands file
let commands: toml::Value = match config.get("commands_file") {
Some(n) => {
if n.is_str() {
let file_string = n.as_str().unwrap();
let file_string = match fs::read_to_string(file_string) {
Ok(n) => n,
Err(_) => {println!("Could not load commands from file"); String::from("[commands]")},
};
toml::from_str(file_string.as_str()).expect("Invalid toml")
} else {
panic!()
}
},
None => {println!("Could not load commands from file"); toml::toml!{[commands]}},
};
let commands = commands.get("commands").expect("Could not find \"[commands]\" field");
Config {
config: config.clone(),
commands: commands.clone(),
}
}
pub fn get_str(&self, string: &str) -> Option<&str> {
match self.config.get(string) {
Some(n) => n.as_str(),
None => None
}
}
pub fn get_cmd_str(&self, string: &str) -> Option<&str> {
match self.commands.get(string) {
Some(n) => n.as_str(),
None => None
}
}
}
fn create_dir(path: &path::PathBuf) -> Result<(), ()> {
match fs::create_dir(path) {
Ok(_) => (),
Err(n) => match n.kind() {
ErrorKind::AlreadyExists => (),
_ => return Err(()),
}
}
return Ok(())
}
fn remove_path_head(path: &path::PathBuf) -> path::PathBuf {
let mut path = path.to_str().unwrap().split("/");
path.next();
let path: path::PathBuf = path.collect();
return path
}
fn append_path_head(path: &path::PathBuf, head: &str) -> path::PathBuf {
let mut head = path::PathBuf::from(head);
head.push(path);
return head
}
fn replace_path_head(path: &path::PathBuf, head: &str) -> path::PathBuf {
let path = remove_path_head(path);
append_path_head(&path, head)
}
pub fn run(config: Config) {
let source = config.get_str("source").unwrap();
let build = config.get_str("build_dir").unwrap();
// Create build directory or panic
create_dir(&path::PathBuf::from(build)).unwrap();
directory_scan(path::PathBuf::from(source), &config);
}
fn check_path(path: &path::PathBuf, config: &Config) -> PathType {
// GET EXCLUDE AND DNS LISTS
// CHECK FOR EXCLUDES AND DO NOT SCANS
// Excludes
// for ex_path in excludes {
// if &ex_path == &path {
// return PathType::Exclude;
// }
// }
// // Do not scans (copy files)
// for dns_path in dns {
// if &dns_path == &path {
// return PathType::DoNotScan;
// }
// }
PathType::Exclude
}
fn copy_file(path: &path::PathBuf) {}
fn directory_scan(path: path::PathBuf, config: &Config) {
println!("Scanning: {:?}", &path);
// Check the path
match check_path(&path, config) {
PathType::Exclude => return,
_ => (),
};
// Create the dir in the build tree
let build_path = replace_path_head(&path, "build/");
create_dir(&build_path).unwrap();
// Iterate over path contents
for x in fs::read_dir(path).unwrap() {
let x = x.as_ref().unwrap().path();
if x.is_dir() {
directory_scan(x, &config);
} else {
file_scan(x, &config);
}
}
}
fn file_scan(path: path::PathBuf, config: &Config) {
// Check path
match check_path(&path, config) {
PathType::Okay => (),
PathType::DoNotScan => {copy_file(&path); return},
PathType::Exclude => return,
};
// File scanning
let mut file_string = String::new();
for line in fs::read_to_string(&path).unwrap().lines() {
if line.contains(":?") {
let v: Vec<&str> = line.trim().split(":?").collect();
let v = v.get(1).unwrap();
println!("INSERTING {} into {:?}", v, path);
file_string.push_str(fs::read_to_string(v).unwrap().as_ref());
} else {
file_string.push_str(line);
file_string.push('\n')
}
}
let dest = replace_path_head(&path, "build/");
fs::write(dest, file_string).expect("Could not write file");
}
|
