Add UAST mode to parse requests

Signed-off-by: Carlos Martín <[email protected]>

Author: carlosms

docs/rest-api.md

@@ -212,7 +212,7 @@ curl -X POST \
 
 ## POST /parse
 
-Receives a file content and returns UAST.
+Receives a file content and returns UAST parsed by the bblfsh server.
 
 ```bash
 curl -X POST \
@@ -221,6 +221,7 @@ curl -X POST \
   -d '{
   "language": "javascript",
   "content": "console.log(test)"
+  "mode": "annotated"
 }'
 ```
 
@@ -243,8 +244,11 @@ curl -X POST \
 }
 ```
 
-The endpoint also receives additional parameters:
+The endpoint accepts these parameters:
 
+- `language`: Language name.
+- `content`: The file contents to parse.
+- `mode`: Transformation mode. Can be one of `native`, `annotated`, `semantic`. The default is `semantic`.
 - `serverUrl` - allows to override bblfsh server URL.
 - `filename` - can be used instead of language. Then the bblfsh server would try to guess the language.
 - `filter` - [xpath query](https://doc.bblf.sh/user/uast-querying.html) to filter the results.

server/handler/uast.go

@@ -16,12 +16,21 @@ import (
 	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
 )
 
+type uastMode = string
+
+const (
+	native    uastMode = "native"
+	annotated uastMode = "annotated"
+	semantic  uastMode = "semantic"
+)
+
 type parseRequest struct {
-	ServerURL string `json:"serverUrl"`
-	Language  string `json:"language"`
-	Filename  string `json:"filename"`
-	Content   string `json:"content"`
-	Filter    string `json:"filter"`
+	ServerURL string   `json:"serverUrl"`
+	Language  string   `json:"language"`
+	Filename  string   `json:"filename"`
+	Content   string   `json:"content"`
+	Filter    string   `json:"filter"`
+	Mode      uastMode `json:"mode"`
 }
 
 // Parse returns a function that parses text contents using bblfsh and
@@ -48,11 +57,26 @@ func Parse(bbblfshServerURL string) RequestProcessFunc {
 			return nil, err
 		}
 
+		var mode bblfsh.Mode
+		switch req.Mode {
+		case native:
+			mode = bblfsh.Native
+		case annotated:
+			mode = bblfsh.Annotated
+		case semantic:
+			mode = bblfsh.Semantic
+		case "":
+			mode = bblfsh.Semantic
+		default:
+			return nil, serializer.NewHTTPError(http.StatusBadRequest,
+				fmt.Sprintf(`invalid "mode" %q; it must be one of "native", "annotated", "semantic"`, req.Mode))
+		}
+
 		resp, lang, err := cli.NewParseRequest().
 			Language(req.Language).
 			Filename(req.Filename).
 			Content(req.Content).
-			Mode(bblfsh.Semantic).
+			Mode(mode).
 			UAST()
 
 		if bblfsh.ErrSyntax.Is(err) {

server/handler/uast_integration_test.go

@@ -107,6 +107,59 @@ func (suite *UASTFilterSuite) TestFilterError() {
 	suite.Equal(http.StatusBadRequest, res.Code)
 }
 
+type UASTModeSuite struct {
+	suite.Suite
+	handler http.Handler
+}
+
+func TestUASTModeSuite(t *testing.T) {
+	q := new(UASTModeSuite)
+	q.handler = lg.RequestLogger(logrus.New())(handler.APIHandlerFunc(handler.Parse(bblfshServerURL())))
+
+	if !isIntegration() {
+		t.Skip("use the env var GITBASEPG_INTEGRATION_TESTS=true to run this test")
+	}
+
+	suite.Run(t, q)
+}
+
+func (suite *UASTModeSuite) TestSuccess() {
+	testCases := []string{
+		`{ "content": "console.log('test')", "language": "javascript", "mode": "" }`,
+		`{ "content": "console.log('test')", "language": "javascript", "mode": "native" }`,
+		`{ "content": "console.log('test')", "language": "javascript", "mode": "annotated" }`,
+		`{ "content": "console.log('test')", "language": "javascript", "mode": "semantic" }`,
+	}
+
+	for _, tc := range testCases {
+		suite.T().Run(tc, func(t *testing.T) {
+			req, _ := http.NewRequest("POST", "/parse", strings.NewReader(tc))
+
+			res := httptest.NewRecorder()
+			suite.handler.ServeHTTP(res, req)
+
+			suite.Require().Equal(http.StatusOK, res.Code, res.Body.String())
+
+			var resBody serializer.Response
+			err := json.Unmarshal(res.Body.Bytes(), &resBody)
+			suite.Nil(err)
+
+			suite.Equal(res.Code, resBody.Status)
+			suite.NotEmpty(resBody.Data)
+		})
+	}
+}
+
+func (suite *UASTModeSuite) TestWrongMode() {
+	jsonRequest := `{ "content": "console.log('test')", "language": "javascript", "mode": "foo" }`
+	req, _ := http.NewRequest("POST", "/parse", strings.NewReader(jsonRequest))
+
+	res := httptest.NewRecorder()
+	suite.handler.ServeHTTP(res, req)
+
+	suite.Equal(http.StatusBadRequest, res.Code)
+}
+
 // JSON: [<UAST(console.log("test"))>]
 // Easy to obtain in the frontend with SELECT UAST('console.log("test")', 'JavaScript') AS uast
 // Gitbase v0.18.0-beta.1, Bblfsh v2.9.2-drivers