Merge pull request #97 from bzz/nodext

Node documentation and convenience

Author: bzz

src/main/native/jni_utils.cc

@@ -14,14 +14,18 @@ JNIEnv *getJNIEnv() {
 
     case JNI_EDETACHED:  // Thread is detached, need to attach
       jvm->AttachCurrentThread((void **)&pEnv, NULL);
+      // FIXME(bzz): this is a memory leak (at least)
+      //  - jvm->DetachCurrentThread() is never called
+      //  - local references are _never_ deleted :scream:
+      //    https://developer.android.com/training/articles/perf-jni#local-and-global-references
       break;
   }
 
   return pEnv;
 }
 
 // Class fully qualified names
-const char CLS_NODE[] = "org/bblfsh/client/v2/Node";
+const char CLS_NODE[] = "org/bblfsh/client/v2/NodeExt";
 const char CLS_CTX[] = "org/bblfsh/client/v2/ContextExt";
 const char CLS_OBJ[] = "java/lang/Object";
 const char CLS_RE[] = "java/lang/RuntimeException";

src/main/native/org_bblfsh_client_v2_ContextExt.h

@@ -4,7 +4,7 @@
 #include "org_bblfsh_client_v2_Context.h"
 #include "org_bblfsh_client_v2_ContextExt.h"
 #include "org_bblfsh_client_v2_Context__.h"
-#include "org_bblfsh_client_v2_Node.h"
+#include "org_bblfsh_client_v2_NodeExt.h"
 #include "org_bblfsh_client_v2_libuast_Libuast.h"
 
 #include "libuast.h"
@@ -560,6 +560,15 @@ Java_org_bblfsh_client_v2_Context_00024_create(JNIEnv *env, jobject self) {
   return (long)c;
 }
 
+JNIEXPORT void JNICALL
+Java_org_bblfsh_client_v2_Context_dispose(JNIEnv *env, jobject self){
+  Context *p = getHandle<Context>(env, self, nativeContext);
+  setHandle<Context>(env, self, 0, nativeContext);
+  delete p;
+};
+
+
+
 // ==========================================
 //              v2.ContextExt()
 // ==========================================
@@ -589,8 +598,8 @@ Java_org_bblfsh_client_v2_ContextExt_dispose(JNIEnv *env, jobject self) {
 //                v2.Node()
 // ==========================================
 
-JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_Node_load(JNIEnv *env,
-                                                              jobject self) {
+JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_NodeExt_load(JNIEnv *env,
+                                                                 jobject self) {
   auto ctx = new Context();
   jobject node = ctx->LoadFrom(self);
   delete (ctx);

src/main/native/org_bblfsh_client_v2_Node.h

@@ -100,7 +100,7 @@ class BblfshClient(host: String, port: Int, maxMsgSize: Int) {
 object BblfshClient {
   val DEFAULT_MAX_MSG_SIZE = 100 * 1024 * 1024 // bytes
 
-  // TODO(bzz): expose new 'children' order and use enum/case class
+  // TODO(bzz): expose new 'children' order, use enum/case class
   val PreOrder = 0
   val PostOrder = 1
   val LevelOrder = 2
@@ -113,7 +113,7 @@ object BblfshClient {
     maxMsgSize: Int = DEFAULT_MAX_MSG_SIZE
   ): BblfshClient = new BblfshClient(host, port, maxMsgSize)
 
-  def filter(node: Node, query: String): List[Node] = Libuast.synchronized {
+  def filter(node: NodeExt, query: String): List[NodeExt] = Libuast.synchronized {
     libuast.filter(node, query)
   }
 
@@ -142,14 +142,19 @@ object BblfshClient {
       BblfshClient.decode(bufDirectCopy)
     }
   }
-  
-  // TODO(bzz): implement
-  // def iterator(node: Node, treeOrder: Int): Libuast.UastIterator = {
-  //   libuast.iterator(node, treeOrder)
+
+  // TODO(bzz): implement iterator
+  // def iterator(node: NodeExt, treeOrder: Int): Libuast.NodeIterator = {
+  //   new Libuast.NodeIterator(node, treeOrder)
+  // }
+  // def iterator(node: JNode, treeOrder: Int): Libuast.NodeIterator = {
+  //   new Libuast.NodeIterator(node, treeOrder)
   // }
 
-  // implicit class NodeMethods(val node: Node) {
-  //   def filter(query: String): List[Node] = {
+  // Enables API: resp.uast.decode().load().filter("//query")
+  // TODO(bzz): implement XPath query
+  // implicit class NodeExtMethods(val node: NodeExt) {
+  //   def filter(query: String): List[NodeExt] = {
   //     BblfshClient.filter(node, query)
   //   }
   // }

src/main/native/org_bblfsh_client_v2_NodeExt.h

@@ -3,15 +3,15 @@ package org.bblfsh.client.v2
 import java.nio.ByteBuffer
 
 /**
-  * Represents Go-side results of Libuast.decode()
+  * Represents Go-side constructed tree, result of Libuast.decode()
   *
   * This is equivalent of pyuast.ContextExt API
   */
 case class ContextExt(nativeContext: Long) {
-    @native def root(): Node
-    // @native def load() // TODO(bzz): implement after clarifying when it's needed
+    @native def root(): NodeExt
+    // @native def load(): JNode // TODO(bzz): clarify when it's needed VS just .root().load()
     @native def filter()
-    @native def encode(n: Node): ByteBuffer
+    @native def encode(n: NodeExt): ByteBuffer
 
     @native def dispose()
     override def finalize(): Unit = {

src/main/native/org_bblfsh_client_v2_libuast_Libuast.cc

@@ -4,9 +4,23 @@ import java.io.Serializable
 
 import scala.collection.mutable
 
-/** UAST nodes representation on the JVM side.
+/**
+  * UAST representation for the nodes originated from the Go side.
+  * This is equivalent of pyuast.NodeExt API.
   *
-  *  Mirrors https://godoc.org/github.com/bblfsh/sdk/uast/nodes
+  * @param ctx pointer to the native ContextExt
+  * @param handle pointer to the native Node
+  */
+case class NodeExt(ctx: Long, handle: Long) {
+  @native def load(): JNode
+}
+
+
+/**
+  * UAST representation for the nodes originated from or loaded to the JVM side.
+  * Mirrors https://godoc.org/github.com/bblfsh/sdk/uast/nodes
+  *
+  * This is equivalent of pyuast.Node API.
   */
 sealed abstract class JNode {
   /* Dynamic dispatch is a convenience to be called from JNI */
@@ -53,6 +67,7 @@ case class JBool(value: Boolean) extends JNode
 
 case class JObject(obj: mutable.Buffer[JField]) extends JNode {
   def this() = this(mutable.Buffer[JField]())
+  def filter(p: ((String, JNode)) => Boolean) = this.obj.filter(p)
   def add(k: String, v: JNode) = {
     obj += ((k, v))
   }
@@ -67,11 +82,13 @@ case object JObject {
 
 case class JArray(arr: mutable.Buffer[JNode]) extends JNode {
   def this(size: Int) = this(new mutable.ArrayBuffer[JNode](size))
+  def filter(p: JNode => Boolean) = this.arr.filter(p)
   def add(n: JNode) = {
     arr += n
   }
 }
 case object JArray {
+  /** Helper to construct literals in map-like notation */
   def apply[T <:  (Product with Serializable with JNode)](ns: T *)   = {
     val ja = new JArray(ns.length)
     ja.arr ++= ns

src/main/native/org_bblfsh_client_v2_libuast_Libuast.h

@@ -1,6 +1,6 @@
 package org.bblfsh.client.v2.libuast
 
-import org.bblfsh.client.v2.{ContextExt, JNode, Node}
+import org.bblfsh.client.v2.{ContextExt, JNode, NodeExt}
 
 import scala.collection.Iterator
 import java.io.File
@@ -80,11 +80,11 @@ class Libuast {
     }
   }
 
-  // TODO(bzz): implement iterators
-  // def iterator(node: Node, treeOrder: Int) = {
-  //   new Libuast.UastIterator(node, treeOrder)
-  // }
+  @native def filter(node: NodeExt, query: String): List[NodeExt]
+
+//  def iterator(node: Node, treeOrder: Int) =
+//    new Libuast.NodeIterator(node, treeOrder)
 
   @native def decode(buf: ByteBuffer): ContextExt
-  @native def filter(node: Node, query: String): List[Node]
+
 }

src/main/scala/org/bblfsh/client/v2/BblfshClient.scala

@@ -11,7 +11,7 @@ class BblfshClientLoadTest extends BblfshClientBaseTest {
 
   "Loading Go -> JVM of a real tree" should "bring JNode tree to memory" in {
     val uast = resp.uast.decode()
-    val rootNode: Node = uast.root()
+    val rootNode: NodeExt = uast.root()
 
     println(s"Loading $rootNode")
     val root = rootNode.load()
@@ -55,7 +55,7 @@ class BblfshClientLoadTest extends BblfshClientBaseTest {
   "Decoding, loading & encoding to different context" should "produce the same results" in {
     // decode -> load -> encode, and compare bytes
     val uast = resp.uast.decode()
-    val rootNode: Node = uast.root()
+    val rootNode: NodeExt = uast.root()
 
     println(s"Loading $rootNode")
     val root = rootNode.load()
@@ -66,7 +66,7 @@ class BblfshClientLoadTest extends BblfshClientBaseTest {
 
     // decode -> load -> encoded -> decode -> load, and compare trees
     val uast2 = BblfshClient.decode(data)
-    val rootNode2: Node = uast2.root()
+    val rootNode2: NodeExt = uast2.root()
     println(s"Loading $rootNode2")
     val root2 = rootNode2.load()
 

src/main/scala/org/bblfsh/client/v2/ContextExt.scala

@@ -24,7 +24,7 @@ class BblfshClientParseTest extends BblfshClientBaseTest {
 
   "Decoded UAST RootNode" should "not be NULL" in {
     val uast = resp.uast.decode()
-    val rootNode: Node = uast.root()
+    val rootNode: NodeExt = uast.root()
     println(rootNode.getClass)
 
     rootNode should not be null
@@ -36,7 +36,7 @@ class BblfshClientParseTest extends BblfshClientBaseTest {
 
   "Encoding back the RootNode of decoded UAST" should "produce same bytes" in {
     val uastCtx: ContextExt = resp.uast.decode()
-    val rootNode: Node = uastCtx.root()
+    val rootNode: NodeExt = uastCtx.root()
     println(s"Root node: $rootNode")
 
     val encodedBytes: ByteBuffer = uastCtx.encode(rootNode)