jsonfmt --sort-keys

Author: fileformat

cmd/jsonfmt/README.md

@@ -7,6 +7,7 @@ Default mode is `--fractured` when no mode flag is provided.
 ## Options
 
 * `--canonical`: the same output as `jq . --sort-keys`
+* `--sort-keys`: sort object keys case-insensitively
 * `--line`: everything on a single line
 * `--trailing-newline`: if a trailing newline should be emitted
 * `--eol`: end-of-line character(s) `[ lf | cr' | crlf ]`.  Default is `lf`.

cmd/jsonfmt/jsonfmt.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"sort"
 	"strings"
 
 	fracturedjson "github.com/FileFormatInfo/go-fractured-json"
@@ -57,7 +58,79 @@ func decodeJSON(input []byte) (any, error) {
 	return v, nil
 }
 
-func formatJSON(input []byte, canonical bool, line bool, fractured bool) (string, error) {
+func encodeSortedJSON(v any) ([]byte, error) {
+	switch t := v.(type) {
+	case map[string]any:
+		keys := make([]string, 0, len(t))
+		for k := range t {
+			keys = append(keys, k)
+		}
+		sort.Slice(keys, func(i, j int) bool {
+			li := strings.ToLower(keys[i])
+			lj := strings.ToLower(keys[j])
+			if li == lj {
+				return keys[i] < keys[j]
+			}
+			return li < lj
+		})
+
+		var buf bytes.Buffer
+		buf.WriteByte('{')
+		for i, k := range keys {
+			if i > 0 {
+				buf.WriteByte(',')
+			}
+			keyJSON, err := json.Marshal(k)
+			if err != nil {
+				return nil, err
+			}
+			buf.Write(keyJSON)
+			buf.WriteByte(':')
+			valJSON, err := encodeSortedJSON(t[k])
+			if err != nil {
+				return nil, err
+			}
+			buf.Write(valJSON)
+		}
+		buf.WriteByte('}')
+		return buf.Bytes(), nil
+	case []any:
+		var buf bytes.Buffer
+		buf.WriteByte('[')
+		for i, item := range t {
+			if i > 0 {
+				buf.WriteByte(',')
+			}
+			itemJSON, err := encodeSortedJSON(item)
+			if err != nil {
+				return nil, err
+			}
+			buf.Write(itemJSON)
+		}
+		buf.WriteByte(']')
+		return buf.Bytes(), nil
+	default:
+		return json.Marshal(t)
+	}
+}
+
+func maybeSortKeys(input []byte, sortKeys bool) ([]byte, error) {
+	if !sortKeys {
+		return input, nil
+	}
+	decoded, err := decodeJSON(input)
+	if err != nil {
+		return nil, err
+	}
+	return encodeSortedJSON(decoded)
+}
+
+func formatJSON(input []byte, canonical bool, line bool, fractured bool, sortKeys bool) (string, error) {
+	input, err := maybeSortKeys(input, sortKeys)
+	if err != nil {
+		return "", err
+	}
+
 	if fractured {
 		return fracturedjson.Reformat(string(input))
 	}
@@ -116,6 +189,7 @@ func main() {
 	var canonical = pflag.Bool("canonical", false, "Output canonical JSON (same as jq . --sort-keys)")
 	var line = pflag.Bool("line", false, "Output JSON on a single line")
 	var fractured = pflag.Bool("fractured", false, "Use fractured JSON formatting")
+	var sortKeys = pflag.Bool("sort-keys", false, "Sort object keys case-insensitively")
 	var trailingNewline = pflag.Bool("trailing-newline", false, "Emit a trailing newline")
 	var eol = pflag.String("eol", "lf", "End-of-line style: lf, cr, or crlf")
 
@@ -158,7 +232,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	formatted, err := formatJSON(input, canonicalMode, lineMode, fracturedMode)
+	formatted, err := formatJSON(input, canonicalMode, lineMode, fracturedMode, *sortKeys)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "ERROR: unable to format JSON: %v\n", err)
 		os.Exit(1)

cmd/jsonfmt/jsonfmt_test.go

@@ -52,7 +52,7 @@ func TestApplyEOL(t *testing.T) {
 }
 
 func TestFormatJSONLine(t *testing.T) {
-	out, err := formatJSON([]byte("{\n  \"b\": 2,\n  \"a\": 1\n}\n"), false, true, false)
+	out, err := formatJSON([]byte("{\n  \"b\": 2,\n  \"a\": 1\n}\n"), false, true, false, false)
 	if err != nil {
 		t.Fatalf("formatJSON line error: %v", err)
 	}
@@ -62,7 +62,7 @@ func TestFormatJSONLine(t *testing.T) {
 }
 
 func TestFormatJSONCanonicalSortsKeys(t *testing.T) {
-	out, err := formatJSON([]byte("{\"b\":2,\"a\":1}"), true, false, false)
+	out, err := formatJSON([]byte("{\"b\":2,\"a\":1}"), true, false, false, false)
 	if err != nil {
 		t.Fatalf("formatJSON canonical error: %v", err)
 	}
@@ -75,7 +75,7 @@ func TestFormatJSONCanonicalSortsKeys(t *testing.T) {
 }
 
 func TestFormatJSONExpanded(t *testing.T) {
-	out, err := formatJSON([]byte("{\"k\":\"v\"}"), false, false, false)
+	out, err := formatJSON([]byte("{\"k\":\"v\"}"), false, false, false, false)
 	if err != nil {
 		t.Fatalf("formatJSON expanded error: %v", err)
 	}
@@ -85,11 +85,21 @@ func TestFormatJSONExpanded(t *testing.T) {
 }
 
 func TestFormatJSONFractured(t *testing.T) {
-	out, err := formatJSON([]byte("{\"a\":1,\"b\":2}"), false, false, true)
+	out, err := formatJSON([]byte("{\"a\":1,\"b\":2}"), false, false, true, false)
 	if err != nil {
 		t.Fatalf("formatJSON fractured error: %v", err)
 	}
 	if !strings.Contains(out, "\"a\"") || !strings.Contains(out, "\"b\"") {
 		t.Fatalf("fractured output missing keys: %q", out)
 	}
 }
+
+func TestFormatJSONLineSortKeysCaseInsensitive(t *testing.T) {
+	out, err := formatJSON([]byte("{\"b\":1,\"A\":2,\"a\":3,\"B\":4}"), false, true, false, true)
+	if err != nil {
+		t.Fatalf("formatJSON line sort-keys error: %v", err)
+	}
+	if out != "{\"A\":2,\"a\":3,\"B\":4,\"b\":1}" {
+		t.Fatalf("line sort-keys output = %q", out)
+	}
+}

testdata/jsonfmt.txtar

@@ -6,6 +6,10 @@ stdout '^\{"z":3,"a":1,"b":\{"x":2,"y":1\}\}$'
 exec jsonfmt --canonical jsonfmt_input_small.json
 stdout '(?s)^\{\n  "a": 1,\n  "b": \{\n    "x": 2,\n    "y": 1\n  \},\n  "z": 3\n\}$'
 
+# explicit case-insensitive sort order
+exec jsonfmt --line --sort-keys jsonfmt_input_case.json
+stdout '^\{"A":2,"a":3,"B":4,"b":1\}$'
+
 # trailing newline and CRLF mode
 exec jsonfmt --line --trailing-newline --eol=crlf jsonfmt_input_array.json
 stdout '^\[\{"n":2,"s":"b"\},\{"n":1,"s":"a"\}\]\r\n$'
@@ -22,3 +26,6 @@ stderr 'use at most one of --canonical, --line, --fractured'
   {"n": 2, "s": "b"},
   {"n": 1, "s": "a"}
 ]
+
+-- jsonfmt_input_case.json --
+{"b":1,"A":2,"a":3,"B":4}