cmd: added new output formats. fixes #82. (#93)

Now you can change the output format to 2 new ones: json and csv. - Added json support - Added csv support - Now the table output format is called 'pretty'. It is the default format.

Author: ajnavarro

cmd/gitql/query.go

@@ -9,17 +9,18 @@ import (
 
 "github.com/gitql/gitql"
 gitqlgit "github.com/gitql/gitql/git"
+"github.com/gitql/gitql/internal/format"
 "github.com/gitql/gitql/sql"
 
-"github.com/olekukonko/tablewriter"
 "gopkg.in/src-d/go-git.v4"
 )
 
 type CmdQuery struct {
 cmd
 
-Path string `short:"p" long:"path" description:"Path where the git repository is located"`
-Args struct {
+Path string `short:"p" long:"path" description:"Path where the git repository is located"`
+Format string `short:"f" long:"format" default:"pretty" description:"Ouptut format. Formats supported: pretty, csv, json."`
+Args struct {
 SQL string `positional-arg-name:"sql" required:"true" description:"SQL query to execute"`
 } `positional-args:"yes"`
 
@@ -86,34 +87,39 @@ func (c *CmdQuery) executeQuery() error {
 return err
 }
 
-c.printQuery(schema, iter)
-
-return nil
+return c.printQuery(schema, iter)
 }
 
-func (c *CmdQuery) printQuery(schema sql.Schema, iter sql.RowIter) {
-w := tablewriter.NewWriter(os.Stdout)
+func (c *CmdQuery) printQuery(schema sql.Schema, iter sql.RowIter) error {
+f, err := format.NewFormat(c.Format, os.Stdout)
+if err != nil {
+return err
+}
+
 headers := []string{}
 for _, f := range schema {
 headers = append(headers, f.Name)
 }
-w.SetHeader(headers)
+
+if err := f.WriteHeader(headers); err != nil {
+return err
+}
+
 for {
 row, err := iter.Next()
 if err == io.EOF {
 break
 }
 if err != nil {
-fmt.Printf("Error: %v\n", err)
-return
+return err
 }
-rowStrings := []string{}
-for _, v := range row.Fields() {
-rowStrings = append(rowStrings, fmt.Sprintf("%v", v))
+
+if err := f.Write(row.Fields()); err != nil {
+return err
 }
-w.Append(rowStrings)
 }
-w.Render()
+
+return f.Close()
 }
 
 func findDotGitFolder(path string) (string, error) {

internal/format/common.go

@@ -0,0 +1,25 @@
+package format
+
+import (
+"fmt"
+"io"
+)
+
+type Format interface {
+WriteHeader(headers []string) error
+Write(line []interface{}) error
+Close() error
+}
+
+func NewFormat(id string, w io.Writer) (Format, error) {
+switch id {
+case "pretty":
+return NewPrettyFormat(w), nil
+case "csv":
+return NewCsvFormat(w), nil
+case "json":
+return NewJsonFormat(w), nil
+default:
+return nil, fmt.Errorf("format not supported: %v", id)
+}
+}

internal/format/common_test.go

@@ -0,0 +1,49 @@
+package format
+
+import (
+"bytes"
+"testing"
+
+"github.com/stretchr/testify/assert"
+)
+
+func TestNewFormat_InvalidId(t *testing.T) {
+assert := assert.New(t)
+
+f, err := NewFormat("INVALID", bytes.NewBuffer(nil))
+assert.Nil(f)
+assert.NotNil(err)
+}
+
+func testNewFormat(id string, t *testing.T) {
+assert := assert.New(t)
+
+w := bytes.NewBuffer(nil)
+f, err := NewFormat(id, w)
+assert.Nil(err)
+assert.NotNil(f)
+}
+
+func testFormat(fs *formatSpec, writer *bytes.Buffer, t *testing.T) {
+assert := assert.New(t)
+
+err := fs.Format.WriteHeader(fs.Headers)
+assert.Nil(err)
+for _, l := range fs.Lines {
+err := fs.Format.Write(l)
+assert.Nil(err)
+}
+err = fs.Format.Close()
+assert.Nil(err)
+
+assert.Equal(fs.Result, writer.String())
+
+writer.Reset()
+}
+
+type formatSpec struct {
+Headers []string
+Lines [][]interface{}
+Format Format
+Result string
+}

internal/format/csv.go

@@ -0,0 +1,36 @@
+package format
+
+import (
+"encoding/csv"
+"fmt"
+"io"
+)
+
+type CsvFormat struct {
+cw *csv.Writer
+}
+
+func NewCsvFormat(w io.Writer) *CsvFormat {
+return &CsvFormat{
+cw: csv.NewWriter(w),
+}
+}
+
+func (cf *CsvFormat) WriteHeader(headers []string) error {
+return cf.cw.Write(headers)
+}
+
+func (cf *CsvFormat) Write(line []interface{}) error {
+rowStrings := []string{}
+for _, v := range line {
+rowStrings = append(rowStrings, fmt.Sprintf("%v", v))
+}
+
+return cf.cw.Write(rowStrings)
+}
+
+func (cf *CsvFormat) Close() error {
+cf.cw.Flush()
+
+return nil
+}

internal/format/csv_test.go

@@ -0,0 +1,24 @@
+package format
+
+import (
+"bytes"
+"testing"
+)
+
+func TestNewCsvFormat(t *testing.T) {
+w := bytes.NewBuffer(nil)
+testFormat(&formatSpec{
+Format: NewCsvFormat(w),
+Result: "a,b,c\na1,b1,c1\n",
+Headers: []string{"a", "b", "c"},
+Lines: [][]interface{}{
+[]interface{}{
+"a1", "b1", "c1",
+},
+},
+}, w, t)
+}
+
+func TestNewFormat_Csv(t *testing.T) {
+testNewFormat("csv", t)
+}

internal/format/json.go

@@ -0,0 +1,36 @@
+package format
+
+import (
+"encoding/json"
+"io"
+)
+
+type JsonFormat struct {
+je *json.Encoder
+keys []string
+}
+
+func NewJsonFormat(w io.Writer) *JsonFormat {
+return &JsonFormat{
+je: json.NewEncoder(w),
+}
+}
+
+func (cf *JsonFormat) WriteHeader(headers []string) error {
+cf.keys = headers
+
+return nil
+}
+
+func (cf *JsonFormat) Write(line []interface{}) error {
+j := make(map[string]interface{})
+for i, k := range cf.keys {
+j[k] = line[i]
+}
+
+return cf.je.Encode(j)
+}
+
+func (cf *JsonFormat) Close() error {
+return nil
+}

internal/format/json_test.go

@@ -0,0 +1,25 @@
+package format
+
+import (
+"bytes"
+"testing"
+)
+
+func TestNewJsonFormat(t *testing.T) {
+w := bytes.NewBuffer(nil)
+testFormat(&formatSpec{
+Format: NewJsonFormat(w),
+Result: "{\"a\":\"a1\",\"b\":\"b1\",\"c\":\"c1\"}\n",
+Headers: []string{"a", "b", "c"},
+Lines: [][]interface{}{
+[]interface{}{
+"a1", "b1", "c1",
+},
+},
+}, w, t)
+}
+
+
+func TestNewFormat_Json(t *testing.T) {
+testNewFormat("json", t)
+}

internal/format/pretty.go

@@ -0,0 +1,40 @@
+package format
+
+import (
+"fmt"
+"io"
+
+"github.com/olekukonko/tablewriter"
+)
+
+type PrettyFormat struct {
+tw *tablewriter.Table
+}
+
+func NewPrettyFormat(w io.Writer) *PrettyFormat {
+return &PrettyFormat{
+tw: tablewriter.NewWriter(w),
+}
+}
+
+func (pf *PrettyFormat) WriteHeader(headers []string) error {
+pf.tw.SetHeader(headers)
+
+return nil
+}
+
+func (pf *PrettyFormat) Write(line []interface{}) error {
+rowStrings := []string{}
+for _, v := range line {
+rowStrings = append(rowStrings, fmt.Sprintf("%v", v))
+}
+pf.tw.Append(rowStrings)
+
+return nil
+}
+
+func (pf *PrettyFormat) Close() error {
+pf.tw.Render()
+
+return nil
+}

internal/format/pretty_test.go

@@ -0,0 +1,26 @@
+package format
+
+import (
+"bytes"
+"testing"
+)
+
+func TestNewPrettyFormat(t *testing.T) {
+w := bytes.NewBuffer(nil)
+testFormat(&formatSpec{
+Format: NewPrettyFormat(w),
+Result: "+----+----+----+\n| A | B | C |" +
+"\n+----+----+----+\n| a1 | b1 | c1 |" +
+"\n+----+----+----+\n",
+Headers: []string{"a", "b", "c"},
+Lines: [][]interface{}{
+[]interface{}{
+"a1", "b1", "c1",
+},
+},
+}, w, t)
+}
+
+func TestNewFormat_Pretty(t *testing.T) {
+testNewFormat("pretty", t)
+}