commit 13a99e73ae4f2868422974c04324c0efe6153034 · tholps.site/skidmark

+5 -5

src/closures.rs

···

       5
       5
        
       use boa_engine::Context;

     

       6
       6
        
       

     

       7
       7
        
       use crate::{

     

       8
       8
       -
           project::ProjectContext,

     

       8
       8
       +
           project::Project,

     

       9
       9
        
           types::{SkidContext, Token},

     

       10
       10
        
       };

     

       11
       11
        
       

     

       12
       12
       -
       type ClosureFunction = fn(&[Token], &mut ProjectContext, &mut SkidContext) -> Vec<Token>;

     

       12
       12
       +
       type ClosureFunction = fn(&[Token], &mut Project, &mut SkidContext) -> Vec<Token>;

     

       13
       13
        
       

     

       14
       14
        
       pub struct Closure {

     

       15
       15
        
           pub opener: &'static str,

     
···

       55
       55
        
       

     

       56
       56
        
       fn closure_comment(

     

       57
       57
        
           _tokens: &[Token],

     

       58
       58
       -
           _project_context: &mut ProjectContext,

     

       58
       58
       +
           _project_context: &mut Project,

     

       59
       59
        
           _skid_context: &mut SkidContext,

     

       60
       60
        
       ) -> Vec<Token> {

     

       61
       61
        
           Vec::new()

     
···

       63
       63
        
       

     

       64
       64
        
       fn closure_section(

     

       65
       65
        
           tokens: &[Token],

     

       66
       66
       -
           _project_context: &mut ProjectContext,

     

       66
       66
       +
           _project_context: &mut Project,

     

       67
       67
        
           _skid_context: &mut SkidContext,

     

       68
       68
        
       ) -> Vec<Token> {

     

       69
       69
        
           tokens.to_vec()

     
···

       71
       71
        
       

     

       72
       72
        
       fn closure_js(

     

       73
       73
        
           tokens: &[Token],

     

       74
       74
       -
           project_context: &mut ProjectContext,

     

       74
       74
       +
           project_context: &mut Project,

     

       75
       75
        
           skid_context: &mut SkidContext,

     

       76
       76
        
       ) -> Vec<Token> {

     

       77
       77
        
           Vec::new()

+7 -7

src/console.rs

···

       2
       2
        
       

     

       3
       3
        
       use colored::Colorize;

     

       4
       4
        
       

     

       5
       5
       -
       use crate::project::{Indexing, ProjectContext};

     

       5
       5
       +
       use crate::project::{Indexing, Project};

     

       6
       6
        
       

     

       7
       7
        
       pub fn error_generic(msg: &String) {

     

       8
       8
        
           println!("{} {}", "[ERROR]".red(), msg);

     

       9
       9
        
           exit(1);

     

       10
       10
        
       }

     

       11
       11
        
       

     

       12
       12
       -
       pub fn error_skid(context: &ProjectContext, origin_index: usize, origin_line: usize, msg: &String) {

     

       12
       12
       +
       pub fn error_skid(proj_context: &Project, origin_index: usize, origin_line: usize, msg: &String) {

     

       13
       13
        
           println!(

     

       14
       14
        
               "{} {}:{}; {}",

     

       15
       15
        
               "[ERROR]".red(),

     

       16
       16
       -
               context

     

       16
       16
       +
               proj_context

     

       17
       17
        
                   .file_for_index(origin_index)

     

       18
       18
        
                   .expect("Panic in the error func.... (file_for_index() was None!)")

     

       19
       19
        
                   .into_os_string()

     
···

       29
       29
        
           println!("{} {}", "[WARN]".yellow(), msg);

     

       30
       30
        
       }

     

       31
       31
        
       

     

       32
       32
       -
       pub fn warn_skid(context: &ProjectContext, origin_index: usize, origin_line: usize, msg: &String) {

     

       32
       32
       +
       pub fn warn_skid(proj_context: &Project, origin_index: usize, origin_line: usize, msg: &String) {

     

       33
       33
        
           println!(

     

       34
       34
        
               "{} {}:{}; {}",

     

       35
       35
        
               "[WARN]".yellow(),

     

       36
       36
       -
               context

     

       36
       36
       +
               proj_context

     

       37
       37
        
                   .file_for_index(origin_index)

     

       38
       38
        
                   .expect("Panic in the warn func.... (file_for_index() was None!)")

     

       39
       39
        
                   .into_os_string()

     
···

       49
       49
        
       }

     

       50
       50
        
       

     

       51
       51
        
       pub fn reminder_skid(

     

       52
       52
       -
           context: &ProjectContext,

     

       52
       52
       +
           proj_context: &Project,

     

       53
       53
        
           origin_index: usize,

     

       54
       54
        
           origin_line: usize,

     

       55
       55
        
           msg: &String,

     
···

       57
       57
        
           println!(

     

       58
       58
        
               "{} {}:{}; {}",

     

       59
       59
        
               "[REMINDER]".cyan(),

     

       60
       60
       -
               context

     

       60
       60
       +
               proj_context

     

       61
       61
        
                   .file_for_index(origin_index)

     

       62
       62
        
                   .expect("Panic in the warn func.... (file_for_index() was None!)")

     

       63
       63
        
                   .into_os_string()

+131

src/macros/for_each.rs

···

       1
       1
       +
       use crate::{console::*, project::Project, stringtools::*, types::*};

     

       2
       2
       +
       

     

       3
       3
       +
       fn for_each_base(

     

       4
       4
       +
           identifier: &String,

     

       5
       5
       +
           replacements: &[String],

     

       6
       6
       +
           proj_context: &mut Project,

     

       7
       7
       +
           origin_index: usize,

     

       8
       8
       +
           origin_line: usize,

     

       9
       9
       +
           scope: &[Token],

     

       10
       10
       +
       ) -> Vec<Token> {

     

       11
       11
       +
           let mut output = Vec::new();

     

       12
       12
       +
           let block: Vec<Token> = scope.into();

     

       13
       13
       +
       

     

       14
       14
       +
           let mut replacement_count: usize = 0;

     

       15
       15
       +
       

     

       16
       16
       +
           let mut replacement_pattern = find_pattern(scope, format!("[[{}..1]]", identifier));

     

       17
       17
       +
       

     

       18
       18
       +
           if replacement_pattern.is_none() {

     

       19
       19
       +
               warn_skid(

     

       20
       20
       +
                   proj_context,

     

       21
       21
       +
                   origin_index,

     

       22
       22
       +
                   origin_line,

     

       23
       23
       +
                   &format!(

     

       24
       24
       +
                       "Macro `for_each_arg` given block with no \"[[{}..1]]\", intentional?",

     

       25
       25
       +
                       identifier

     

       26
       26
       +
                   ),

     

       27
       27
       +
               );

     

       28
       28
       +
           }

     

       29
       29
       +
       

     

       30
       30
       +
           while replacement_pattern.is_some() {

     

       31
       31
       +
               replacement_count += 1;

     

       32
       32
       +
               replacement_pattern = find_pattern(

     

       33
       33
       +
                   scope,

     

       34
       34
       +
                   format!("[[{}..{}]]", identifier, replacement_count + 1),

     

       35
       35
       +
               );

     

       36
       36
       +
           }

     

       37
       37
       +
       

     

       38
       38
       +
           if replacement_count == 0 {

     

       39
       39
       +
               for _i in 0..replacements.iter().count() {

     

       40
       40
       +
                   output.append(&mut block.clone());

     

       41
       41
       +
               }

     

       42
       42
       +
               return output;

     

       43
       43
       +
           }

     

       44
       44
       +
       

     

       45
       45
       +
           if replacements.len() % replacement_count != 0 {

     

       46
       46
       +
               error_skid(proj_context, origin_index, origin_line,

     

       47
       47
       +
                   &format!("`for_each_var` was not given a number of arguments({}) that was a multiple of its replacement posistions({}) (got {:?})",

     

       48
       48
       +
                   replacements.len(),

     

       49
       49
       +
                   replacement_count,

     

       50
       50
       +
                   replacements));

     

       51
       51
       +
           }

     

       52
       52
       +
       

     

       53
       53
       +
           let mut replacement_index: usize = 0;

     

       54
       54
       +
           let mut arg_output: Vec<Token> = block.clone();

     

       55
       55
       +
           for r in replacements {

     

       56
       56
       +
               let mut found_pattern = find_pattern(

     

       57
       57
       +
                   &arg_output,

     

       58
       58
       +
                   format!("[[{}..{}]]", identifier, replacement_index + 1),

     

       59
       59
       +
               );

     

       60
       60
       +
       

     

       61
       61
       +
               while found_pattern.is_some() {

     

       62
       62
       +
                   let (start, len) = found_pattern.unwrap();

     

       63
       63
       +
                   let replacement = split_to_tokens(r.clone(), origin_index);

     

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

     

       65
       65
       +
                   found_pattern = find_pattern(

     

       66
       66
       +
                       &arg_output,

     

       67
       67
       +
                       format!("[[{}..{}]]", identifier, replacement_index + 1),

     

       68
       68
       +
                   );

     

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

     

       70
       70
       +
               }

     

       71
       71
       +
       

     

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

     

       73
       73
       +
               replacement_index += 1;

     

       74
       74
       +
               if replacement_index == replacement_count {

     

       75
       75
       +
                   replacement_index = 0;

     

       76
       76
       +
                   output.append(&mut arg_output.trim_whitespace().into());

     

       77
       77
       +
                   arg_output = block.clone();

     

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

     

       79
       79
       +
               }

     

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

     

       81
       81
       +
           }

     

       82
       82
       +
           return output;

     

       83
       83
       +
       }

     

       84
       84
       +
       

     

       85
       85
       +
       pub fn macro_for_each_arg(

     

       86
       86
       +
           origin_index: usize,

     

       87
       87
       +
           origin_line: usize,

     

       88
       88
       +
           proj_context: &mut Project,

     

       89
       89
       +
           _skid_context: &mut SkidContext,

     

       90
       90
       +
           args: &Vec<String>,

     

       91
       91
       +
           scope: &[Token],

     

       92
       92
       +
       ) -> Vec<Token> {

     

       93
       93
       +
           return for_each_base(

     

       94
       94
       +
               &args[0],

     

       95
       95
       +
               &args[1..],

     

       96
       96
       +
               proj_context,

     

       97
       97
       +
               origin_index,

     

       98
       98
       +
               origin_line,

     

       99
       99
       +
               scope,

     

       100
       100
       +
           );

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       pub fn macro_for_each_file_in_group(

     

       104
       104
       +
           origin_index: usize,

     

       105
       105
       +
           origin_line: usize,

     

       106
       106
       +
           proj_context: &mut Project,

     

       107
       107
       +
           _skid_context: &mut SkidContext,

     

       108
       108
       +
           args: &Vec<String>,

     

       109
       109
       +
           scope: &[Token],

     

       110
       110
       +
       ) -> Vec<Token> {

     

       111
       111
       +
           let mut files: Vec<String> = Vec::new();

     

       112
       112
       +
           for g in &proj_context.filegroups {

     

       113
       113
       +
               if g.name == args[1] {

     

       114
       114
       +
                   for f in &g.files {

     

       115
       115
       +
                       let path = f

     

       116
       116
       +
                           .file_input

     

       117
       117
       +
                           .strip_prefix(&proj_context.input_folder)

     

       118
       118
       +
                           .unwrap();

     

       119
       119
       +
                       files.push(path.to_str().unwrap().into());

     

       120
       120
       +
                   }

     

       121
       121
       +
               }

     

       122
       122
       +
           }

     

       123
       123
       +
           return for_each_base(

     

       124
       124
       +
               &args[0],

     

       125
       125
       +
               &files,

     

       126
       126
       +
               proj_context,

     

       127
       127
       +
               origin_index,

     

       128
       128
       +
               origin_line,

     

       129
       129
       +
               scope,

     

       130
       130
       +
           );

     

       131
       131
       +
       }

+2 -2

src/macros/insert.rs

···

       3
       3
        
       use crate::{

     

       4
       4
        
           console::error_skid,

     

       5
       5
        
           macros::template::SkidTemplate,

     

       6
       6
       -
           project::{Indexing, ProjectContext},

     

       6
       6
       +
           project::{Indexing, Project},

     

       7
       7
        
           stringtools::split_to_tokens,

     

       8
       8
        
           types::{SkidContext, Token},

     

       9
       9
        
       };

     
···

       11
       11
        
       pub fn macro_insert(

     

       12
       12
        
           origin_index: usize,

     

       13
       13
        
           origin_line: usize,

     

       14
       14
       -
           context: &mut ProjectContext,

     

       14
       14
       +
           context: &mut Project,

     

       15
       15
        
           _skid_context: &mut SkidContext,

     

       16
       16
        
           args: &Vec<String>,

     

       17
       17
        
           _scope: &[Token],

+28 -14

src/macros/mod.rs

···

       1
       1
       +
       pub mod for_each;

     

       1
       2
        
       pub mod insert;

     

       2
       3
        
       pub mod simple_blocks;

     

       3
       4
        
       pub mod simple_macros;

     

       4
       5
        
       pub mod template;

     

       5
       5
       -
       use crate::macros::simple_macros::macro_reminder;

     

       6
       6
        
       

     

       7
       7
        
       use super::types::Macro;

     

       8
       8
       -
       

     

       8
       8
       +
       use for_each::*;

     

       9
       9
        
       use insert::macro_insert;

     

       10
       10
       -
       use simple_blocks::{macro_comment, macro_for_each_arg, macro_repeat, macro_section};

     

       11
       11
       -
       use simple_macros::{macro_filename, macro_filename_canonical, macro_time};

     

       10
       10
       +
       use simple_blocks::*;

     

       11
       11
       +
       use simple_macros::*;

     

       12
       12
        
       use template::macro_template;

     

       13
       13
        
       

     

       14
       14
        
       pub static MACRO_LIST: &'static [Macro] = &[

     
···

       16
       16
        
           Macro {

     

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

     

       18
       18
        
               expansion: macro_insert,

     

       19
       19
       -
               has_scope: false,

     

       19
       19
       +
               takes_block: false,

     

       20
       20
        
               min_args: 1,

     

       21
       21
        
               max_args: 1,

     

       22
       22
        
           },

     

       23
       23
        
           Macro {

     

       24
       24
        
               symbol: "time",

     

       25
       25
        
               expansion: macro_time,

     

       26
       26
       -
               has_scope: false,

     

       26
       26
       +
               takes_block: false,

     

       27
       27
        
               min_args: 1,

     

       28
       28
        
               max_args: 1,

     

       29
       29
        
           },

     

       30
       30
        
           Macro {

     

       31
       31
        
               symbol: "filename",

     

       32
       32
        
               expansion: macro_filename,

     

       33
       33
       -
               has_scope: false,

     

       33
       33
       +
               takes_block: false,

     

       34
       34
        
               min_args: 0,

     

       35
       35
        
               max_args: 0,

     

       36
       36
        
           },

     

       37
       37
        
           Macro {

     

       38
       38
        
               symbol: "filename_canonical",

     

       39
       39
        
               expansion: macro_filename_canonical,

     

       40
       40
       -
               has_scope: false,

     

       40
       40
       +
               takes_block: false,

     

       41
       41
        
               min_args: 0,

     

       42
       42
        
               max_args: 0,

     

       43
       43
        
           },

     

       44
       44
        
           Macro {

     

       45
       45
        
               symbol: "reminder",

     

       46
       46
        
               expansion: macro_reminder,

     

       47
       47
       -
               has_scope: false,

     

       47
       47
       +
               takes_block: false,

     

       48
       48
        
               min_args: 1,

     

       49
       49
        
               max_args: 1,

     

       50
       50
        
           },

     

       51
       51
       +
           Macro {

     

       52
       52
       +
               symbol: "output_filename",

     

       53
       53
       +
               expansion: macro_output_filename,

     

       54
       54
       +
               takes_block: false,

     

       55
       55
       +
               min_args: 0,

     

       56
       56
       +
               max_args: 1,

     

       57
       57
       +
           },

     

       51
       58
        
           // Scoped

     

       52
       59
        
           Macro {

     

       53
       60
        
               symbol: "comment", // Nothing

     

       54
       61
        
               expansion: macro_comment,

     

       55
       55
       -
               has_scope: true,

     

       62
       62
       +
               takes_block: true,

     

       56
       63
        
               min_args: 0,

     

       57
       64
        
               max_args: 0,

     

       58
       65
        
           },

     

       59
       66
        
           Macro {

     

       60
       67
        
               symbol: "repeat", // Outputs what its give x number of times

     

       61
       68
        
               expansion: macro_repeat,

     

       62
       62
       -
               has_scope: true,

     

       69
       69
       +
               takes_block: true,

     

       63
       70
        
               min_args: 1,

     

       64
       71
        
               max_args: 1,

     

       65
       72
        
           },

     

       66
       73
        
           Macro {

     

       67
       74
        
               symbol: "section",

     

       68
       75
        
               expansion: macro_section,

     

       69
       69
       -
               has_scope: true,

     

       76
       76
       +
               takes_block: true,

     

       70
       77
        
               min_args: 0,

     

       71
       78
        
               max_args: 1,

     

       72
       79
        
           },

     

       73
       80
        
           Macro {

     

       74
       81
        
               symbol: "template",

     

       75
       82
        
               expansion: macro_template,

     

       76
       76
       -
               has_scope: true,

     

       83
       83
       +
               takes_block: true,

     

       77
       84
        
               min_args: 1,

     

       78
       85
        
               max_args: usize::max_value(),

     

       79
       86
        
           },

     

       80
       87
        
           Macro {

     

       81
       88
        
               symbol: "for_each_arg",

     

       82
       89
        
               expansion: macro_for_each_arg,

     

       83
       83
       -
               has_scope: true,

     

       90
       90
       +
               takes_block: true,

     

       84
       91
        
               min_args: 1,

     

       85
       92
        
               max_args: usize::max_value(),

     

       93
       93
       +
           },

     

       94
       94
       +
           Macro {

     

       95
       95
       +
               symbol: "for_each_file_in_group",

     

       96
       96
       +
               expansion: macro_for_each_file_in_group,

     

       97
       97
       +
               takes_block: true,

     

       98
       98
       +
               min_args: 2,

     

       99
       99
       +
               max_args: 2,

     

       86
       100
        
           },

     

       87
       101
        
       ];

+6 -90

src/macros/simple_blocks.rs

···

       1
       1
        
       // This file for implementations of short blocks, im qualifying that as less than 30ish lines

     

       2
       2
       -
       

     

       3
       2
        
       use crate::{

     

       4
       4
       -
           console::{error_skid, warn_skid},

     

       5
       5
       -
           project::ProjectContext,

     

       6
       6
       -
           stringtools::{find_pattern, split_to_tokens, TokenTools},

     

       3
       3
       +
           console::*,

     

       4
       4
       +
           project::Project,

     

       5
       5
       +
           stringtools::TokenTools,

     

       7
       6
        
           types::{SkidContext, Token},

     

       8
       7
        
       };

     

       9
       8
        
       

     

       10
       9
        
       pub fn macro_comment(

     

       11
       10
        
           _origin_index: usize,

     

       12
       11
        
           _origin_line: usize,

     

       13
       13
       -
           _context: &mut ProjectContext,

     

       12
       12
       +
           _context: &mut Project,

     

       14
       13
        
           _skid_context: &mut SkidContext,

     

       15
       14
        
           _args: &Vec<String>,

     

       16
       15
        
           _scope: &[Token],

     
···

       21
       20
        
       pub fn macro_section(

     

       22
       21
        
           _origin_index: usize,

     

       23
       22
        
           _origin_line: usize,

     

       24
       24
       -
           _context: &mut ProjectContext,

     

       23
       23
       +
           _context: &mut Project,

     

       25
       24
        
           _skid_context: &mut SkidContext,

     

       26
       25
        
           _args: &Vec<String>,

     

       27
       26
        
           scope: &[Token],

     
···

       36
       35
        
       pub fn macro_repeat(

     

       37
       36
        
           _origin_index: usize,

     

       38
       37
        
           _origin_line: usize,

     

       39
       39
       -
           _context: &mut ProjectContext,

     

       38
       38
       +
           _context: &mut Project,

     

       40
       39
        
           _skid_context: &mut SkidContext,

     

       41
       40
        
           args: &Vec<String>,

     

       42
       41
        
           scope: &[Token],

     
···

       54
       53
        
           }

     

       55
       54
        
           return tokens;

     

       56
       55
        
       }

     

       57
       57
       -
       

     

       58
       58
       -
       pub fn macro_for_each_arg(

     

       59
       59
       -
           origin_index: usize,

     

       60
       60
       -
           origin_line: usize,

     

       61
       61
       -
           context: &mut ProjectContext,

     

       62
       62
       -
           _skid_context: &mut SkidContext,

     

       63
       63
       -
           args: &Vec<String>,

     

       64
       64
       -
           scope: &[Token],

     

       65
       65
       -
       ) -> Vec<Token> {

     

       66
       66
       -
           let mut output = Vec::new();

     

       67
       67
       -
           let block: Vec<Token> = scope.into();

     

       68
       68
       -
           let varname = &args[0];

     

       69
       69
       -
           let real_args = &args[1..];

     

       70
       70
       -
       

     

       71
       71
       -
           let mut replacement_count: usize = 0;

     

       72
       72
       -
       

     

       73
       73
       -
           let mut replacement_pattern = find_pattern(scope, format!("[[{}..1]]", varname));

     

       74
       74
       -
       

     

       75
       75
       -
           if replacement_pattern.is_none() {

     

       76
       76
       -
               warn_skid(

     

       77
       77
       -
                   context,

     

       78
       78
       -
                   origin_index,

     

       79
       79
       -
                   origin_line,

     

       80
       80
       -
                   &format!(

     

       81
       81
       -
                       "Macro `for_each_arg` given block with no \"[[{}..1]]\", intentional?",

     

       82
       82
       -
                       varname

     

       83
       83
       -
                   ),

     

       84
       84
       -
               );

     

       85
       85
       -
           }

     

       86
       86
       -
       

     

       87
       87
       -
           while replacement_pattern.is_some() {

     

       88
       88
       -
               replacement_count += 1;

     

       89
       89
       -
               replacement_pattern =

     

       90
       90
       -
                   find_pattern(scope, format!("[[{}..{}]]", varname, replacement_count + 1));

     

       91
       91
       -
           }

     

       92
       92
       -
       

     

       93
       93
       -
           if replacement_count == 0 {

     

       94
       94
       -
               for _i in 0..real_args.iter().count() {

     

       95
       95
       -
                   output.append(&mut block.clone());

     

       96
       96
       -
               }

     

       97
       97
       -
               return output;

     

       98
       98
       -
           }

     

       99
       99
       -
       

     

       100
       100
       -
           if real_args.len() % replacement_count != 0 {

     

       101
       101
       -
               error_skid(context, origin_index, origin_line,

     

       102
       102
       -
                   &format!("`for_each_var` was not given a number of arguments({}) that was a multiple of its replacement posistions({}) (got {:?})",

     

       103
       103
       -
                   real_args.len(),

     

       104
       104
       -
                   replacement_count,

     

       105
       105
       -
                   real_args));

     

       106
       106
       -
           }

     

       107
       107
       -
       

     

       108
       108
       -
           let mut replacement_index: usize = 0;

     

       109
       109
       -
           let mut arg_output: Vec<Token> = block.clone();

     

       110
       110
       -
           for arg in real_args {

     

       111
       111
       -
               let mut found_pattern = find_pattern(

     

       112
       112
       -
                   &arg_output,

     

       113
       113
       -
                   format!("[[{}..{}]]", varname, replacement_index + 1),

     

       114
       114
       -
               );

     

       115
       115
       -
       

     

       116
       116
       -
               while found_pattern.is_some() {

     

       117
       117
       -
                   let (start, len) = found_pattern.unwrap();

     

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

     

       119
       119
       -
                   arg_output.splice(start..start + len, replacement);

     

       120
       120
       -
                   found_pattern = find_pattern(

     

       121
       121
       -
                       &arg_output,

     

       122
       122
       -
                       format!("[[{}..{}]]", varname, replacement_index + 1),

     

       123
       123
       -
                   );

     

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

     

       125
       125
       -
               }

     

       126
       126
       -
       

     

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

     

       128
       128
       -
               replacement_index += 1;

     

       129
       129
       -
               if replacement_index == replacement_count {

     

       130
       130
       -
                   replacement_index = 0;

     

       131
       131
       -
                   output.append(&mut arg_output.trim_whitespace().into());

     

       132
       132
       -
                   arg_output = block.clone();

     

       133
       133
       -
                   //println!("push");

     

       134
       134
       -
               }

     

       135
       135
       -
               //println!("test");

     

       136
       136
       -
           }

     

       137
       137
       -
       

     

       138
       138
       -
           return output;

     

       139
       139
       -
       }

+52 -9

src/macros/simple_macros.rs

···

       4
       4
        
       use chrono::Local;

     

       5
       5
        
       

     

       6
       6
        
       use crate::{

     

       7
       7
       -
           console::{error_skid, reminder_skid},

     

       8
       8
       -
           macros::template::SkidTemplate,

     

       9
       9
       -
           project::{Indexing, ProjectContext},

     

       7
       7
       +
           args,

     

       8
       8
       +
           console::{error_skid, reminder_skid, warn_skid},

     

       9
       9
       +
           project::{Indexing, Project},

     

       10
       10
        
           stringtools::split_to_tokens,

     

       11
       11
        
           types::{SkidContext, Token},

     

       12
       12
        
       };

     
···

       14
       14
        
       pub fn macro_time(

     

       15
       15
        
           origin_index: usize,

     

       16
       16
        
           origin_line: usize,

     

       17
       17
       -
           context: &mut ProjectContext,

     

       17
       17
       +
           context: &mut Project,

     

       18
       18
        
           _skid_context: &mut SkidContext,

     

       19
       19
        
           args: &Vec<String>,

     

       20
       20
        
           _scope: &[Token],

     
···

       40
       40
        
       

     

       41
       41
        
       pub fn macro_filename(

     

       42
       42
        
           origin_index: usize,

     

       43
       43
       -
           origin_line: usize,

     

       44
       44
       -
           context: &mut ProjectContext,

     

       43
       43
       +
           _origin_line: usize,

     

       44
       44
       +
           proj_context: &mut Project,

     

       45
       45
        
           _skid_context: &mut SkidContext,

     

       46
       46
        
           _args: &Vec<String>,

     

       47
       47
        
           _scope: &[Token],

     

       48
       48
        
       ) -> Vec<Token> {

     

       49
       49
        
           return split_to_tokens(

     

       50
       50
       -
               context

     

       50
       50
       +
               proj_context

     

       51
       51
        
                   .file_for_index(origin_index)

     

       52
       52
        
                   .unwrap()

     

       53
       53
        
                   .to_str()

     
···

       57
       57
        
           );

     

       58
       58
        
       }

     

       59
       59
        
       

     

       60
       60
       +
       pub fn macro_output_filename(

     

       61
       61
       +
           origin_index: usize,

     

       62
       62
       +
           origin_line: usize,

     

       63
       63
       +
           proj_context: &mut Project,

     

       64
       64
       +
           _skid_context: &mut SkidContext,

     

       65
       65
       +
           args: &Vec<String>,

     

       66
       66
       +
           _scope: &[Token],

     

       67
       67
       +
       ) -> Vec<Token> {

     

       68
       68
       +
           let mut in_filepath = proj_context.input_folder.clone();

     

       69
       69
       +
           if args.len() == 0 {

     

       70
       70
       +
               in_filepath.push(proj_context.file_for_index(origin_index).unwrap());

     

       71
       71
       +
           } else {

     

       72
       72
       +
               in_filepath.push(&args[0]);

     

       73
       73
       +
           }

     

       74
       74
       +
       

     

       75
       75
       +
           if in_filepath.exists() {

     

       76
       76
       +
               for g in &proj_context.filegroups {

     

       77
       77
       +
                   if !g.process {

     

       78
       78
       +
                       continue;

     

       79
       79
       +
                   }

     

       80
       80
       +
                   for f in &g.files {

     

       81
       81
       +
                       if f.file_input == in_filepath {

     

       82
       82
       +
                           let stripped = f

     

       83
       83
       +
                               .file_out

     

       84
       84
       +
                               .strip_prefix(&proj_context.output_folder)

     

       85
       85
       +
                               .unwrap();

     

       86
       86
       +
                           return split_to_tokens(stripped.to_str().unwrap().into(), origin_index);

     

       87
       87
       +
                       }

     

       88
       88
       +
                   }

     

       89
       89
       +
               }

     

       90
       90
       +
           }

     

       91
       91
       +
           warn_skid(

     

       92
       92
       +
               proj_context,

     

       93
       93
       +
               origin_index,

     

       94
       94
       +
               origin_line,

     

       95
       95
       +
               &format!(

     

       96
       96
       +
                   "output_filename given a file with no matching output file ({:?}), returning empty",

     

       97
       97
       +
                   in_filepath

     

       98
       98
       +
               ),

     

       99
       99
       +
           );

     

       100
       100
       +
           Vec::new()

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       60
       103
        
       pub fn macro_filename_canonical(

     

       61
       104
        
           origin_index: usize,

     

       62
       105
        
           _origin_line: usize,

     

       63
       63
       -
           context: &mut ProjectContext,

     

       106
       106
       +
           context: &mut Project,

     

       64
       107
        
           _skid_context: &mut SkidContext,

     

       65
       108
        
           _args: &Vec<String>,

     

       66
       109
        
           _scope: &[Token],

     
···

       79
       122
        
       pub fn macro_reminder(

     

       80
       123
        
           origin_index: usize,

     

       81
       124
        
           origin_line: usize,

     

       82
       82
       -
           context: &mut ProjectContext,

     

       125
       125
       +
           context: &mut Project,

     

       83
       126
        
           _skid_context: &mut SkidContext,

     

       84
       127
        
           args: &Vec<String>,

     

       85
       128
        
           _scope: &[Token],

+3 -3

src/macros/template.rs

···

       1
       1
        
       use crate::{

     

       2
       2
        
           console::error_skid,

     

       3
       3
       -
           project::ProjectContext,

     

       3
       3
       +
           project::Project,

     

       4
       4
        
           reservednames::{RESERVED_NAMES_HTML, RESERVED_NAMES_MISC},

     

       5
       5
        
           stringtools::{find_pattern, split_to_tokens, WhitespaceChecks},

     

       6
       6
        
           types::{IsScoped, SkidContext, Token},

     
···

       36
       36
        
               //_file: &mut InputFile,

     

       37
       37
        
               origin_index: usize,

     

       38
       38
        
               origin_line: usize,

     

       39
       39
       -
               proj_context: &mut ProjectContext,

     

       39
       39
       +
               proj_context: &mut Project,

     

       40
       40
        
               args: &Vec<String>,

     

       41
       41
        
               scope: &[Token],

     

       42
       42
        
           ) -> Vec<Token> {

     
···

       137
       137
        
       pub fn macro_template(

     

       138
       138
        
           origin_index: usize,

     

       139
       139
        
           origin_line: usize,

     

       140
       140
       -
           project_context: &mut ProjectContext,

     

       140
       140
       +
           project_context: &mut Project,

     

       141
       141
        
           skid_context: &mut SkidContext,

     

       142
       142
        
           args: &Vec<String>,

     

       143
       143
        
           scope: &[Token],

+23 -23

src/main.rs

···

       16
       16
        
       use console::*;

     

       17
       17
        
       use macros::MACRO_LIST;

     

       18
       18
        
       use markdown::{CompileOptions, Constructs, Options, ParseOptions};

     

       19
       19
       -
       use project::{parse_project, Indexing, ProjectContext};

     

       19
       19
       +
       use project::{parse_project, Indexing, Project};

     

       20
       20
        
       use reservednames::RESERVED_NAMES_HTML;

     

       21
       21
        
       use std::{

     

       22
       22
        
           env,

     
···

       30
       30
        
       // strings split on kind of abitrary chars..

     

       31
       31
        
       static DELIMITERS: &'static [char] = &[

     

       32
       32
        
           ' ', '\n', '\t', '(', ')', '{', '}', '[', ']', '<', '>', '\\', '\'', '\"', ';', '?', '^', '-',

     

       33
       33
       +
           '`',

     

       33
       34
        
       ];

     

       34
       35
        
       

     

       35
       36
        
       #[derive(PartialEq)]

     
···

       75
       76
        
           //     }

     

       76
       77
        
           // }

     

       77
       78
        
       

     

       78
       78
       -
           for group in &mut project.filegroups {

     

       79
       79
       -
               if !group.process {

     

       79
       79
       +
           for i in 0..project.filegroups.len() {

     

       80
       80
       +
               if !project.filegroups[i].process {

     

       80
       81
        
                   continue;

     

       81
       82
        
               }

     

       82
       82
       -
               for infile in &mut group.files {

     

       83
       83
       -
                   let contents =

     

       84
       84
       -
                       fs::read_to_string(&infile.file_input).expect("File unreadable or missing");

     

       85
       85
       -
                   let tokens =

     

       86
       86
       -
                       split_to_tokens(contents, project.context.index_of_file(&infile.file_input));

     

       83
       83
       +
               let convert_html = project.filegroups[i].convert_html;

     

       84
       84
       +
               for k in 0..project.filegroups[i].files.len() {

     

       85
       85
       +
                   let file_input = project.filegroups[i].files[k].file_input.clone();

     

       86
       86
       +
                   let contents = fs::read_to_string(&project.filegroups[i].files[k].file_input)

     

       87
       87
       +
                       .expect("File unreadable or missing");

     

       88
       88
       +
                   let tokens = split_to_tokens(contents, project.index_of_file(&file_input));

     

       87
       89
        
       

     

       88
       88
       -
                   let mut skid_context =

     

       89
       89
       -
                       SkidContext::new(project.context.index_of_file(&infile.file_input));

     

       90
       90
       +
                   let mut skid_context = SkidContext::new(project.index_of_file(&file_input));

     

       90
       91
        
                   write_file(

     

       91
       91
       -
                       infile,

     

       92
       92
       -
                       group.convert_html,

     

       93
       93
       -
                       &process_skid(&tokens, &mut project.context, &mut skid_context),

     

       92
       92
       +
                       &project.filegroups[i].files[k].file_skidout.clone(),

     

       93
       93
       +
                       &project.filegroups[i].files[k].file_out.clone(),

     

       94
       94
       +
                       convert_html,

     

       95
       95
       +
                       &process_skid(&tokens, &mut project, &mut skid_context),

     

       94
       96
        
                   );

     

       95
       97
        
               }

     

       96
       98
        
           }

     
···

       98
       100
        
       

     

       99
       101
        
       fn find_and_run_macro(

     

       100
       102
        
           tokens_in: &[Token],

     

       101
       101
       -
           proj_context: &mut ProjectContext,

     

       103
       103
       +
           proj_context: &mut Project,

     

       102
       104
        
           skid_context: &mut SkidContext,

     

       103
       105
        
       ) -> Option<(Vec<Token>, usize)> {

     

       104
       106
        
           // (Output, to be consumed size)

     
···

       288
       290
        
       

     

       289
       291
        
       fn process_skid(

     

       290
       292
        
           tokens_in: &[Token],

     

       291
       291
       -
           proj_context: &mut ProjectContext,

     

       293
       293
       +
           proj_context: &mut Project,

     

       292
       294
        
           skid_context: &mut SkidContext,

     

       293
       295
        
       ) -> Vec<Token> {

     

       294
       296
        
           //}, context: &mut ProjectContext) {

     
···

       351
       353
        
           return tokens;

     

       352
       354
        
       }

     

       353
       355
        
       

     

       354
       354
       -
       fn write_file(file: &InputFile, convert_html: bool, tokens: &[Token]) {

     

       356
       356
       +
       fn write_file(file_skidout: &PathBuf, file_out: &PathBuf, convert_html: bool, tokens: &[Token]) {

     

       355
       357
        
           //println!("{:?}", tokens);

     

       356
       358
        
           let mut skid_output: String = "".to_string();

     

       357
       359
        
           for t in tokens {

     

       358
       360
        
               skid_output.push(t.contents);

     

       359
       361
        
           }

     

       360
       362
        
       

     

       361
       361
       -
           let mut folder = file.file_skidout.clone();

     

       363
       363
       +
           let mut folder = file_skidout.clone();

     

       362
       364
        
           folder.pop();

     

       363
       365
        
           if fs::create_dir_all(&folder).is_err() {

     

       364
       366
        
               error_generic(&format!("Could not make the folder {:?}", &folder));

     

       365
       367
        
           }

     

       366
       368
        
       

     

       367
       369
        
           if convert_html {

     

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

     

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

     

       369
       371
        
       

     

       370
       372
        
               //let html_output = markdown::to_html(&skid_output);

     

       371
       373
        
               let html_output = markdown::to_html_with_options(

     
···

       392
       394
        
                   },

     

       393
       395
        
               )

     

       394
       396
        
               .unwrap();

     

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

     

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

     

       396
       398
        
           } else {

     

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

     

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

     

       398
       400
        
           }

     

       399
       401
        
           ok_generic(&format!(

     

       400
       402
        
               "{} written",

     

       401
       401
       -
               file.file_out

     

       402
       402
       -
                   .to_str()

     

       403
       403
       -
                   .unwrap_or("Couldnt Unwrap file_out name")

     

       403
       403
       +
               file_out.to_str().unwrap_or("Couldnt Unwrap file_out name")

     

       404
       404
        
           ));

     

       405
       405
        
       }

+29 -23

src/project.rs

···

       8
       8
        
       pub struct Project {

     

       9
       9
        
           pub filegroups: Vec<FileGroup>,

     

       10
       10
        
           //pub settings: ProjectSettings,

     

       11
       11
       -
           pub context: ProjectContext,

     

       11
       11
       +
           //pub context: ProjectContext,

     

       12
       12
       +
           pub input_folder: PathBuf,

     

       13
       13
       +
           pub output_folder: PathBuf,

     

       14
       14
       +
           pub global_pre_insert: PathBuf,

     

       15
       15
       +
           pub global_post_insert: PathBuf,

     

       16
       16
       +
       

     

       17
       17
       +
           pub filemap: Vec<PathBuf>, // mapped to index

     

       12
       18
        
       }

     

       13
       19
        
       

     

       14
       20
        
       pub struct FileGroup {

     
···

       20
       26
        
           pub convert_html: bool,

     

       21
       27
        
       }

     

       22
       28
        
       

     

       23
       23
       -
       pub struct ProjectContext {

     

       24
       24
       -
           pub input_folder: PathBuf,

     

       25
       25
       -
           pub output_folder: PathBuf,

     

       26
       26
       -
           pub global_pre_insert: PathBuf,

     

       27
       27
       -
           pub global_post_insert: PathBuf,

     

       29
       29
       +
       // pub struct ProjectContext {

     

       30
       30
       +
       //     pub input_folder: PathBuf,

     

       31
       31
       +
       //     pub output_folder: PathBuf,

     

       32
       32
       +
       //     pub global_pre_insert: PathBuf,

     

       33
       33
       +
       //     pub global_post_insert: PathBuf,

     

       28
       34
        
       

     

       29
       29
       -
           pub filemap: Vec<PathBuf>, // mapped to index

     

       30
       30
       -
       }

     

       35
       35
       +
       //     pub filemap: Vec<PathBuf>, // mapped to index

     

       36
       36
       +
       // }

     

       31
       37
        
       

     

       32
       38
        
       macro_rules! get_table_bool_or_default {

     

       33
       39
        
           ($table:ident, $key:expr, $default:expr) => {

     
···

       59
       65
        
       

     

       60
       66
        
           let mut project: Project = Project {

     

       61
       67
        
               filegroups: Vec::new(),

     

       62
       62
       -
               context: ProjectContext {

     

       63
       63
       -
                   input_folder: PathBuf::new(),

     

       64
       64
       -
                   output_folder: PathBuf::new(),

     

       65
       65
       -
                   global_pre_insert: PathBuf::new(),

     

       66
       66
       -
                   global_post_insert: PathBuf::new(),

     

       67
       67
       -
                   filemap: Vec::new(),

     

       68
       68
       -
               },

     

       68
       68
       +
               //context: ProjectContext {

     

       69
       69
       +
               input_folder: PathBuf::new(),

     

       70
       70
       +
               output_folder: PathBuf::new(),

     

       71
       71
       +
               global_pre_insert: PathBuf::new(),

     

       72
       72
       +
               global_post_insert: PathBuf::new(),

     

       73
       73
       +
               filemap: Vec::new(),

     

       74
       74
       +
               //},

     

       69
       75
        
           };

     

       70
       76
        
           let config = tomlfile

     

       71
       77
        
               .parse::<Table>()

     
···

       81
       87
        
               .parent()

     

       82
       88
        
               .expect("Project file unreadable or missing.");

     

       83
       89
        
       

     

       84
       84
       -
           project.context.input_folder = PathBuf::from(get_table_string_or_default!(

     

       90
       90
       +
           project.input_folder = PathBuf::from(get_table_string_or_default!(

     

       85
       91
        
               settings_section,

     

       86
       92
        
               "inputFolder",

     

       87
       93
        
               "skid"

     

       88
       94
        
           ));

     

       89
       95
        
       

     

       90
       90
       -
           project.context.output_folder = PathBuf::from(get_table_string_or_default!(

     

       96
       96
       +
           project.output_folder = PathBuf::from(get_table_string_or_default!(

     

       91
       97
        
               settings_section,

     

       92
       98
        
               "outputFolder",

     

       93
       99
        
               "content"

     

       94
       100
        
           ));

     

       95
       101
        
       

     

       96
       96
       -
           project.context.global_pre_insert = project_root.join(get_table_string_or_default!(

     

       102
       102
       +
           project.global_pre_insert = project_root.join(get_table_string_or_default!(

     

       97
       103
        
               settings_section,

     

       98
       104
        
               "preInsertGlobal",

     

       99
       105
        
               ""

     

       100
       106
        
           ));

     

       101
       101
       -
           project.context.global_post_insert = project_root.join(get_table_string_or_default!(

     

       107
       107
       +
           project.global_post_insert = project_root.join(get_table_string_or_default!(

     

       102
       108
        
               settings_section,

     

       103
       109
        
               "postInsertGlobal",

     

       104
       110
        
               ""

     
···

       112
       118
        
       

     

       113
       119
        
               let pre_insert = get_table_string_or_default!(filegroup_def, "preInsert", "");

     

       114
       120
        
               let post_insert = get_table_string_or_default!(filegroup_def, "postInsert", "");

     

       115
       115
       -
               let process = get_table_bool_or_default!(filegroup_def, "process", false);

     

       121
       121
       +
               let process = get_table_bool_or_default!(filegroup_def, "process", true);

     

       116
       122
        
               let convert_html = get_table_bool_or_default!(filegroup_def, "convertHTML", true);

     

       117
       123
        
               let extention = get_table_string_or_default!(filegroup_def, "outputExtention", "html");

     

       118
       124
        
       

     
···

       142
       148
        
                       });

     

       143
       149
        
       

     

       144
       150
        
                       let mut new_file = crate::types::InputFile::new();

     

       145
       145
       -
                       new_file.file_input = project.context.input_folder.clone();

     

       151
       151
       +
                       new_file.file_input = project.input_folder.clone();

     

       146
       152
        
                       new_file.file_input.push(filename);

     

       147
       153
        
       

     

       148
       148
       -
                       new_file.file_out = project.context.output_folder.clone();

     

       154
       154
       +
                       new_file.file_out = project.output_folder.clone();

     

       149
       155
        
                       new_file.file_out.push(filename);

     

       150
       156
        
                       new_file.file_out.set_extension(extention);

     

       151
       157
        
       

     
···

       171
       177
        
           // fn section_name_for_index(&self, index: usize) -> String;

     

       172
       178
        
       }

     

       173
       179
        
       

     

       174
       174
       -
       impl Indexing for ProjectContext {

     

       180
       180
       +
       impl Indexing for Project {

     

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

     

       176
       182
        
               let cannonical = f.canonicalize().unwrap();

     

       177
       183
        
               let mut index = 0;

+7 -7

src/types.rs

···

       3
       3
        
       use crate::{

     

       4
       4
        
           console::error_skid,

     

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

     

       6
       6
       -
           project::ProjectContext,

     

       6
       6
       +
           project::Project,

     

       7
       7
        
       };

     

       8
       8
        
       

     

       9
       9
        
       pub struct Token {

     
···

       42
       42
        
       }

     

       43
       43
        
       

     

       44
       44
        
       type MacroExpansion =

     

       45
       45
       -
           fn(usize, usize, &mut ProjectContext, &mut SkidContext, &Vec<String>, &[Token]) -> Vec<Token>;

     

       45
       45
       +
           fn(usize, usize, &mut Project, &mut SkidContext, &Vec<String>, &[Token]) -> Vec<Token>;

     

       46
       46
        
       // (

     

       47
       47
        
       //     origin_index: usize,

     

       48
       48
        
       //     origin_line: usize,

     
···

       55
       55
        
       pub struct Macro {

     

       56
       56
        
           pub symbol: &'static str,

     

       57
       57
        
           pub expansion: MacroExpansion,

     

       58
       58
       -
           pub has_scope: bool, //takes blocks of text input as well as parameters using [[{}]]

     

       58
       58
       +
           pub takes_block: bool, //takes blocks of text input as well as parameters using [[{}]]

     

       59
       59
        
           pub min_args: usize,

     

       60
       60
        
           pub max_args: usize,

     

       61
       61
        
       }

     
···

       65
       65
        
               &self,

     

       66
       66
        
               origin_index: usize,

     

       67
       67
        
               origin_line: usize,

     

       68
       68
       -
               context: &mut ProjectContext,

     

       68
       68
       +
               context: &mut Project,

     

       69
       69
        
               skid_context: &mut SkidContext,

     

       70
       70
        
               args: &Vec<String>,

     

       71
       71
        
               scope: &[Token],

     
···

       81
       81
        
               Macro {

     

       82
       82
        
                   symbol: "default_symbol",

     

       83
       83
        
                   expansion: macro_comment,

     

       84
       84
       -
                   has_scope: true,

     

       84
       84
       +
                   takes_block: true,

     

       85
       85
        
                   min_args: 0,

     

       86
       86
        
                   max_args: usize::max_value(),

     

       87
       87
        
               }

     
···

       93
       93
        
               &self,

     

       94
       94
        
               origin_index: usize,

     

       95
       95
        
               origin_line: usize,

     

       96
       96
       -
               proj_context: &mut ProjectContext,

     

       96
       96
       +
               proj_context: &mut Project,

     

       97
       97
        
               skid_context: &mut SkidContext,

     

       98
       98
        
               args: &Vec<String>,

     

       99
       99
        
               block: &[Token],

     
···

       117
       117
        
       

     

       118
       118
        
       impl IsScoped for Macro {

     

       119
       119
        
           fn is_scoped(&self) -> bool {

     

       120
       120
       -
               self.has_scope

     

       120
       120
       +
               self.takes_block

     

       121
       121
        
           }

     

       122
       122
        
       }

     

       123
       123