@sdboyer/thema-ui 0.0.0-stage → 0.1.0

package/errors/E0128.md

@@ -0,0 +1,34 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0128: there is no value at the path given for the lineage
+
+The caller named a path for the lineage, and there is no value there. The CLI's
+`-p` flag and the Go API's cue.Value both lead here; check the path against the
+file.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+lineage: {
+	name: "ship"
+	schemas: {
+		"0": {
+			"0": {
+				schema: {
+					a: string
+				}
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0128]: there is no value at lineages.ship to bind as a lineage
+  |
+  = detail: field not found: lineages
+```

package/errors/E0129.md

@@ -0,0 +1,42 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0129: a schema is not a struct
+
+Every schema is a struct: an instance is an object with fields, never a bare
+scalar or list. Here both the joinSchema (E0130) and the schema are strings.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+joinSchema: string
+schemas: {
+	"0": {
+		"0": {
+			schema: string
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0130]: joinSchema is string, not a struct
+ --> lineage.cue:2:1
+  |
+2 | joinSchema: string
+  | ^^^^^^^^^^
+  |
+  = help: a joinSchema is a struct every schema in the lineage is an instance of, or _ to join nothing
+
+error[E0129]: schema 0.0 is string, not a struct
+ --> lineage.cue:6:4
+  |
+6 |             schema: string
+  |             ^^^^^^
+  |
+  = help: every schema is a struct
+```

package/errors/E0130.md

@@ -0,0 +1,43 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0130: the joinSchema is not a struct
+
+A lineage's joinSchema is a struct every schema in the lineage is an instance
+of, or `_` to join nothing. Here it is a string, so the schema that must be an
+instance of it cannot be a struct either (E0129).
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+joinSchema: string
+schemas: {
+	"0": {
+		"0": {
+			schema: string
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0130]: joinSchema is string, not a struct
+ --> lineage.cue:2:1
+  |
+2 | joinSchema: string
+  | ^^^^^^^^^^
+  |
+  = help: a joinSchema is a struct every schema in the lineage is an instance of, or _ to join nothing
+
+error[E0129]: schema 0.0 is string, not a struct
+ --> lineage.cue:6:4
+  |
+6 |             schema: string
+  |             ^^^^^^
+  |
+  = help: every schema is a struct
+```

package/errors/E0131.md

@@ -0,0 +1,42 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0131: an example is not an instance of its schema
+
+A schema's examples are instances of it, checked when the lineage binds. This
+example lacks the field the schema requires; CUE's reasons are in the detail
+and its positions are the notes.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				count: int
+			}
+			examples: {
+				empty: {}
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0131]: example empty of schema 0.0 is not an instance of it
+ --> lineage.cue:9:5
+  |
+6 |                 count: int
+  |                        --- here
+...
+9 |                 empty: {}
+  |                 ^^^^^
+  |
+  = detail: count: incomplete value int
+```

package/errors/E0132.md

@@ -0,0 +1,40 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0132: a schema uses a comprehension
+
+A schema's fields are known without evaluating any data. A comprehension makes
+them depend on evaluation, and then no check can describe the schema: not
+compatibility between versions, not whether a lens produces every field.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: int
+				if true {
+					b: int
+				}
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0132]: schema 0.0 uses a comprehension
+ --> lineage.cue:7:5
+  |
+7 |                 if true {
+  |                 ^^
+  |
+  = note: a schema's fields must be known without evaluating data: no check can describe a schema whose fields depend on evaluation
+  = help: write the fields the comprehension would produce
+```

package/errors/E0133.md

@@ -0,0 +1,46 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0133: a schema's references form a cycle
+
+References within a schema may not form a cycle: a cycle makes the schema's
+paths unbounded, and no check can describe it. Each cycle is reported once, at
+the reference that closes it.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				#A: {b?: #B}
+				#B: {a?: #A}
+				root: #A
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0133]: schema 0.0 has a reference cycle: #B -> #A -> #B
+ --> lineage.cue:6:10
+  |
+6 |                 #A: {b?: #B}
+  |                      ^
+  |
+  = note: a schema's references may not form a cycle: no check can describe a schema whose paths are unbounded
+
+error[E0133]: schema 0.0 has a reference cycle: #A -> #B -> #A
+ --> lineage.cue:7:10
+  |
+7 |                 #B: {a?: #A}
+  |                      ^
+  |
+  = note: a schema's references may not form a cycle: no check can describe a schema whose paths are unbounded
+```

package/errors/E0134.md

@@ -0,0 +1,36 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0134: a schema refers to a value that contains it
+
+A schema may not refer to a value that contains it, such as the lineage's own
+schemas: that is a cycle through the lineage, and the schema's shape would
+depend on the lineage it is part of.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				n: <=len(schemas)
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0134]: schema 0.0 refers to schemas, which contains it
+ --> lineage.cue:6:14
+  |
+6 |                 n: <=len(schemas)
+  |                          ^^^^^^^
+  |
+  = note: a schema's references may not form a cycle: no check can describe a schema whose paths are unbounded
+```

package/errors/E0135.md

@@ -0,0 +1,109 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0135: a schema's chain of references is too deep to follow
+
+thema follows a schema's references to check them for cycles, to a depth of 64.
+A chain of references longer than that is reported rather than followed: a
+schema's references form a finite tree, and a chain this long is not one an
+author writes by hand.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a0:  a1
+				a1:  a2
+				a2:  a3
+				a3:  a4
+				a4:  a5
+				a5:  a6
+				a6:  a7
+				a7:  a8
+				a8:  a9
+				a9:  a10
+				a10: a11
+				a11: a12
+				a12: a13
+				a13: a14
+				a14: a15
+				a15: a16
+				a16: a17
+				a17: a18
+				a18: a19
+				a19: a20
+				a20: a21
+				a21: a22
+				a22: a23
+				a23: a24
+				a24: a25
+				a25: a26
+				a26: a27
+				a27: a28
+				a28: a29
+				a29: a30
+				a30: a31
+				a31: a32
+				a32: a33
+				a33: a34
+				a34: a35
+				a35: a36
+				a36: a37
+				a37: a38
+				a38: a39
+				a39: a40
+				a40: a41
+				a41: a42
+				a42: a43
+				a43: a44
+				a44: a45
+				a45: a46
+				a46: a47
+				a47: a48
+				a48: a49
+				a49: a50
+				a50: a51
+				a51: a52
+				a52: a53
+				a53: a54
+				a54: a55
+				a55: a56
+				a56: a57
+				a57: a58
+				a58: a59
+				a59: a60
+				a60: a61
+				a61: a62
+				a62: a63
+				a63: a64
+				a64: a65
+				a65: a66
+				a66: int
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0135]: schema 0.0 has a chain of references deeper than 64 at a65
+  --> lineage.cue:70:5
+   |
+70 |                 a64: a65
+   |                 ^^^
+   |
+
+error[E0135]: schema 0.0 has a chain of references deeper than 64 at a66
+  --> lineage.cue:71:5
+   |
+71 |                 a65: a66
+   |                 ^^^
+   |
+```

package/errors/E0137.md

@@ -0,0 +1,37 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0137: the lineage's name is not an identifier
+
+A lineage's name is an identifier: a letter followed by letters and digits. It
+names the thing the schemas describe in generated code and in error messages,
+so it must be usable as a name everywhere thema emits it.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship-v2"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0137]: the lineage's name is "ship-v2", which is not an identifier
+ --> lineage.cue:1:7
+  |
+1 | name: "ship-v2"
+  |       ^^^^^^^^^
+  |
+  = detail: name: invalid value "ship-v2" (out of bound =~"^[A-Za-z][A-Za-z0-9_]*$")
+  = help: a name starts with a letter and continues with letters and digits
+```

package/errors/E0140.md

@@ -0,0 +1,46 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0140: a schema refers to another schema of the lineage
+
+A schema reads a field of another schema through the lineage. A schema may
+refer only to its own body and CUE's builtin packages: one reached through the
+lineage's schemas is another schema, and this schema's meaning would then live
+in that one (reference rule ref-sibling-schema). Each schema declares its own
+fields.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+lin: {
+	name: "ship"
+	schemas: {
+		"0": "0": {
+			schema: {a: int}
+		}
+		"0": "1": {
+			schema: {a: lin.schemas["0"]["0"].schema.a, b?: int}
+		}
+	}
+	lenses: {
+		"0.1->0.0": {
+			v0_1: _
+			v0_0: {a: v0_1.a}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0140]: a in schema 0.1 refers to schemas["0"]["0"].schema.a, a schema in the lineage
+ --> lineage.cue:8:16
+  |
+8 |             schema: {a: lin.schemas["0"]["0"].schema.a, b?: int}
+  |                         ^^^
+  |
+  = note: reference rule ref-sibling-schema
+  = help: a schema may refer only to its own body and CUE's builtin packages
+```

package/errors/E0141.md

@@ -0,0 +1,35 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0141: a schema or lens refers to something the lineage declares outside it
+
+A schema reads something the lineage declares outside the schema: its name,
+#LatestVersion, the joinSchema, the lenses or a helper field (reference rule
+ref-lineage-meta). The schema writes the literal it wants.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+lin: {
+	name: "ship"
+	schemas: {
+		"0": "0": {
+			schema: {a: string, n: lin.name}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0141]: n in schema 0.0 refers to name, which is declared in the lineage outside the schema
+ --> lineage.cue:5:27
+  |
+5 |             schema: {a: string, n: lin.name}
+  |                                    ^^^
+  |
+  = note: reference rule ref-lineage-meta
+  = help: a schema may refer only to its own body and CUE's builtin packages
+```

package/errors/E0142.md

@@ -0,0 +1,38 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0142: a schema or lens refers to something declared outside the lineage
+
+A schema refers to a definition declared outside the lineage, at the top of
+the file. Editing the definition would edit every version that refers to it,
+published ones included (reference rule ref-outside-lineage). Each schema
+declares the definition it uses.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+#Color: "red" | "blue"
+
+lin: {
+	name: "ship"
+	schemas: {
+		"0": "0": {
+			schema: {c: #Color}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0142]: c in schema 0.0 refers to #Color, which is declared outside the lineage
+ --> lineage.cue:7:16
+  |
+7 |             schema: {c: #Color}
+  |                         ^^^^^^
+  |
+  = note: reference rule ref-outside-lineage
+  = help: a schema may refer only to its own body and CUE's builtin packages
+```

package/errors/E0143.md

@@ -0,0 +1,62 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0143: a schema or lens refers to a package that is not one of CUE's builtins
+
+A schema refers to a definition in another package of the author's module.
+Only CUE's builtin packages may be referred to (reference rule ref-import):
+the other package can change without the lineage's file changing, so a
+published version's meaning would not be fixed by the lineage. The schema
+declares the definition itself.
+
+## Example
+
+`cue.mod/module.cue`:
+
+```cue
+module: "example.com/m"
+language: version: "v0.9.0"
+```
+
+`lineage.cue`:
+
+```cue
+package m
+
+import "example.com/m/common"
+
+lin: {
+	name: "ship"
+	schemas: {
+		"0": "0": {
+			schema: {c: common.#Color}
+		}
+	}
+}
+```
+
+`common/common.cue`:
+
+```cue
+package common
+
+#Color: "red" | "blue"
+```
+
+`data.json`:
+
+```json
+{"c": "red"}
+```
+
+thema reports:
+
+```
+error[E0143]: c in schema 0.0 refers to #Color, in package "example.com/m/common", which is not one of CUE's builtin packages
+ --> lineage.cue:9:16
+  |
+9 |             schema: {c: common.#Color}
+  |                         ^^^^^^
+  |
+  = note: reference rule ref-import
+  = help: a schema may refer only to its own body and CUE's builtin packages
+```

package/errors/E0144.md

@@ -0,0 +1,49 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0144: a lens refers to a schema of the lineage
+
+A lens returns a field of a schema, read through the lineage. A lens may
+refer only to the instance it takes, its own body and CUE's builtin packages
+(reference rule ref-lens-to-schema); it builds what it returns from the
+instance it takes.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+lin: {
+	name: "ship"
+	schemas: {
+		"0": "0": {
+			schema: {a: string}
+		}
+		"1": "0": {
+			schema: {b: string}
+		}
+	}
+	lenses: {
+		"1.0->0.0": {
+			v1_0: _
+			v0_0: {a: v1_0.b}
+		}
+		"0.0->1.0": {
+			v0_0: _
+			v1_0: {b: lin.schemas["0"]["0"].schema.a}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0144]: v1_0.b in lens 0.0->1.0 refers to schemas["0"]["0"].schema.a, a schema
+  --> lineage.cue:18:14
+   |
+18 |             v1_0: {b: lin.schemas["0"]["0"].schema.a}
+   |                       ^^^
+   |
+   = note: reference rule ref-lens-to-schema
+   = help: a lens may refer only to v0_0, the instance it takes, its own body and CUE's builtin packages
+```