Merge pull request #13 from eiri/none-objects-array

Support parsing of none-object arrays

Author: eiri

Makefile

@@ -32,9 +32,9 @@ format: ## format code
 
 .PHONY: run
 run: ## run for debug
-	@cat $(PWD)/testdata/data.json | go run main.go columns_value.go
+	@go run main.go columns_value.go -c seq,name,bool $(PWD)/testdata/data.json
 	@echo
-	@go run main.go columns_value.go -c seq,number,name -m $(PWD)/testdata/data.json
+	@go run main.go columns_value.go $(PWD)/testdata/misc-array.json
 	@echo
 
 .PHONY: deps

main.go

@@ -8,7 +8,6 @@ import (
 	"gopkg.in/alecthomas/kingpin.v2"
 	"io"
 	"os"
-	"reflect"
 	"sort"
 )
 
@@ -93,50 +92,53 @@ func renderMarkdown(w io.Writer, header Header, rows Rows) {
 }
 
 func parseJSON(r io.Reader) (header Header, rows Rows, err error) {
-	var vv []interface{}
-	var v interface{}
+	var raw interface{}
 	d := json.NewDecoder(r)
 	d.UseNumber()
-	err = d.Decode(&v)
+	err = d.Decode(&raw)
 	if err != nil {
 		return
 	}
-	switch v := v.(type) {
+	var records []interface{}
+	switch rec := raw.(type) {
 	case []interface{}:
-		header = makeHeader(v[0])
-		vv = v
+		records = rec
 	case map[string]interface{}:
-		header = makeHeader(v)
-		vv = append(vv, v)
+		records = append(records, rec)
 	default:
 		err = errors.New("Unsupported JSON data structure")
 		return
 	}
-	if len(header) == 0 {
-		err = errors.New("Can't find specified column(s)")
-		return
-	}
 
-	for _, v := range vv {
-		// we just skip none-object rows for now
-		if v, ok := v.(map[string]interface{}); ok {
-			var row []string
-			for _, key := range header {
-				val := fmt.Sprintf("%v", v[key])
-				row = append(row, val)
+	tableble := true
+	for _, val := range records {
+		var rec map[string]interface{}
+		if r, ok := val.(map[string]interface{}); ok && tableble {
+			rec = r
+		} else {
+			rec = map[string]interface{}{"value": val}
+			tableble = false
+		}
+		if len(header) == 0 {
+			header, err = makeHeader(rec)
+			if err != nil {
+				break
 			}
-			rows = append(rows, row)
 		}
+		var row []string
+		for _, key := range header {
+			cell := fmt.Sprintf("%v", rec[key])
+			row = append(row, cell)
+		}
+		rows = append(rows, row)
 	}
 
 	return
 }
 
-func makeHeader(val interface{}) Header {
-	var header Header
-	r := reflect.ValueOf(val)
-	for _, key := range r.MapKeys() {
-		header = append(header, key.String())
+func makeHeader(m map[string]interface{}) (header Header, err error) {
+	for key := range m {
+		header = append(header, key)
 	}
 	sort.Strings(header)
 	if len(*columns) > 0 {
@@ -149,5 +151,8 @@ func makeHeader(val interface{}) Header {
 		}
 		header = tmp
 	}
-	return header
+	if len(header) == 0 {
+		err = errors.New("Can't find specified column(s)")
+	}
+	return
 }

main_test.go

@@ -20,14 +20,27 @@ var headertests = []headertestpair{
 
 // TestMakeHeader to ensure we are getting sorted list of strings
 func TestMakeHeader(t *testing.T) {
-	in := map[string]int{"b": 1, "z": 2, "a": 3, "r": 4, "o": 5}
+	in := map[string]interface{}{"b": 1, "z": 2, "a": 3, "r": 4, "o": 5}
 	for _, pair := range headertests {
 		columns = pair.columns
-		out := makeHeader(in)
+		out, err := makeHeader(in)
+		if err != nil {
+			t.Fatal(err)
+		}
 		if !reflect.DeepEqual(pair.expect, out) {
 			t.Errorf("Expecting %#v, got %#v", pair.expect, out)
 		}
 	}
+	// return error
+	columns = &ColumnsValue{"none"}
+	out, err := makeHeader(in)
+	if err == nil {
+		t.Error("Expecting error, got nil")
+	}
+	var expect Header
+	if !reflect.DeepEqual(expect, out) {
+		t.Errorf("Expecting %#v, got %#v", expect, out)
+	}
 }
 
 // TestParseJSONObject to ensure we can parse JSON object
@@ -75,3 +88,32 @@ func TestParseJSONArray(t *testing.T) {
 		t.Errorf("Expecting %#v, got %#v", expectRows, rows)
 	}
 }
+
+// TestParseMiscJSONArray to ensure we can parse arbitrary JSON array
+func TestParseMiscJSONArray(t *testing.T) {
+	columns = &ColumnsValue{}
+	r, err := os.Open("testdata/misc-array.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	header, rows, err := parseJSON(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectHeader := Header{"value"}
+	if !reflect.DeepEqual(expectHeader, header) {
+		t.Errorf("Expecting %#v, got %#v", expectHeader, header)
+	}
+	expectRows := Rows{
+		[]string{"309"},
+		[]string{"true"},
+		[]string{"zG8dnbd1iXDHAewJ"},
+		[]string{"false"},
+		[]string{"773"},
+		[]string{"Og3TQltUz2eIW6ZF"},
+		[]string{"map[note:c#]"},
+	}
+	if !reflect.DeepEqual(expectRows, rows) {
+		t.Errorf("Expecting %#v, got %#v", expectRows, rows)
+	}
+}

testdata/misc-array.json

@@ -0,0 +1 @@
+[309,true,"zG8dnbd1iXDHAewJ",false,773,"Og3TQltUz2eIW6ZF",{"note":"c#"}]