tholps.site
Tholp's bespoke website generator
Named sections
+1
-1
src/args.rs
+1
-1
src/args.rs
-78
src/closures.rs
-78
src/closures.rs
···
1
-
// Closures are essentally blocked macros that change behavior on symbol instead of name
2
-
// Instances of most types of closures can be named as sections ...
3
-
// ... to work with !insert() to pick certain parts out of a file
4
-
5
-
use boa_engine::Context;
6
-
7
-
use crate::{
8
-
project::Project,
9
-
types::{SkidContext, Token},
10
-
};
11
-
12
-
type ClosureFunction = fn(&[Token], &mut Project, &mut SkidContext) -> Vec<Token>;
13
-
14
-
pub struct Closure {
15
-
pub opener: &'static str,
16
-
pub opener2: &'static str,
17
-
pub closer: &'static str,
18
-
pub function: ClosureFunction,
19
-
}
20
-
21
-
// (opener) name (opener2) ... (closer)
22
-
23
-
// << js ! .. >>
24
-
// <!-- comment -->
25
-
// [ name {{ .. }}]
26
-
27
-
// <!-- ... --> comment
28
-
// ?name<< >> named js
29
-
// ?name[[ ]] named section
30
-
// ?<< >> js
31
-
// ?[[ ]] section
32
-
// ?name^[[]] named emphemeral section
33
-
// ?name-[[]] named inverted section
34
-
35
-
pub static CLOSURE_LIST: &'static [Closure] = &[
36
-
Closure {
37
-
opener: "?",
38
-
opener2: "<<",
39
-
closer: ">>",
40
-
function: closure_js,
41
-
},
42
-
Closure {
43
-
opener: "<!--",
44
-
opener2: "", // blank means it doesnt accept a name
45
-
closer: "-->",
46
-
function: closure_comment,
47
-
},
48
-
Closure {
49
-
opener: "?",
50
-
opener2: "{{",
51
-
closer: "}}",
52
-
function: closure_section,
53
-
},
54
-
];
55
-
56
-
fn closure_comment(
57
-
_tokens: &[Token],
58
-
_project_context: &mut Project,
59
-
_skid_context: &mut SkidContext,
60
-
) -> Vec<Token> {
61
-
Vec::new()
62
-
}
63
-
64
-
fn closure_section(
65
-
tokens: &[Token],
66
-
_project_context: &mut Project,
67
-
_skid_context: &mut SkidContext,
68
-
) -> Vec<Token> {
69
-
tokens.to_vec()
70
-
}
71
-
72
-
fn closure_js(
73
-
tokens: &[Token],
74
-
project_context: &mut Project,
75
-
skid_context: &mut SkidContext,
76
-
) -> Vec<Token> {
77
-
Vec::new()
78
-
}
···
+4
src/console.rs
+4
src/console.rs
+35
-7
src/macros/insert.rs
+35
-7
src/macros/insert.rs
···
2
3
use crate::{
4
console::error_skid,
5
-
macros::template::SkidTemplate,
6
project::{Indexing, Project},
7
stringtools::split_to_tokens,
8
types::{SkidContext, Token},
···
11
pub fn macro_insert(
12
origin_index: usize,
13
origin_line: usize,
14
-
context: &mut Project,
15
-
_skid_context: &mut SkidContext,
16
args: &Vec<String>,
17
_scope: &[Token],
18
) -> Vec<Token> {
19
-
let origin_file = context
20
.file_for_index_canonical(origin_index)
21
.expect("Macro 'Insert' was given a bad origin index")
22
.clone();
23
24
let mut arg = args[0].clone();
25
let mut search_from_root = arg.starts_with("//");
26
let mut ok = false;
···
44
}
45
46
if search_from_root {
47
-
let mut include_path = context.input_folder.clone();
48
include_path.push(&arg);
49
50
if include_path.exists() && include_path.is_file() {
···
54
}
55
56
if !ok {
57
-
error_skid(context, origin_index, origin_line, &format!("Insert was unable to find the file \"{}\" relative to its origin or in project root.", arg));
58
}
59
60
let mut output = fs::read_to_string(&include_file).expect("File unreadable or missing");
···
62
output.pop();
63
} //remove trailing newlines
64
65
-
return split_to_tokens(output, context.index_of_file(&PathBuf::from(&include_file)));
66
}
···
2
3
use crate::{
4
console::error_skid,
5
+
process_skid,
6
project::{Indexing, Project},
7
stringtools::split_to_tokens,
8
types::{SkidContext, Token},
···
11
pub fn macro_insert(
12
origin_index: usize,
13
origin_line: usize,
14
+
proj_context: &mut Project,
15
+
skid_context: &mut SkidContext,
16
args: &Vec<String>,
17
_scope: &[Token],
18
) -> Vec<Token> {
19
+
let origin_file = proj_context
20
.file_for_index_canonical(origin_index)
21
.expect("Macro 'Insert' was given a bad origin index")
22
.clone();
23
24
+
let mut sections_ids_to_keep = Vec::new();
25
+
26
+
if args.len() > 1 {
27
+
for a in &args[1..] {
28
+
let id = proj_context.index_of_section_name(a);
29
+
sections_ids_to_keep.push(id);
30
+
}
31
+
}
32
+
33
let mut arg = args[0].clone();
34
let mut search_from_root = arg.starts_with("//");
35
let mut ok = false;
···
53
}
54
55
if search_from_root {
56
+
let mut include_path = proj_context.input_folder.clone();
57
include_path.push(&arg);
58
59
if include_path.exists() && include_path.is_file() {
···
63
}
64
65
if !ok {
66
+
error_skid(proj_context, origin_index, origin_line, &format!("Insert was unable to find the file \"{}\" relative to its origin or in project root.", arg));
67
}
68
69
let mut output = fs::read_to_string(&include_file).expect("File unreadable or missing");
···
71
output.pop();
72
} //remove trailing newlines
73
74
+
if sections_ids_to_keep.len() > 0 {
75
+
let mut processed = process_skid(
76
+
&split_to_tokens(
77
+
output,
78
+
proj_context.index_of_file(&PathBuf::from(&include_file)),
79
+
),
80
+
proj_context,
81
+
skid_context,
82
+
);
83
+
processed.retain(|t| sections_ids_to_keep.contains(&t.section_index));
84
+
for t in &mut processed {
85
+
t.pre_proccessed = true;
86
+
}
87
+
return processed;
88
+
} else {
89
+
return split_to_tokens(
90
+
output,
91
+
proj_context.index_of_file(&PathBuf::from(&include_file)),
92
+
);
93
+
}
94
}
+1
-1
src/macros/mod.rs
+1
-1
src/macros/mod.rs
+15
-7
src/macros/simple_blocks.rs
+15
-7
src/macros/simple_blocks.rs
···
1
// This file for implementations of short blocks, im qualifying that as less than 30ish lines
2
use crate::{
3
-
console::*,
4
-
project::Project,
5
-
stringtools::TokenTools,
6
types::{SkidContext, Token},
7
};
8
···
20
pub fn macro_section(
21
_origin_index: usize,
22
_origin_line: usize,
23
-
_context: &mut Project,
24
_skid_context: &mut SkidContext,
25
-
_args: &Vec<String>,
26
scope: &[Token],
27
) -> Vec<Token> {
28
let mut tokens = Vec::new();
29
-
for tok in scope {
30
-
tokens.push(tok.clone());
31
}
32
return tokens;
33
}
34
···
1
// This file for implementations of short blocks, im qualifying that as less than 30ish lines
2
use crate::{
3
+
project::{Indexing, Project},
4
types::{SkidContext, Token},
5
};
6
···
18
pub fn macro_section(
19
_origin_index: usize,
20
_origin_line: usize,
21
+
proj_context: &mut Project,
22
_skid_context: &mut SkidContext,
23
+
args: &Vec<String>,
24
scope: &[Token],
25
) -> Vec<Token> {
26
let mut tokens = Vec::new();
27
+
if args.len() == 1 {
28
+
let section_index = proj_context.index_of_section_name(&args[0]);
29
+
for tok in scope {
30
+
let mut new = tok.clone();
31
+
new.section_index = section_index;
32
+
tokens.push(new);
33
+
}
34
+
} else {
35
+
for tok in scope {
36
+
tokens.push(tok.clone());
37
+
}
38
}
39
+
40
return tokens;
41
}
42
-1
src/macros/simple_macros.rs
-1
src/macros/simple_macros.rs
+9
-5
src/main.rs
+9
-5
src/main.rs
···
1
mod args;
2
-
mod closures;
3
mod console;
4
mod macros;
5
mod project;
···
24
path::PathBuf,
25
};
26
use stringtools::{collect_arguments, collect_block, split_to_tokens};
27
-
use types::{InputFile, Token};
28
29
// really need to change this whole thing to work with characters rather than
30
// strings split on kind of abitrary chars..
···
58
project_path = project_folder.clone();
59
project_path.push("skidmark.toml");
60
}
61
-
println!("Operatting on {:?}", &project_path.as_os_str());
62
assert!(env::set_current_dir(&project_folder).is_ok());
63
64
let mut project = parse_project(&project_path);
···
69
num = num + group.files.len();
70
}
71
72
-
println!("Proccesing {} files.", num);
73
// for group in &mut project.filegroups {
74
// for infile in &mut group.files {
75
// process_skid(infile, group.convert_html, &mut project.context);
···
288
None
289
}
290
291
-
fn process_skid(
292
tokens_in: &[Token],
293
proj_context: &mut Project,
294
skid_context: &mut SkidContext,
···
306
let mut working_index = 0;
307
308
while working_index < tokens.len() {
309
if tokens[working_index] == '\\' && !escaped {
310
tokens[working_index].contents = '\0'; // skip over this later when outputting to avoid shifting memory rn
311
escaped = true;
···
1
mod args;
2
mod console;
3
mod macros;
4
mod project;
···
23
path::PathBuf,
24
};
25
use stringtools::{collect_arguments, collect_block, split_to_tokens};
26
+
use types::Token;
27
28
// really need to change this whole thing to work with characters rather than
29
// strings split on kind of abitrary chars..
···
57
project_path = project_folder.clone();
58
project_path.push("skidmark.toml");
59
}
60
+
info_generic(&format!("Operatting on {:?}", &project_path.as_os_str()));
61
assert!(env::set_current_dir(&project_folder).is_ok());
62
63
let mut project = parse_project(&project_path);
···
68
num = num + group.files.len();
69
}
70
71
+
info_generic(&format!("Proccesing {} files.", num));
72
// for group in &mut project.filegroups {
73
// for infile in &mut group.files {
74
// process_skid(infile, group.convert_html, &mut project.context);
···
287
None
288
}
289
290
+
pub fn process_skid(
291
tokens_in: &[Token],
292
proj_context: &mut Project,
293
skid_context: &mut SkidContext,
···
305
let mut working_index = 0;
306
307
while working_index < tokens.len() {
308
+
if tokens[working_index].pre_proccessed {
309
+
working_index += 1;
310
+
continue;
311
+
}
312
+
313
if tokens[working_index] == '\\' && !escaped {
314
tokens[working_index].contents = '\0'; // skip over this later when outputting to avoid shifting memory rn
315
escaped = true;
+24
-4
src/project.rs
+24
-4
src/project.rs
···
15
pub global_post_insert: PathBuf,
16
17
pub filemap: Vec<PathBuf>, // mapped to index
18
}
19
20
pub struct FileGroup {
···
65
66
let mut project: Project = Project {
67
filegroups: Vec::new(),
68
-
//context: ProjectContext {
69
input_folder: PathBuf::new(),
70
output_folder: PathBuf::new(),
71
global_pre_insert: PathBuf::new(),
72
global_post_insert: PathBuf::new(),
73
filemap: Vec::new(),
74
-
//},
75
};
76
let config = tomlfile
77
.parse::<Table>()
···
173
fn file_for_index(&self, i: usize) -> Option<PathBuf>;
174
fn file_for_index_canonical(&self, i: usize) -> Option<&PathBuf>;
175
176
-
// fn index_of_section_name(&mut self, name: String) -> usize;
177
-
// fn section_name_for_index(&self, index: usize) -> String;
178
}
179
180
impl Indexing for Project {
···
204
return None;
205
}
206
return Some(&self.filemap[i]);
207
}
208
}
···
15
pub global_post_insert: PathBuf,
16
17
pub filemap: Vec<PathBuf>, // mapped to index
18
+
pub section_name_map: Vec<String>,
19
}
20
21
pub struct FileGroup {
···
66
67
let mut project: Project = Project {
68
filegroups: Vec::new(),
69
input_folder: PathBuf::new(),
70
output_folder: PathBuf::new(),
71
global_pre_insert: PathBuf::new(),
72
global_post_insert: PathBuf::new(),
73
filemap: Vec::new(),
74
+
section_name_map: Vec::new(),
75
};
76
let config = tomlfile
77
.parse::<Table>()
···
173
fn file_for_index(&self, i: usize) -> Option<PathBuf>;
174
fn file_for_index_canonical(&self, i: usize) -> Option<&PathBuf>;
175
176
+
fn index_of_section_name(&mut self, name: &String) -> usize;
177
+
fn section_name_for_index(&self, index: usize) -> Option<&String>;
178
}
179
180
impl Indexing for Project {
···
204
return None;
205
}
206
return Some(&self.filemap[i]);
207
+
}
208
+
209
+
// Some weirdly placed + and - 1 because 0 is the default index
210
+
fn index_of_section_name(&mut self, name: &String) -> usize {
211
+
let mut index = 0;
212
+
while index < self.section_name_map.len() {
213
+
if *name == self.section_name_map[index] {
214
+
return index + 1;
215
+
}
216
+
index += 1;
217
+
}
218
+
self.section_name_map.push(name.clone());
219
+
return self.section_name_map.len();
220
+
}
221
+
222
+
fn section_name_for_index(&self, index: usize) -> Option<&String> {
223
+
if (index - 1) >= self.section_name_map.len() {
224
+
return None;
225
+
}
226
+
return Some(&self.section_name_map[index - 1]);
227
}
228
}
+3
src/stringtools.rs
+3
src/stringtools.rs
···
1
use super::DELIMITERS;
2
use crate::types::Token;
3
4
+
//TODO: Theres a couple functions that are still written like tokens are strings not chars, they work fine
5
+
// for now but they may need to be changed later
6
+
7
pub fn collect_arguments(tokens: &[Token]) -> Option<(Vec<String>, usize)> {
8
// Returns arguments vec and number of tokens to be consumed
9
//let mut output = Vec::new();
+7
-9
src/types.rs
+7
-9
src/types.rs
···
12
pub origin_index: usize,
13
pub template_origin: usize,
14
pub origin_line: usize,
15
-
pub section_name_index: usize,
16
}
17
18
impl PartialEq<char> for Token {
···
134
impl Token {
135
pub fn new(contents: char, origin_file: usize, line_number: usize) -> Token {
136
Token {
137
-
contents: contents,
138
origin_index: origin_file,
139
template_origin: origin_file,
140
origin_line: line_number,
141
-
section_name_index: 0,
142
}
143
}
144
}
145
146
-
// impl ToString for Token {
147
-
// fn to_string(&self) -> String {
148
-
// return self.contents.clone();
149
-
// }
150
-
// }
151
-
152
impl Clone for Token {
153
fn clone(&self) -> Self {
154
let mut t = Token::new(
···
156
self.origin_index.clone(),
157
self.origin_line,
158
);
159
t.template_origin = self.template_origin;
160
return t;
161
}
162
}
···
12
pub origin_index: usize,
13
pub template_origin: usize,
14
pub origin_line: usize,
15
+
pub section_index: usize,
16
+
pub pre_proccessed: bool,
17
}
18
19
impl PartialEq<char> for Token {
···
135
impl Token {
136
pub fn new(contents: char, origin_file: usize, line_number: usize) -> Token {
137
Token {
138
+
contents,
139
origin_index: origin_file,
140
template_origin: origin_file,
141
origin_line: line_number,
142
+
section_index: 0,
143
+
pre_proccessed: false,
144
}
145
}
146
}
147
148
impl Clone for Token {
149
fn clone(&self) -> Self {
150
let mut t = Token::new(
···
152
self.origin_index.clone(),
153
self.origin_line,
154
);
155
+
t.section_index = self.section_index;
156
t.template_origin = self.template_origin;
157
+
t.pre_proccessed = self.pre_proccessed;
158
return t;
159
}
160
}