[Json] A minimal examplotron-style JSON validation language.

[John Cowan <[e-mail]>]

The trouble is that "validation" is a very vague term.  I would be happy
with a language that can only express simple type validation, minimally as
follows:

0) JSON values are divided into types, namely null, numbers, strings,
booleans, object types, and arrays of any of these.

1) An object type specifies what attributes the corresponding object has
and what the types of the corresponding values are, or else specifies that
it may have arbitrary keys and values.   It may have a name in the schema
language

2) When an array is expected, the validator will check that all its
contents have the same specified type.

3) There is a way to specify for a given object type whether it must
contain exactly the specified keys, may contain a superset of the specified
keys where the additional keys are not checked, or may contain a subset of
the specified keys.

This language leaves validation of the values of strings and numbers to
lpost-validation code.  It just makes sure that for a statically typed
language a proper combination of records/structs/classes that can be
generated in advance can represent any JSON value that is valid against the
schema.

Here is a very simple examplotron language:

Sample document from json.org:

{"menu": {
  "id": "file",
  "value": "File",
  "popup": {
    "menuitem": [
      {"value": "New", "onclick": "CreateNewDoc()"},
      {"value": "Open", "onclick": "OpenDoc()"},
      {"value": "Close", "onclick": "CloseDoc()"}
    ]
  }
}}

Corresponding schema (constructed by hand, may have errors):

{
  "root": {"menu", "menu"},
  "menu": {
    "id": "",
    "value": "",
    "popup": "popup",
  },
  "popup":  {"menuitem": ["menuitem"]},
  "menuitem": {
    "value": "",
    "onclick": ""
  }
  "__whole__": {"menu": "root"},
  "__strictness__": {"menu": "superset"}
}

A schema is a JSON object whose keys are the names of object types, and
whose values are the corresponding definitions.  Object type names are
meaningful only within the schema.  In addition, the key "__whole__"
(mandatory) is the type of the whole document. If the key "__strictness__"
is present, its keys are object types and its values are one of the strings
"exact", "subset", or "superset".  Object types without names, or those not
mentioned in "__strictness__", are always exact.

An object type definition is an object whose keys are the keys of objects
that are valid against it and whose values are the corresponding types.
Alternatively, an empty object designates an object with arbitrary keys (in
effect, a dictionary).

An object type's designator can be its name (as a string), or an in-place
object type definition.  A null type's designator is the null value.
Designators for a number, string, or boolean type are specified by any
number, the empty string "", or any boolean respectively. An array type's
designator is an array with one value, a designator for the type of the
elements of the array.

The schema for schemas is not very useful: it is simply {"__whole__": {}},
because the top-level keys have unpredictable names.


On Wed, May 29, 2019 at 10:59 AM Nico Williams <[e-mail]>
wrote:

> On Tue, May 28, 2019 at 08:47:16PM -0700, Tim Bray wrote:
> > TBH, what I want from a schema system is (a) useful error messages and
> (b)
> > ability to drive code generation, classes and serializer/deserializers
> and
> > so on.
>
> This is all I want as well.  Validation and codegen.
>
> _______________________________________________
> json mailing list
> [e-mail]
> https://www.ietf.org/mailman/listinfo/json
>