Use function ptrs for Rules

Author: fileformat

run.sh

@@ -24,4 +24,4 @@ fi
 cargo install --locked --quiet --version 3.12.0 bacon
 
 # run the app
-bacon --headless run -- --bin namelint -- --rules ./test/custom_rules.yaml --config ./config/self.yaml
+bacon run -- --bin namelint -- --rules ./test/custom_rules.yaml --config ./config/self.yaml

src/main.rs

@@ -9,6 +9,7 @@ mod run_lint;
 mod schema;
 mod structs;
 mod rules;
+mod regex_rule;
 
 use std::{collections::HashMap, ffi::OsString, fs::{self}};
 use clap::{arg, Command};
@@ -20,7 +21,7 @@ use parse_config::parse_config;
 use parse_rules::parse_rules;
 use run_lint::run_lint;
 use schema::{must_load_validator, SchemaType};
-use structs::{ConfigFile, FileData, Rule, RuleSet};
+use structs::{ConfigFile, FileData, Lint, RuleFn, RuleSet};
 
 static RULES_DIR: Dir = include_dir!("./rules");
 
@@ -55,7 +56,7 @@ fn main() {
 	//LATER: convert to log level let verbose = binding.get_count("verbose");
 	let rule_validator = must_load_validator(SchemaType::Rule);
 
-	let mut all_rules: HashMap<String, Rule> = HashMap::new();
+	let mut all_rules: HashMap<String, RuleFn> = HashMap::new();
 	let mut all_rulesets: HashMap<String, RuleSet> = HashMap::new();
 
 	for rule_file in RULES_DIR.find("*.yaml").unwrap() {
@@ -155,12 +156,14 @@ fn main() {
 		println!("DEBUG: file '{}'", file.lintpath);
 	}
 
-	for (index, lint) in config.lints.iter_mut().enumerate() {
-		if lint.name.is_none() {
-			lint.name = Some(format!("#{}", index));
-		}
-		println!("DEBUG: applying lint {}", lint.name.clone().unwrap());
-		run_lint(lint, &mut files, &all_rules, &all_rulesets);
+	for (index, cfg_lint) in config.lints.iter_mut().enumerate() {
+		let lint:Lint = Lint {
+			name: cfg_lint.name.clone().unwrap_or_else(|| format!("#{}", index)),
+			paths: cfg_lint.paths.clone(),
+			rules: cfg_lint.rules.clone(),
+		};
+		println!("DEBUG: applying lint {}", lint.name);
+		run_lint(&lint, &mut files, &all_rules, &all_rulesets);
 	}
 
 	for file in files.iter_mut() {

src/parse_rules.rs

@@ -1,10 +1,10 @@
 use std::collections::HashMap;
-use regex::RegexBuilder;
 
 use crate::load::{must_load_yaml, must_yaml_to_json};
-use crate::structs::{Rule, RuleFile, RuleSet};
+use crate::structs::{RuleFile, RuleFn, RuleSet};
+use crate::regex_rule::build_regex_rule_fn;
 
-pub fn parse_rules(body: &str, src: &str, validator: &jsonschema::Validator, all_rules: &mut HashMap<String, Rule>, all_rulesets: &mut HashMap<String, RuleSet>) {
+pub fn parse_rules(body: &str, src: &str, validator: &jsonschema::Validator, all_rules: &mut HashMap<String, RuleFn>, all_rulesets: &mut HashMap<String, RuleSet>) {
 	let yaml_data = must_load_yaml(body, &src);
 	let json_data = must_yaml_to_json(&yaml_data, &src);
 	let is_valid = validator.validate(&json_data);
@@ -27,25 +27,11 @@ pub fn parse_rules(body: &str, src: &str, validator: &jsonschema::Validator, all
 	}
 
 	if rulef.rules.is_some() {
-		let mut rules = rulef.rules.unwrap();
-		for rule in rules.iter_mut() {
+		let rules = rulef.rules.unwrap();
+		for rule in rules.iter() {
 			println!("DEBUG: Loading rule: {} ({})", rule.title, rule.rule_id);
-			if rule.regex.is_some() {
-				let rule_regex = rule.regex.as_mut().unwrap();
-				let mut regex_builder = RegexBuilder::new(&rule_regex.pattern);
-				if rule_regex.case_insensitive {
-					regex_builder.case_insensitive(true);
-				}
-				let regex = regex_builder.build();
-				if regex.is_ok() {
-					rule_regex.regex = regex.ok();
-				} else {
-					println!("ERROR: Invalid regex for rule_id {}: {}", rule.rule_id, regex.err().unwrap());
-					continue;
-				}
-
-			}
-			all_rules.insert(rule.rule_id.clone(), rule.clone());
+			let tmp_rule = rule.clone();
+			all_rules.insert(rule.rule_id.clone(), build_regex_rule_fn(&tmp_rule));
 		}
 	}
 }

src/regex_rule.rs

@@ -0,0 +1,47 @@
+use regex::{Regex, RegexBuilder};
+
+use crate::structs::{ Rule, RuleFn };
+
+pub fn build_regex_rule_fn<'a>(the_rule: &Rule) -> RuleFn<'a> {
+	let rule_id: &'static str = Box::leak(the_rule.rule_id.clone().into_boxed_str());
+	let rregex = the_rule.regex.clone();
+	if rregex.is_none() {
+		println!("ERROR: Rule {} has no regex", rule_id);
+		std::process::exit(9);
+	}
+	let rregex = rregex.unwrap();
+	let pattern = rregex.pattern;
+	let case_insensitive = rregex.case_insensitive;
+	let matches: bool;
+	if rregex.expect == "match" {
+		matches = true;
+	} else if rregex.expect == "nonmatch" {
+		matches = false;
+	} else {
+		println!("ERROR: Rule {} has invalid expect value: '{}'", rule_id, rregex.expect);
+		std::process::exit(10);
+	}
+
+	let mut regex_builder = RegexBuilder::new(&pattern);
+	if case_insensitive {
+		regex_builder.case_insensitive(true);
+	}
+	let regex = regex_builder.build();
+	if regex.is_err() {
+		let err = regex.as_ref().err().unwrap();
+		println!("ERROR: Invalid regex for rule_id {}: {}", rule_id, err);
+	}
+
+	let regex: &'static Regex = Box::leak(Box::new(regex.unwrap()));
+
+	Box::new(move |test: &str| {
+		if regex.is_match(test) == matches {
+			println!("DEBUG: Rule {} success for: '{}'", rule_id, test);
+			return true;
+		} else {
+			println!("DEBUG: Rule {} failed for : '{}'", rule_id, test);
+			return false;
+		}
+	})
+}
+

src/run_lint.rs

@@ -1,12 +1,11 @@
 use std::collections::HashMap;
 
-use crate::structs::{ConfigLint, FileData, Rule, RuleSet};
+use crate::structs::{Lint, FileData, RuleFn, RuleSet};
 
-pub fn run_lint(lint: &ConfigLint, files: &mut Vec<FileData>, all_rules: &HashMap<String, Rule>, _all_rulesets: &HashMap<String, RuleSet>) {
+pub fn run_lint(lint: &Lint, files: &mut Vec<FileData>, all_rules: &HashMap<String, RuleFn>, _all_rulesets: &HashMap<String, RuleSet>) {
 
 
-	let mut rules: Vec<Rule> = Vec::new();
-
+	// LATER: load rules from rulesets too
 	let lint_rules = &lint.rules;
 	if lint_rules.is_some() {
 		let lint_rules = lint_rules.as_ref().unwrap();
@@ -15,43 +14,21 @@ pub fn run_lint(lint: &ConfigLint, files: &mut Vec<FileData>, all_rules: &HashMa
 
 			let the_rule = all_rules.get(rule_id);
 			if the_rule.is_none() {
-				println!("ERROR: unknown rule_id '{}'", rule_id);
+				println!("ERROR: lint {} has unknown rule_id '{}'", lint.name, rule_id);
 				std::process::exit(7);
 			}
-			let the_rule = the_rule.unwrap();
-			rules.push(the_rule.clone());
-		}
-	}
-
-	// LATER: load rules from rulesets
-	if rules.len() == 0 {
-		println!("WARNING: no rules for {}", lint.name.clone().unwrap());
-		return;
-	}
-
-	for rule in rules.iter() {
-
-		if rule.regex.is_none() {
-			println!("ERROR: Rule {} has no regex", rule.rule_id);
-			continue;
-		}
-
-		let regex_data = rule.regex.as_ref().unwrap();
-		if regex_data.regex.is_none() {
-			println!("ERROR: Rule {} has invalid regex", rule.rule_id);
-			continue;
-		}
-		let regex = regex_data.regex.as_ref().unwrap();
-		let expect = regex_data.expect == "match";
-
-		for file in files.iter_mut() {
-			let value = &file.file_name;
-			let result = regex.is_match(value);
-			if result != expect {
-				println!("DEBUG: failed match for '{}': rule={} expect={}, got={}", value, regex_data.pattern, expect, result);
-				file.failed.push(rule.rule_id.clone());
-			} else {
-				file.passed.push(rule.rule_id.clone());
+			let rule_fn = the_rule.unwrap();
+
+
+			for file in files.iter_mut() {
+				let value = &file.file_name;
+				let result = rule_fn(value);
+				if result {
+					file.passed.push(rule_id.clone());
+				} else {
+					println!("DEBUG: failed match for '{}': rule={}", file.file_name, rule_id);
+					file.failed.push(rule_id.clone());
+				}
 			}
 		}
 	}

src/structs.rs

@@ -62,10 +62,20 @@ pub struct ConfigLint {
 	pub rulesets: Option<Vec<String>>,
 }
 
+pub struct Lint {
+	pub name: String,
+	pub paths: Vec<String>,
+	pub rules: Option<Vec<String>>,
+}
+
 #[derive(serde::Deserialize, Debug, Clone)]
 pub struct ConfigFile {
 	pub dirs: Option<Vec<String>>,
 	#[serde(rename = "ignore-dirs")]
 	pub ignore_dirs: Option<Vec<String>>,
 	pub lints: Vec<ConfigLint>,
 }
+
+//pub type RuleFn = fn(String) -> bool;
+//pub type RuleFn = Box<dyn Fn(&str) -> bool>;
+pub type RuleFn<'a> = Box<dyn Fn(&str) -> bool + 'a>;