test: add root replacer test back

Author: HerringtonDarkholme

crates/core/src/replacer.rs

@@ -1,7 +1,7 @@
 use crate::matcher::NodeMatch;
 use crate::source::{Content, Edit as E};
 use crate::Pattern;
-use crate::{Doc, Node};
+use crate::{Doc, Node, Root};
 
 type Edit<D> = E<<D as Doc>::Source>;
 type Underlying<S> = Vec<<S as Content>::Underlying>;
@@ -26,6 +26,12 @@ where
   }
 }
 
+impl<D: Doc> Replacer<D> for Root<D> {
+  fn generate_replacement(&self, nm: &NodeMatch<D>) -> Underlying<D::Source> {
+    structural::gen_replacement(self, nm)
+  }
+}
+
 impl<D: Doc> Replacer<D> for Pattern<D> {
   fn generate_replacement(&self, nm: &NodeMatch<D>) -> Underlying<D::Source> {
     structural::gen_replacement(&self.root, nm)

crates/core/src/replacer/structural.rs

@@ -115,3 +115,130 @@ fn get_meta_var_replacement<D: Doc>(
   };
   Some(replaced)
 }
+
+#[cfg(test)]
+mod test {
+  use super::*;
+  use crate::language::{Language, Tsx};
+  use crate::meta_var::MetaVarEnv;
+  use crate::{replacer::Replacer, Root};
+  use std::collections::HashMap;
+
+  fn test_pattern_replace(replacer: &str, vars: &[(&str, &str)], expected: &str) {
+    let mut env = MetaVarEnv::new();
+    let roots: Vec<_> = vars
+      .iter()
+      .map(|(v, p)| (v, Tsx.ast_grep(p).inner))
+      .collect();
+    for (var, root) in &roots {
+      env.insert(var.to_string(), root.root());
+    }
+    let dummy = Tsx.ast_grep("dummy");
+    let node_match = NodeMatch::new(dummy.root(), env.clone());
+    let replacer = Root::new(replacer, Tsx);
+    let replaced = replacer.generate_replacement(&node_match);
+    let replaced = String::from_utf8_lossy(&replaced);
+    assert_eq!(
+      replaced,
+      expected,
+      "wrong replacement {replaced} {expected} {:?}",
+      HashMap::from(env)
+    );
+  }
+
+  #[test]
+  fn test_no_env() {
+    test_pattern_replace("let a = 123", &[], "let a = 123");
+    test_pattern_replace(
+      "console.log('hello world'); let b = 123;",
+      &[],
+      "console.log('hello world'); let b = 123;",
+    );
+  }
+
+  #[test]
+  fn test_single_env() {
+    test_pattern_replace("let a = $A", &[("A", "123")], "let a = 123");
+    test_pattern_replace(
+      "console.log($HW); let b = 123;",
+      &[("HW", "'hello world'")],
+      "console.log('hello world'); let b = 123;",
+    );
+  }
+
+  #[test]
+  fn test_multiple_env() {
+    test_pattern_replace("let $V = $A", &[("A", "123"), ("V", "a")], "let a = 123");
+    test_pattern_replace(
+      "console.log($HW); let $B = 123;",
+      &[("HW", "'hello world'"), ("B", "b")],
+      "console.log('hello world'); let b = 123;",
+    );
+  }
+
+  #[test]
+  fn test_multiple_occurrences() {
+    test_pattern_replace("let $A = $A", &[("A", "a")], "let a = a");
+    test_pattern_replace("var $A = () => $A", &[("A", "a")], "var a = () => a");
+    test_pattern_replace(
+      "const $A = () => { console.log($B); $A(); };",
+      &[("B", "'hello world'"), ("A", "a")],
+      "const a = () => { console.log('hello world'); a(); };",
+    );
+  }
+
+  fn test_ellipsis_replace(replacer: &str, vars: &[(&str, &str)], expected: &str) {
+    let mut env = MetaVarEnv::new();
+    let roots: Vec<_> = vars
+      .iter()
+      .map(|(v, p)| (v, Tsx.ast_grep(p).inner))
+      .collect();
+    for (var, root) in &roots {
+      env.insert_multi(var.to_string(), root.root().children().collect());
+    }
+    let dummy = Tsx.ast_grep("dummy");
+    let node_match = NodeMatch::new(dummy.root(), env.clone());
+    let replacer = Root::new(replacer, Tsx);
+    let replaced = replacer.generate_replacement(&node_match);
+    let replaced = String::from_utf8_lossy(&replaced);
+    assert_eq!(
+      replaced,
+      expected,
+      "wrong replacement {replaced} {expected} {:?}",
+      HashMap::from(env)
+    );
+  }
+
+  #[test]
+  fn test_ellipsis_meta_var() {
+    test_ellipsis_replace(
+      "let a = () => { $$$B }",
+      &[("B", "alert('works!')")],
+      "let a = () => { alert('works!') }",
+    );
+    test_ellipsis_replace(
+      "let a = () => { $$$B }",
+      &[("B", "alert('works!');console.log(123)")],
+      "let a = () => { alert('works!');console.log(123) }",
+    );
+  }
+
+  #[test]
+  fn test_multi_ellipsis() {
+    test_ellipsis_replace(
+      "import {$$$A, B, $$$C} from 'a'",
+      &[("A", "A"), ("C", "C")],
+      "import {A, B, C} from 'a'",
+    );
+  }
+
+  #[test]
+  fn test_replace_in_string() {
+    test_pattern_replace("'$A'", &[("A", "123")], "'123'");
+  }
+
+  #[test]
+  fn test_nested_matching_replace() {
+    // TODO
+  }
+}

crates/core/src/replacer/template.rs

@@ -6,6 +6,7 @@ use crate::meta_var::{split_first_meta_var, MetaVarEnv};
 use crate::source::{Content, Doc};
 use std::borrow::Cow;
 
+// TODO: this should be public
 enum Fixer<'a, C: IndentSensitive> {
   // no meta_var, pure text
   Textual(Cow<'a, [C::Underlying]>),