Revert "refactor: try to remove helper clone"

This reverts commit 9fdc1bc2.

scie-grammar/src/grammar/grammar/mod.rs

@@ -109,12 +109,11 @@ impl Grammar {
         prev_state: Option<StackElement>,
         emit_binary_tokens: bool,
     ) {
-        let mut rule_factory = RuleFactory::new(self);
         if self.root_id == -1 {
             let repository = self.grammar.repository.clone().unwrap();
             let based = repository.clone().map.base_s.unwrap();
             self.root_id =
-                rule_factory.get_compiled_rule_id(based.clone(), repository.clone());
+                RuleFactory::get_compiled_rule_id(based.clone(), self, repository.clone());
         }
 
         let mut is_first_line: bool = false;

scie-grammar/src/rule.rs

@@ -15,20 +15,13 @@ fn remove_first(s: &str) -> &str {
     last
 }
 
-pub struct RuleFactory<'a> {
-    helper: &'a mut Grammar
-}
+pub struct RuleFactory {}
 
-impl<'a> RuleFactory<'a> {
-    pub fn new(helper: &mut Grammar) -> RuleFactory {
-        RuleFactory {
-            helper
-        }
-    }
+impl RuleFactory {
     // todo: add more rule builder
-    pub fn compile_captures(
-        &mut self,
+    fn compile_captures(
         captures: Option<Box<IRawCaptures>>,
+        helper: &mut Grammar,
         repository: IRawRepository,
     ) -> Vec<CaptureRule> {
         let mut r = vec![];
@@ -58,7 +51,7 @@ impl<'a> RuleFactory<'a> {
                 let desc = captures.clone().unwrap().map.capture_map[&id_str].clone();
                 if let Some(rule) = options_patterns {
                     retokenizeCapturedWithRuleId =
-                        self.get_compiled_rule_id(desc, repository.clone());
+                        RuleFactory::get_compiled_rule_id(desc, helper, repository.clone());
                 }
                 // r[numericCaptureId] = RuleFactory::create_capture_rule(helper, desc.location, desc.name, desc.content_name, retokenizeCapturedWithRuleId);
             }
@@ -68,8 +61,8 @@ impl<'a> RuleFactory<'a> {
     }
 
     pub fn compile_patterns(
-        &mut self,
         origin_patterns: Option<Vec<IRawRule>>,
+        helper: Box<&mut Grammar>,
         repository: IRawRepository,
     ) -> ICompilePatternsResult {
         let mut r: Vec<i32> = vec![];
@@ -84,7 +77,7 @@ impl<'a> RuleFactory<'a> {
                         let first = remove_first(include_s.as_str());
                         let local_included_rule = map.get(first);
                         if let Some(rule) = local_included_rule {
-                            pattern_id = self.get_compiled_rule_id(*rule.clone(), repository.clone());
+                            pattern_id = RuleFactory::get_compiled_rule_id(*rule.clone(), &mut (*helper).clone(), repository.clone());
                         } else {
                             println!("CANNOT find rule for scopeName: {:?}", pattern.clone().include);
                         }
@@ -92,7 +85,7 @@ impl<'a> RuleFactory<'a> {
                         let option = pattern.include.unwrap();
                         let local_included_rule = map.get(option.as_str());
                         if let Some(rule) = local_included_rule {
-                            pattern_id = self.get_compiled_rule_id(*(rule).clone(), repository.clone());
+                            pattern_id = RuleFactory::get_compiled_rule_id(*(rule).clone(), &mut (*helper).clone(), repository.clone());
                         }
                     } else {
                         println!("todo: {:?}", pattern.include);
@@ -112,11 +105,11 @@ impl<'a> RuleFactory<'a> {
                         }
                     }
                 } else {
-                    pattern_id = self.get_compiled_rule_id(pattern, repository.clone());
+                    pattern_id = RuleFactory::get_compiled_rule_id(pattern, &mut (*helper).clone(), repository.clone());
                 }
 
                 if pattern_id != -1 {
-                    let rule = self.helper.get_rule(pattern_id);
+                    let rule = helper.get_rule(pattern_id);
                     println!("{:?}", rule)
                 }
             }
@@ -131,17 +124,18 @@ impl<'a> RuleFactory<'a> {
     }
 
     pub fn get_compiled_rule_id(
-        &mut self,
         mut desc: IRawRule,
+        helper: &mut Grammar,
         repository: IRawRepository,
     ) -> i32 {
         if let None = desc.id {
-            let id = self.helper.register_id();
+            let id = helper.register_id();
             desc.id = Some(id.clone());
 
             if let Some(match_s) = desc.match_s {
-                let rule_factory = self.compile_captures(
+                let rule_factory = RuleFactory::compile_captures(
                     desc.captures.clone(),
+                    helper,
                     repository.clone(),
                 );
                 let match_rule = MatchRule::new(
@@ -152,7 +146,7 @@ impl<'a> RuleFactory<'a> {
                     rule_factory,
                 );
 
-                self.helper.register_rule(Box::new(match_rule));
+                helper.register_rule(Box::new(match_rule));
                 return desc.id.unwrap();
             };
 
@@ -169,8 +163,9 @@ impl<'a> RuleFactory<'a> {
                     }
                 }
 
-                let rule_factory = self.compile_patterns(
+                let rule_factory = RuleFactory::compile_patterns(
                     patterns.clone(),
+                    Box::new(helper),
                     repository.clone(),
                 );
                 let include_only_rule = IncludeOnlyRule::new(
@@ -180,17 +175,18 @@ impl<'a> RuleFactory<'a> {
                     desc.content_name.clone(),
                     rule_factory,
                 );
-                self.helper.register_rule(Box::new(include_only_rule));
+                helper.register_rule(Box::new(include_only_rule));
                 return desc.id.unwrap();
             }
 
             if let Some(while_s) = desc.while_s {
                 let begin_rule_factory =
-                    self.compile_captures(desc.begin_captures, repository.clone());
+                    RuleFactory::compile_captures(desc.begin_captures, helper, repository.clone());
                 let end_rule_factory =
-                    self.compile_captures(desc.end_captures, repository.clone());
-                let pattern_factory = self.compile_patterns(
+                    RuleFactory::compile_captures(desc.end_captures, helper, repository.clone());
+                let pattern_factory = RuleFactory::compile_patterns(
                     desc.patterns.clone(),
+                    Box::new(helper),
                     repository.clone(),
                 );
 
@@ -206,14 +202,14 @@ impl<'a> RuleFactory<'a> {
                     pattern_factory,
                 );
 
-                self.helper.register_rule(Box::new(begin_while_rule));
+                helper.register_rule(Box::new(begin_while_rule));
                 return desc.id.unwrap();
             }
 
             let begin_rule_factory =
-                self.compile_captures(desc.begin_captures, repository.clone());
+                RuleFactory::compile_captures(desc.begin_captures, helper, repository.clone());
             let end_rule_factory =
-                self.compile_captures(desc.end_captures, repository.clone());
+                RuleFactory::compile_captures(desc.end_captures, helper, repository.clone());
             // let pattern_factory = RuleFactory::compile_patterns(
             //     desc.patterns.clone(),
             //     Box::new(helper),
@@ -234,7 +230,7 @@ impl<'a> RuleFactory<'a> {
                 // pattern_factory,
             );
 
-            self.helper.register_rule(Box::new(begin_end_rule));
+            helper.register_rule(Box::new(begin_end_rule));
             return desc.id.unwrap();
         }
 
@@ -331,7 +327,7 @@ impl BeginWhileRule {
             end_captures: None,
             apply_end_pattern_last: None,
             patterns: None,
-            cached_compiled_patterns: None,
+            cached_compiled_patterns: None
         }
     }
 }
@@ -398,7 +394,7 @@ impl BeginEndRule {
             end_captures: None,
             apply_end_pattern_last,
             patterns: None,
-            cached_compiled_patterns: None,
+            cached_compiled_patterns: None
         }
     }
 }