modelspec

const (
	RuleSyntax     = "syntax"        // the source is not valid HCL or JSON
	RuleEncoding   = "encoding"      // the source is not valid UTF-8
	RuleLimit      = "limit"         // the source exceeds a size or nesting limit
	RuleShape      = "shape"         // valid syntax, but not the structure ModelSpec defines
	RuleLiteral    = "literal"       // an HCL value that is not a literal (decision 0009)
	RuleReference  = "reference"     // a name that does not resolve (decisions 0014, 0013)
	RuleReserved   = "reserved-name" // a reserved kind token used as a concept name (decision 0015)
	RuleDuplicate  = "duplicate-name"
	RuleNameForm   = "name-form" // a dot in a concept name (decision 0014)
	RuleEnumValues = "enum-values"
	RuleType       = "unknown-type"
	RuleAttribute  = "attribute"
	RuleKey        = "key"
	RuleMemberKind = "member-kind"
	RuleVersion    = "modelspec-version"
	RuleModule     = "module"
	RuleCollection = "collection"
	RuleUnknown    = "unknown-field" // a top-level JSON field the format does not define
	RuleIO         = "unreadable"    // a file found by a directory search that cannot be read
	RuleSkipped    = "skipped-file"  // a model-named link, pipe or device a search does not read: an error, and its module is not checked
	RuleStaleTwin  = "stale-twin"    // a JSON twin that is not what its HCL exports to
	RuleNameCase   = "name-case"     // names in one scope that differ only by case

	RulePublishModuleName = "publish-module-name"
	RulePublishEntities   = "publish-entities"
	RulePublishProperties = "publish-properties"
	RulePublishNameForm   = "publish-name-form"
	RulePublishComponent  = "publish-component-property"
	RulePublishQualified  = "publish-qualified-entity"
)

const (
	// MaxNumberLength is the most characters one number literal may have. The
	// HCL library reads a number into 512 bits, about 154 decimal digits, and
	// rounds beyond that, so two different long integers could look equal. With
	// at most 40 characters (and an exponent within MaxNumberExponent) every
	// accepted number is read exactly, and two numbers are equal only when they
	// are the same value. It also bounds the time to read one: the library's
	// time to read `1e10000000`, 10 bytes, was ten seconds.
	MaxNumberLength = 40
	// MaxNumberExponent is the largest exponent, either sign, a number literal
	// may have: with at most MaxNumberLength characters a number is then between
	// 1e-140 and 1e140, a size where a decimal is read, compared and written
	// exactly and in constant time.
	MaxNumberExponent = 100
	// MaxNameLength is the most bytes, as written, a name may have: a block
	// label, an identifier or attribute name, a type, entity, component, enum or
	// kind reference, and an item of `key` or `use` (JSON: every object key and
	// the same strings). The standard states no length. Real names are a few
	// words, and where the databases a model describes limit an identifier it is
	// between 63 and 128 bytes, so 255 leaves room.
	MaxNameLength = 255
	// MaxMessageBytes is the most bytes of one finding's message. Longer ones are
	// cut with a marker (clipText), and so is every piece of the user's text
	// that a message echoes (MaxEchoBytes), so that one finding cannot be large
	// however large the input is.
	MaxMessageBytes = 1024
	// MaxEchoBytes is the most bytes of one piece of the user's text, such as a
	// name or a value, a message repeats: as many as a name may have, so a name
	// is always shown whole.
	MaxEchoBytes = MaxNameLength
)

const (
	HCLSuffix  = ".modelspec.hcl"
	JSONSuffix = ".modelspec.json"
)

const (
	// MaxInputBytes is the largest source, in bytes, that is read. The lexer holds
	// every token of a file in memory at once, and the peak is about 420 to 470
	// MiB for each MB of one-byte tokens, so 1 MiB keeps one file under 500 MiB
	// and about a second of work. Chinook's model is under 8 KB and the largest
	// corpus file 30 KB; a module is a set of files, each under the limit.
	MaxInputBytes = 1 << 20
	// MaxDepth is the deepest nesting of HCL braces, brackets, quoted strings and
	// heredocs, counted from tokens (blocks, lists, objects), and of JSON arrays
	// and objects. Real models nest four or five levels in HCL, six to eight in
	// the JSON form.
	MaxDepth = 64
	// MaxHeredocLines is the most lines one heredoc may have. The lexer makes one
	// piece of each line, and the HCL parser joins the pieces of a template one at
	// a time, copying the text and shifting the rest of the list each time: time
	// that grows with the square of their number. (Pieces that the lexer also
	// starts at each `$` and `%`, and in quoted strings, are removed before the
	// parser sees them: see parserInput.) No real heredoc, a query or a pattern,
	// comes near the limit.
	MaxHeredocLines = 1000
	// MaxSyntaxFindings is the most syntax errors, or non-literal tokens, reported
	// for one HCL file.
	MaxSyntaxFindings = 50
)

const MaxFindings = 1000

const SpecVersion = "1.0-draft"