commit f5031460da62a2e0515e84a70cd0b479d4be4e24 · tholps.site/skidmark

+42 -4

src/macros/template.rs

···

       102
       102
        
                   args_index += 1;

     

       103
       103
        
               }

     

       104
       104
        
       

     

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

     

       106
       106
       -
               while found_pattern.is_some() {

     

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

     

       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_pattern = find_pattern(&output, "[[{}]]".into());

     

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

     

       111
       111
       +
               }

     

       112
       112
       +
       

     

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

     

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

     

       115
       115
       +
               while found_trailing_pattern.is_some() {

     

       116
       116
       +
                   let (start, len) = found_trailing_pattern.unwrap();

     

       117
       117
       +
                   let mut replacement = Vec::new();

     

       118
       118
       +
                   for arg in &args[self.args.len()..] {

     

       119
       119
       +
                       replacement.append(&mut split_to_tokens(arg.clone() + " ".into(), origin_index));

     

       120
       120
       +
                   }

     

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

     

       122
       122
       +
                   found_trailing_pattern = find_pattern(&output, "[[..]]".into());

     

       123
       123
       +
               }

     

       124
       124
       +
       

     

       125
       125
       +
               //replace [[".."]] with space seperated quoted remaining args

     

       126
       126
       +
               found_trailing_pattern = find_pattern(&output, "[[\"..\"]]".into());

     

       127
       127
       +
               while found_trailing_pattern.is_some() {

     

       128
       128
       +
                   let (start, len) = found_trailing_pattern.unwrap();

     

       129
       129
       +
                   let mut replacement = Vec::new();

     

       130
       130
       +
                   for arg in &args[self.args.len()..] {

     

       131
       131
       +
                       replacement.append(&mut split_to_tokens("\"".to_string() + arg + "\" ".into(), origin_index));

     

       132
       132
       +
                   }

     

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

     

       134
       134
       +
                   found_trailing_pattern = find_pattern(&output, "[[\"..\"]]".into());

     

       111
       135
        
               }

     

       112
       136
        
       

     

       113
       137
        
               output

     
···

       142
       166
        
                       format!(

     

       143
       167
        
                           "Attempted to make a template using a reserved name \"{}\"",

     

       144
       168
        
                           args[0]

     

       169
       169
       +
                       ),

     

       170
       170
       +
                   );

     

       171
       171
       +
               }

     

       172
       172
       +
           }

     

       173
       173
       +
       

     

       174
       174
       +
           for arg in args {

     

       175
       175
       +
               if arg == ".." || arg == "\"..\"" {

     

       176
       176
       +
                   error_skid(

     

       177
       177
       +
                       context,

     

       178
       178
       +
                       origin_index,

     

       179
       179
       +
                       origin_line,

     

       180
       180
       +
                       format!(

     

       181
       181
       +
                           "Attempted to make a template using a reserved parameter name \"{}\"",

     

       182
       182
       +
                           arg

     

       145
       183
        
                       ),

     

       146
       184
        
                   );

     

       147
       185
        
               }

+1 -1

src/main.rs

···

       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",

     

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

     

       301
       301
        
               file.file_htmlout

     

       302
       302
        
                   .to_str()

     

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