Introduce json format

cmd/config.go

@@ -89,7 +89,7 @@ func getWriter(outputStream string) io.WriteCloser {
 // Validate validates the config object
 // and returns error if not valid.
 func (c *Config) Validate() error {
-	allFormats := []string{stdout}
+	allFormats := []string{rowmark, jsonFormat}
 
 	formatValid := false
 	for _, format := range allFormats {
@@ -106,14 +106,18 @@ func (c *Config) Validate() error {
 }
 
 const (
-	stdout = "stdout"
+	rowmark    = "rowmark"
+	jsonFormat = "json"
 )
 
 // Formatter instantiates a new formatted
 // based on config.Format
 func (c *Config) Formatter() Formatter {
-	if strings.ToLower(c.Format) == stdout {
-		return &StdoutFormatter{}
+	format := strings.ToLower(c.Format)
+	if format == rowmark {
+		return &RowMarkFormatter{}
+	} else if format == jsonFormat {
+		return &JSONFormatter{}
 	}
-	return &StdoutFormatter{}
+	return &RowMarkFormatter{}
 }

cmd/config_test.go

@@ -36,27 +36,37 @@ func TestConfigValidate(t *testing.T) {
 	config = &cmd.Config{}
 	assert.Error(t, config.Validate())
 
-	config = &cmd.Config{Format: "stdout"}
+	config = &cmd.Config{Format: "rowmark"}
 	assert.NoError(t, config.Validate())
 
-	config = &cmd.Config{Format: "stdOUT"}
+	config = &cmd.Config{Format: "rowMARK"}
+	assert.NoError(t, config.Validate())
+
+	config = &cmd.Config{Format: "json"}
 	assert.NoError(t, config.Validate())
 }
 
 func TestDefaultConfigFormatter(t *testing.T) {
 	config := &cmd.Config{}
 
-	formatter, ok := config.Formatter().(*cmd.StdoutFormatter)
+	formatter, ok := config.Formatter().(*cmd.RowMarkFormatter)
 
 	assert.True(t, ok)
 	assert.NotNil(t, formatter)
 }
 
-func TestStdoutConfigFormatter(t *testing.T) {
-	config := &cmd.Config{Format: "stdout"}
+func TestConfigFormatter(t *testing.T) {
+	var config *cmd.Config
+	var formatter cmd.Formatter
+	var ok bool
 
-	formatter, ok := config.Formatter().(*cmd.StdoutFormatter)
+	config = &cmd.Config{Format: "rowmark"}
+	formatter, ok = config.Formatter().(*cmd.RowMarkFormatter)
+	assert.True(t, ok)
+	assert.NotNil(t, formatter)
 
+	config = &cmd.Config{Format: "json"}
+	formatter, ok = config.Formatter().(*cmd.JSONFormatter)
 	assert.True(t, ok)
 	assert.NotNil(t, formatter)
 }

cmd/formatter.go

@@ -1,31 +1,48 @@
 package cmd
 
 import (
+	"encoding/json"
 	"fmt"
+	"io"
 
 	"github.com/aswinkarthik93/csvdiff/pkg/digest"
 )
 
 // Formatter defines the interface through which differences
 // can be formatted and displayed
 type Formatter interface {
-	Format(digest.Difference)
+	Format(digest.Difference, io.Writer)
 }
 
-// StdoutFormatter formats diff to STDOUT
-type StdoutFormatter struct{}
+// RowMarkFormatter formats diff by marking each row as
+// ADDED/MODIFIED. It mutates the row and adds as a new column.
+type RowMarkFormatter struct{}
 
 // Format prints the diff to os.Stdout
-func (f *StdoutFormatter) Format(diff digest.Difference) {
-	fmt.Printf("Additions %d\n", len(diff.Additions))
-	fmt.Printf("Modifications %d\n", len(diff.Modifications))
-	fmt.Println("Rows:")
+func (f *RowMarkFormatter) Format(diff digest.Difference, w io.Writer) {
+	fmt.Fprintf(w, "Additions %d\n", len(diff.Additions))
+	fmt.Fprintf(w, "Modifications %d\n", len(diff.Modifications))
+	fmt.Fprintf(w, "Rows:\n")
 
 	for _, added := range diff.Additions {
-		fmt.Printf("%s,%s\n", added, "ADDED")
+		fmt.Fprintf(w, "%s,%s\n", added, "ADDED")
 	}
 
 	for _, modified := range diff.Modifications {
-		fmt.Printf("%s,%s\n", modified, "MODIFIED")
+		fmt.Fprintf(w, "%s,%s\n", modified, "MODIFIED")
 	}
 }
+
+// JSONFormatter formats diff to as a JSON Object
+type JSONFormatter struct{}
+
+// Format prints the diff as a JSON
+func (f *JSONFormatter) Format(diff digest.Difference, w io.Writer) {
+	data, err := json.MarshalIndent(diff, "", "  ")
+
+	if err != nil {
+		panic(err)
+	}
+
+	w.Write(data)
+}

cmd/formatter_test.go

@@ -0,0 +1,55 @@
+package cmd_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/aswinkarthik93/csvdiff/cmd"
+	"github.com/aswinkarthik93/csvdiff/pkg/digest"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestJSONFormat(t *testing.T) {
+	var formatter cmd.Formatter
+	diff := digest.Difference{
+		Additions:     []string{"additions"},
+		Modifications: []string{"modification"},
+	}
+	expected := `{
+  "Additions": [
+    "additions"
+  ],
+  "Modifications": [
+    "modification"
+  ]
+}`
+
+	var buffer bytes.Buffer
+
+	formatter = &cmd.JSONFormatter{}
+
+	formatter.Format(diff, &buffer)
+	assert.Equal(t, expected, buffer.String())
+}
+
+func TestRowMarkFormatter(t *testing.T) {
+	var formatter cmd.Formatter
+	diff := digest.Difference{
+		Additions:     []string{"additions"},
+		Modifications: []string{"modification"},
+	}
+	expected := `Additions 1
+Modifications 1
+Rows:
+additions,ADDED
+modification,MODIFIED
+`
+
+	var buffer bytes.Buffer
+
+	formatter = &cmd.RowMarkFormatter{}
+
+	formatter.Format(diff, &buffer)
+	assert.Equal(t, expected, buffer.String())
+}

cmd/root.go

@@ -77,7 +77,7 @@ Most suitable for csv files created from database tables`,
 
 		diff := digest.Diff(baseConfig, deltaConfig)
 
-		config.Formatter().Format(diff)
+		config.Formatter().Format(diff, os.Stdout)
 	},
 }
 
@@ -104,6 +104,7 @@ func init() {
 
 	rootCmd.Flags().IntSliceVarP(&config.PrimaryKeyPositions, "primary-key", "p", []int{0}, "Primary key positions of the Input CSV as comma separated values Eg: 1,2")
 	rootCmd.Flags().IntSliceVarP(&config.ValueColumnPositions, "columns", "", []int{}, "Selectively compare positions in CSV Eg: 1,2. Default is entire row")
+	rootCmd.Flags().StringVarP(&config.Format, "format", "", "rowmark", "Available (rowmark|json)")
 
 	rootCmd.Flags().BoolVarP(&timed, "time", "", false, "Measure time")
 	rootCmd.Flags().BoolVarP(&version, "version", "", false, "Display version")