commit 0bb5d81bae4b881e8819d2fd253e50e2f1232ad6 · tholps.site/skidmark

+1 -2

src/macros/insert.rs

···

       36
       36
        
           let mut search_from_root = arg.starts_with("//");

     

       37
       37
        
           let mut ok = false;

     

       38
       38
        
       

     

       39
       39
       -
           if search_from_root

     

       40
       40
       -
           {

     

       39
       39
       +
           if search_from_root {

     

       41
       40
        
               arg.drain(0..2); //remove "//"

     

       42
       41
        
           }

     

       43
       42

+9 -2

src/macros/mod.rs

···

       1
       1
        
       pub mod clear;

     

       2
       2
        
       pub mod insert;

     

       3
       3
        
       pub mod simple_blocks;

     

       4
       4
       +
       pub mod template;

     

       4
       5
        
       use super::types::Macro;

     

       5
       6
        
       

     

       6
       7
        
       use clear::macro_clear;

     

       7
       8
        
       use insert::macro_insert;

     

       8
       9
        
       use simple_blocks::{macro_comment, macro_null, macro_repeat};

     

       10
       10
       +
       use template::macro_template;

     

       9
       11
        
       

     

       10
       10
       -
       pub static MACRO_LIST: [Macro<'_>; 5] = [

     

       12
       12
       +
       pub static MACRO_LIST: [Macro<'_>; 6] = [

     

       11
       13
        
           // Unscoped

     

       12
       14
        
           Macro {

     

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

     
···

       31
       33
        
               has_scope: true,

     

       32
       34
        
           },

     

       33
       35
        
           Macro {

     

       34
       34
       -
               symbol: "preformatted",

     

       36
       36
       +
               symbol: "section",

     

       35
       37
        
               expand: macro_null,

     

       38
       38
       +
               has_scope: true,

     

       39
       39
       +
           },

     

       40
       40
       +
           Macro {

     

       41
       41
       +
               symbol: "template",

     

       42
       42
       +
               expand: macro_template,

     

       36
       43
        
               has_scope: true,

     

       37
       44
        
           },

     

       38
       45
        
       ];

+27 -16

src/main.rs

···

       4
       4
        
       mod types;

     

       5
       5
        
       

     

       6
       6
        
       use macros::MACRO_LIST;

     

       7
       7
       -
       use markdown::{to_html_with_options, CompileOptions, Options};

     

       7
       7
       +
       use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};

     

       8
       8
        
       use projectparse::{parse_project, FileIndexing, ProjectContext};

     

       9
       9
        
       use std::{

     

       10
       10
        
           env,

     
···

       19
       19
        
       };

     

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

     

       21
       21
        
       

     

       22
       22
       -
       static DELIMITERS: [char; 12] = [' ', '\n', '\t', '(', ')', '{', '}', '[', ']', '\\', '\'', '\"'];

     

       22
       22
       +
       static DELIMITERS: [char; 12] = [

     

       23
       23
       +
           ' ', '\n', '\t', '(', ')', '{', '}', '[', ']', '\\', '\'', '\"',

     

       24
       24
       +
       ];

     

       23
       25
        
       

     

       24
       26
        
       fn main() {

     

       25
       27
        
           let mut project_folder = PathBuf::from(env::current_dir().unwrap().as_path());

     
···

       66
       68
        
       

     

       67
       69
        
           while file.working_index < file.tokens.len() {

     

       68
       70
        
               //look for macros or blocks

     

       69
       69
       -
               println!(">\"{}\"<", file.tokens[file.working_index].contents);

     

       71
       71
       +
               //println!(">\"{}\"<", file.tokens[file.working_index].contents);

     

       70
       72
        
       

     

       71
       73
        
               if file.tokens[file.working_index].contents == "\\" {

     

       72
       74
        
                   file.working_index += 2;

     
···

       107
       109
        
                                   collect_arguments(&file.tokens[file.working_index..]);

     

       108
       110
        
                               let expansion: Vec<Token>;

     

       109
       111
        
                               let block_tokcount: usize;

     

       110
       110
       -
                               if ephemeral {

     

       111
       111
       -
                                   expansion = Vec::new();

     

       112
       112
       -
                                   block_tokcount = 0;

     

       113
       113
       -
                               } else {

     

       114
       114
       -
                                   if m.has_scope {

     

       115
       115
       -
                                       let block: Vec<Token>;

     

       116
       116
       -
                                       (block, block_tokcount) = collect_block(

     

       117
       117
       -
                                           &file.tokens[(file.working_index + args_tokcount)..],

     

       118
       118
       -
                                       );

     

       119
       119
       -
                                       println!("{}", block_tokcount);

     

       112
       112
       +
       

     

       113
       113
       +
                               if m.has_scope {

     

       114
       114
       +
                                   println!("is scoped.");

     

       115
       115
       +
                                   let block: Vec<Token>;

     

       116
       116
       +
                                   (block, block_tokcount) =

     

       117
       117
       +
                                       collect_block(&file.tokens[(file.working_index + args_tokcount)..]);

     

       118
       118
       +
       

     

       119
       119
       +
                                   if ephemeral {

     

       120
       120
       +
                                       expansion = Vec::new();

     

       121
       121
       +
                                   } else {

     

       120
       122
        
                                       expansion = (m.expand)(

     

       121
       123
        
                                           file,

     

       122
       124
        
                                           file.tokens[file.working_index].origin_file,

     

       123
       125
        
                                           context,

     

       124
       126
        
                                           &args,

     

       125
       125
       -
                                           &block[..],

     

       127
       127
       +
                                           &block[3..block.len() - 3],

     

       126
       128
        
                                       );

     

       129
       129
       +
                                   }

     

       130
       130
       +
                               } else {

     

       131
       131
       +
                                   block_tokcount = 0;

     

       132
       132
       +
       

     

       133
       133
       +
                                   if ephemeral {

     

       134
       134
       +
                                       expansion = Vec::new();

     

       127
       135
        
                                   } else {

     

       128
       128
       -
                                       block_tokcount = 0;

     

       129
       136
        
                                       expansion = (m.expand)(

     

       130
       137
        
                                           file,

     

       131
       138
        
                                           file.tokens[file.working_index].origin_file,

     
···

       177
       184
        
                   compile: CompileOptions {

     

       178
       185
        
                       allow_dangerous_html: true,

     

       179
       186
        
                       allow_dangerous_protocol: true,

     

       187
       187
       +
                       gfm_tagfilter: false,

     

       188
       188
       +
                       // gfm_footnote_clobber_prefix:

     

       189
       189
       +
                       gfm_task_list_item_checkable: true,

     

       190
       190
       +
                       allow_any_img_src: true,

     

       180
       191
        
                       ..CompileOptions::gfm()

     

       181
       192
        
                   },

     

       182
       182
       -
                   ..Options::gfm()

     

       193
       193
       +
                   ..Options::default()

     

       183
       194
        
               },

     

       184
       195
        
           )

     

       185
       196
        
           .unwrap();

+1 -1

src/projectparse.rs

···

       174
       174
        
       

     

       175
       175
        
       impl FileIndexing for ProjectContext {

     

       176
       176
        
           fn index_of_file(&mut self, f: &PathBuf) -> usize {

     

       177
       177
       -
               let mut cannonical = f.canonicalize().unwrap();

     

       177
       177
       +
               let cannonical = f.canonicalize().unwrap();

     

       178
       178
        
               let mut index = 0;

     

       179
       179
        
               for p in &self.filemap {

     

       180
       180
        
                   if cannonical == *p {

+11 -2

src/stringtools.rs

···

       1
       1
        
       use core::fmt;

     

       2
       2
       -
       use std::{ascii::escape_default, fmt::Arguments, ops::Index, process::exit, thread::sleep};

     

       2
       2
       +
       use std::{ascii::escape_default, error, fmt::Arguments, ops::Index, process::exit, thread::sleep};

     

       3
       3
        
       

     

       4
       4
        
       use super::DELIMITERS;

     

       5
       5
        
       use crate::types::Token;

     
···

       83
       83
        
                   if tok.contents != "{"

     

       84
       84
        
                   // Expected block start, got garbage

     

       85
       85
        
                   {

     

       86
       86
       +
                       // println!("Expected block start, got {}",tok.contents);

     

       87
       87
       +
                       // for t in &block

     

       88
       88
       +
                       // {

     

       89
       89
       +
                       //     print!("{} ", t.contents);

     

       90
       90
       +
                       // }

     

       91
       91
       +
                       // exit(1);

     

       86
       92
        
                       return (Vec::new(), 0);

     

       87
       93
        
                   }

     

       88
       94
        
               }

     
···

       115
       121
        
                       scope_count -= 1;

     

       116
       122
        
                       entering_bracket_count = 0;

     

       117
       123
        
                   }

     

       124
       124
       +
                   if scope_count == 0 {

     

       125
       125
       +
                       break;

     

       126
       126
       +
                   }

     

       118
       127
        
               } else {

     

       119
       119
       -
                   entering_bracket_count = 0;

     

       128
       128
       +
                   exiting_bracket_count = 0;

     

       120
       129
        
               }

     

       121
       130
        
               if tok.contents == "\\" {

     

       122
       131
        
                   escaped = true;