[feat] implement more napi interface

Author: HerringtonDarkholme

.editorconfig

@@ -9,7 +9,7 @@ indent_size = 2
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
-insert_final_newline = true
+insert_final_newline = false
 
 [*.md]
 trim_trailing_whitespace = false

crates/napi/__test__/index.spec.ts

@@ -29,3 +29,9 @@ test('findAll from native code', t => {
     end: { row: 0, col: 37 },
   })
 })
+
+test('findByString not match', t => {
+  const sg = AstGrep.js('console.log(123)')
+  const match = sg.root().findByString('notExist')
+  t.is(match, null)
+})

crates/napi/src/lib.rs

@@ -48,12 +48,12 @@ pub struct Range {
 }
 
 #[napi]
-pub struct SGNode {
-  inner: SharedReference<SGRoot, Node<'static, FrontEndLanguage>>,
+pub struct SgNode {
+  inner: SharedReference<SgRoot, Node<'static, FrontEndLanguage>>,
 }
 
 #[napi]
-impl SGNode {
+impl SgNode {
   #[napi]
   pub fn range(&self) -> Range {
     let start_pos = self.inner.start_pos();
@@ -64,49 +64,177 @@ impl SGNode {
     }
   }
 
+  #[napi]
+  pub fn is_leaf(&self) -> bool {
+    self.inner.is_leaf()
+  }
+  #[napi]
+  pub fn kind(&self) -> String {
+    self.inner.kind().to_string()
+  }
+  #[napi]
+  pub fn text(&self) -> String {
+    self.inner.text().to_string()
+  }
+}
+
+#[napi]
+impl SgNode {
+  #[napi]
+  pub fn matches(&self, m: String) -> bool {
+    self.inner.matches(&*m)
+  }
+
+  #[napi]
+  pub fn inside(&self, m: String) -> bool {
+    self.inner.inside(&*m)
+  }
+
+  #[napi]
+  pub fn has(&self, m: String) -> bool {
+    self.inner.has(&*m)
+  }
+
+  #[napi]
+  pub fn precedes(&self, m: String) -> bool {
+    self.inner.precedes(&*m)
+  }
+
+  #[napi]
+  pub fn follows(&self, m: String) -> bool {
+    self.inner.follows(&*m)
+  }
+}
+
+/// tree traversal API
+#[napi]
+impl SgNode {
+  #[napi]
+  pub fn children(&self, reference: Reference<SgNode>, env: Env) -> Result<Vec<SgNode>> {
+    let children = reference.inner.children();
+    Self::from_iter_to_vec(&reference, env, children)
+  }
+
   #[napi]
   pub fn find_by_string(
     &self,
-    reference: Reference<SGNode>,
+    reference: Reference<SgNode>,
     env: Env,
     pattern: String,
-  ) -> Result<Option<SGNode>> {
+  ) -> Result<Option<SgNode>> {
     let pattern = Pattern::new(&pattern, reference.inner.lang().clone());
-    let node = if let Some(node) = self.inner.find(pattern) {
-      node.get_node().clone()
+    let node = reference.inner.find(pattern).map(|n| n.get_node().clone());
+    Self::transpose_option(reference, env, node)
+  }
+
+  fn transpose_option(
+    reference: Reference<SgNode>,
+    env: Env,
+    node: Option<Node<'static, FrontEndLanguage>>,
+  ) -> Result<Option<SgNode>> {
+    if let Some(node) = node {
+      let root_ref = reference.inner.clone_owner(env)?;
+      let inner = root_ref.share_with(env, move |_| Ok(node))?;
+      Ok(Some(SgNode { inner }))
     } else {
-      return Ok(None);
-    };
-    let root_ref = reference.inner.clone_owner(env)?;
-    let inner = root_ref.share_with(env, move |_| Ok(node))?;
-    Ok(Some(SGNode { inner }))
+      Ok(None)
+    }
   }
 
   #[napi]
   pub fn find_all(
     &self,
-    reference: Reference<SGNode>,
+    reference: Reference<SgNode>,
     env: Env,
     pattern: String,
-  ) -> Result<Vec<SGNode>> {
+  ) -> Result<Vec<SgNode>> {
     let mut ret = vec![];
     for node_match in self.inner.find_all(&*pattern) {
       let node = node_match.get_node().clone();
       let root_ref = reference.inner.clone_owner(env)?;
-      let sg_node = SGNode {
+      let sg_node = SgNode {
+        inner: root_ref.share_with(env, move |_| Ok(node))?,
+      };
+      ret.push(sg_node);
+    }
+    Ok(ret)
+  }
+
+  fn from_iter_to_vec(
+    reference: &Reference<SgNode>,
+    env: Env,
+    iter: impl Iterator<Item = Node<'static, FrontEndLanguage>>,
+  ) -> Result<Vec<SgNode>> {
+    let mut ret = vec![];
+    for node in iter {
+      let root_ref = reference.inner.clone_owner(env)?;
+      let sg_node = SgNode {
         inner: root_ref.share_with(env, move |_| Ok(node))?,
       };
       ret.push(sg_node);
     }
     Ok(ret)
   }
+
+  #[napi]
+  pub fn field(
+    &self,
+    reference: Reference<SgNode>,
+    env: Env,
+    name: String,
+  ) -> Result<Option<SgNode>> {
+    let node = reference.inner.field(&name);
+    Self::transpose_option(reference, env, node)
+  }
+
+  #[napi]
+  pub fn parent(&self, reference: Reference<SgNode>, env: Env) -> Result<Option<SgNode>> {
+    let node = reference.inner.parent();
+    Self::transpose_option(reference, env, node)
+  }
+
+  #[napi]
+  pub fn child(&self, reference: Reference<SgNode>, env: Env, nth: u32) -> Result<Option<SgNode>> {
+    let inner = reference.inner.child(nth as usize);
+    Self::transpose_option(reference, env, inner)
+  }
+
+  #[napi]
+  pub fn ancestors(&self, reference: Reference<SgNode>, env: Env) -> Result<Vec<SgNode>> {
+    let ancestors = reference.inner.ancestors();
+    Self::from_iter_to_vec(&reference, env, ancestors)
+  }
+
+  #[napi]
+  pub fn next(&self, reference: Reference<SgNode>, env: Env) -> Result<Option<SgNode>> {
+    let inner = reference.inner.next();
+    Self::transpose_option(reference, env, inner)
+  }
+
+  #[napi]
+  pub fn next_all(&self, reference: Reference<SgNode>, env: Env) -> Result<Vec<SgNode>> {
+    let inner = reference.inner.next_all();
+    Self::from_iter_to_vec(&reference, env, inner)
+  }
+
+  #[napi]
+  pub fn prev(&self, reference: Reference<SgNode>, env: Env) -> Result<Option<SgNode>> {
+    let inner = reference.inner.prev();
+    Self::transpose_option(reference, env, inner)
+  }
+
+  #[napi]
+  pub fn prev_all(&self, reference: Reference<SgNode>, env: Env) -> Result<Vec<SgNode>> {
+    let inner = reference.inner.prev_all();
+    Self::from_iter_to_vec(&reference, env, inner)
+  }
 }
 
 #[napi(js_name = "AstGrep")]
-pub struct SGRoot(AstGrep<FrontEndLanguage>);
+pub struct SgRoot(AstGrep<FrontEndLanguage>);
 
 #[napi]
-impl SGRoot {
+impl SgRoot {
   fn from_lang(src: String, fe_lang: FrontEndLanguage) -> Self {
     Self(AstGrep::new(src, fe_lang))
   }
@@ -132,8 +260,8 @@ impl SGRoot {
   }
 
   #[napi]
-  pub fn root(&self, root_ref: Reference<SGRoot>, env: Env) -> Result<SGNode> {
+  pub fn root(&self, root_ref: Reference<SgRoot>, env: Env) -> Result<SgNode> {
     let inner = root_ref.share_with(env, |root| Ok(root.0.root()))?;
-    Ok(SGNode { inner })
+    Ok(SgNode { inner })
   }
 }