jsonfmt options for detailed fractured output

fileformat · fileformat · commit 279b043f2fa3 · 2026-03-10T14:03:05.000-04:00
diff --git a/cmd/jsonfmt/README.md b/cmd/jsonfmt/README.md
@@ -12,3 +12,30 @@ Default mode is `--fractured` when no mode flag is provided.
 * `--trailing-newline`: if a trailing newline should be emitted
 * `--eol`: end-of-line character(s) `[ lf | cr' | crlf ]`.  Default is `lf`.
 * `--fractured`: compact output with [FracturedJson](https://github.com/j-brooke/FracturedJson) using the [go-fractured-json](https://github.com/FileFormatInfo/go-fractured-json) library
+
+## Fractured Options
+
+`jsonfmt` exposes `go-fractured-json` options as `--fractured-*` flags, including:
+
+* `--fractured-max-total-line-length`
+* `--fractured-max-inline-complexity`
+* `--fractured-max-compact-array-complexity`
+* `--fractured-max-table-row-complexity`
+* `--fractured-max-prop-name-padding`
+* `--fractured-colon-before-prop-name-padding`
+* `--fractured-table-comma-placement` (`before-padding`, `after-padding`, `before-padding-except-numbers`)
+* `--fractured-min-compact-array-row-items`
+* `--fractured-always-expand-depth`
+* `--fractured-nested-bracket-padding`
+* `--fractured-simple-bracket-padding`
+* `--fractured-colon-padding`
+* `--fractured-comma-padding`
+* `--fractured-comment-padding`
+* `--fractured-number-list-alignment` (`left`, `right`, `decimal`, `normalize`)
+* `--fractured-indent-spaces`
+* `--fractured-use-tab-to-indent`
+* `--fractured-prefix-string`
+* `--fractured-comment-policy` (`error`, `remove`, `preserve`)
+* `--fractured-preserve-blank-lines`
+* `--fractured-allow-trailing-commas`
+* `--fractured-json-eol-style` (`default`, `crlf`, `lf`)
diff --git a/cmd/jsonfmt/jsonfmt.go b/cmd/jsonfmt/jsonfmt.go
@@ -125,14 +125,141 @@ func maybeSortKeys(input []byte, sortKeys bool) ([]byte, error) {
 	return encodeSortedJSON(decoded)
 }
 
-func formatJSON(input []byte, canonical bool, line bool, fractured bool, sortKeys bool) (string, error) {
+type fracturedFlagValues struct {
+	jsonEolStyle               string
+	maxTotalLineLength         int
+	maxInlineComplexity        int
+	maxCompactArrayComplexity  int
+	maxTableRowComplexity      int
+	maxPropNamePadding         int
+	colonBeforePropNamePadding bool
+	tableCommaPlacement        string
+	minCompactArrayRowItems    int
+	alwaysExpandDepth          int
+	nestedBracketPadding       bool
+	simpleBracketPadding       bool
+	colonPadding               bool
+	commaPadding               bool
+	commentPadding             bool
+	numberListAlignment        string
+	indentSpaces               int
+	useTabToIndent             bool
+	prefixString               string
+	commentPolicy              string
+	preserveBlankLines         bool
+	allowTrailingCommas        bool
+}
+
+func parseEolStyle(v string) (fracturedjson.EolStyle, error) {
+	switch strings.ToLower(v) {
+	case "default":
+		return fracturedjson.EolDefault, nil
+	case "crlf":
+		return fracturedjson.EolCRLF, nil
+	case "lf":
+		return fracturedjson.EolLF, nil
+	default:
+		return fracturedjson.EolDefault, fmt.Errorf("invalid fractured json eol style %q (expected: default, crlf, lf)", v)
+	}
+}
+
+func parseTableCommaPlacement(v string) (fracturedjson.TableCommaPlacement, error) {
+	switch strings.ToLower(v) {
+	case "before-padding":
+		return fracturedjson.CommaBeforePadding, nil
+	case "after-padding":
+		return fracturedjson.CommaAfterPadding, nil
+	case "before-padding-except-numbers":
+		return fracturedjson.CommaBeforePaddingExceptNumbers, nil
+	default:
+		return fracturedjson.CommaBeforePaddingExceptNumbers, fmt.Errorf("invalid fractured table comma placement %q (expected: before-padding, after-padding, before-padding-except-numbers)", v)
+	}
+}
+
+func parseNumberListAlignment(v string) (fracturedjson.NumberListAlignment, error) {
+	switch strings.ToLower(v) {
+	case "left":
+		return fracturedjson.NumberLeft, nil
+	case "right":
+		return fracturedjson.NumberRight, nil
+	case "decimal":
+		return fracturedjson.NumberDecimal, nil
+	case "normalize":
+		return fracturedjson.NumberNormalize, nil
+	default:
+		return fracturedjson.NumberDecimal, fmt.Errorf("invalid fractured number list alignment %q (expected: left, right, decimal, normalize)", v)
+	}
+}
+
+func parseCommentPolicy(v string) (fracturedjson.CommentPolicy, error) {
+	switch strings.ToLower(v) {
+	case "error":
+		return fracturedjson.CommentTreatAsError, nil
+	case "remove":
+		return fracturedjson.CommentRemove, nil
+	case "preserve":
+		return fracturedjson.CommentPreserve, nil
+	default:
+		return fracturedjson.CommentTreatAsError, fmt.Errorf("invalid fractured comment policy %q (expected: error, remove, preserve)", v)
+	}
+}
+
+func buildFracturedOptions(flags fracturedFlagValues) (fracturedjson.Options, error) {
+	options := fracturedjson.RecommendedOptions()
+
+	eolStyle, err := parseEolStyle(flags.jsonEolStyle)
+	if err != nil {
+		return options, err
+	}
+	commaPlacement, err := parseTableCommaPlacement(flags.tableCommaPlacement)
+	if err != nil {
+		return options, err
+	}
+	numberAlignment, err := parseNumberListAlignment(flags.numberListAlignment)
+	if err != nil {
+		return options, err
+	}
+	commentPolicy, err := parseCommentPolicy(flags.commentPolicy)
+	if err != nil {
+		return options, err
+	}
+
+	options.JsonEolStyle = eolStyle
+	options.MaxTotalLineLength = flags.maxTotalLineLength
+	options.MaxInlineComplexity = flags.maxInlineComplexity
+	options.MaxCompactArrayComplexity = flags.maxCompactArrayComplexity
+	options.MaxTableRowComplexity = flags.maxTableRowComplexity
+	options.MaxPropNamePadding = flags.maxPropNamePadding
+	options.ColonBeforePropNamePadding = flags.colonBeforePropNamePadding
+	options.TableCommaPlacement = commaPlacement
+	options.MinCompactArrayRowItems = flags.minCompactArrayRowItems
+	options.AlwaysExpandDepth = flags.alwaysExpandDepth
+	options.NestedBracketPadding = flags.nestedBracketPadding
+	options.SimpleBracketPadding = flags.simpleBracketPadding
+	options.ColonPadding = flags.colonPadding
+	options.CommaPadding = flags.commaPadding
+	options.CommentPadding = flags.commentPadding
+	options.NumberListAlignment = numberAlignment
+	options.IndentSpaces = flags.indentSpaces
+	options.UseTabToIndent = flags.useTabToIndent
+	options.PrefixString = strings.ReplaceAll(flags.prefixString, `\t`, "\t")
+	options.CommentPolicy = commentPolicy
+	options.PreserveBlankLines = flags.preserveBlankLines
+	options.AllowTrailingCommas = flags.allowTrailingCommas
+
+	return options, nil
+}
+
+func formatJSON(input []byte, canonical bool, line bool, fractured bool, sortKeys bool, fracturedOptions fracturedjson.Options) (string, error) {
 	input, err := maybeSortKeys(input, sortKeys)
 	if err != nil {
 		return "", err
 	}
 
 	if fractured {
-		return fracturedjson.Reformat(string(input))
+		f := fracturedjson.NewFormatter()
+		f.Options = fracturedOptions
+		return f.Reformat(string(input), 0)
 	}
 
 	if line {
@@ -193,6 +320,30 @@ func main() {
 	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")
 
+	defaults := fracturedjson.RecommendedOptions()
+	var fracturedJsonEolStyle = pflag.String("fractured-json-eol-style", "default", "Fractured JSON EOL style: default, crlf, lf")
+	var fracturedMaxTotalLineLength = pflag.Int("fractured-max-total-line-length", defaults.MaxTotalLineLength, "Fractured max total line length")
+	var fracturedMaxInlineComplexity = pflag.Int("fractured-max-inline-complexity", defaults.MaxInlineComplexity, "Fractured max inline complexity")
+	var fracturedMaxCompactArrayComplexity = pflag.Int("fractured-max-compact-array-complexity", defaults.MaxCompactArrayComplexity, "Fractured max compact array complexity")
+	var fracturedMaxTableRowComplexity = pflag.Int("fractured-max-table-row-complexity", defaults.MaxTableRowComplexity, "Fractured max table row complexity")
+	var fracturedMaxPropNamePadding = pflag.Int("fractured-max-prop-name-padding", defaults.MaxPropNamePadding, "Fractured max property name padding")
+	var fracturedColonBeforePropNamePadding = pflag.Bool("fractured-colon-before-prop-name-padding", defaults.ColonBeforePropNamePadding, "Fractured: place colon before prop-name padding")
+	var fracturedTableCommaPlacement = pflag.String("fractured-table-comma-placement", "before-padding-except-numbers", "Fractured table comma placement: before-padding, after-padding, before-padding-except-numbers")
+	var fracturedMinCompactArrayRowItems = pflag.Int("fractured-min-compact-array-row-items", defaults.MinCompactArrayRowItems, "Fractured min compact array row items")
+	var fracturedAlwaysExpandDepth = pflag.Int("fractured-always-expand-depth", defaults.AlwaysExpandDepth, "Fractured always-expand depth")
+	var fracturedNestedBracketPadding = pflag.Bool("fractured-nested-bracket-padding", defaults.NestedBracketPadding, "Fractured nested bracket padding")
+	var fracturedSimpleBracketPadding = pflag.Bool("fractured-simple-bracket-padding", defaults.SimpleBracketPadding, "Fractured simple bracket padding")
+	var fracturedColonPadding = pflag.Bool("fractured-colon-padding", defaults.ColonPadding, "Fractured colon padding")
+	var fracturedCommaPadding = pflag.Bool("fractured-comma-padding", defaults.CommaPadding, "Fractured comma padding")
+	var fracturedCommentPadding = pflag.Bool("fractured-comment-padding", defaults.CommentPadding, "Fractured comment padding")
+	var fracturedNumberListAlignment = pflag.String("fractured-number-list-alignment", "decimal", "Fractured number list alignment: left, right, decimal, normalize")
+	var fracturedIndentSpaces = pflag.Int("fractured-indent-spaces", defaults.IndentSpaces, "Fractured indent spaces")
+	var fracturedUseTabToIndent = pflag.Bool("fractured-use-tab-to-indent", defaults.UseTabToIndent, "Fractured use tabs to indent")
+	var fracturedPrefixString = pflag.String("fractured-prefix-string", defaults.PrefixString, "Fractured prefix string (use \\t for tabs)")
+	var fracturedCommentPolicy = pflag.String("fractured-comment-policy", "error", "Fractured comment policy: error, remove, preserve")
+	var fracturedPreserveBlankLines = pflag.Bool("fractured-preserve-blank-lines", defaults.PreserveBlankLines, "Fractured preserve blank lines")
+	var fracturedAllowTrailingCommas = pflag.Bool("fractured-allow-trailing-commas", defaults.AllowTrailingCommas, "Fractured allow trailing commas")
+
 	var help = pflag.BoolP("help", "h", false, "Show help message")
 	var version = pflag.Bool("version", false, "Print version information")
 
@@ -217,6 +368,35 @@ func main() {
 		os.Exit(1)
 	}
 
+	fracturedOptions, err := buildFracturedOptions(fracturedFlagValues{
+		jsonEolStyle:               *fracturedJsonEolStyle,
+		maxTotalLineLength:         *fracturedMaxTotalLineLength,
+		maxInlineComplexity:        *fracturedMaxInlineComplexity,
+		maxCompactArrayComplexity:  *fracturedMaxCompactArrayComplexity,
+		maxTableRowComplexity:      *fracturedMaxTableRowComplexity,
+		maxPropNamePadding:         *fracturedMaxPropNamePadding,
+		colonBeforePropNamePadding: *fracturedColonBeforePropNamePadding,
+		tableCommaPlacement:        *fracturedTableCommaPlacement,
+		minCompactArrayRowItems:    *fracturedMinCompactArrayRowItems,
+		alwaysExpandDepth:          *fracturedAlwaysExpandDepth,
+		nestedBracketPadding:       *fracturedNestedBracketPadding,
+		simpleBracketPadding:       *fracturedSimpleBracketPadding,
+		colonPadding:               *fracturedColonPadding,
+		commaPadding:               *fracturedCommaPadding,
+		commentPadding:             *fracturedCommentPadding,
+		numberListAlignment:        *fracturedNumberListAlignment,
+		indentSpaces:               *fracturedIndentSpaces,
+		useTabToIndent:             *fracturedUseTabToIndent,
+		prefixString:               *fracturedPrefixString,
+		commentPolicy:              *fracturedCommentPolicy,
+		preserveBlankLines:         *fracturedPreserveBlankLines,
+		allowTrailingCommas:        *fracturedAllowTrailingCommas,
+	})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ERROR: %v\n", err)
+		os.Exit(1)
+	}
+
 	args := pflag.Args()
 	if len(args) == 0 {
 		args = []string{"-"}
@@ -232,7 +412,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	formatted, err := formatJSON(input, canonicalMode, lineMode, fracturedMode, *sortKeys)
+	formatted, err := formatJSON(input, canonicalMode, lineMode, fracturedMode, *sortKeys, fracturedOptions)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "ERROR: unable to format JSON: %v\n", err)
 		os.Exit(1)
diff --git a/cmd/jsonfmt/jsonfmt_test.go b/cmd/jsonfmt/jsonfmt_test.go
@@ -3,6 +3,8 @@ package main
 import (
 	"strings"
 	"testing"
+
+	fracturedjson "github.com/FileFormatInfo/go-fractured-json"
 )
 
 func TestResolveModes(t *testing.T) {
@@ -52,7 +54,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, false)
+	out, err := formatJSON([]byte("{\n  \"b\": 2,\n  \"a\": 1\n}\n"), false, true, false, false, fracturedjson.RecommendedOptions())
 	if err != nil {
 		t.Fatalf("formatJSON line error: %v", err)
 	}
@@ -62,7 +64,7 @@ func TestFormatJSONLine(t *testing.T) {
 }
 
 func TestFormatJSONCanonicalSortsKeys(t *testing.T) {
-	out, err := formatJSON([]byte("{\"b\":2,\"a\":1}"), true, false, false, false)
+	out, err := formatJSON([]byte("{\"b\":2,\"a\":1}"), true, false, false, false, fracturedjson.RecommendedOptions())
 	if err != nil {
 		t.Fatalf("formatJSON canonical error: %v", err)
 	}
@@ -75,7 +77,7 @@ func TestFormatJSONCanonicalSortsKeys(t *testing.T) {
 }
 
 func TestFormatJSONExpanded(t *testing.T) {
-	out, err := formatJSON([]byte("{\"k\":\"v\"}"), false, false, false, false)
+	out, err := formatJSON([]byte("{\"k\":\"v\"}"), false, false, false, false, fracturedjson.RecommendedOptions())
 	if err != nil {
 		t.Fatalf("formatJSON expanded error: %v", err)
 	}
@@ -85,7 +87,7 @@ func TestFormatJSONExpanded(t *testing.T) {
 }
 
 func TestFormatJSONFractured(t *testing.T) {
-	out, err := formatJSON([]byte("{\"a\":1,\"b\":2}"), false, false, true, false)
+	out, err := formatJSON([]byte("{\"a\":1,\"b\":2}"), false, false, true, false, fracturedjson.RecommendedOptions())
 	if err != nil {
 		t.Fatalf("formatJSON fractured error: %v", err)
 	}
@@ -95,11 +97,59 @@ func TestFormatJSONFractured(t *testing.T) {
 }
 
 func TestFormatJSONLineSortKeysCaseInsensitive(t *testing.T) {
-	out, err := formatJSON([]byte("{\"b\":1,\"A\":2,\"a\":3,\"B\":4}"), false, true, false, true)
+	out, err := formatJSON([]byte("{\"b\":1,\"A\":2,\"a\":3,\"B\":4}"), false, true, false, true, fracturedjson.RecommendedOptions())
 	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)
 	}
 }
+
+func TestBuildFracturedOptions(t *testing.T) {
+	opts, err := buildFracturedOptions(fracturedFlagValues{
+		jsonEolStyle:               "lf",
+		maxTotalLineLength:         80,
+		maxInlineComplexity:        1,
+		maxCompactArrayComplexity:  1,
+		maxTableRowComplexity:      1,
+		maxPropNamePadding:         8,
+		colonBeforePropNamePadding: true,
+		tableCommaPlacement:        "after-padding",
+		minCompactArrayRowItems:    2,
+		alwaysExpandDepth:          0,
+		nestedBracketPadding:       false,
+		simpleBracketPadding:       true,
+		colonPadding:               false,
+		commaPadding:               false,
+		commentPadding:             false,
+		numberListAlignment:        "right",
+		indentSpaces:               2,
+		useTabToIndent:             true,
+		prefixString:               "\\t",
+		commentPolicy:              "remove",
+		preserveBlankLines:         true,
+		allowTrailingCommas:        true,
+	})
+	if err != nil {
+		t.Fatalf("buildFracturedOptions error: %v", err)
+	}
+	if opts.JsonEolStyle != fracturedjson.EolLF || opts.TableCommaPlacement != fracturedjson.CommaAfterPadding || opts.NumberListAlignment != fracturedjson.NumberRight || opts.CommentPolicy != fracturedjson.CommentRemove {
+		t.Fatalf("unexpected enum mapping in options: %+v", opts)
+	}
+	if opts.PrefixString != "\t" {
+		t.Fatalf("expected prefix string to decode to tab, got %q", opts.PrefixString)
+	}
+}
+
+func TestBuildFracturedOptionsInvalidEnum(t *testing.T) {
+	_, err := buildFracturedOptions(fracturedFlagValues{
+		jsonEolStyle:        "bad",
+		tableCommaPlacement: "before-padding-except-numbers",
+		numberListAlignment: "decimal",
+		commentPolicy:       "error",
+	})
+	if err == nil {
+		t.Fatalf("expected invalid enum error")
+	}
+}
diff --git a/testdata/jsonfmt.txtar b/testdata/jsonfmt.txtar
@@ -10,6 +10,10 @@ stdout '(?s)^\{\n  "a": 1,\n  "b": \{\n    "x": 2,\n    "y": 1\n  \},\n  "z": 3\
 exec jsonfmt --line --sort-keys jsonfmt_input_case.json
 stdout '^\{"A":2,"a":3,"B":4,"b":1\}$'
 
+# fractured option passthrough
+exec jsonfmt --fractured-always-expand-depth=0 --fractured-indent-spaces=2 jsonfmt_input_nested.json
+stdout '(?s)^\{\n  "x": \{"a": 1\}\n\}$'
+
 # 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$'
@@ -29,3 +33,6 @@ stderr 'use at most one of --canonical, --line, --fractured'
 
 -- jsonfmt_input_case.json --
 {"b":1,"A":2,"a":3,"B":4}
+
+-- jsonfmt_input_nested.json --
+{"x":{"a":1}}
