Merge branch 'master' into docs/update-examples

Author: ajnavarro

CHANGELOG.md

@@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- When it's added the `-v` verbose flag, gitbase will use `debug` as logging level, ignoring any other passed ([#935](https://github.com/src-d/gitbase/pull/935))
+
+### Fixed
+
+- If using docker image, and `info` logging level, it will be now used instead of `debug` ([#935](https://github.com/src-d/gitbase/pull/935))
+
+
 ## [0.24.0-beta1] - 2019-07-08
 
 ### Added

cmd/gitbase/command/server.go

@@ -83,8 +83,8 @@ type Server struct {
 	MetricsPort    int            `long:"metrics-port" env:"GITBASE_METRICS_PORT" default:"2112" description:"Port where the server is going to expose prometheus metrics"`
 	ReadOnly       bool           `short:"r" long:"readonly" description:"Only allow read queries. This disables creating and deleting indexes as well. Cannot be used with --user-file." env:"GITBASE_READONLY"`
 	SkipGitErrors  bool           // SkipGitErrors disables failing when Git errors are found.
-	Verbose        bool           `short:"v" description:"Activates the verbose mode"`
-	LogLevel       string         `long:"log-level" env:"GITBASE_LOG_LEVEL" choice:"info" choice:"debug" choice:"warning" choice:"error" choice:"fatal" default:"info" description:"logging level"`
+	Verbose        bool           `short:"v" description:"Activates the verbose mode (equivalent to debug logging level), overwriting any passed logging level"`
+	LogLevel       string         `long:"log-level" env:"GITBASE_LOG_LEVEL" choice:"info" choice:"debug" choice:"warning" choice:"error" choice:"fatal" default:"info" description:"logging level; ignored if using -v verbose flag"`
 }
 
 type jaegerLogrus struct {
@@ -138,11 +138,18 @@ func (c *Server) Execute(args []string) error {
 
 	// info is the default log level
 	if c.LogLevel != "info" {
-		level, err := logrus.ParseLevel(c.LogLevel)
-		if err != nil {
-			return fmt.Errorf("cannot parse log level: %s", err.Error())
+		if c.Verbose {
+			logrus.Infof(
+				"ignoring passed '%s' log-level, using requesed '-v' verbose flag instead",
+				c.LogLevel,
+			)
+		} else {
+			level, err := logrus.ParseLevel(c.LogLevel)
+			if err != nil {
+				return fmt.Errorf("cannot parse log level: %s", err.Error())
+			}
+			logrus.SetLevel(level)
 		}
-		logrus.SetLevel(level)
 	}
 
 	var err error

docs/using-gitbase/configuration.md

@@ -117,6 +117,7 @@ Help Options:
       -r, --readonly                                   Only allow read queries. This disables creating and
                                                        deleting indexes as well. Cannot be used with
                                                        --user-file. [$GITBASE_READONLY]
-      -v                                               Activates the verbose mode
+      -v                                               Activates the verbose mode (equivalent to debug
+                                                       logging level), overwriting any passed logging level
           --log-level=[info|debug|warning|error|fatal] logging level (default: info) [$GITBASE_LOG_LEVEL]
 ```

docs/using-gitbase/functions.md

@@ -169,6 +169,26 @@ Also, if you want to retrieve values from a non common property, you can pass it
 
 > uast_extract(nodes_column, 'some-property')
 
+## How to use `loc`
+
+`loc` will return statistics about the lines of code in a file, such as the code lines, comment lines, etc.
+
+It requires a file path and a file content.
+
+> loc(file_path, blob_content)
+
+The result of this function is a JSON document with the following shape:
+
+```
+{
+	"Code": code lines,
+	"Comment": comment lines,
+	"Blank": blank lines,
+	"Name": file name,
+	"Lang": language
+}
+```
+
 ## How to use `commit_file_stats`
 
 `commit_file_stats` will return statistics about the line changes in all files in the given range of commits classifying them in 4 categories: code, comments, blank lines and other.

init.sh

@@ -10,10 +10,12 @@ user=${GITBASE_USER}
 password=${GITBASE_PASSWORD}
 EOT
 
-/tini -s -- /bin/gitbase server -v \
+export GITBASE_LOG_LEVEL=${GITBASE_LOG_LEVEL:-debug}
+
+/tini -s -- /bin/gitbase server \
     --host=0.0.0.0 \
     --port=3306 \
     --user="$GITBASE_USER" \
     --password="$GITBASE_PASSWORD" \
     --directories="$GITBASE_REPOS" \
-    $SIVA_ARGS
+    $SIVA_ARGS

internal/function/loc.go

@@ -52,6 +52,15 @@ func (f *LOC) WithChildren(children ...sql.Expression) (sql.Expression, error) {
 	return NewLOC(children...)
 }
 
+// LocFile is the result of the LOC function for each file.
+type LocFile struct {
+	Code     int32  `json:"Code"`
+	Comments int32  `json:"Comment"`
+	Blanks   int32  `json:"Blank"`
+	Name     string `json:"Name"`
+	Lang     string `json:"Language"`
+}
+
 // Eval implements the Expression interface.
 func (f *LOC) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	span, ctx := ctx.Span("gitbase.LOC")
@@ -70,11 +79,19 @@ func (f *LOC) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		return nil, nil
 	}
 
-	return gocloc.AnalyzeReader(
+	file := gocloc.AnalyzeReader(
 		path,
 		languages.Langs[lang],
 		bytes.NewReader(blob), &gocloc.ClocOptions{},
-	), nil
+	)
+
+	return LocFile{
+		Code:     file.Code,
+		Comments: file.Comments,
+		Blanks:   file.Blanks,
+		Name:     file.Name,
+		Lang:     file.Lang,
+	}, nil
 }
 
 func (f *LOC) getInputValues(ctx *sql.Context, row sql.Row) (string, []byte, error) {

internal/function/loc_test.go

@@ -3,11 +3,10 @@ package function
 import (
 	"testing"
 
-	"github.com/hhatto/gocloc"
-	"github.com/stretchr/testify/require"
-	"gopkg.in/src-d/go-errors.v1"
 	"github.com/src-d/go-mysql-server/sql"
 	"github.com/src-d/go-mysql-server/sql/expression"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/src-d/go-errors.v1"
 )
 
 func TestLoc(t *testing.T) {
@@ -22,7 +21,7 @@ func TestLoc(t *testing.T) {
 		{"too few args given", sql.NewRow("foo.foobar"), nil, nil},
 		{"too many args given", sql.NewRow("foo.rb", "bar", "baz"), nil, sql.ErrInvalidArgumentNumber},
 		{"invalid blob type given", sql.NewRow("foo", 5), nil, sql.ErrInvalidType},
-		{"path and blob are given", sql.NewRow("foo", "#!/usr/bin/env python\n\nprint 'foo'"), &gocloc.ClocFile{
+		{"path and blob are given", sql.NewRow("foo", "#!/usr/bin/env python\n\nprint 'foo'"), LocFile{
 			Code: 2, Comments: 0, Blanks: 1, Name: "foo", Lang: "Python",
 		}, nil},
 	}