- [#] updated cmd:fmt -s, --concise option implemented

Author: suntong

imp_fmt.go

@@ -28,7 +28,11 @@ func (x *FmtCommand) Exec(args []string) error {
 
 	var out bytes.Buffer
 	var err error
-	if Opts.Compact {
+	if x.Concise {
+		var formatted string
+		formatted, err = FormatJSONMixed(data)
+		out.WriteString(formatted)
+	} else if Opts.Compact {
 		err = json.Compact(&out, data)
 	} else {
 		err = json.Indent(&out, data, Opts.Prefix, Opts.Indent)

jsonfiddle_test.go

@@ -68,6 +68,8 @@ func TestExec(t *testing.T) {
 	testIt(t, "Schedules", "fmt", "-i", "Schedules.json")
 	testIt(t, "CustomerP", "fmt", "-p", "-i", "CustomerP.json")
 	testIt(t, "CustomerPC", "fmt", "-c", "-p", "-i", "CustomerP.json")
+	testIt(t, "FmtConciseO", "fmt", "-s", "-i", "FmtConciseO.json")
+	testIt(t, "FmtConciseA", "fmt", "--concise", "-i", "FmtConciseA.json")
 	// -- sort
 	t.Logf("\n\n== Testing Basic sort Functions\n\n")
 	testIt(t, "CustomerSI", "sort", "-i", "Customer.json")

prop_fmt.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// FormatJSONMixed handles two top-level JSON structures:
+// 1. A single-key object containing an array: {"key": [elements]}
+// 2. A pure array of objects: [elements]
+// It formats the output with compact, single-line array elements.
+func FormatJSONMixed(input interface{}) (string, error) {
+	var rawJSON []byte
+	var err error
+
+	// 1. Ensure we have raw JSON bytes to work with.
+	switch v := input.(type) {
+	case []byte:
+		rawJSON = v
+	case string:
+		rawJSON = []byte(v)
+	default:
+		rawJSON, err = json.Marshal(v)
+		if err != nil {
+			return "", fmt.Errorf("failed to marshal input: %v", err)
+		}
+	}
+
+	// 2. Unmarshal into a generic interface{} to check its type.
+	var genericData interface{}
+	if err := json.Unmarshal(rawJSON, &genericData); err != nil {
+		return "", fmt.Errorf("failed to unmarshal JSON: %v", err)
+	}
+
+	var sb strings.Builder
+
+	// Determine the array source based on the top-level structure
+	switch v := genericData.(type) {
+	case map[string]interface{}:
+		// --- Case 1: Root is a single-key object ---
+
+		// Validation check ensures only one key exists
+		if len(v) != 1 {
+			return "", fmt.Errorf("input JSON object must have exactly one root key, found %d", len(v))
+		}
+
+		sb.WriteString("{ ")
+
+		// Use a composite loop/assignment to get the single key/value pair
+		// because Go maps are unordered and cannot be accessed by index or
+		// a known key without knowing the key name first
+		var key string
+		var value interface{}
+		for k, val := range v {
+			key = k
+			value = val
+			break // geet the 1st (and only) pair, see earlier strong validation check
+		}
+
+		// Validate the value is an array (slice)
+		elementArray, ok := value.([]interface{})
+		if !ok {
+			return "", fmt.Errorf("value for key %q is not a JSON array", key)
+		}
+
+		keyBytes, _ := json.Marshal(key)
+		// Write the indented key and array start
+		//sb.WriteString("  ") // 2-space indent
+		sb.Write(keyBytes)
+		sb.WriteString(": [\n")
+
+		// Format the elements
+		if err := formatArrayElements(&sb, elementArray, 4); err != nil {
+			return "", err
+		}
+
+		// Write the closing array and object
+		sb.WriteString("  ]\n")
+		sb.WriteString("}")
+
+	case []interface{}:
+		// --- Case 2: Root is a pure array ---
+
+		sb.WriteString("[\n")
+
+		// Format the elements
+		if err := formatArrayElements(&sb, v, 2); err != nil {
+			return "", err
+		}
+
+		// Write the closing array bracket
+		sb.WriteString("]")
+
+	default:
+		return "", fmt.Errorf("unsupported root JSON structure. Must be an array object or an array")
+	}
+
+	return sb.String(), nil
+}
+
+// formatArrayElements contains the core logic for marshalling and indenting elements.
+func formatArrayElements(sb *strings.Builder, elements []interface{}, indentSpaces int) error {
+	indent := strings.Repeat(" ", indentSpaces)
+	numElements := len(elements)
+
+	for i, element := range elements {
+		// Marshal the single element (compact, one-line string)
+		elemBytes, err := json.Marshal(element)
+		if err != nil {
+			return fmt.Errorf("failed to marshal element %d: %v", i, err)
+		}
+
+		// Write the indented element
+		sb.WriteString(indent)
+		sb.Write(elemBytes)
+
+		// Add comma and newline
+		if i < numElements-1 {
+			sb.WriteString(",")
+		}
+		sb.WriteString("\n")
+	}
+	return nil
+}

prop_fmt_test.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"testing"
+)
+
+// NOTE: The FormatJSONMixed function and the Element/Root structs
+// are assumed to be in a file named 'json_formatter.go' in the same directory.
+
+// Test data used for the Object-Wrapped Array case
+type testObjectData struct {
+	Users []struct {
+		ID     int  `json:"id"`
+		Active bool `json:"active"`
+	} `json:"users"`
+}
+
+// Test data used for the Pure Array case
+type testArrayData []struct {
+	Name string `json:"name"`
+	City string `json:"city"`
+}
+
+func TestFormatJSONMixed_Object(t *testing.T) {
+	// GIVEN a structured Go object that will serialize to {"key": [elements]}
+	testData := testObjectData{
+		Users: []struct {
+			ID     int  `json:"id"`
+			Active bool `json:"active"`
+		}{
+			{ID: 1, Active: true},
+			{ID: 2, Active: false},
+		},
+	}
+
+	// The expected output for this structure
+	expected := `{ "users": [
+    {"active":true,"id":1},
+    {"active":false,"id":2}
+  ]
+}`
+
+	// WHEN the formatting function is called
+	formatted, err := FormatJSONMixed(testData)
+
+	// THEN it should format correctly without error
+	if err != nil {
+		t.Fatalf("FormatJSONMixed failed with error: %v", err)
+	}
+
+	if formatted != expected {
+		t.Errorf("Object Test Failed.\nExpected:\n%s\nGot:\n%s", expected, formatted)
+	}
+}
+
+func TestFormatJSONMixed_Array(t *testing.T) {
+	// GIVEN a structured Go array that will serialize to [elements]
+	testData := testArrayData{
+		{Name: "Alice", City: "NYC"},
+		{Name: "Bob", City: "LA"},
+		{Name: "Charlie", City: "SF"},
+	}
+
+	// The expected output for this structure
+	expected := `[
+  {"city":"NYC","name":"Alice"},
+  {"city":"LA","name":"Bob"},
+  {"city":"SF","name":"Charlie"}
+]`
+
+	// WHEN the formatting function is called
+	formatted, err := FormatJSONMixed(testData)
+
+	// THEN it should format correctly without error
+	if err != nil {
+		t.Fatalf("FormatJSONMixed failed with error: %v", err)
+	}
+
+	if formatted != expected {
+		t.Errorf("Array Test Failed.\nExpected:\n%s\nGot:\n%s", expected, formatted)
+	}
+}

test/FmtConciseA.json

@@ -0,0 +1 @@
+[{"city":"NYC","name":"Alice"},{"city":"LA","name":"Bob"},{"city":"SF","name":"Charlie"}]

test/FmtConciseA.ref

@@ -0,0 +1,5 @@
+[
+  {"city":"NYC","name":"Alice"},
+  {"city":"LA","name":"Bob"},
+  {"city":"SF","name":"Charlie"}
+]

test/FmtConciseO.json

@@ -0,0 +1 @@
+{"users":[{"active":true,"id":1},{"active":false,"id":2}]}

test/FmtConciseO.ref

@@ -0,0 +1,5 @@
+{ "users": [
+    {"active":true,"id":1},
+    {"active":false,"id":2}
+  ]
+}