commit 141d8a02e0501dd6f2e0cf1527331f6210360fb6 · tholps.site/skidmark

+31 -11

src/macros/mod.rs

···

       9
       9
        
       use simple_macros::{macro_clear, macro_filename, macro_filename_canonical, macro_time};

     

       10
       10
        
       use template::macro_template;

     

       11
       11
        
       

     

       12
       12
       -
       pub static MACRO_LIST: &'static [Macro<'_>] = &[

     

       12
       12
       +
       pub static MACRO_LIST: &'static [Macro] = &[

     

       13
       13
        
           // Unscoped

     

       14
       14
        
           Macro {

     

       15
       15
        
               symbol: "insert", // Inserts another file

     

       16
       16
       -
               expand: macro_insert,

     

       16
       16
       +
               expansion: macro_insert,

     

       17
       17
        
               has_scope: false,

     

       18
       18
       +
               min_args: 1,

     

       19
       19
       +
               max_args: 1,

     

       18
       20
        
           },

     

       19
       21
        
           Macro {

     

       20
       22
        
               symbol: "clear", // Clears text buffer

     

       21
       21
       -
               expand: macro_clear,

     

       23
       23
       +
               expansion: macro_clear,

     

       22
       24
        
               has_scope: false,

     

       25
       25
       +
               min_args: 0,

     

       26
       26
       +
               max_args: 0,

     

       23
       27
        
           },

     

       24
       28
        
           Macro {

     

       25
       29
        
               symbol: "time",

     

       26
       26
       -
               expand: macro_time,

     

       30
       30
       +
               expansion: macro_time,

     

       27
       31
        
               has_scope: false,

     

       32
       32
       +
               min_args: 1,

     

       33
       33
       +
               max_args: 1,

     

       28
       34
        
           },

     

       29
       35
        
           Macro {

     

       30
       36
        
               symbol: "filename",

     

       31
       31
       -
               expand: macro_filename,

     

       37
       37
       +
               expansion: macro_filename,

     

       32
       38
        
               has_scope: false,

     

       39
       39
       +
               min_args: 0,

     

       40
       40
       +
               max_args: 0,

     

       33
       41
        
           },

     

       34
       42
        
           Macro {

     

       35
       43
        
               symbol: "filename_canonical",

     

       36
       36
       -
               expand: macro_filename_canonical,

     

       44
       44
       +
               expansion: macro_filename_canonical,

     

       37
       45
        
               has_scope: false,

     

       46
       46
       +
               min_args: 0,

     

       47
       47
       +
               max_args: 0,

     

       38
       48
        
           },

     

       39
       49
        
           // Scoped

     

       40
       50
        
           Macro {

     

       41
       51
        
               symbol: "comment", // Nothing

     

       42
       42
       -
               expand: macro_comment,

     

       52
       52
       +
               expansion: macro_comment,

     

       43
       53
        
               has_scope: true,

     

       54
       54
       +
               min_args: 0,

     

       55
       55
       +
               max_args: 0,

     

       44
       56
        
           },

     

       45
       57
        
           Macro {

     

       46
       58
        
               symbol: "repeat", // Outputs what its give x number of times

     

       47
       47
       -
               expand: macro_repeat,

     

       59
       59
       +
               expansion: macro_repeat,

     

       48
       60
        
               has_scope: true,

     

       61
       61
       +
               min_args: 1,

     

       62
       62
       +
               max_args: 1,

     

       49
       63
        
           },

     

       50
       64
        
           Macro {

     

       51
       65
        
               symbol: "section",

     

       52
       52
       -
               expand: macro_section,

     

       66
       66
       +
               expansion: macro_section,

     

       53
       67
        
               has_scope: true,

     

       68
       68
       +
               min_args: 0,

     

       69
       69
       +
               max_args: 1,

     

       54
       70
        
           },

     

       55
       71
        
           Macro {

     

       56
       72
        
               symbol: "template",

     

       57
       57
       -
               expand: macro_template,

     

       73
       73
       +
               expansion: macro_template,

     

       58
       74
        
               has_scope: true,

     

       75
       75
       +
               min_args: 1,

     

       76
       76
       +
               max_args: usize::max_value(),

     

       59
       77
        
           },

     

       60
       78
        
           Macro {

     

       61
       79
        
               symbol: "for_each_arg",

     

       62
       62
       -
               expand: macro_for_each_arg,

     

       80
       80
       +
               expansion: macro_for_each_arg,

     

       63
       81
        
               has_scope: true,

     

       82
       82
       +
               min_args: 1,

     

       83
       83
       +
               max_args: usize::max_value(),

     

       64
       84
        
           },

     

       65
       85
        
       ];

+4 -4

src/macros/simple_blocks.rs

···

       103
       103
        
                   let replacement = split_to_tokens(arg.clone(), origin_index);

     

       104
       104
        
                   arg_output.splice(start..start + len, replacement);

     

       105
       105
        
                   found_pattern = find_pattern(&arg_output, format!("[[..{}]]", replacement_index + 1));

     

       106
       106
       -
                   println!("{}", replacement_index + 1);

     

       106
       106
       +
                   //println!("{}", replacement_index + 1);

     

       107
       107
        
               }

     

       108
       108
        
       

     

       109
       109
       -
               println!("{} {}", replacement_index, replacement_count);

     

       109
       109
       +
               //println!("{} {}", replacement_index, replacement_count);

     

       110
       110
        
               replacement_index += 1;

     

       111
       111
        
               if replacement_index == replacement_count {

     

       112
       112
        
                   replacement_index = 0;

     

       113
       113
        
                   output.append(&mut arg_output.trim_whitespace().into());

     

       114
       114
        
                   arg_output = block.clone();

     

       115
       115
       -
                   println!("push");

     

       115
       115
       +
                   //println!("push");

     

       116
       116
        
               }

     

       117
       117
       -
               println!("test");

     

       117
       117
       +
               //println!("test");

     

       118
       118
        
           }

     

       119
       119
        
       

     

       120
       120
        
           return output;

+8 -8

src/macros/template.rs

···

       102
       102
        
                   args_index += 1;

     

       103
       103
        
               }

     

       104
       104
        
       

     

       105
       105
       -
               let mut found_block_pattern = find_pattern(&output, "[[{}]]".into());

     

       106
       106
       -
               while found_block_pattern.is_some() {

     

       107
       107
       -
                   let (start, len) = found_block_pattern.unwrap();

     

       108
       108
       -
                   let replacement = scope.to_vec();

     

       109
       109
       -
                   output.splice(start..start + len, replacement);

     

       110
       110
       -
                   found_block_pattern = find_pattern(&output, "[[{}]]".into());

     

       111
       111
       -
               }

     

       112
       112
       -
       

     

       113
       105
        
               //replace [[..]] with space seperated remaining args

     

       114
       106
        
               let mut found_trailing_pattern = find_pattern(&output, "[[..]]".into());

     

       115
       107
        
               while found_trailing_pattern.is_some() {

     
···

       135
       127
        
                   }

     

       136
       128
        
                   output.splice(start..start + len, replacement);

     

       137
       129
        
                   found_trailing_pattern = find_pattern(&output, "[[\"..\"]]".into());

     

       130
       130
       +
               }

     

       131
       131
       +
       

     

       132
       132
       +
               let mut found_block_pattern = find_pattern(&output, "[[{}]]".into());

     

       133
       133
       +
               while found_block_pattern.is_some() {

     

       134
       134
       +
                   let (start, len) = found_block_pattern.unwrap();

     

       135
       135
       +
                   let replacement = scope.to_vec();

     

       136
       136
       +
                   output.splice(start..start + len, replacement);

     

       137
       137
       +
                   found_block_pattern = find_pattern(&output, "[[{}]]".into());

     

       138
       138
        
               }

     

       139
       139
        
       

     

       140
       140
        
               output

+49 -35

src/main.rs

···

       7
       7
        
       use console::*;

     

       8
       8
        
       use macros::MACRO_LIST;

     

       9
       9
        
       use markdown::{to_html_with_options, CompileOptions, Constructs, Options, ParseOptions};

     

       10
       10
       -
       use projectparse::{parse_project, FileIndexing, ProjectContext};

     

       10
       10
       +
       use projectparse::{parse_project, FileGroup, FileIndexing, ProjectContext};

     

       11
       11
        
       use std::{

     

       12
       12
       -
           env,

     

       12
       12
       +
           convert, env,

     

       13
       13
        
           fs::{self, File},

     

       14
       14
        
           io::Write,

     

       15
       15
        
           path::PathBuf,

     
···

       20
       20
        
           trim_whitespace_tokens,

     

       21
       21
        
       };

     

       22
       22
        
       use types::{InputFile, Macro, Token};

     

       23
       23
       +
       

     

       24
       24
       +
       use crate::types::Expand;

     

       23
       25
        
       

     

       24
       26
        
       static DELIMITERS: &'static [char] = &[

     

       25
       27
        
           ' ', '\n', '\t', '(', ')', '{', '}', '[', ']', '<', '>', '\\', '\'', '\"', ';',

     
···

       55
       57
        
           println!("Proccesing {} files.", num);

     

       56
       58
        
           for group in &mut project.filegroups {

     

       57
       59
        
               for infile in &mut group.files {

     

       58
       58
       -
                   process_file(infile, &mut project.context);

     

       60
       60
       +
                   process_file(infile, group.convert_html, &mut project.context);

     

       59
       61
        
               }

     

       60
       62
        
           }

     

       61
       63
        
       }

     

       62
       64
        
       

     

       63
       63
       -
       fn process_file(file: &mut InputFile, context: &mut ProjectContext) {

     

       65
       65
       +
       fn process_file(file: &mut InputFile, convert_html: bool, context: &mut ProjectContext) {

     

       64
       66
        
           //}, context: &mut ProjectContext) {

     

       65
       67
        
           let contents = fs::read_to_string(&file.file_input).expect("File unreadable or missing");

     

       66
       68
        
           //println!("{}\n {}", f.filename_out, contents);

     
···

       138
       140
        
                                   if ephemeral {

     

       139
       141
        
                                       expansion = Vec::new();

     

       140
       142
        
                                   } else {

     

       141
       141
       -
                                       expansion = (m.expand)(

     

       143
       143
       +
                                       expansion = m.expand(

     

       142
       144
        
                                           file,

     

       143
       145
        
                                           file.tokens[file.working_index].origin_file,

     

       144
       146
        
                                           file.tokens[file.working_index].line_number,

     
···

       153
       155
        
                                   if ephemeral {

     

       154
       156
        
                                       expansion = Vec::new();

     

       155
       157
        
                                   } else {

     

       156
       156
       -
                                       expansion = (m.expand)(

     

       158
       158
       +
                                       expansion = m.expand(

     

       157
       159
        
                                           file,

     

       158
       160
        
                                           file.tokens[file.working_index].origin_file,

     

       159
       161
        
                                           file.tokens[file.working_index].line_number,

     
···

       270
       272
        
           for t in &file.tokens {

     

       271
       273
        
               skid_output += &t.contents;

     

       272
       274
        
           }

     

       273
       273
       -
           fs::write(&file.file_skidout, &skid_output).expect("Couldn't write skid to file");

     

       274
       275
        
       

     

       275
       275
       -
           //let html_output = markdown::to_html(&skid_output);

     

       276
       276
       -
           let html_output = markdown::to_html_with_options(

     

       277
       277
       -
               &skid_output,

     

       278
       278
       -
               &Options {

     

       279
       279
       -
                   compile: CompileOptions {

     

       280
       280
       -
                       allow_dangerous_html: true,

     

       281
       281
       -
                       allow_dangerous_protocol: true,

     

       282
       282
       -
                       gfm_tagfilter: false,

     

       283
       283
       -
                       // gfm_footnote_clobber_prefix:

     

       284
       284
       -
                       gfm_task_list_item_checkable: true,

     

       285
       285
       -
                       allow_any_img_src: true,

     

       286
       286
       -
                       ..CompileOptions::gfm()

     

       287
       287
       -
                   },

     

       288
       288
       -
                   parse: ParseOptions {

     

       289
       289
       -
                       constructs: Constructs {

     

       290
       290
       -
                           code_indented: false,

     

       291
       291
       -
                           ..Constructs::gfm()

     

       276
       276
       +
           if convert_html {

     

       277
       277
       +
               fs::write(&file.file_skidout, &skid_output).expect("Couldn't write skid to file");

     

       278
       278
       +
       

     

       279
       279
       +
               //let html_output = markdown::to_html(&skid_output);

     

       280
       280
       +
               let html_output = markdown::to_html_with_options(

     

       281
       281
       +
                   &skid_output,

     

       282
       282
       +
                   &Options {

     

       283
       283
       +
                       compile: CompileOptions {

     

       284
       284
       +
                           allow_dangerous_html: true,

     

       285
       285
       +
                           allow_dangerous_protocol: true,

     

       286
       286
       +
                           gfm_tagfilter: false,

     

       287
       287
       +
                           // gfm_footnote_clobber_prefix:

     

       288
       288
       +
                           gfm_task_list_item_checkable: true,

     

       289
       289
       +
                           allow_any_img_src: true,

     

       290
       290
       +
                           ..CompileOptions::gfm()

     

       292
       291
        
                       },

     

       293
       293
       -
                       ..ParseOptions::default()

     

       292
       292
       +
                       parse: ParseOptions {

     

       293
       293
       +
                           constructs: Constructs {

     

       294
       294
       +
                               code_indented: false,

     

       295
       295
       +
                               //html_flow: false,

     

       296
       296
       +
                               ..Constructs::gfm()

     

       297
       297
       +
                           },

     

       298
       298
       +
                           ..ParseOptions::default()

     

       299
       299
       +
                       },

     

       294
       300
        
                   },

     

       295
       295
       -
               },

     

       296
       296
       -
           )

     

       297
       297
       -
           .unwrap();

     

       298
       298
       -
           fs::write(&file.file_htmlout, &html_output).expect("Couldn't write html to file");

     

       299
       299
       -
           ok_generic(format!(

     

       300
       300
       -
               "\"{}\" written \n\n",

     

       301
       301
       -
               file.file_htmlout

     

       302
       302
       -
                   .to_str()

     

       303
       303
       -
                   .unwrap_or("Couldnt Unwrap htmlout name")

     

       304
       304
       -
           ));

     

       301
       301
       +
               )

     

       302
       302
       +
               .unwrap();

     

       303
       303
       +
               fs::write(&file.file_out, &html_output).expect("Couldn't write output to file");

     

       304
       304
       +
               ok_generic(format!(

     

       305
       305
       +
                   "\"{}\" written \n\n",

     

       306
       306
       +
                   file.file_out

     

       307
       307
       +
                       .to_str()

     

       308
       308
       +
                       .unwrap_or("Couldnt Unwrap file_out name")

     

       309
       309
       +
               ));

     

       310
       310
       +
           } else {

     

       311
       311
       +
               fs::write(&file.file_out, &skid_output).expect("Couldn't write output to file");

     

       312
       312
       +
               ok_generic(format!(

     

       313
       313
       +
                   "\"{}\" written \n\n",

     

       314
       314
       +
                   file.file_out

     

       315
       315
       +
                       .to_str()

     

       316
       316
       +
                       .unwrap_or("Couldnt Unwrap file_out name")

     

       317
       317
       +
               ));

     

       318
       318
       +
           }

     

       305
       319
        
       }

+12 -5

src/projectparse.rs

···

       21
       21
        
           pub pre_insert: PathBuf,

     

       22
       22
        
           pub post_insert: PathBuf,

     

       23
       23
        
           pub process: bool,

     

       24
       24
       +
           pub convert_html: bool,

     

       25
       25
       +
           pub output_extention: String,

     

       24
       26
        
       }

     

       25
       27
        
       

     

       26
       28
        
       // pub struct ProjectSettings {

     
···

       118
       120
        
                   continue;

     

       119
       121
        
               }

     

       120
       122
        
               let filegroup_def: &toml::map::Map<String, toml::Value> = v.as_table().unwrap();

     

       121
       121
       -
               let name = k.clone();

     

       123
       123
       +
       

     

       122
       124
        
               let pre_insert = get_table_string_or_default!(filegroup_def, "preInsert", "");

     

       123
       125
        
               let post_insert = get_table_string_or_default!(filegroup_def, "postInsert", "");

     

       124
       126
        
               let process = get_table_bool_or_default!(filegroup_def, "process", false);

     

       127
       127
       +
               let convert_html = get_table_bool_or_default!(filegroup_def, "convertHTML", true);

     

       128
       128
       +
               let extention = get_table_string_or_default!(filegroup_def, "outputExtention", "html");

     

       125
       129
        
       

     

       126
       130
        
               let recurse_find = get_table_bool_or_default!(filegroup_def, "recursiveFind", false);

     

       127
       131
        
       

     
···

       133
       137
        
                   pre_insert: pre_insert.into(),

     

       134
       138
        
                   post_insert: post_insert.into(),

     

       135
       139
        
                   process,

     

       140
       140
       +
                   convert_html,

     

       141
       141
       +
                   output_extention: extention.into(),

     

       136
       142
        
               };

     

       137
       143
        
       

     

       138
       144
        
               if filegroup_def.contains_key("files") {

     
···

       146
       152
        
                               k

     

       147
       153
        
                           )

     

       148
       154
        
                       });

     

       155
       155
       +
       

     

       149
       156
        
                       let mut new_file = crate::types::InputFile::new();

     

       150
       157
        
                       new_file.file_input = project.context.input_folder.clone();

     

       151
       158
        
                       new_file.file_input.push(filename);

     

       152
       159
        
       

     

       153
       153
       -
                       new_file.file_htmlout = project.context.output_folder.clone();

     

       154
       154
       -
                       new_file.file_htmlout.push(filename);

     

       155
       155
       -
                       new_file.file_htmlout.set_extension("html");

     

       160
       160
       +
                       new_file.file_out = project.context.output_folder.clone();

     

       161
       161
       +
                       new_file.file_out.push(filename);

     

       162
       162
       +
                       new_file.file_out.set_extension(extention);

     

       156
       163
        
       

     

       157
       157
       -
                       new_file.file_skidout = new_file.file_htmlout.clone();

     

       164
       164
       +
                       new_file.file_skidout = new_file.file_out.clone();

     

       158
       165
        
                       new_file.file_skidout.set_extension("sko");

     

       159
       166
        
       

     

       160
       167
        
                       group.files.push(new_file);

src/stringtools.rs

···

       262
       262
        
       

     

       263
       263
        
       pub fn find_pattern(tokens: &[Token], pat: String) -> Option<(usize, usize)> {

     

       264
       264
        
           // (startpoint, length)

     

       265
       265
       +
           // FIXME: this fucks up when the begining of a pattern is repeated

     

       266
       266
       +
           // ex. searching for "[[hello]]" in "[[[[hello]]" yeilds None

     

       267
       267
       +
           // ALSO, this is a coarse search, operating on tokens only, not the characters within

     

       265
       268
        
           let split_pattern = split_to_tokens(pat, 0);

     

       266
       269
        
           let mut pattern_index: usize = 0;

     

       267
       270
        
           let mut token_index: usize = 0;

+56 -6

src/types.rs

···

       1
       1
        
       use std::path::PathBuf;

     

       2
       2
        
       

     

       3
       3
       -
       use crate::{macros::template::SkidTemplate, projectparse::ProjectContext};

     

       3
       3
       +
       use crate::{

     

       4
       4
       +
           console::error_skid,

     

       5
       5
       +
           macros::{simple_blocks::macro_comment, template::SkidTemplate},

     

       6
       6
       +
           projectparse::ProjectContext,

     

       7
       7
       +
       };

     

       4
       8
        
       

     

       5
       9
        
       pub struct Token {

     

       6
       10
        
           pub contents: String,

     
···

       12
       16
        
       pub struct InputFile {

     

       13
       17
        
           pub file_input: PathBuf,

     

       14
       18
        
           pub file_skidout: PathBuf,

     

       15
       15
       -
           pub file_htmlout: PathBuf,

     

       19
       19
       +
           pub file_out: PathBuf,

     

       16
       20
        
           pub tokens: Vec<Token>,

     

       17
       21
        
           pub working_index: usize,

     

       18
       22
        
           pub templates: Vec<SkidTemplate>,

     
···

       29
       33
        
       //     _scope: &[Token],

     

       30
       34
        
       // ) -> Vec<Token>

     

       31
       35
        
       

     

       32
       32
       -
       pub struct Macro<'a> {

     

       33
       33
       -
           pub symbol: &'a str,

     

       34
       34
       -
           pub expand: MacroExpansion,

     

       36
       36
       +
       pub struct Macro {

     

       37
       37
       +
           pub symbol: &'static str,

     

       38
       38
       +
           pub expansion: MacroExpansion,

     

       35
       39
        
           pub has_scope: bool, //takes blocks of text input as well as parameters using {{...}}

     

       40
       40
       +
           pub min_args: usize,

     

       41
       41
       +
           pub max_args: usize,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       pub trait Expand {

     

       45
       45
       +
           fn expand(

     

       46
       46
       +
               &self,

     

       47
       47
       +
               input_file: &mut InputFile,

     

       48
       48
       +
               origin_index: usize,

     

       49
       49
       +
               origin_line: usize,

     

       50
       50
       +
               context: &mut ProjectContext,

     

       51
       51
       +
               args: &Vec<String>,

     

       52
       52
       +
               scope: &[Token],

     

       53
       53
       +
           ) -> Vec<Token>;

     

       54
       54
       +
       

     

       55
       55
       +
           fn default() -> Macro;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       impl Expand for Macro {

     

       59
       59
       +
           fn expand(

     

       60
       60
       +
               &self,

     

       61
       61
       +
               input_file: &mut InputFile,

     

       62
       62
       +
               origin_index: usize,

     

       63
       63
       +
               origin_line: usize,

     

       64
       64
       +
               context: &mut ProjectContext,

     

       65
       65
       +
               args: &Vec<String>,

     

       66
       66
       +
               scope: &[Token],

     

       67
       67
       +
           ) -> Vec<Token> {

     

       68
       68
       +
               if (args.len() > self.max_args) || (args.len() < self.min_args) {

     

       69
       69
       +
                   error_skid(context, origin_index, origin_line, format!("Macro \'{}\' was given a number of arguments ({}) not in its acceptable range ({}-{})",

     

       70
       70
       +
               self.symbol, args.len(), self.min_args, if self.max_args == usize::max_value() {"No Limit".to_string()} else {format!("{}", self.max_args)}));

     

       71
       71
       +
                   Vec::new()

     

       72
       72
       +
               } else {

     

       73
       73
       +
                   (self.expansion)(input_file, origin_index, origin_line, context, args, scope)

     

       74
       74
       +
               }

     

       75
       75
       +
           }

     

       76
       76
       +
       

     

       77
       77
       +
           fn default() -> Macro {

     

       78
       78
       +
               Macro {

     

       79
       79
       +
                   symbol: "default_symbol",

     

       80
       80
       +
                   expansion: macro_comment,

     

       81
       81
       +
                   has_scope: true,

     

       82
       82
       +
                   min_args: 0,

     

       83
       83
       +
                   max_args: usize::max_value(),

     

       84
       84
       +
               }

     

       85
       85
       +
           }

     

       36
       86
        
       }

     

       37
       87
        
       

     

       38
       88
        
       impl InputFile {

     
···

       40
       90
        
               InputFile {

     

       41
       91
        
                   file_input: "".into(),

     

       42
       92
        
                   file_skidout: "".into(),

     

       43
       43
       -
                   file_htmlout: "".into(),

     

       93
       93
       +
                   file_out: "".into(),

     

       44
       94
        
                   tokens: Vec::new(),

     

       45
       95
        
                   working_index: 0,

     

       46
       96
        
                   templates: Vec::new(),