Merge pull request #565 from mcarmonaa/improvement/update-bblfsh-client

Improvement/update bblfsh client

Author: ajnavarro

Gopkg.lock

@@ -53,13 +53,17 @@
   version = "1.6.5"
 
 [[constraint]]
-  name = "gopkg.in/bblfsh/client-go.v2"
-  version = "2.8.4"
+  name = "gopkg.in/bblfsh/client-go.v3"
+  version = "3.0.0"
 
-[[constraint]]
+[[override]]
   name = "gopkg.in/bblfsh/sdk.v1"
   version = "1.16.0"
 
+[[constraint]]
+  name = "gopkg.in/bblfsh/sdk.v2"
+  version = "2.3.0"
+
 [[constraint]]
   name = "github.com/uber/jaeger-client-go"
   version = "^2.7.0"

Gopkg.toml

@@ -142,7 +142,7 @@ SELECT file_path, uast(blob_content, language(file_path)) FROM files;
 This function allows you to directly filter the retrieved UAST by performing a XPATH query on it:
 
 ```sql
-SELECT file_path, uast(blob_content, language(file_path), "//FuncLit") FROM files;
+SELECT file_path, uast(blob_content, language(file_path), "//uast:FunctionGroup") FROM files;
 ```
 
 This UDF will give you `semantic` UASTs by default. To get some other type see the UDF [`uast_mode`](#retrieving-different-kinds-of-uasts-using-uast_mode).
@@ -162,39 +162,39 @@ SELECT file_path, uast_mode("native", blob_content, language(file_path)) FROM fi
 ## Filtering UASTs by XPath queries
 
 ```sql
-SELECT file_path, uast_xpath(uast(blob_content, language(file_path)), "//FieldList") FROM files;
+SELECT file_path, uast_xpath(uast(blob_content, language(file_path)), "//uast:Identifier") FROM files;
 
-SELECT file_path, uast_xpath(uast_mode("annotated", blob_content, language(file_path)), "//*[@roleFunction]") FROM files;
+SELECT file_path, uast_xpath(uast_mode("annotated", blob_content, language(file_path)), "//*[@role='Function']") FROM files;
 ```
 
 ## Extracting information from UAST nodes
 
-You can retrieve information from the UAST nodes either through the special selectors `@type`, `@token`, `@role`, `@startpos`, `@endpos`:
+You can retrieve information from the UAST nodes either through the special selectors `@type`, `@token`, `@role`, `@pos`:
 
 ```sql
-SELECT file_path, uast_extract(uast(blob_content, language(file_path), "//FuncLit"), "@startpos") FROM files;
+SELECT file_path, uast_extract(uast(blob_content, language(file_path), "//uast:Block"), "@pos") FROM files;
 ```
 
 or through a specific property:
 
 ```sql
-SELECT file_path, uast_extract(uast(blob_content, language(file_path), "//FuncLit"), "internalRole") FROM files;
+SELECT file_path, uast_extract(uast(blob_content, language(file_path), "//uast:Identifier"), "Name") FROM files;
 ```
 
 As result, you will get an array showing a list of the retrieved information. Each element in the list matches a node in the given sequence of nodes having a value for that property. It means that the length of the properties list may not be equal to the length of the given sequence of nodes:
 
 ```sh
-+-------------------+------------------------------------------------------------------------------------------------+
-| file_path         | uast_extract(uast(files.blob_content, language(files.file_path), "//FuncLit"), "internalRole") |
-+-------------------+------------------------------------------------------------------------------------------------+
-| benchmark_test.go | ["Args","Args","Args","Args","Args","Args","Args"]                                             |
-+-------------------+------------------------------------------------------------------------------------------------+
++-------------------------------------------------------------------------------------------------------------------+
+| file_path        | uast_extract(uast(files.blob_content, language(files.file_path), "//uast:Identifier"), "Name") |
++-------------------+-----------------------------------------------------------------------------------------------+
+| _example/main.go | ["main","driver","NewDefault","sqle","createTestDatabase","AddDatabase","driver","auth"]       |
++-------------------+-----------------------------------------------------------------------------------------------+
 ```
 
 ## Getting the children of a list of nodes
 
 The UDF `uast_children` will return a flattened array of the children nodes from all the nodes in the given array.
 
 ```sql
-SELECT file_path, uast_children(uast(blob_content, language(file_path), "//FuncLit")) FROM files;
+SELECT file_path, uast_children(uast(blob_content, language(file_path), "//uast:Alias")) FROM files;
 ```

docs/using-gitbase/examples.md

@@ -9,98 +9,61 @@ To make some common tasks easier for the user, there are some functions to inter
 |is_remote(reference_name)bool| check if the given reference name is from a remote one                                                          |
 |is_tag(reference_name)bool| check if the given reference name is a tag                                                                         |
 |language(path, [blob])text| gets the language of a file given its path and the optional content of the file                                    |
-|uast(blob, [lang, [xpath]]) blob| returns a sequence of serialized UAST nodes in semantic mode                                                 |
-|uast_mode(mode, blob, lang) blob| returns a sequence of serialized UAST nodes specifying its language and mode (semantic, annotated or native) |
+|uast(blob, [lang, [xpath]]) blob| returns a node array of UAST nodes in semantic mode                                                          |
+|uast_mode(mode, blob, lang) blob| returns a node array of UAST nodes specifying its language and mode (semantic, annotated or native)          |
 |uast_xpath(blob, xpath) blob| performs an XPath query over the given UAST nodes                                                                |
 |uast_extract(blob, key) text array| extracts information identified by the given key from the uast nodes                                       |
-|uast_children(blob) blob| returns a flattened array of the children UAST nodes from each one of the UAST nodes in the given sequence           |
+|uast_children(blob) blob| returns a flattened array of the children UAST nodes from each one of the UAST nodes in the given array              |
 
 
 ## Note about uast, uast_mode, uast_xpath and uast_children functions
 
-The data returned by these functions are a list of UAST nodes serialized as explained below.
+These functions make use of [UAST version 2](https://docs.sourced.tech/babelfish/uast/uast-v2), so you should get familiar with the concepts explained in the bblfsh documentation.
 
-Each node is serialized sequentially using [protobuf](https://developers.google.com/protocol-buffers/) and prefixed by an Int32 (in big endian byte order) specifying the length of the serialized node. The [bblfsh/sdk](https://github.com/bblfsh/sdk) contains the proto files and the tools to do it.
-
-It results in a byte stream following this structure:
-```
-BigEndianInt32(len(marhsal(node))+marshal(node)+
-BigEndianInt32(len(marhsal(node))+marshal(node)+
-BigEndianInt32(len(marhsal(node))+marshal(node)+
-...
-```
+The data returned by these functions is a serialized [array node](https://docs.sourced.tech/babelfish/uast/representation-v2#array) using [protobuf](https://developers.google.com/protocol-buffers/) which contains UAST [object nodes](https://docs.sourced.tech/babelfish/uast/representation-v2#object).
 
 As an example of how to manage the serialized data programatically, checkout out the Go code below:
 ```go
 import (
 	"bytes"
-	"encoding/binary"
-	"errors"
-	"io"
+	"fmt"
 
-	"github.com/bblfsh/sdk/uast"
+	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
+	"gopkg.in/bblfsh/sdk.v2/uast/nodes/nodesproto"
 )
 
-func marshalNodes(nodes []*uast.Node) (out []byte, err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			out, err = nil, r.(error)
-		}
-	}()
+func marshalNodes(arr nodes.Array) (interface{}, error) {
+	if len(arr) == 0 {
+		return nil, nil
+	}
 
 	buf := &bytes.Buffer{}
-	for _, n := range nodes {
-		if n != nil {
-			data, err := n.Marshal()
-			if err != nil {
-				return nil, err
-			}
-
-			if err := binary.Write(
-				buf, binary.BigEndian, int32(len(data)),
-			); err != nil {
-				return nil, err
-			}
-
-			n, _ := buf.Write(data)
-			if n != len(data) {
-				return nil, errors.New("couldn't write all the data")
-			}
-		}
+	if err := nodesproto.WriteTo(buf, arr); err != nil {
+		return nil, err
 	}
 
 	return buf.Bytes(), nil
 }
 
-func unmarshalNodes(data []byte) ([]*uast.Node, error) {
+func unmarshalNodes(data []byte) (nodes.Array, error) {
 	if len(data) == 0 {
 		return nil, nil
 	}
 
-	nodes := []*uast.Node{}
-	buf := bytes.NewBuffer(data)
-	for {
-		var nodeLen int32
-		if err := binary.Read(
-			buf, binary.BigEndian, &nodeLen,
-		); err != nil {
-			if err == io.EOF {
-				break
-			}
-
-			return nil, err
-		}
-
-		node := uast.NewNode()
-		if err := node.Unmarshal(buf.Next(int(nodeLen))); err != nil {
-			return nil, err
-		}
-
-		nodes = append(nodes, node)
+	buf := bytes.NewReader(data)
+	n, err := nodesproto.ReadTree(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	if n.Kind() != nodes.KindArray {
+		return nil, fmt.Errorf("unmarshal: wrong kind of node found %q, expected %q",
+			n.Kind(), nodes.KindArray.String())
 	}
 
-	return nodes, nil
+	return n.(nodes.Array), nil
 }
+
 ```
 
 ## How to formulate XPath queries when use uast and uast_xpath functions
@@ -109,15 +72,14 @@ Have a look at the [bblfsh docs](https://docs.sourced.tech/babelfish/using-babel
 
 ## How to use uast_extract
 
-Check out the [UAST specification](https://docs.sourced.tech/babelfish/uast/uast-specification) to know what an UAST node represents.
+Check out the [UAST v2 specification](https://docs.sourced.tech/babelfish/uast/uast-v2) to know what an UAST node represents.
 
 `uast_extracts` accepts special selectors to match common node properties:
 
 - `@type`
 - `@token`
 - `@role`
-- `@startpos`
-- `@endpos`
+- `@pos`
 
 Using these selectors as in,