format: a JSON document can be minified or indented

json gains a formatting setting taking record-per-line, minified or indented,
with the layout literals held on a style so the arithmetic that hits an exact
byte count measures whichever one is in use rather than predicting it. The
default is the layout this format has always written, pinned by two new golden
values.

The measurement that shaped this is a negative one: no reader can tell the
three apart. The same records minified, one per line, indented by two and
indented by four all parse in CPython's json and in V8. So the value of the
setting is entirely outside the parser - a minified document of any size is one
line and ends without a newline, an indented one holds about a third fewer
records in the same bytes - and the structural checker has to be TOLD which
layout to expect, for the reason the CSV dialect is told.

That immediately falsified what the existing checker said about itself. It read
"the manifest states one record per line" and counted lines against it, so both
new layouts would have broken it. The sentence was not wrong - it stopped being
true the day the layout became something a person can ask for.

Each layout answers for its own floor: 216 B minified, 219 B a record per line,
318 B indented. The registry declares the default layout's, the generator
answers for the rest, and the refusal names the layout it is about because the
same size is legal in another.

The canary is the half that makes the rest mean anything: a checker handed a
file and the RIGHT layout name would pass even if it ignored the name, so the
guard hands it every wrong one instead. Six pairs, six refusals.

Six mutations, all caught - including one already in the list that this
refactor had staled, which staleness.py found rather than a reader.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: donislawdev

CHANGELOG.md

@@ -83,6 +83,21 @@ because it turns other people's test suites red.
   generated text is English, so a file written in one would be byte for byte
   the same file as UTF-8 - a setting that changes nothing.
 
+- **JSON documents can be minified or indented.** A `formatting` setting on
+  `json` taking `record-per-line`, `minified` or `indented`. It defaults to the
+  one record per line this format has always written, so a recipe that says
+  nothing gets the same bytes.
+
+  ```
+  tfg generate --format json --size 1mb --set formatting=minified
+  ```
+
+  Every reader accepts all three, which is the point: what changes is
+  everything around the parser. A minified document of any size is one single
+  line and ends without a newline, and an indented one holds roughly a third
+  fewer records in the same number of bytes. The smallest document each layout
+  can produce differs too, and asking for less names the layout it is about.
+
 ### Security
 
 - **On Windows, the desktop window loads the library it uses for dark menus from

README.md

@@ -477,7 +477,8 @@ recipe. `tfg formats <id>` prints the allowed range or list for each:
 | `csv` | `delimiter`, `line_ending`, `header`, `quote_style`, `columns` |
 | `log` | `entry_format`, `timestamps`, `rate`, `methods`, `status_mix`, `level_mix`, `ip_version`, `line_ending` |
 | `txt`, `md` | `encoding`, `bom` |
-| `json`, `xml`, `html`, `svg` | none |
+| `json` | `formatting` |
+| `xml`, `html`, `svg` | none |
 
 ```
 tfg generate --format jpg --size 500kb --set width=1920 --set height=1080 --set quality=85

internal/format/jsonfile/json.go

@@ -38,10 +38,6 @@ import (
 const (
 	generatorVersion = "1"
 
-	// The document is an array with one record per line. Minified on one line
-	// and indented forms come later as a property.
-	prologue = "[\n"
-
 	emailDomain = "@example.com"
 
 	// Fixed widths, so the parts that are not the note stay predictable.
@@ -54,36 +50,14 @@ const (
 	// be asked for.
 	maxIDDigits = 19
 
-	// The literal parts of a record, named so the arithmetic below is a
-	// constant expression rather than a number somebody has to keep in step.
-	openID   = `{"id":`
-	openName = `,"name":"`
-	openMail = `","email":"`
-	openAmt  = `","amount":`
-	openAct  = `,"active":`
-	nullPart = `,"retired":null`
-	openTags = `,"tags":["`
-	tagSep   = `","`
-	openAddr = `"],"address":{"city":"`
-	openZip  = `","zip":"`
-	openNote = `"},"note":"`
-	closeRec = `"}`
-
-	// A record either has another one after it or closes the array.
-	tailMore = closeRec + ",\n"
-	tailLast = closeRec + "\n]\n"
-
 	// widestBool is "false", the longer of the two.
 	widestBool = 5
-
-	// fixedWidth is every literal byte of a closing record - everything except
-	// the record number, the name, the two tags, the city and the note.
-	fixedWidth = len(openID) + len(openName) + len(openMail) + len(emailDomain) +
-		len(openAmt) + amountWidth + len(openAct) + widestBool + len(nullPart) +
-		len(openTags) + len(tagSep) + len(openAddr) + len(openZip) + zipWidth +
-		len(openNote) + len(tailLast)
 )
 
+// The literal parts of a record live on the style, because there are three
+// layouts of them and the arithmetic has to measure whichever one is in use.
+// See style.go.
+
 func init() {
 	format.Register(format.Descriptor{
 		ID:          "json",
@@ -95,7 +69,12 @@ func init() {
 		// by naming a byte count - that is a shape request, and it arrives with
 		// the record count property. The minimum here is the array and one whole
 		// record.
-		MinBytes: minimumBytes(),
+		//
+		// The DEFAULT layout's minimum, the way CSV declares its default
+		// dialect's. Every other layout answers for itself, through the same
+		// refusal, and SmallestAccepted asks the generator rather than reading
+		// this number.
+		MinBytes: minimumBytes(defaultStyle()),
 
 		Padding: format.PaddingChannel{
 			Name:     "the note value of the last record",
@@ -107,27 +86,38 @@ func init() {
 		// structure under test. The file name and the manifest carry it instead.
 		Label:  format.LabelExternalOnly,
 		Oracle: "node-json",
-		// Nesting depth, key counts, value types, indentation and NDJSON come
-		// later. Declaring none now makes a recipe asking for them fail loudly.
-		Properties:       nil,
+		// Nesting depth, key counts, value types and NDJSON come later.
+		// Declaring only what is here makes a recipe asking for them fail
+		// loudly rather than quietly producing something else.
+		Properties:       properties(),
 		GeneratorVersion: generatorVersion,
 		Generator:        generator{},
 	})
 }
 
 type generator struct{}
 
-type memo struct{ seed uint64 }
+type memo struct {
+	seed uint64
+	s    style
+}
 
 func (generator) Plan(r format.Request) (format.Plan, error) {
-	min := minimumBytes()
+	s, err := parseStyle(r.Properties)
+	if err != nil {
+		return format.Plan{}, err
+	}
+
+	min := minimumBytes(s)
 	if r.Bytes < min {
 		return format.Plan{}, &format.BelowMinimumError{
 			Format:    "JSON",
 			Requested: r.Bytes,
 			Minimum:   min,
-			Reason:    "a document holds whole records and one record with every value type needs that much",
-			Hint:      fmt.Sprintf("Ask for %d B or more.", min),
+			Reason: fmt.Sprintf(
+				"a document holds whole records, and one %s record with every value type needs that much",
+				s.name),
+			Hint: fmt.Sprintf("Ask for %d B or more.", min),
 		}
 	}
 
@@ -136,15 +126,15 @@ func (generator) Plan(r format.Request) (format.Plan, error) {
 		Exact:       true,
 		Determinism: format.DeterminismByte,
 		Properties: map[string]any{
-			"encoding":   "utf-8",
-			"formatting": "record-per-line",
-			"root":       "array",
-			"depth":      3,
+			"encoding": "utf-8",
+			Formatting: s.name,
+			"root":     "array",
+			"depth":    3,
 			// Stated even though it is always false here, so a test can assert
 			// on it without knowing which formats carry a label internally.
 			format.PropertyLabelEmbedded: false,
 		},
-		Memo: memo{seed: r.Seed},
+		Memo: memo{seed: r.Seed, s: s},
 	}, nil
 }
 
@@ -154,24 +144,28 @@ func (generator) Write(ctx context.Context, w io.Writer, p format.Plan) error {
 		return fmt.Errorf("json: the plan was not produced by this generator")
 	}
 
-	if err := core.WriteAll(w, []byte(prologue)); err != nil {
+	if err := core.WriteAll(w, []byte(m.s.prologue)); err != nil {
 		return err
 	}
 
 	rng := core.NewRand(m.seed)
-	return core.FillRecords(ctx, w, rng, p.Bytes-int64(len(prologue)), &records{})
+	return core.FillRecords(ctx, w, rng, p.Bytes-int64(len(m.s.prologue)), &records{s: m.s})
 }
 
 // records builds the objects inside the array. It carries the record number, so
-// the id counts up the way a real export does.
-type records struct{ next int64 }
+// the id counts up the way a real export does, and the layout the document is
+// being written in.
+type records struct {
+	next int64
+	s    style
+}
 
 // Shortest is the smallest record this builder can close a document with: the
 // widest record number, the longest word in all five places a word appears, the
 // longer of the two booleans, and an empty note. It has to hold for every draw
 // rather than for the lucky one.
 func (r *records) Shortest() int64 {
-	return int64(maxIDDigits + 5*longestWord + fixedWidth)
+	return int64(maxIDDigits + 5*longestWord + r.s.fixed())
 }
 
 func (r *records) Append(dst []byte, rng *rand.Rand) []byte {
@@ -211,47 +205,47 @@ func (r *records) append(dst []byte, rng *rand.Rand, want int64) []byte {
 	city := words[rng.IntN(len(words))]
 	zip := 10000 + rng.IntN(90000)
 
-	dst = append(dst, openID...)
+	dst = append(dst, r.s.openID...)
 	dst = strconv.AppendInt(dst, r.next, 10)
-	dst = append(dst, openName...)
+	dst = append(dst, r.s.openName...)
 	dst = append(dst, name...)
-	dst = append(dst, openMail...)
+	dst = append(dst, r.s.openMail...)
 	dst = append(dst, name...)
 	dst = append(dst, emailDomain...)
-	dst = append(dst, openAmt...)
+	dst = append(dst, r.s.openAmt...)
 	dst = strconv.AppendInt(dst, int64(whole), 10)
 	dst = append(dst, '.')
 	if cents < 10 {
 		dst = append(dst, '0')
 	}
 	dst = strconv.AppendInt(dst, int64(cents), 10)
-	dst = append(dst, openAct...)
+	dst = append(dst, r.s.openAct...)
 	if active {
 		dst = append(dst, "true"...)
 	} else {
 		dst = append(dst, "false"...)
 	}
-	dst = append(dst, nullPart...)
-	dst = append(dst, openTags...)
+	dst = append(dst, r.s.nullPart...)
+	dst = append(dst, r.s.openTags...)
 	dst = append(dst, tagA...)
-	dst = append(dst, tagSep...)
+	dst = append(dst, r.s.tagSep...)
 	dst = append(dst, tagB...)
-	dst = append(dst, openAddr...)
+	dst = append(dst, r.s.openAddr...)
 	dst = append(dst, city...)
-	dst = append(dst, openZip...)
+	dst = append(dst, r.s.openZip...)
 	dst = strconv.AppendInt(dst, int64(zip), 10)
-	dst = append(dst, openNote...)
+	dst = append(dst, r.s.openNote...)
 
 	if want < 0 {
 		dst = appendPhrase(dst, rng, 3+rng.IntN(5))
-		return append(dst, tailMore...)
+		return append(dst, r.s.tailMore...)
 	}
 
 	// Everything written so far, plus the bytes that close the record and the
 	// array.
-	used := int64(len(dst)-start) + int64(len(tailLast))
+	used := int64(len(dst)-start) + int64(len(r.s.tailLast))
 	dst = appendFiller(dst, want-used)
-	return append(dst, tailLast...)
+	return append(dst, r.s.tailLast...)
 }
 
 // appendPhrase writes a readable note. Words and single spaces only - a JSON
@@ -281,9 +275,9 @@ func appendFiller(dst []byte, n int64) []byte {
 // minimumBytes is the opening bracket and one whole record, computed rather
 // than written down so it cannot drift away from the template the way a number
 // in a document would.
-func minimumBytes() int64 {
-	var r records
-	return int64(len(prologue)) + r.Shortest()
+func minimumBytes(s style) int64 {
+	r := records{s: s}
+	return int64(len(s.prologue)) + r.Shortest()
 }
 
 // longestWord is the widest draw, because the minimum has to hold for every