Put a facade between the nfa ast and the Patterns coming from the parser

The nfa should be independent of the ast that the parser produces

Author: egli

src/translator.rs

@@ -8,6 +8,7 @@ use self::graph::Boundary;
 
 mod boundaries;
 mod graph;
+mod match_pattern;
 mod nfa;
 mod trie;
 
@@ -25,7 +26,7 @@ pub enum TranslationError {
     },
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Default)]
 pub struct Translation {
     /// Input string to be translated
     input: String,

src/translator/match_pattern.rs

@@ -0,0 +1,118 @@
+use std::ops::Deref;
+
+use crate::parser::{Pattern, Patterns};
+
+use crate::translator::nfa::{AST, NFA};
+
+use super::Translation;
+
+impl From<&Patterns> for AST {
+    fn from(patterns: &Patterns) -> Self {
+        match patterns.len() {
+            0 => todo!(),
+            1 => AST::from(&patterns[0]),
+            _ => {
+                let mut ast = AST::from(&patterns[0]);
+                for pattern in patterns.iter().skip(1) {
+                    let other = AST::from(pattern);
+                    ast = AST::Concat(Box::new(ast), Box::new(other));
+                }
+                ast
+            }
+        }
+    }
+}
+
+impl From<&Box<Pattern>> for AST {
+    fn from(pattern: &Box<Pattern>) -> Self {
+        AST::from(pattern.deref())
+    }
+}
+
+impl From<&Pattern> for AST {
+    fn from(item: &Pattern) -> Self {
+        match item {
+            Pattern::Empty => todo!(),
+            Pattern::Characters(s) => AST::String(s.to_string()),
+            Pattern::Boundary => todo!(),
+            Pattern::Any => AST::Any,
+            Pattern::Set(hash_set) => AST::Set(hash_set.clone()),
+            Pattern::Attributes(hash_set) => todo!(),
+            Pattern::Group(vec) => todo!(),
+            Pattern::Negate(pattern) => todo!(),
+            Pattern::Optional(pattern) => AST::Optional(Box::new(AST::from(pattern))),
+            Pattern::ZeroOrMore(pattern) => AST::ZeroOrMore(Box::new(AST::from(pattern))),
+            Pattern::OneOrMore(pattern) => AST::OneOrMore(Box::new(AST::from(pattern))),
+            Pattern::Either(left, right) => AST::Either(Box::new(AST::from(left)), Box::new(AST::from(right)))
+        }
+    }
+}
+
+impl AST {
+    /// Combine the pre and post patterns with the match characters into one big regexp AST by joining the with concat
+    fn from_match_rule(pre: &Patterns, chars: String, post: &Patterns) -> Self {
+        AST::Concat(Box::new(AST::Concat(Box::new(AST::from(pre)), Box::new(AST::String(chars)))), Box::new(AST::from(post)))
+    }
+}
+
+impl NFA {
+    fn merge_patterns(&mut self, patterns: &Patterns) {
+	match patterns.len() {
+	    0 => (),
+	    1 => {
+		let ast = AST::from(&patterns[0]);
+		self.add_fragment(&ast);
+	    }
+	    _ => {
+		let ast = AST::from(&patterns[0]);
+		let mut union = self.add_fragment(&ast);
+		for pattern in patterns.iter().skip(1) {
+		    let ast = AST::from(pattern);
+		    let fragment = self.add_fragment(&ast);
+		    union = self.add_union(&union, &fragment)
+		}
+	    }
+	}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::parser::PatternParser;
+
+    #[test]
+    fn find_pattern() {
+        let patterns = PatternParser::new("abc").pattern().unwrap();
+        let translation = Translation::default();
+	let ast = AST::from(&patterns);
+        let nfa = NFA::from(&ast);
+        assert_eq!(nfa.find_translations("abc"), vec![translation]);
+        assert!(nfa.find_translations("def").is_empty());
+    }
+
+    #[test]
+    fn find_character_class() {
+        let patterns = PatternParser::new("[abc]").pattern().unwrap();
+        let translation = Translation::default();
+	let ast = AST::from(&patterns);
+        let nfa = NFA::from(&ast);
+        assert_eq!(nfa.find_translations("a"), vec![translation.clone()]);
+        assert_eq!(nfa.find_translations("b"), vec![translation.clone()]);
+        assert_eq!(nfa.find_translations("c"), vec![translation]);
+        assert!(nfa.find_translations("def").is_empty());
+    }
+
+    #[test]
+    fn find_character_class_one_or_more() {
+        let patterns = PatternParser::new("[abc]+").pattern().unwrap();
+        let translation = Translation::default();
+	let ast = AST::from(&patterns);
+        let nfa = NFA::from(&ast);
+        assert_eq!(nfa.find_translations("a"), vec![translation.clone()]);
+        assert_eq!(nfa.find_translations("b"), vec![translation.clone()]);
+        assert_eq!(nfa.find_translations("c"), vec![translation]);
+        assert!(nfa.find_translations("def").is_empty());
+    }
+
+}