@sdboyer/thema-ui 0.0.0-bootstrap.0 → 0.1.0

package/errors/E0344.md

@@ -0,0 +1,58 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0344: a constant in a lens is not an instance of its target field
+
+A constant written in a lens is an instance of the target field it fills. Here
+a string is written where the target declares an int; CUE's account of the
+conflict is in the detail.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	a: string
+	b: int
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		b: "one"
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	a: string
+	b: int
+}
+```
+
+thema reports:
+
+```
+error[E0344]: "one" is not an instance of 1.0's b
+ --> history/1.0.thema:9:6
+  |
+3 |     b: int
+  |        --- here
+...
+9 |         b: "one"
+  |            ^^^^^
+  |            ----- also here
+  |
+  = detail: schema.b: conflicting values int and "one" (mismatched types int and string)
+```

package/errors/E0345.md

@@ -0,0 +1,51 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0345: a lens maps a target field twice
+
+Each target field is mapped once. Two mappings for one field would have to
+agree on every instance, and the lens language has no way to say which wins.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	b: string
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		b: v0_0.a
+		b: "x"
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	b: string
+}
+```
+
+thema reports:
+
+```
+error[E0345]: b is mapped twice
+ --> history/1.0.thema:9:3
+  |
+9 |         b: "x"
+  |         ^
+  |
+```

package/errors/E0346.md

@@ -0,0 +1,45 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0346: a lens produces nothing for a field its target version requires
+
+A lens produces every field its target requires. Here the new version adds a
+required field the source lacks, and no lens says where it comes from.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	a: string
+	b: int
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	a: string
+	b: int
+}
+```
+
+thema reports:
+
+```
+error[E0346]: history/1.0.thema has no ForwardLens, and 1.0 requires b: write ForwardLens: {v0_0: _, v1_0: {b: <mapping>}}
+ --> history/1.0.thema:1:1
+  |
+1 | Schema: {
+  | ^^^^^^
+  |
+```

package/errors/E0347.md

@@ -0,0 +1,53 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0347: a field the source version has and the target lacks is neither mapped nor dropped
+
+A field the source version has and the target lacks is either mapped somewhere
+or dropped, explicitly. A forgotten rename would otherwise be silent data loss.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	before:    string
+	unchanged: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	after:     string
+	unchanged: string
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		after: "x"
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	after:     string
+	unchanged: string
+}
+```
+
+thema reports:
+
+```
+error[E0347]: 0.0 declares before and 1.0 does not, and nothing maps it: write <field>: v0_0.before to move it, or before: _drop
+ --> history/1.0.thema:6:1
+  |
+6 | ForwardLens: {
+  | ^^^^^^^^^^^
+  |
+```

package/errors/E0348.md

@@ -0,0 +1,50 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0348: a _coalesce reads a field the source version always has
+
+coalesce supplies a fallback for a field that may be absent. Over a field the
+source always has, the fallback could never apply; write the reference alone.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	b: string
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		b: _coalesce(v0_0.a, "x")
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	b: string
+}
+```
+
+thema reports:
+
+```
+error[E0348]: 0.0 always has a, so _coalesce's fallback could never apply: write b: v0_0.a
+ --> history/1.0.thema:8:6
+  |
+8 |         b: _coalesce(v0_0.a, "x")
+  |            ^^^^^^^^^
+  |
+```

package/errors/E0349.md

@@ -0,0 +1,52 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0349: a _coalesce's fallback may itself be absent
+
+coalesce's fallback is what the lens uses when the field is absent, so the
+fallback itself must always exist: a constant, or a field the source always
+has. An optional field may be absent too.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a?: string
+	b?: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	c: string
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		c: _coalesce(v0_0.a, v0_0.b)
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	c: string
+}
+```
+
+thema reports:
+
+```
+error[E0349]: b is optional in 0.0, so it cannot be _coalesce's fallback: the fallback must always exist
+ --> history/1.0.thema:8:24
+  |
+8 |         c: _coalesce(v0_0.a, v0_0.b)
+  |                              ^^^^
+  |
+```

package/errors/E0350.md

@@ -0,0 +1,54 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0350: a _match has two arms for one value
+
+Each arm of a match matches one source value; two arms for the same value
+would have to agree. Write each value once.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	kind: "a" | "b"
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	kind: 1 | 2
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		kind: _match(v0_0.kind, {
+			"a": 1
+			"a": 2
+			"b": 2
+		})
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	kind: 1 | 2
+}
+```
+
+thema reports:
+
+```
+error[E0350]: _match has two arms for "a"
+  --> history/1.0.thema:10:4
+   |
+10 |             "a": 2
+   |             ^^^
+   |
+```

package/errors/E0351.md

@@ -0,0 +1,54 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0351: a _match is not exhaustive
+
+A match is exhaustive: every value the source field can hold is matched by
+an arm, or accepted by the target as it is, or caught by a `[_]` arm. Here one
+value of an enum is none of these.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	kind: "a" | "b" | "c"
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	kind: "a" | "b"
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		kind: _match(v0_0.kind, {
+			"a": "b"
+		})
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	kind: "a" | "b"
+}
+```
+
+thema reports:
+
+```
+error[E0351]: _match on kind is not exhaustive: 0.0's kind may be "c", which no arm matches and 1.0's kind does not accept
+ --> history/1.0.thema:8:9
+  |
+8 |         kind: _match(v0_0.kind, {
+  |               ^^^^^^
+  |
+  = help: add an arm for "c", or a [_] arm
+```

package/errors/E0352.md

@@ -0,0 +1,60 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0352: a _match passes values through to a target the lens cannot test them against
+
+A value no arm of a match matches passes through where the target accepts it.
+To decide that, the compiler tests the source's values against the target
+field's type, which must be self-contained: a type that refers to other fields
+cannot be tested on its own. Match every value with an arm, or add a `[_]`
+arm.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	kind: "a" | "b" | "c"
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	allowed: [...string]
+	kind:    or(allowed)
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		allowed: ["a", "b"]
+		kind: _match(v0_0.kind, {
+			"c": "a"
+		})
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	allowed: [...string]
+	kind:    or(allowed)
+}
+```
+
+thema reports:
+
+```
+error[E0352]: _match on kind: 1.0's kind is not a self-contained type
+  --> history/1.0.thema:10:9
+   |
+10 |         kind: _match(v0_0.kind, {
+   |               ^^^^^^
+   |
+   = note: a value no arm matches passes through where the target accepts it, which cannot be tested against a type that refers to other fields
+   = help: match every value with an arm, or add a [_] arm
+```

package/errors/E0353.md

@@ -0,0 +1,53 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0353: an _each maps something other than an open list to an open list
+
+each maps the elements of an open list, `[...T]`, in the source to an open list
+in the target, element by element. A source field that is not a list has no
+elements to map.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	name: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	names: [...string]
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		names: _each(v0_0.name, {
+			item
+		})
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	names: [...string]
+}
+```
+
+thema reports:
+
+```
+error[E0353]: _each maps a list to a list; 0.0's name and 1.0's names must both be lists
+ --> history/1.0.thema:8:10
+  |
+8 |         names: _each(v0_0.name, {
+  |                ^^^^^
+  |
+```

package/errors/E0354.md

@@ -0,0 +1,43 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0354: the first version has a lens
+
+A lens maps between a version and its predecessor. The first version has no
+predecessor, so a lens in its file has nothing to map from.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+
+ForwardLens: {
+	v0_0: _
+	v0_0: {
+		a: "x"
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+```
+
+thema reports:
+
+```
+error[E0354]: history/0.0.thema is the first version, and has no previous version to map from
+ --> history/0.0.thema:5:1
+  |
+5 | ForwardLens: {
+  | ^^^^^^^^^^^
+  |
+  = help: remove the lens; a lens maps between a version and its predecessor
+```

package/errors/E0355.md

@@ -0,0 +1,55 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0355: a minor version has a ForwardLens
+
+A minor version is backward compatible with its predecessor, so an instance of
+the predecessor is already an instance of it: translating forward is implicit,
+and a minor version's file has no ForwardLens.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	a: string
+}
+```
+
+`ship/history/0.1.thema`:
+
+```cue
+Schema: {
+	a:  string
+	b?: int
+}
+
+ForwardLens: {
+	v0_0: _
+	v0_1: {
+		b: 1
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	a:  string
+	b?: int
+}
+```
+
+thema reports:
+
+```
+error[E0355]: history/0.1.thema is backward compatible with 0.0, so it has no ForwardLens
+ --> history/0.1.thema:6:1
+  |
+6 | ForwardLens: {
+  | ^^^^^^^^^^^
+  |
+  = note: an instance of a version is already an instance of its minor successor; translating forward is implicit
+  = help: remove the ForwardLens, or make a breaking change
+```

package/errors/E0356.md

@@ -0,0 +1,65 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0356: a normal-form lens is outside what the authoring form expresses
+
+Decompile turns a normal-form lineage back into version files. It expresses
+exactly the lenses the compiler produces. A lacuna in the authoring form
+describes one field, so a normal-form lacuna over several is outside that, and
+Decompile refuses it rather than approximate.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a: string
+				n: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			a: v0_0.a
+			n: 0
+		}
+		lacunas: [{
+			targetFields: [{path: "a", value: v1_0.a}, {path: "n", value: v1_0.n}]
+			message: "n is a placeholder"
+			type:    "Placeholder"
+		}]
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.a
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0356]: lens 0.0->1.0 is outside the authoring form: a lacuna over several fields
+ --> lineage.cue:1:1
+  |
+1 | name: "ship"
+  | ^^^^
+  |
+  = help: the authoring form expresses the lenses Compile produces: mappings that copy and compute, and _drop, _coalesce, _match and _each
+```