Module rad::processor

processor

“processor” module is about processing of given input.

Processor substitutes all macros only when the macros were already defined and returns untouched string back if not found any.

Processor can handle various types of inputs (string|stdin|file)

Detailed usage

use rad::RadResult;
use rad::Processor;
use rad::MacroType;
use rad::AuthType;
use rad::CommentType;
use rad::DiffOption;
use std::path::Path;
 
// Builder
let mut processor = Processor::new()
    .comment(CommentType::Start)                         // Use comment
    .custom_macro_char('~')                              // use custom macro character
    .custom_comment_char('#')                            // use custom comment character
    .purge(true)                                         // Purge undefined macro
    .greedy(true)                                        // Makes all macro greedy
    .silent(true)                                        // Silents all warnings
    .nopanic(true)                                       // No panic in any circumstances
    .assert(true)                                        // Enable assertion mode
    .lenient(true)                                       // Disable strict mode
    .custom_rules(Some(vec![Path::new("rule.r4f")]))?    // Read from frozen rule files
    .write_to_file(Some(Path::new("out.txt")))?          // default is stdout
    .error_to_file(Some(Path::new("err.txt")))?          // default is stderr
    .unix_new_line(true)                                 // use unix new line for formatting
    .discard(true)                                       // discard all output
    // Permission
    .allow(Some(vec![AuthType::ENV]))                    // Grant permission of authtypes
    .allow_with_warning(Some(vec![AuthType::CMD]))       // Grant permission of authypes with warning enabled
    // Debugging options
    .debug(true)                                         // Turn on debug mode
    .log(true)                                           // Use logging to terminal
    .diff(DiffOption::All)                               // Print diff in final result
    .interactive(true)                                   // Use interactive mode

// Comment char and macro char cannot be same 
// Unallowed pattern for the characters are [a-zA-Z1-9\\_\*\^\|\+\(\)=,]
 
// Use Processor::empty() instead of Processor::new()
// if you don't want any default macros
 
// Print information about current processor permissions
// This is an warning and can be suppressed with silent option
processor.print_permission()?;

// Add basic rules(= register functions)
// test function is not included in this demo
processor.add_basic_rules(vec![("test", test as MacroType)]);

// You can add basic rule in form of closure too
processor.add_closure_rule(
    "test",                                                       // Name of macro
    2,                                                            // Count of arguments
    Box::new(|args: Vec<String>| -> Option<String> {              // Closure as an internal logic
        Some(format!("First : {}\nSecond: {}", args[0], args[1]))
    })
);

// Register a hook macro
// Trigger and execution macro should be defined otherwise
processor.register_hook(
	HookType::Macro,            // Macro type
	trigger_macro,              // Macro that triggers
	hook_div,                   // Macro to be executed
	1,    						// target count
	false 						// Resetable
)
 
// Add custom rules(in order of "name, args, body") 
processor.add_custom_rules(vec![("test","a_src a_link","$a_src() -> $a_link()")]);

// Add custom rules without any arguments
processor.add_static_rules(vec![("test","TEST"),("lul","kekw")]);

// Undefine rules
processor.undefine_rules(vec!["name1", "name2"]);

// Undefine only custom rules
processor.undefine_custom_rules(vec!["name1", "name2"]);
 
// Process with inputs
// This prints to desginated write destinations
processor.from_string(r#"$define(test=Test)"#)?;
processor.from_stdin()?;
processor.from_file(Path::new("from.txt"))?;
 
processor.freeze_to_file(Path::new("out.r4f"))?; // Create frozen file
 
// Print out result
// This will print counts of warning and errors.
// It will also print diff between source and processed if diff option was
// given as builder pattern.
processor.print_result()?;                       

Structs

Processor

Processor that parses(lexes) given input and print out to desginated output