Record why a table owns its selector spelling and which names the import drops, and correct the complexity gate's own note

AGENTS.md

@@ -8,4 +8,4 @@
 - One spelling per result: reject the other at `New`, and let the error name the spelling to use.
 - A standing choice a reader would relitigate goes under Decisions in the README, not in a comment.
 - A README example is a `json` block that loads and renders as a category; `readme_test.go` runs every one.
-- Cyclomatic complexity is gated at 14: the table-shaped dispatches (`eachToken`, `calc.factor`, `walkPath`) sit at 13–14 and stay whole; anything else that reaches 14 is decomposed.
+- Cyclomatic complexity is gated at 14: the table-shaped dispatches (`linkParent`, `compileTemplate`, `renderEdges`) sit at it and stay whole; a function that would pass it is decomposed.

CHANGELOG.md

@@ -44,8 +44,9 @@ replacement, and each removed path, column or flag.
   name both sexes carry is a row under each. `person` reads them, so its columns are
   `first`, `last`, `prefix` and `sex`; `person.femalefirst` and `person.malefirst` are
   no longer paths — draw `sex[f].first-name` and `sex[m].first-name` instead.
-  `en_US.title` links to `sex` as well, so `en_US.person.prefix` draws `Mr` or `Ms`
-  without contradicting the record's `sex`.
+    `en_US.title` links to `sex` as well, so `en_US.person.prefix` draws `Mr` or `Ms`
+  without contradicting the record's `sex`; `sv_SE.title` is an unsexed table of the
+  same shape.
 - `sv_SE.personnummer` and `sv_SE.samordningsnummer`, Skatteverket's test series
   from a `sv_SE.birth-number` table under `sex`, in place of `sv_SE.ssn`, whose
   `ssn.mmdd`, `ssn.mmdd.m` and `ssn.mmdd.d` go with it. `en_US.ssn` now draws the

README.md

@@ -1097,8 +1097,13 @@ App developers writing tests and fixtures, in Go and at a shell:
 - **A title is a table under `sex`.** A prefix drawn apart would put `Mr` on a record
   whose `sex` column says `female`, which is the disagreement the record exists to
   prevent; the tables this set already has are what a title needs, so `en_US.title`
-  links to `sex` as `first-name` does. Swedish has no everyday sexed honorific, so
-  `sv_SE` keeps an unsexed `dr` and `prof`.
+    links to `sex` as `first-name` does. Swedish has no everyday sexed honorific, so
+  `sv_SE.title` is a table as well but carries no `parent`.
+- **A table owns the spelling of a selector on it.** A reference reaches a table by a
+  path that carries no selector — `sv_SE.person.first` reads `first-name` through
+  `sex` — so the walk that resolved a name cannot say where a reader would type one.
+  The table's own location can, which is why it keeps its path, and why an ambiguity
+  error names `sv_SE.sex[f].first-name[Kim]` rather than the table's own name.
 - **No builtin reads the clock, so a date is bounded by days, never by an age.**
   An `age(min,max)` would make a seeded fixture change with the day it runs on,
   which is what a seed exists to prevent; a birthdate for someone 20 to 60 is
@@ -1119,8 +1124,10 @@ App developers writing tests and fixtures, in Go and at a shell:
   than computed from the date drawn.
 - **The US given names come from a mirror of the SSA file.** ssa.gov refuses a
   client outside the US, so `names-us.py` reads a GitHub copy that ends at 2020,
-  which a count over the births since 1930 barely feels; `--names` takes the
-  official zip.
+    which a count over the births since 1930 barely feels; `--names` takes the
+  official zip. The SSA's placeholder rows — `Unknown`, `Baby`, `Infant` — are
+  top-1000 entries that name nobody, so the import drops them by name rather than by
+  a rank a regeneration would move.
 - **`List` advertises direct descents only.** `region.municipality.locality` is
   listed, and `region.locality` resolves too but is not: the set of every descent
   through a chain of five tables is every subsequence of it, and the direct chain is
@@ -1210,6 +1217,9 @@ family.go       a family of linked tables: the rows a render pins, and the fence
 reference.go    reference sigils, and binding references across the tree
 graph.go        the render graph: edges, cycles, the repeat bound, tree walks
 builtins.go     the {name()} function registry and its implementations
+layout.go       date and time layouts: the instants one is proved against, and the two samples
+checksum.go     the check characters a derivation appends, and the IBAN they sit inside
+transform.go    the builtins that rewrite an operand's value, and the ASCII folding
 calc.go         the {calc()} arithmetic evaluator: parser, eval, validation
 datatype.go     column datatypes: DataType, where datatype and null may sit, a column's datatype
 value.go        the value proof: what a typed column or calc operand holds, checked at load

builtins.go

@@ -7,8 +7,6 @@ import (
 	"math"
 	"strconv"
 	"strings"
-	"time"
-	"unicode"
 )
 
 // maxLen caps sample output lengths (hex, nanoid, base64, digits, upper, lower)
@@ -91,13 +89,11 @@ func derive(f func(emitted string) string) func([]string) callFn {
 		return func(_ *session, emitted string, _ []string) string { return f(emitted) }
 	}
 }
-
 func sample(f func(rng) string) func([]string) callFn {
 	return func([]string) callFn {
 		return func(s *session, _ string, _ []string) string { return f(s) }
 	}
 }
-
 func chars(alphabet string) func([]string) callFn {
 	return func(a []string) callFn {
 		n := atoi(a[0])
@@ -116,96 +112,6 @@ func formatFloat(v float64, dp int) string {
 	return s
 }
 
-// transforms are the builtins that rewrite one operand's value; they nest, so
-// {lowercase(ascii(x))} folds then lowers.
-var transforms = map[string]func(string) string{
-	"ascii":     asciiFold,
-	"lowercase": strings.ToLower,
-	"uppercase": strings.ToUpper,
-}
-
-// unwrapTransform peels nested transform calls off an operand arg, returning the
-// field it finally names and the transforms to apply, innermost last.
-func unwrapTransform(arg string) (leaf string, chain []func(string) string, err error) {
-	for {
-		name, args, isCall := funcCall(arg)
-		if !isCall {
-			return arg, chain, nil
-		}
-		fn, isTransform := transforms[name]
-		if !isTransform {
-			return "", nil, fmt.Errorf("%s(%s) is not a transform, so it cannot be an operand", name, strings.Join(args, ","))
-		}
-		if len(args) != 1 {
-			return "", nil, fmt.Errorf("%s takes 1 arg, got %d", name, len(args))
-		}
-		chain = append(chain, fn)
-		arg = args[0]
-	}
-}
-
-func transformArg(fields map[string]node, a []string) error {
-	leaf, _, err := unwrapTransform(a[0])
-	if err != nil {
-		return err
-	}
-	if isRef(leaf) {
-		_, _, err := refShape(leaf)
-		return err
-	}
-	return checkArm(leaf, fields, false)
-}
-
-func transformOperand(a []string) []string {
-	leaf, _, err := unwrapTransform(a[0])
-	if err != nil {
-		return nil
-	}
-	return []string{leaf}
-}
-
-func transformPrep(outer func(string) string) func([]string) callFn {
-	return func(a []string) callFn {
-		_, chain, err := unwrapTransform(a[0])
-		if err != nil {
-			panic(fmt.Sprintf("fejkdata: transform arg %q reached prep unvalidated: %v", a[0], err))
-		}
-		return func(_ *session, _ string, operands []string) string {
-			v := operands[0]
-			for i := len(chain) - 1; i >= 0; i-- {
-				v = chain[i](v)
-			}
-			return outer(v)
-		}
-	}
-}
-
-// asciiFolds maps the Latin letters with diacritics or ligatures to ASCII.
-var asciiFolds = map[rune]string{
-	'À': "A", 'Á': "A", 'Â': "A", 'Ã': "A", 'Ä': "A", 'Å': "A", 'Æ': "AE", 'Ç': "C",
-	'È': "E", 'É': "E", 'Ê': "E", 'Ë': "E", 'Ì': "I", 'Í': "I", 'Î': "I", 'Ï': "I",
-	'Ð': "D", 'Ñ': "N", 'Ò': "O", 'Ó': "O", 'Ô': "O", 'Õ': "O", 'Ö': "O", 'Ø': "O",
-	'Ù': "U", 'Ú': "U", 'Û': "U", 'Ü': "U", 'Ý': "Y", 'Þ': "Th", 'ß': "ss", 'Œ': "OE",
-	'à': "a", 'á': "a", 'â': "a", 'ã': "a", 'ä': "a", 'å': "a", 'æ': "ae", 'ç': "c",
-	'è': "e", 'é': "e", 'ê': "e", 'ë': "e", 'ì': "i", 'í': "i", 'î': "i", 'ï': "i",
-	'ð': "d", 'ñ': "n", 'ò': "o", 'ó': "o", 'ô': "o", 'õ': "o", 'ö': "o", 'ø': "o",
-	'ù': "u", 'ú': "u", 'û': "u", 'ü': "u", 'ý': "y", 'þ': "th", 'ÿ': "y", 'œ': "oe",
-}
-
-// asciiFold rewrites s to ASCII: folded Latin letters stay, any other non-ASCII
-// rune is dropped.
-func asciiFold(s string) string {
-	var b strings.Builder
-	for _, r := range s {
-		if r <= unicode.MaxASCII {
-			b.WriteRune(r)
-		} else {
-			b.WriteString(asciiFolds[r])
-		}
-	}
-	return b.String()
-}
-
 // atoi parses an arg a builtin's check already validated. It panics rather than
 // returning zero, so a check that stops covering its own args is a stack trace and
 // not a silently wrong length, range or decimal count.
@@ -225,7 +131,6 @@ func atof(s string) float64 {
 	}
 	return f
 }
-
 func randBytes(r rng, n int) []byte {
 	b := make([]byte, n)
 	for i := range b {
@@ -233,7 +138,6 @@ func randBytes(r rng, n int) []byte {
 	}
 	return b
 }
-
 func randChars(r rng, n int, alphabet string) string {
 	b := make([]byte, n)
 	for i := range b {
@@ -256,7 +160,6 @@ func plainInt(s string) (int, error) {
 	}
 	return n, nil
 }
-
 func posIntArg(_ map[string]node, a []string) error {
 	n, err := plainInt(a[0])
 	if errors.Is(err, strconv.ErrRange) {
@@ -273,7 +176,6 @@ func posIntArg(_ map[string]node, a []string) error {
 	}
 	return nil
 }
-
 func intRangeArgs(_ map[string]node, a []string) error {
 	lo, err := plainInt(a[0])
 	if err != nil {
@@ -294,7 +196,6 @@ func intRangeArgs(_ map[string]node, a []string) error {
 	}
 	return nil
 }
-
 func floatArgs(_ map[string]node, a []string) error {
 	lo, e1 := strconv.ParseFloat(a[0], 64)
 	hi, e2 := strconv.ParseFloat(a[1], 64)
@@ -322,7 +223,6 @@ func floatArgs(_ map[string]node, a []string) error {
 	}
 	return nil
 }
-
 func seqArg(_ map[string]node, a []string) error {
 	if len(a) > 1 {
 		return fmt.Errorf("seq takes at most one name, got %d args", len(a))
@@ -376,229 +276,3 @@ func ulid(r rng) string {
 	}
 	return string(out)
 }
-
-// luhnCheck returns the Luhn check digit (0-9) over the digits of s; non-digit
-// runes are skipped. Doubling runs from the rightmost digit, so the result is
-// correct whatever the payload length.
-func luhnCheck(s string) int {
-	sum, double := 0, true
-	for i := len(s) - 1; i >= 0; i-- {
-		c := s[i]
-		if c < '0' || c > '9' {
-			continue
-		}
-		d := int(c - '0')
-		if double {
-			if d *= 2; d > 9 {
-				d -= 9
-			}
-		}
-		double = !double
-		sum += d
-	}
-	return (10 - sum%10) % 10
-}
-
-// mod11Check returns the weighted mod-11 check character over the digits of s
-// (weights 2..7 cycling from the right). A would-be value of 10 emits 'X', as in
-// ISBN-10 / ISO 7064; non-digits are skipped.
-func mod11Check(s string) string {
-	sum, w := 0, 2
-	for i := len(s) - 1; i >= 0; i-- {
-		c := s[i]
-		if c < '0' || c > '9' {
-			continue
-		}
-		sum += int(c-'0') * w
-		if w++; w > 7 {
-			w = 2
-		}
-	}
-	if chk := (11 - sum%11) % 11; chk != 10 {
-		return string(rune('0' + chk))
-	}
-	return "X"
-}
-
-// eanCheck returns the EAN-13 / UPC-A / ISBN-13 / GTIN check digit over the
-// digits of s: weights 3 and 1 alternating from the rightmost digit, mod 10.
-func eanCheck(s string) string {
-	sum, w := 0, 3
-	for i := len(s) - 1; i >= 0; i-- {
-		c := s[i]
-		if c < '0' || c > '9' {
-			continue
-		}
-		sum += int(c-'0') * w
-		w = 4 - w // 3 <-> 1
-	}
-	return string(rune('0' + (10-sum%10)%10))
-}
-
-// ibanLen maps a supported country code to the full IBAN length. The check digits
-// sit between the country code and the BBAN, so — unlike luhn/ean — iban can't be
-// a left-to-right derivation; it generates the whole value instead.
-var ibanLen = map[string]int{"BE": 16, "DE": 22, "DK": 18, "ES": 24, "FI": 18, "NO": 15, "SE": 24}
-
-func ibanArg(_ map[string]node, a []string) error {
-	if _, ok := ibanLen[a[0]]; !ok {
-		return fmt.Errorf("iban(%q): unsupported country code", a[0])
-	}
-	return nil
-}
-
-// iban generates a structurally valid IBAN for cc: a numeric BBAN of the right
-// length, then mod-97 check digits. Real bank/branch structure isn't modelled —
-// the result passes length and checksum validation, which is what fake data needs.
-func iban(r rng, cc string) string {
-	bban := make([]byte, ibanLen[cc]-4)
-	for i := range bban {
-		bban[i] = byte('0' + r.IntN(10))
-	}
-	rem := 0
-	feed := func(d int) { rem = (rem*10 + d) % 97 }
-	for _, c := range bban {
-		feed(int(c - '0'))
-	}
-	for i := 0; i < len(cc); i++ { // letters A-Z -> 10..35, fed as two digits
-		v := int(cc[i]-'A') + 10
-		feed(v / 10)
-		feed(v % 10)
-	}
-	feed(0)
-	feed(0)
-	return fmt.Sprintf("%s%02d%s", cc, 98-rem, bban)
-}
-
-const dayLayout = "2006-01-02"
-
-// Alike in no field; layoutDay differs from layoutProbe in its date fields only,
-// layoutClock in its clock fields only.
-var (
-	layoutProbe  = time.Date(2001, 2, 3, 4, 5, 6, 0, time.UTC)
-	layoutProbe2 = time.Date(2010, 11, 12, 13, 14, 15, 0, time.UTC)
-	layoutDay    = time.Date(2010, 11, 12, 4, 5, 6, 0, time.UTC)
-	layoutClock  = time.Date(2001, 2, 3, 13, 14, 15, 0, time.UTC)
-)
-
-// quotedLayout reports whether an arg carries the single quotes a layout is written in.
-func quotedLayout(a string) bool {
-	return len(a) >= 2 && a[0] == '\'' && a[len(a)-1] == '\''
-}
-
-// layoutArg is the Go layout a quoted arg holds, refused when unquoted or constant.
-func layoutArg(a string) (string, error) {
-	if !quotedLayout(a) {
-		bare := strings.Trim(a, `'"`)
-		if strings.HasPrefix(a, `"`) || strings.HasSuffix(a, `"`) {
-			return "", fmt.Errorf("layout %s is double-quoted; write '%s'", a, bare)
-		}
-		return "", fmt.Errorf("layout %s is not quoted; write '%s', which a shell keeps only inside a double-quoted argument", a, bare)
-	}
-	layout := a[1 : len(a)-1]
-	if layoutProbe.Format(layout) == layoutProbe2.Format(layout) {
-		return "", fmt.Errorf("layout '%s' names no field, so it is the constant %q; write it as text", layout, layout)
-	}
-	return layout, nil
-}
-
-// layoutOf is layoutArg for an arg a check already validated.
-func layoutOf(a string) string {
-	layout, err := layoutArg(a)
-	if err != nil {
-		panic(fmt.Sprintf("fejkdata: builtin arg %q reached prep unvalidated: %v", a, err))
-	}
-	return layout
-}
-
-// layoutArity checks a call ending in a layout takes n args, naming the quoted
-// layout where an unquoted one split into more.
-func layoutArity(name string, n int, a []string) error {
-	if len(a) == n {
-		return nil
-	}
-	hint := ""
-	if len(a) > n && !split(a[n-1:]) {
-		hint = fmt.Sprintf("; a layout holding a comma is quoted: '%s'", strings.Join(a[n-1:], ", "))
-	}
-	return fmt.Errorf("%s takes %d argument%s, got %d%s", name, n, plural(n), len(a), hint)
-}
-
-// split reports whether the surplus args already hold a quoted layout, which no
-// comma split apart.
-func split(a []string) bool {
-	for _, arg := range a {
-		if quotedLayout(arg) {
-			return true
-		}
-	}
-	return false
-}
-
-func plural(n int) string { return map[bool]string{true: "s"}[n != 1] }
-
-func dateArgs(_ map[string]node, a []string) error {
-	if err := layoutArity("date", 3, a); err != nil {
-		return err
-	}
-	from, err := time.Parse(dayLayout, a[0])
-	if err != nil {
-		return fmt.Errorf("date(from,to,layout): from %q is not a YYYY-MM-DD date", a[0])
-	}
-	to, err := time.Parse(dayLayout, a[1])
-	if err != nil {
-		return fmt.Errorf("date(from,to,layout): to %q is not a YYYY-MM-DD date", a[1])
-	}
-	if to.Before(from) {
-		return fmt.Errorf("date(from,to,layout): from %s is after to %s", a[0], a[1])
-	}
-	layout, err := layoutArg(a[2])
-	if err != nil {
-		return err
-	}
-	if layoutProbe.Format(layout) == layoutDay.Format(layout) {
-		return fmt.Errorf("date(from,to,layout): '%s' names no date field; write time('%s')", layout, layout)
-	}
-	if from.Equal(to) && layoutProbe.Format(layout) == layoutClock.Format(layout) {
-		return fmt.Errorf("date(%s,%s,'%s') is the constant %q; write it as text", a[0], a[1], layout, from.Format(layout))
-	}
-	return nil
-}
-
-func timeArg(_ map[string]node, a []string) error {
-	if err := layoutArity("time", 1, a); err != nil {
-		return err
-	}
-	layout, err := layoutArg(a[0])
-	if err != nil {
-		return err
-	}
-	if layoutProbe.Format(layout) != layoutDay.Format(layout) {
-		return fmt.Errorf("time(layout): '%s' names a date field; write date(from,to,layout)", layout)
-	}
-	return nil
-}
-
-// datePrep draws a second in [from 00:00:00, to 23:59:59] UTC; the span is counted
-// in seconds, since a Duration overflows past 292 years.
-func datePrep(a []string) callFn {
-	from, err := time.Parse(dayLayout, a[0])
-	if err != nil {
-		panic(fmt.Sprintf("fejkdata: builtin arg %q reached prep unvalidated: %v", a[0], err))
-	}
-	to, err := time.Parse(dayLayout, a[1])
-	if err != nil {
-		panic(fmt.Sprintf("fejkdata: builtin arg %q reached prep unvalidated: %v", a[1], err))
-	}
-	layout, start, span := layoutOf(a[2]), from.Unix(), int(to.Unix()-from.Unix())+86400
-	return func(s *session, _ string, _ []string) string {
-		return time.Unix(start+int64(s.IntN(span)), 0).UTC().Format(layout)
-	}
-}
-
-func timePrep(a []string) callFn {
-	layout := layoutOf(a[0])
-	return func(s *session, _ string, _ []string) string {
-		return time.Unix(int64(s.IntN(86400)), 0).UTC().Format(layout)
-	}
-}

builtins_test.go

@@ -331,8 +331,8 @@ func TestBuiltinLayoutErrorsNameARunnableSpelling(t *testing.T) {
 		t.Errorf("%v names a layout that renders its own quotes", err)
 	}
 	_, err = compile(parse(t, `"{time(15:04)}"`))
-	if err == nil || !strings.Contains(err.Error(), "write '15:04'") || !strings.Contains(err.Error(), "shell") {
-		t.Fatalf("a bare layout = %v, want it named quoted and the shell explained", err)
+	if err == nil || !strings.Contains(err.Error(), "write '15:04'") {
+		t.Fatalf("a bare layout = %v, want it named quoted", err)
 	}
 	// The comma hint belongs to a layout that split, not to a call given extra args.
 	_, err = compile(parse(t, `"{time(0,12,'15:04')}"`))

checksum.go

@@ -0,0 +1,96 @@
+package fejkdata
+
+import "fmt"
+
+// luhnCheck returns the Luhn check digit (0-9) over the digits of s; non-digit
+// runes are skipped. Doubling runs from the rightmost digit, so the result is
+// correct whatever the payload length.
+func luhnCheck(s string) int {
+	sum, double := 0, true
+	for i := len(s) - 1; i >= 0; i-- {
+		c := s[i]
+		if c < '0' || c > '9' {
+			continue
+		}
+		d := int(c - '0')
+		if double {
+			if d *= 2; d > 9 {
+				d -= 9
+			}
+		}
+		double = !double
+		sum += d
+	}
+	return (10 - sum%10) % 10
+}
+
+// mod11Check returns the weighted mod-11 check character over the digits of s
+// (weights 2..7 cycling from the right). A would-be value of 10 emits 'X', as in
+// ISBN-10 / ISO 7064; non-digits are skipped.
+func mod11Check(s string) string {
+	sum, w := 0, 2
+	for i := len(s) - 1; i >= 0; i-- {
+		c := s[i]
+		if c < '0' || c > '9' {
+			continue
+		}
+		sum += int(c-'0') * w
+		if w++; w > 7 {
+			w = 2
+		}
+	}
+	if chk := (11 - sum%11) % 11; chk != 10 {
+		return string(rune('0' + chk))
+	}
+	return "X"
+}
+
+// eanCheck returns the EAN-13 / UPC-A / ISBN-13 / GTIN check digit over the
+// digits of s: weights 3 and 1 alternating from the rightmost digit, mod 10.
+func eanCheck(s string) string {
+	sum, w := 0, 3
+	for i := len(s) - 1; i >= 0; i-- {
+		c := s[i]
+		if c < '0' || c > '9' {
+			continue
+		}
+		sum += int(c-'0') * w
+		w = 4 - w // 3 <-> 1
+	}
+	return string(rune('0' + (10-sum%10)%10))
+}
+
+// ibanLen maps a supported country code to the full IBAN length. The check digits
+// sit between the country code and the BBAN, so — unlike luhn/ean — iban can't be
+// a left-to-right derivation; it generates the whole value instead.
+var ibanLen = map[string]int{"BE": 16, "DE": 22, "DK": 18, "ES": 24, "FI": 18, "NO": 15, "SE": 24}
+
+func ibanArg(_ map[string]node, a []string) error {
+	if _, ok := ibanLen[a[0]]; !ok {
+		return fmt.Errorf("iban(%q): unsupported country code", a[0])
+	}
+	return nil
+}
+
+// iban generates a structurally valid IBAN for cc: a numeric BBAN of the right
+// length, then mod-97 check digits. Real bank/branch structure isn't modelled —
+// the result passes length and checksum validation, which is what fake data needs.
+func iban(r rng, cc string) string {
+	bban := make([]byte, ibanLen[cc]-4)
+	for i := range bban {
+		bban[i] = byte('0' + r.IntN(10))
+	}
+	rem := 0
+	feed := func(d int) { rem = (rem*10 + d) % 97 }
+	for _, c := range bban {
+		feed(int(c - '0'))
+	}
+	for i := 0; i < len(cc); i++ { // letters A-Z -> 10..35, fed as two digits
+		v := int(cc[i]-'A') + 10
+		feed(v / 10)
+		feed(v % 10)
+	}
+	feed(0)
+	feed(0)
+	return fmt.Sprintf("%s%02d%s", cc, 98-rem, bban)
+}

cmd/fejkdata/main.go

@@ -28,6 +28,9 @@ const usage = `Usage: fejkdata [flags] <path|template>
   <template>             a format string or JSON value to render inline, e.g.
                          'name: {/sv_SE.person.last}' or '{"format":"{x}","x":["bosse","lina"]}'
 
+A layout inside a template is single-quoted, so quote the whole argument with " to
+keep it: "{date(1990-01-01,2010-12-31,'2006-01-02')}".
+
 An argument containing a { token, or a JSON object, array or string, is a
 template; any other argument is a path (a path never contains a brace or a quote,
 and a bracket only as a [selector] after a table's name). Templates reach the

data.go

@@ -62,6 +62,7 @@ func loadData(sources []dataSource) (map[string]node, error) {
 	if len(root) == 0 {
 		return nil, fmt.Errorf("no .json data found")
 	}
+	setTablePaths(root)
 	if err := linkTables(root); err != nil {
 		return nil, err
 	}

data/sv_SE/person.json

@@ -2,6 +2,6 @@
   "format": "{prefix}{first} {last}",
   "first": "{.first-name.name}",
   "last": "{.last-name.name}",
-  "prefix": ["", { "format": "{title} ", "title": ["dr", "prof"], "weight": 0.05 }],
+  "prefix": ["", { "format": "{.title.name} ", "weight": 0.05 }],
   "sex": "{.sex.name}"
 }

data/sv_SE/title.json

@@ -0,0 +1 @@
+{ "format": "{name}", "rows": "title.tsv", "key": "name", "weight": "share" }

data/sv_SE/title.tsv

@@ -0,0 +1,3 @@
+name	share
+dr	3
+prof	1

data_test.go

@@ -413,4 +413,10 @@ func TestShippedUSTitleAgreesWithSex(t *testing.T) {
 			t.Errorf("en_US.person.prefix never drew %q in 3000 draws", want)
 		}
 	}
+	swedish := map[string]bool{"dr": true, "prof": true}
+	for i := 0; i < 50; i++ {
+		if got := fake(t, f, "sv_SE.title"); !swedish[got] {
+			t.Fatalf("sv_SE.title = %q, want an unsexed Swedish honorific", got)
+		}
+	}
 }

family.go

@@ -97,7 +97,7 @@ func (d *draws) rowOf(t *table) int {
 // pinRow pins row r of t where it agrees with the rows pinned before it.
 func (d *draws) pinRow(t *table, r int) error {
 	if pr, ok := d.pinned(t); ok && pr != r {
-		return fmt.Errorf("%s and %s are two rows of %s", t.selectorSpelling(pr), t.selectorSpelling(r), t.category)
+		return fmt.Errorf("%s and %s are two rows of %s", t.selectorSpelling(pr), t.selectorSpelling(r), t.path)
 	}
 	for a := t.parentT; a != nil; a = a.parentT {
 		if pa, ok := d.pinned(a); ok && !t.under(r, a, pa) {

layout.go

@@ -0,0 +1,146 @@
+package fejkdata
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+const dayLayout = "2006-01-02"
+
+// The instants a layout is proved against: layoutProbe2 is alike in no field, while
+// layoutDay differs from layoutProbe in its date fields alone and layoutClock in its
+// clock fields alone, so formatting two of them tells which kind a layout names.
+var (
+	layoutProbe  = time.Date(2001, 2, 3, 4, 5, 6, 0, time.UTC)
+	layoutProbe2 = time.Date(2010, 11, 12, 13, 14, 15, 0, time.UTC)
+	layoutDay    = time.Date(2010, 11, 12, 4, 5, 6, 0, time.UTC)
+	layoutClock  = time.Date(2001, 2, 3, 13, 14, 15, 0, time.UTC)
+)
+
+func namesAField(layout string) bool {
+	return layoutProbe.Format(layout) != layoutProbe2.Format(layout)
+}
+func namesADateField(layout string) bool {
+	return layoutProbe.Format(layout) != layoutDay.Format(layout)
+}
+func namesAClockField(layout string) bool {
+	return layoutProbe.Format(layout) != layoutClock.Format(layout)
+}
+
+// quotedLayout reports whether an arg carries the single quotes a layout is written in.
+func quotedLayout(a string) bool {
+	return len(a) >= 2 && a[0] == '\'' && a[len(a)-1] == '\''
+}
+
+// layoutArg is the Go layout a quoted arg holds, refused when unquoted or constant.
+func layoutArg(a string) (string, error) {
+	if !quotedLayout(a) {
+		bare := strings.Trim(a, `'"`)
+		if strings.HasPrefix(a, `"`) || strings.HasSuffix(a, `"`) {
+			return "", fmt.Errorf("layout %s is double-quoted; write '%s'", a, bare)
+		}
+		return "", fmt.Errorf("layout %s is not quoted; write '%s'", a, bare)
+	}
+	layout := a[1 : len(a)-1]
+	if !namesAField(layout) {
+		return "", fmt.Errorf("layout '%s' names no field, so it is the constant %q; write it as text", layout, layout)
+	}
+	return layout, nil
+}
+
+// layoutOf is layoutArg for an arg a check already validated.
+func layoutOf(a string) string {
+	layout, err := layoutArg(a)
+	if err != nil {
+		panic(fmt.Sprintf("fejkdata: builtin arg %q reached prep unvalidated: %v", a, err))
+	}
+	return layout
+}
+
+// layoutArity checks a call ending in a layout takes n args, naming the quoted
+// layout where an unquoted one split into more.
+func layoutArity(name string, n int, a []string) error {
+	if len(a) == n {
+		return nil
+	}
+	hint := ""
+	if len(a) > n && !holdsQuotedLayout(a[n-1:]) {
+		hint = fmt.Sprintf("; a layout holding a comma is quoted: '%s'", strings.Join(a[n-1:], ", "))
+	}
+	return fmt.Errorf("%s takes %d argument%s, got %d%s", name, n, plural(n), len(a), hint)
+}
+
+// holdsQuotedLayout reports whether the surplus args already carry a quoted layout,
+// which no comma split apart.
+func holdsQuotedLayout(a []string) bool {
+	for _, arg := range a {
+		if quotedLayout(arg) {
+			return true
+		}
+	}
+	return false
+}
+func dateArgs(_ map[string]node, a []string) error {
+	if err := layoutArity("date", 3, a); err != nil {
+		return err
+	}
+	from, err := time.Parse(dayLayout, a[0])
+	if err != nil {
+		return fmt.Errorf("date(from,to,layout): from %q is not a YYYY-MM-DD date", a[0])
+	}
+	to, err := time.Parse(dayLayout, a[1])
+	if err != nil {
+		return fmt.Errorf("date(from,to,layout): to %q is not a YYYY-MM-DD date", a[1])
+	}
+	if to.Before(from) {
+		return fmt.Errorf("date(from,to,layout): from %s is after to %s", a[0], a[1])
+	}
+	layout, err := layoutArg(a[2])
+	if err != nil {
+		return err
+	}
+	if !namesADateField(layout) {
+		return fmt.Errorf("date(from,to,layout): '%s' names no date field; write time('%s')", layout, layout)
+	}
+	if from.Equal(to) && !namesAClockField(layout) {
+		return fmt.Errorf("date(%s,%s,'%s') is the constant %q; write it as text", a[0], a[1], layout, from.Format(layout))
+	}
+	return nil
+}
+func timeArg(_ map[string]node, a []string) error {
+	if err := layoutArity("time", 1, a); err != nil {
+		return err
+	}
+	layout, err := layoutArg(a[0])
+	if err != nil {
+		return err
+	}
+	if namesADateField(layout) {
+		return fmt.Errorf("time(layout): '%s' names a date field; write date(from,to,layout)", layout)
+	}
+	return nil
+}
+
+// datePrep draws a second in [from 00:00:00, to 23:59:59] UTC; the span is counted
+// in seconds, since a Duration overflows past 292 years.
+func datePrep(a []string) callFn {
+	from, err := time.Parse(dayLayout, a[0])
+	if err != nil {
+		panic(fmt.Sprintf("fejkdata: builtin arg %q reached prep unvalidated: %v", a[0], err))
+	}
+	to, err := time.Parse(dayLayout, a[1])
+	if err != nil {
+		panic(fmt.Sprintf("fejkdata: builtin arg %q reached prep unvalidated: %v", a[1], err))
+	}
+	layout, start, span := layoutOf(a[2]), from.Unix(), int(to.Unix()-from.Unix())+86400
+	return func(s *session, _ string, _ []string) string {
+		return time.Unix(start+int64(s.IntN(span)), 0).UTC().Format(layout)
+	}
+}
+func timePrep(a []string) callFn {
+	layout := layoutOf(a[0])
+	return func(s *session, _ string, _ []string) string {
+		return time.Unix(int64(s.IntN(86400)), 0).UTC().Format(layout)
+	}
+}

record.go

@@ -141,8 +141,8 @@ func (f *Generator) FakeRecord(path string) (*Record, error) {
 	}
 	shape := f.recordShapeOf(n)
 	if errors.Is(shape.err, errNoColumns) {
-		column := path[strings.LastIndex(path, ".")+1:]
-		return nil, fmt.Errorf("fejkdata: %s %w; render it as a column of one: '{\"format\":\"\",\"%s\":\"{/%s}\"}'", path, shape.err, column, path)
+		ns := names(segments)
+		return nil, fmt.Errorf(`fejkdata: %s %w; render it as a column of one: {"format":"","%s":"{/%s}"}`, path, shape.err, ns[len(ns)-1], path)
 	}
 	if shape.err != nil {
 		return nil, fmt.Errorf("fejkdata: %s %w", path, shape.err)

record_test.go

@@ -553,7 +553,7 @@ func TestRecordTemplateRejectsATopLevelRepeat(t *testing.T) {
 // error names the record that gives it one.
 func TestRecordOfAFieldlessCategoryNamesTheWrapper(t *testing.T) {
 	f := newGenerator(t, "data", WithSeed(1))
-	want := `'{"format":"","personnummer":"{/sv_SE.personnummer}"}'`
+	want := `{"format":"","personnummer":"{/sv_SE.personnummer}"}`
 	_, err := f.FakeRecord("sv_SE.personnummer")
 	if err == nil || !strings.Contains(err.Error(), want) {
 		t.Fatalf("FakeRecord(sv_SE.personnummer) = %v, want it to name %s", err, want)

table.go

@@ -14,7 +14,7 @@ import (
 // cell of the row a render pinned; a cell carrying tokens compiles to a string node.
 type table struct {
 	category string
-	path     string // the category's path from the data root, set when the tables are linked
+	path     string // the category's path from the data root, which a selector is written at
 	file     string
 	format   *template // fields are the column nodes
 	columns  []string
@@ -340,6 +340,23 @@ func (t *table) compileFormat(format string) error {
 // linkTables binds every table's parent to the table beside it, and proves the
 // links: a parent has a key, every link cell is one, every parent row is linked
 // to, no chain of parents closes, and no child is named like a parent's column.
+// setTablePaths gives every table the path a selector on it is written at, before a
+// link or a draw can name one.
+func setTablePaths(root map[string]node) {
+	var walk func(dir string, children map[string]node)
+	walk = func(dir string, children map[string]node) {
+		for name, child := range children {
+			switch n := child.(type) {
+			case *folder:
+				walk(join(dir, name), n.children)
+			case *table:
+				n.path = join(dir, name)
+			}
+		}
+	}
+	walk("", root)
+}
+
 func linkTables(root map[string]node) error {
 	var walk func(dir string, children map[string]node) error
 	walk = func(dir string, children map[string]node) error {
@@ -351,7 +368,6 @@ func linkTables(root map[string]node) error {
 					return err
 				}
 			case *table:
-				n.path = path
 				if n.parent < 0 {
 					continue
 				}
@@ -510,7 +526,7 @@ func (t *table) under(r int, a *table, pr int) bool {
 // naming several rows resolves inside the ancestors pinned in d.
 func (t *table) find(sel string, d *draws) (int, error) {
 	if t.key < 0 && t.name < 0 {
-		return 0, fmt.Errorf("%s has no key or name column to select a row by", t.spelledPath())
+		return 0, fmt.Errorf("%s has no key or name column to select a row by", t.path)
 	}
 	if r, ok := t.byKey[sel]; ok {
 		return r, nil
@@ -523,34 +539,31 @@ func (t *table) find(sel string, d *draws) (int, error) {
 	case 1:
 		return rows[0], nil
 	case 0:
-		return 0, fmt.Errorf("no row of %s has key or name %q", t.spelledPath(), sel)
+		return 0, fmt.Errorf("no row of %s has key or name %q", t.path, sel)
 	}
-	keys := make([]string, len(rows))
+	return 0, t.ambiguous(sel, rows)
+}
+
+// ambiguous names each row a selector could have meant: a keyed table by its keys,
+// and one told apart only by its parent by the path that selects it.
+func (t *table) ambiguous(sel string, rows []int) error {
+	spellings := make([]string, len(rows))
 	for i, r := range rows {
 		if t.key < 0 {
-			keys[i] = t.selectorSpelling(r)
+			spellings[i] = t.selectorSpelling(r)
 		} else {
-			keys[i] = t.cell(r, t.key)
+			spellings[i] = t.cell(r, t.key)
 		}
 	}
-	listed := strings.Join(keys, ", ")
+	listed := strings.Join(spellings, ", ")
 	if t.key < 0 {
-		return 0, fmt.Errorf("%q names %d rows of %s; select it inside its %s, one of %s", sel, len(rows), t.spelledPath(), t.parentT.spelledPath(), listed)
+		return fmt.Errorf("%q names %d rows of %s; select it inside its %s, one of %s", sel, len(rows), t.path, t.parentT.path, listed)
 	}
 	inside := ""
 	if t.parentT != nil {
-		inside = fmt.Sprintf(", or select it inside its %s", t.parentT.category)
+		inside = fmt.Sprintf(", or select it inside its %s", t.parentT.path)
 	}
-	return 0, fmt.Errorf("%q names %d rows of %s; select one by key, one of %s%s", sel, len(rows), t.spelledPath(), listed, inside)
-}
-
-// spelledPath is the path a selector on t is written at, the category's own name
-// until the tables are linked.
-func (t *table) spelledPath() string {
-	if t.path == "" {
-		return t.category
-	}
-	return t.path
+	return fmt.Errorf("%q names %d rows of %s; select one by key, one of %s%s", sel, len(rows), t.path, listed, inside)
 }
 
 // selectorSpelling is how a path writes a selected row, for messages: by key, or
@@ -558,7 +571,7 @@ func (t *table) spelledPath() string {
 func (t *table) selectorSpelling(r int) string {
 	switch {
 	case t.key >= 0:
-		return t.spelledPath() + "[" + t.cell(r, t.key) + "]"
+		return t.path + "[" + t.cell(r, t.key) + "]"
 	case t.name >= 0:
 		return t.parentT.selectorSpelling(t.parentRow(r)) + "." + t.category + "[" + t.cell(r, t.name) + "]"
 	}

template.go

@@ -112,6 +112,13 @@ func splitArgs(s string) []string {
 	return append(args, strings.TrimSpace(s[start:]))
 }
 
+func plural(n int) string {
+	if n == 1 {
+		return ""
+	}
+	return "s"
+}
+
 // checkFunc validates a function token at compile time: well-formed, naming a
 // known builtin, with the arg count that builtin takes and args its check accepts.
 // fields is passed through for the one builtin (calc) that validates against them.

testdata/shipped_shape.txt

@@ -279,7 +279,7 @@ sv_SE.ip
 sv_SE.last-name	format "{name}"	key name	weight count
 sv_SE.last-name.count	string
 sv_SE.last-name.name	string
-sv_SE.person	format "{prefix}{first} {last}"	reads sv_SE.first-name sv_SE.last-name sv_SE.sex
+sv_SE.person	format "{prefix}{first} {last}"	reads sv_SE.first-name sv_SE.last-name sv_SE.sex sv_SE.title
 sv_SE.person.first	string
 sv_SE.person.last	string
 sv_SE.person.prefix	string
@@ -310,6 +310,9 @@ sv_SE.sex.first-name.name
 sv_SE.sex.first-name.sex
 sv_SE.sex.name	string
 sv_SE.time	format "{time('15:04')}"
+sv_SE.title	format "{name}"	key name	weight share
+sv_SE.title.name	string
+sv_SE.title.share	string
 sv_SE.url	format "https://{host}{path}"
 sv_SE.url.host	string
 sv_SE.url.path	string

transform.go

@@ -0,0 +1,94 @@
+package fejkdata
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+)
+
+// transforms are the builtins that rewrite one operand's value; they nest, so
+// {lowercase(ascii(x))} folds then lowers.
+var transforms = map[string]func(string) string{
+	"ascii":     asciiFold,
+	"lowercase": strings.ToLower,
+	"uppercase": strings.ToUpper,
+}
+
+// unwrapTransform peels nested transform calls off an operand arg, returning the
+// field it finally names and the transforms to apply, innermost last.
+func unwrapTransform(arg string) (leaf string, chain []func(string) string, err error) {
+	for {
+		name, args, isCall := funcCall(arg)
+		if !isCall {
+			return arg, chain, nil
+		}
+		fn, isTransform := transforms[name]
+		if !isTransform {
+			return "", nil, fmt.Errorf("%s(%s) is not a transform, so it cannot be an operand", name, strings.Join(args, ","))
+		}
+		if len(args) != 1 {
+			return "", nil, fmt.Errorf("%s takes 1 arg, got %d", name, len(args))
+		}
+		chain = append(chain, fn)
+		arg = args[0]
+	}
+}
+func transformArg(fields map[string]node, a []string) error {
+	leaf, _, err := unwrapTransform(a[0])
+	if err != nil {
+		return err
+	}
+	if isRef(leaf) {
+		_, _, err := refShape(leaf)
+		return err
+	}
+	return checkArm(leaf, fields, false)
+}
+func transformOperand(a []string) []string {
+	leaf, _, err := unwrapTransform(a[0])
+	if err != nil {
+		return nil
+	}
+	return []string{leaf}
+}
+func transformPrep(outer func(string) string) func([]string) callFn {
+	return func(a []string) callFn {
+		_, chain, err := unwrapTransform(a[0])
+		if err != nil {
+			panic(fmt.Sprintf("fejkdata: transform arg %q reached prep unvalidated: %v", a[0], err))
+		}
+		return func(_ *session, _ string, operands []string) string {
+			v := operands[0]
+			for i := len(chain) - 1; i >= 0; i-- {
+				v = chain[i](v)
+			}
+			return outer(v)
+		}
+	}
+}
+
+// asciiFolds maps the Latin letters with diacritics or ligatures to ASCII.
+var asciiFolds = map[rune]string{
+	'À': "A", 'Á': "A", 'Â': "A", 'Ã': "A", 'Ä': "A", 'Å': "A", 'Æ': "AE", 'Ç': "C",
+	'È': "E", 'É': "E", 'Ê': "E", 'Ë': "E", 'Ì': "I", 'Í': "I", 'Î': "I", 'Ï': "I",
+	'Ð': "D", 'Ñ': "N", 'Ò': "O", 'Ó': "O", 'Ô': "O", 'Õ': "O", 'Ö': "O", 'Ø': "O",
+	'Ù': "U", 'Ú': "U", 'Û': "U", 'Ü': "U", 'Ý': "Y", 'Þ': "Th", 'ß': "ss", 'Œ': "OE",
+	'à': "a", 'á': "a", 'â': "a", 'ã': "a", 'ä': "a", 'å': "a", 'æ': "ae", 'ç': "c",
+	'è': "e", 'é': "e", 'ê': "e", 'ë': "e", 'ì': "i", 'í': "i", 'î': "i", 'ï': "i",
+	'ð': "d", 'ñ': "n", 'ò': "o", 'ó': "o", 'ô': "o", 'õ': "o", 'ö': "o", 'ø': "o",
+	'ù': "u", 'ú': "u", 'û': "u", 'ü': "u", 'ý': "y", 'þ': "th", 'ÿ': "y", 'œ': "oe",
+}
+
+// asciiFold rewrites s to ASCII: folded Latin letters stay, any other non-ASCII
+// rune is dropped.
+func asciiFold(s string) string {
+	var b strings.Builder
+	for _, r := range s {
+		if r <= unicode.MaxASCII {
+			b.WriteRune(r)
+		} else {
+			b.WriteString(asciiFolds[r])
+		}
+	}
+	return b.String()
+}