@sdboyer/thema-ui 0.0.0-stage → 0.1.0

package/errors/E0388.md

@@ -0,0 +1,60 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0388: a lens writes to a target constraint the checker cannot compare
+
+The target constrains a computed value in a way the checker does not compare:
+a regular expression, a validator, or alternatives with gaps. It does not
+reason about string contents. Make the target accept any string, or copy a
+field the target already constrains.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a!: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				id!: =~"^[a-z]+$"
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			id: "x\(v0_0.a)"
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.id
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0388]: id in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:8
+   |
+22 |             id: "x\(v0_0.a)"
+   |                 ^^^^^^^^^^^^
+   |
+   = note: id in the result of lens 0.0->1.0 is a string built by "x\(v0_0.a)", and the target schema accepts only some strings (=~"^[a-z]+$"); the checker does not reason about string contents: make the target accept any string, or copy a field the target already constrains
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-target-constraint)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0389.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0389: a lens indexes a table with a value that is not a finite set of constants
+
+A lens indexes a table by a value that is not one of a finite set of string
+constants. The checker needs every possible key to show each has an entry.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				t: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				u: 1 | 2
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		_T: {a: 1, b: 2}
+		v0_0: _
+		v1_0: {
+			u: _T[v0_0.t]
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			t: ""
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0389]: u in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:7
+   |
+23 |             u: _T[v0_0.t]
+   |                ^^
+   |
+   = note: u in the result of lens 0.0->1.0 indexes a table by v0_0.t, which may be string rather than one of a finite set of string constants; the checker needs every possible key
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-table-key)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0390.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0390: a lens takes the first element of a list that may be empty
+
+A lens takes the first element of a list built by a comprehension with no
+fallback element. When the condition is false the list is empty and the index
+fails. Add a fallback: `[if c {x}, y][0]`.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				n: "a" | "b"
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				s: string
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			s: [if v0_0.n == "a" {"x"}][0]
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			n: "a"
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0390]: s in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:7
+   |
+22 |             s: [if v0_0.n == "a" {"x"}][0]
+   |                ^
+   |
+   = note: s in the result of lens 0.0->1.0 takes the first element of a list built by if v0_0.n == "a" with no fallback, so when the conditions are false the list is empty and the index fails; add an unconditional fallback element: [if c {x}, y][0]
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-head)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0401.md

@@ -0,0 +1,56 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0401: a lens's lacunas are not listed unconditionally
+
+A lens lists every lacuna it can emit unconditionally; each lacuna's own
+condition field decides whether it applies to an instance. A list built with a
+comprehension has no known length until data arrives, so the lacunas cannot be
+checked.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			if v0_1.b != _|_ {
+				{type: "DroppedField", message: "b was dropped"}
+			},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0401]: the lacunas of lens 0.1->0.0 are not listed unconditionally
+  --> lineage.cue:23:3
+   |
+23 |         lacunas: [
+   |         ^^^^^^^
+   |
+   = help: list every lacuna the lens can emit; each lacuna's condition field decides whether it applies
+```

package/errors/E0402.md

@@ -0,0 +1,51 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0402: a lacuna has no message
+
+Every lacuna has a message: the human-readable account of the gap in the
+translation. This one has none.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			{type: "DroppedField", condition: v0_1.b != _|_},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0402]: lacuna 0 of lens 0.1->0.0 has no message
+  --> lineage.cue:24:4
+   |
+24 |             {type: "DroppedField", condition: v0_1.b != _|_},
+   |             ^
+   |
+```

package/errors/E0403.md

@@ -0,0 +1,51 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0403: a lacuna has no type
+
+Every lacuna has a type, one of the lacuna types, saying what kind of gap it
+describes. This one has none.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			{message: "b was dropped", condition: v0_1.b != _|_},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0403]: lacuna 0 of lens 0.1->0.0 has no type
+  --> lineage.cue:24:4
+   |
+24 |             {message: "b was dropped", condition: v0_1.b != _|_},
+   |             ^
+   |
+```

package/errors/E0404.md

@@ -0,0 +1,57 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0404: a lacuna names a field its schema does not declare
+
+A lacuna's source fields are fields of the lens's source schema, and its target
+fields are fields of its target schema. This lacuna names a field neither
+schema declares.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			{
+				type:         "DroppedField"
+				message:      "b was dropped"
+				condition:    v0_1.b != _|_
+				sourceFields: [{path: "nope", value: 1}]
+			},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0404]: lacuna 0 of lens 0.1->0.0 names nope in sourceFields[0], which schema 0.1 does not declare
+  --> lineage.cue:28:21
+   |
+28 |                 sourceFields: [{path: "nope", value: 1}]
+   |                                 ^^^^
+   |
+```

package/errors/E0405.md

@@ -0,0 +1,56 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0405: a lacuna's field path is not a path
+
+A lacuna names a field by its path in CUE path syntax, such as `a.b` or
+`list[0]`. This lacuna's path is not one.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			{
+				type:         "DroppedField"
+				message:      "b was dropped"
+				condition:    v0_1.b != _|_
+				targetFields: [{path: "a..b", value: 1}]
+			},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0405]: lacuna 0 of lens 0.1->0.0 names a field with targetFields[0].path, but "a..b" is not a path
+  --> lineage.cue:28:21
+   |
+28 |                 targetFields: [{path: "a..b", value: 1}]
+   |                                 ^^^^
+   |
+```

package/errors/E0406.md

@@ -0,0 +1,53 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0406: a lacuna's type is not a lacuna type
+
+A lacuna's type is one of the lacuna types thema defines; the help lists them.
+This one names a type that does not exist.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			{type: "Bogus", message: "b was dropped", condition: v0_1.b != _|_},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0406]: the lacuna's type is "Bogus", which is not a lacuna type
+  --> lineage.cue:24:11
+   |
+24 |             {type: "Bogus", message: "b was dropped", condition: v0_1.b != _|_},
+   |                    ^^^^^^^
+   |
+   = detail: lenses.0.1->0.0.lacunas.0.type: 7 errors in empty disjunction:
+   = help: the lacuna types are "AmbiguousMapping", "ChangedDefault", "Defaulted", "DroppedField", "LossyFieldMapping", "Placeholder", "PrecisionLoss"
+```

package/errors/E0407.md

@@ -0,0 +1,54 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0407: a field that is not part of a lacuna
+
+A lacuna has a fixed set of fields: condition, sourceFields, targetFields,
+message and type. A field outside that set is usually a typo; the help names
+the closest.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+		"1": {
+			schema: {
+				a:  string
+				b?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.1->0.0": {
+		v0_1: _
+		v0_0: {
+			a: v0_1.a
+		}
+		lacunas: [
+			{type: "DroppedField", message: "b was dropped", condition: v0_1.b != _|_, severity: 1},
+		]
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0407]: severity is not a field of a lacuna
+  --> lineage.cue:24:79
+   |
+24 |             {type: "DroppedField", message: "b was dropped", condition: v0_1.b != _|_, severity: 1},
+   |                                                                                        ^^^^^^^^
+   |
+   = detail: lenses.0.1->0.0.lacunas.0.severity: severity is not a field of a lacuna; a lacuna has only condition, sourceFields, targetFields, message and type
+   = help: a lacuna has only condition, sourceFields, targetFields, message, type
+```

package/errors/E0410.md

@@ -0,0 +1,56 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0410: a lacunas declaration is not shaped as lacunas
+
+The lacunas field is a struct keyed like the lens body: each key names a
+mapping, and holds a list of that mapping's lacunas, or a struct of keys
+beneath it. A value of any other shape is not a lacuna declaration.
+
+## 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: -1
+	}
+	lacunas: {
+		b: 5
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	a: string
+	b: int
+}
+```
+
+thema reports:
+
+```
+error[E0410]: lacunas.b is a list of the mapping's lacunas, or a struct of keys beneath it
+  --> history/1.0.thema:12:6
+   |
+12 |         b: 5
+   |            ^
+   |
+```

package/errors/E0411.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0411: a lacuna's type is not a lacuna type
+
+A lacuna's type is one of thema's lacuna types, written as a bare name. The
+message lists them.
+
+## 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: -1
+	}
+	lacunas: {
+		b: [{
+			type:    Guess
+			message: "-1 is a placeholder"
+		}]
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	a: string
+	b: int
+}
+```
+
+thema reports:
+
+```
+error[E0411]: the lacuna's type Guess is not a lacuna type
+  --> history/1.0.thema:13:13
+   |
+13 |             type:    Guess
+   |                      ^^^^^
+   |
+   = help: the lacuna types are Placeholder, DroppedField, LossyFieldMapping, ChangedDefault, PrecisionLoss, AmbiguousMapping, Defaulted
+```