mirror of
https://github.com/TECHNOFAB11/pay-respects.git
synced 2025-12-12 06:20:09 +01:00
chore: rearrange directories
This commit is contained in:
iff
parent
d5fb7462e0
commit
4c9aac45a8
46 changed files with 11 additions and 18 deletions
220
parser/src/lib.rs
Normal file
220
parser/src/lib.rs
Normal file
|
|
@ -0,0 +1,220 @@
|
|||
// pay-respects-parser: Compile time rule parser for pay-respects
|
||||
// Copyright (C) 2023 iff
|
||||
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Affero General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use proc_macro::TokenStream;
|
||||
use proc_macro2::TokenStream as TokenStream2;
|
||||
use quote::quote;
|
||||
|
||||
mod replaces;
|
||||
|
||||
#[proc_macro]
|
||||
pub fn parse_rules(input: TokenStream) -> TokenStream {
|
||||
let directory = input.to_string().trim_matches('"').to_owned();
|
||||
let rules = get_rules(directory);
|
||||
|
||||
gen_match_rules(rules)
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize)]
|
||||
struct Rule {
|
||||
command: String,
|
||||
match_err: Vec<MatchError>,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize)]
|
||||
struct MatchError {
|
||||
pattern: Vec<String>,
|
||||
suggest: Vec<String>,
|
||||
}
|
||||
|
||||
fn get_rules(directory: String) -> Vec<Rule> {
|
||||
let files = std::fs::read_dir(directory).expect("Failed to read directory.");
|
||||
|
||||
let mut rules = Vec::new();
|
||||
for file in files {
|
||||
let file = file.expect("Failed to read file.");
|
||||
let path = file.path();
|
||||
let path = path.to_str().expect("Failed to convert path to string.");
|
||||
|
||||
let rule_file = parse_file(Path::new(path));
|
||||
rules.push(rule_file);
|
||||
}
|
||||
rules
|
||||
}
|
||||
|
||||
fn gen_match_rules(rules: Vec<Rule>) -> TokenStream {
|
||||
let command = rules
|
||||
.iter()
|
||||
.map(|x| x.command.to_owned())
|
||||
.collect::<Vec<String>>();
|
||||
let command_matches = rules
|
||||
.iter()
|
||||
.map(|x| {
|
||||
x.match_err
|
||||
.iter()
|
||||
.map(|x| {
|
||||
let pattern = x
|
||||
.pattern
|
||||
.iter()
|
||||
.map(|x| x.to_lowercase())
|
||||
.collect::<Vec<String>>();
|
||||
let suggests = x
|
||||
.suggest
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<String>>();
|
||||
(pattern, suggests)
|
||||
})
|
||||
.collect::<Vec<(Vec<String>, Vec<String>)>>()
|
||||
})
|
||||
.collect::<Vec<Vec<(Vec<String>, Vec<String>)>>>();
|
||||
|
||||
let mut matches_tokens = Vec::new();
|
||||
|
||||
for match_err in command_matches {
|
||||
let mut suggestion_tokens = Vec::new();
|
||||
let mut patterns_tokens = Vec::new();
|
||||
for (pattern, suggests) in match_err {
|
||||
// let mut match_condition = Vec::new();
|
||||
let mut pattern_suggestions = Vec::new();
|
||||
for suggest in suggests {
|
||||
let (suggestion_no_condition, conditions) = parse_conditions(&suggest);
|
||||
let suggest = eval_suggest(&suggestion_no_condition);
|
||||
let suggestion = quote! {
|
||||
if #(#conditions)&&* {
|
||||
#suggest;
|
||||
};
|
||||
};
|
||||
pattern_suggestions.push(suggestion);
|
||||
}
|
||||
let match_tokens = quote! {
|
||||
#(#pattern_suggestions)*
|
||||
};
|
||||
|
||||
suggestion_tokens.push(match_tokens);
|
||||
|
||||
let string_patterns = pattern.join("\", \"");
|
||||
let string_patterns: TokenStream2 =
|
||||
format!("[\"{}\"]", string_patterns).parse().unwrap();
|
||||
patterns_tokens.push(string_patterns);
|
||||
}
|
||||
|
||||
matches_tokens.push(quote! {
|
||||
#(
|
||||
for pattern in #patterns_tokens {
|
||||
if error_msg.contains(pattern) {
|
||||
let split = split_command(&last_command);
|
||||
#suggestion_tokens;
|
||||
};
|
||||
})*
|
||||
})
|
||||
}
|
||||
quote! {
|
||||
let mut last_command = last_command.to_string();
|
||||
match executable {
|
||||
#(
|
||||
#command => {
|
||||
#matches_tokens
|
||||
}
|
||||
)*
|
||||
_ => {}
|
||||
};
|
||||
}
|
||||
.into()
|
||||
}
|
||||
|
||||
fn parse_file(file: &Path) -> Rule {
|
||||
let file = std::fs::read_to_string(file).expect("Failed to read file.");
|
||||
toml::from_str(&file).expect("Failed to parse toml.")
|
||||
}
|
||||
|
||||
fn parse_conditions(suggest: &str) -> (String, Vec<TokenStream2>) {
|
||||
let mut eval_conditions = Vec::new();
|
||||
if suggest.starts_with('#') {
|
||||
let mut lines = suggest.lines().collect::<Vec<&str>>();
|
||||
let mut conditions = String::new();
|
||||
for (i, line) in lines[0..].iter().enumerate() {
|
||||
conditions.push_str(line);
|
||||
if line.ends_with(']') {
|
||||
lines = lines[i + 1..].to_vec();
|
||||
break;
|
||||
}
|
||||
}
|
||||
let conditions = conditions
|
||||
.trim_start_matches(['#', '['])
|
||||
.trim_end_matches(']')
|
||||
.split(',')
|
||||
.collect::<Vec<&str>>();
|
||||
|
||||
for condition in conditions {
|
||||
let (mut condition, arg) = condition.split_once('(').unwrap();
|
||||
condition = condition.trim();
|
||||
let arg = arg.trim_start_matches('(').trim_end_matches(')');
|
||||
let reverse = match condition.starts_with('!') {
|
||||
true => {
|
||||
condition = condition.trim_start_matches('!');
|
||||
true
|
||||
}
|
||||
false => false,
|
||||
};
|
||||
let evaluated_condition = eval_condition(condition, arg);
|
||||
|
||||
eval_conditions.push(quote! {#evaluated_condition == !#reverse});
|
||||
}
|
||||
let suggest = lines.join("\n");
|
||||
return (suggest, eval_conditions);
|
||||
}
|
||||
(suggest.to_owned(), vec![quote! {true}])
|
||||
}
|
||||
|
||||
fn eval_condition(condition: &str, arg: &str) -> TokenStream2 {
|
||||
match condition {
|
||||
"executable" => quote! {executables.contains(&#arg.to_string())},
|
||||
"err_contains" => quote! {error_msg.contains(#arg)},
|
||||
"cmd_contains" => quote! {last_command.contains(#arg)},
|
||||
"min_length" => quote! {(split.len() >= #arg.parse::<usize>().unwrap())},
|
||||
"length" => quote! {(split.len() == #arg.parse::<usize>().unwrap())},
|
||||
"max_length" => quote! {(split.len() <= #arg.parse::<usize>().unwrap() + 1)},
|
||||
"shell" => quote! {(shell == #arg)},
|
||||
_ => unreachable!("Unknown condition when evaluation condition: {}", condition),
|
||||
}
|
||||
}
|
||||
|
||||
fn eval_suggest(suggest: &str) -> TokenStream2 {
|
||||
let mut suggest = suggest.to_owned();
|
||||
if suggest.contains("{{command}}") {
|
||||
suggest = suggest.replace("{{command}}", "{last_command}");
|
||||
}
|
||||
|
||||
let mut replace_list = Vec::new();
|
||||
let mut opt_list = Vec::new();
|
||||
let mut cmd_list = Vec::new();
|
||||
|
||||
replaces::opts(&mut suggest, &mut replace_list, &mut opt_list);
|
||||
replaces::cmd_reg(&mut suggest, &mut replace_list);
|
||||
replaces::err(&mut suggest, &mut replace_list);
|
||||
replaces::command(&mut suggest, &mut replace_list);
|
||||
replaces::shell(&mut suggest, &mut cmd_list);
|
||||
replaces::typo(&mut suggest, &mut replace_list);
|
||||
replaces::shell_tag(&mut suggest, &mut replace_list, cmd_list);
|
||||
|
||||
quote! {
|
||||
#(#opt_list)*
|
||||
candidates.push(format!{#suggest, #(#replace_list),*});
|
||||
}
|
||||
}
|
||||
262
parser/src/replaces.rs
Normal file
262
parser/src/replaces.rs
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
use proc_macro2::TokenStream as TokenStream2;
|
||||
use quote::quote;
|
||||
|
||||
fn rtag(name: &str, x: i32, y: String) -> TokenStream2 {
|
||||
format!("{}{} = {}", name, x, y).parse().unwrap()
|
||||
}
|
||||
|
||||
fn tag(name: &str, x: i32) -> String {
|
||||
format!("{{{}{}}}", name, x)
|
||||
}
|
||||
|
||||
fn eval_placeholder(
|
||||
string: &str,
|
||||
start: &str,
|
||||
end: &str,
|
||||
) -> (std::ops::Range<usize>, std::ops::Range<usize>) {
|
||||
let start_index = string.find(start).unwrap();
|
||||
let end_index = string[start_index..].find(end).unwrap() + start_index + end.len();
|
||||
|
||||
let placeholder = start_index..end_index;
|
||||
|
||||
let args = start_index + start.len()..end_index - end.len();
|
||||
|
||||
(placeholder, args)
|
||||
}
|
||||
|
||||
pub fn opts(
|
||||
suggest: &mut String,
|
||||
replace_list: &mut Vec<TokenStream2>,
|
||||
opt_list: &mut Vec<TokenStream2>,
|
||||
) {
|
||||
let mut replace_tag = 0;
|
||||
let tag_name = "opts";
|
||||
while suggest.contains(" {{opt::") {
|
||||
let (placeholder, args) = eval_placeholder(suggest, " {{opt::", "}}");
|
||||
|
||||
let opt = &suggest[args.to_owned()];
|
||||
let regex = opt.trim();
|
||||
let current_tag = tag(tag_name, replace_tag);
|
||||
let token_tag: TokenStream2 = format!("{}{}", tag_name, replace_tag).parse().unwrap();
|
||||
let command = quote! {
|
||||
let #token_tag = opt_regex(#regex, &mut last_command);
|
||||
};
|
||||
opt_list.push(command);
|
||||
|
||||
replace_list.push(rtag(tag_name, replace_tag, current_tag.to_owned()));
|
||||
suggest.replace_range(placeholder, ¤t_tag);
|
||||
replace_tag += 1;
|
||||
}
|
||||
if replace_tag > 0 {
|
||||
let split = quote! {
|
||||
let split = split_command(&last_command);
|
||||
};
|
||||
opt_list.push(split);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cmd_reg(suggest: &mut String, replace_list: &mut Vec<TokenStream2>) {
|
||||
let mut replace_tag = 0;
|
||||
let tag_name = "cmd";
|
||||
|
||||
while suggest.contains("{{cmd::") {
|
||||
let (placeholder, args) = eval_placeholder(suggest, "{{cmd::", "}}");
|
||||
|
||||
let regex = suggest[args.to_owned()].trim();
|
||||
|
||||
let command = format!("cmd_regex(r###\"{}\"###, &last_command)", regex);
|
||||
|
||||
replace_list.push(rtag(tag_name, replace_tag, command));
|
||||
suggest.replace_range(placeholder, &tag(tag_name, replace_tag));
|
||||
replace_tag += 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn err(suggest: &mut String, replace_list: &mut Vec<TokenStream2>) {
|
||||
let mut replace_tag = 0;
|
||||
let tag_name = "err";
|
||||
|
||||
while suggest.contains("{{err::") {
|
||||
let (placeholder, args) = eval_placeholder(suggest, "{{err::", "}}");
|
||||
|
||||
let regex = suggest[args.to_owned()].trim();
|
||||
|
||||
let command = format!("err_regex(r###\"{}\"###, error_msg)", regex);
|
||||
|
||||
replace_list.push(rtag(tag_name, replace_tag, command));
|
||||
suggest.replace_range(placeholder, &tag(tag_name, replace_tag));
|
||||
replace_tag += 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn command(suggest: &mut String, replace_list: &mut Vec<TokenStream2>) {
|
||||
let mut replace_tag = 0;
|
||||
let tag_name = "command";
|
||||
while suggest.contains("{{command") {
|
||||
let (placeholder, args) = eval_placeholder(suggest, "{{command", "}}");
|
||||
|
||||
let range = suggest[args.to_owned()].trim_matches(|c| c == '[' || c == ']');
|
||||
if let Some((start, end)) = range.split_once(':') {
|
||||
let mut start_string = start.to_string();
|
||||
let start = start.parse::<i32>().unwrap_or(0);
|
||||
if start < 0 {
|
||||
start_string = format!("split.len() {}", start);
|
||||
};
|
||||
let end_string;
|
||||
let parsed_end = end.parse::<i32>();
|
||||
if parsed_end.is_err() {
|
||||
end_string = String::from("split.len()");
|
||||
} else {
|
||||
let end = parsed_end.clone().unwrap();
|
||||
if end < 0 {
|
||||
end_string = format!("split.len() {}", end + 1);
|
||||
} else {
|
||||
end_string = (end + 1).to_string();
|
||||
}
|
||||
};
|
||||
|
||||
let command = format! {r#"split[{}..{}].join(" ")"#, start_string, end_string};
|
||||
|
||||
replace_list.push(rtag(tag_name, replace_tag, command));
|
||||
suggest.replace_range(placeholder, &tag(tag_name, replace_tag));
|
||||
} else {
|
||||
let range = range.parse::<i32>().unwrap_or(0);
|
||||
let command = if range < 0 {
|
||||
format!("split[std::cmp::max(split.len() {}, 0)]", range)
|
||||
} else {
|
||||
format!("split[{}]", range)
|
||||
};
|
||||
|
||||
replace_list.push(rtag(tag_name, replace_tag, command));
|
||||
suggest.replace_range(placeholder, &tag(tag_name, replace_tag));
|
||||
}
|
||||
replace_tag += 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn typo(suggest: &mut String, replace_list: &mut Vec<TokenStream2>) {
|
||||
let mut replace_tag = 0;
|
||||
let tag_name = "typo";
|
||||
|
||||
while suggest.contains("{{typo") {
|
||||
let (placeholder, args) = eval_placeholder(suggest, "{{typo", "}}");
|
||||
|
||||
let string_index = if suggest.contains('[') {
|
||||
let split = suggest[args.to_owned()]
|
||||
.split(&['[', ']'])
|
||||
.collect::<Vec<&str>>();
|
||||
let command_index = split[1];
|
||||
if !command_index.contains(':') {
|
||||
let command_index = command_index.parse::<i32>().unwrap();
|
||||
|
||||
let index = if command_index < 0 {
|
||||
format!("split.len() {}", command_index)
|
||||
} else {
|
||||
command_index.to_string()
|
||||
};
|
||||
format!("{}..{} + 1", index, index)
|
||||
} else {
|
||||
let (start, end) = command_index.split_once(':').unwrap();
|
||||
let start = start.parse::<i32>().unwrap_or(0);
|
||||
let start_string = if start < 0 {
|
||||
format!("split.len() {}", start)
|
||||
} else {
|
||||
start.to_string()
|
||||
};
|
||||
let end = end.parse::<i32>();
|
||||
let end_string = if end.is_err() {
|
||||
String::from("split.len()")
|
||||
} else {
|
||||
let end = end.unwrap();
|
||||
if end < 0 {
|
||||
format!("split.len() {}", end + 1)
|
||||
} else {
|
||||
(end + 1).to_string()
|
||||
}
|
||||
};
|
||||
|
||||
format!("{}..{}", start_string, end_string)
|
||||
}
|
||||
} else {
|
||||
unreachable!("Typo suggestion must have a command index");
|
||||
};
|
||||
let match_list = if suggest.contains('(') {
|
||||
let split = suggest[args.to_owned()]
|
||||
.split_once("(")
|
||||
.unwrap()
|
||||
.1
|
||||
.rsplit_once(")")
|
||||
.unwrap()
|
||||
.0;
|
||||
split.split(',').collect::<Vec<&str>>()
|
||||
} else {
|
||||
unreachable!("Typo suggestion must have a match list");
|
||||
};
|
||||
|
||||
let match_list = match_list
|
||||
.iter()
|
||||
.map(|s| s.trim().to_string())
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
let command = if match_list[0].starts_with("eval_shell_command(") {
|
||||
let function = match_list.join(",");
|
||||
// add a " after first comma, and a " before last )
|
||||
let function = format!(
|
||||
"{}\"{}{}",
|
||||
&function[..function.find(',').unwrap() + 1],
|
||||
&function[function.find(',').unwrap() + 1..function.len() - 1],
|
||||
"\")"
|
||||
);
|
||||
format!(
|
||||
"suggest_typo(&split[{}], {}, executables)",
|
||||
string_index, function
|
||||
)
|
||||
} else {
|
||||
let string_match_list = match_list.join("\".to_string(), \"");
|
||||
let string_match_list = format!("\"{}\".to_string()", string_match_list);
|
||||
format!(
|
||||
"suggest_typo(&split[{}], vec![{}], executables)",
|
||||
string_index, string_match_list
|
||||
)
|
||||
};
|
||||
|
||||
replace_list.push(rtag(tag_name, replace_tag, command));
|
||||
suggest.replace_range(placeholder, &tag(tag_name, replace_tag));
|
||||
replace_tag += 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn shell(suggest: &mut String, cmd_list: &mut Vec<String>) {
|
||||
while suggest.contains("{{shell") {
|
||||
let (placeholder, args) = eval_placeholder(suggest, "{{shell", "}}");
|
||||
let range = suggest[args.to_owned()].trim_matches(|c| c == '(' || c == ')');
|
||||
|
||||
let command = format!("eval_shell_command(shell, {})", range);
|
||||
|
||||
suggest.replace_range(placeholder, &command);
|
||||
cmd_list.push(command);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn shell_tag(
|
||||
suggest: &mut String,
|
||||
replace_list: &mut Vec<TokenStream2>,
|
||||
cmd_list: Vec<String>,
|
||||
) {
|
||||
let mut replace_tag = 0;
|
||||
let tag_name = "shell";
|
||||
|
||||
for command in cmd_list {
|
||||
if suggest.contains(&command) {
|
||||
*suggest = suggest.replace(&command, &tag(tag_name, replace_tag));
|
||||
|
||||
let split = command.split_once(',').unwrap();
|
||||
let argument = split.1.trim_end_matches(')').trim();
|
||||
let argument = format!("\"{}\"", argument);
|
||||
let function = format!("{}, {}).join(\"\")", split.0, argument);
|
||||
// let function = format!("\"{}, {}\"", split.0, split.1);
|
||||
replace_list.push(rtag(tag_name, replace_tag, function));
|
||||
replace_tag += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue