meaning

type Binding struct {
	Model, Property, Role, Match, Note string
	Line                               int
}

type Checker struct {
	// Schema validates each file; the embedded schema when nil.
	Schema Validator
	// Resolve reads other graphs; when nil none is available.
	Resolve Resolver
	// Models reads the models bindings name; HCLReader when nil.
	Models ModelReader
	// Profile selects extra rules.
	Profile Profile
	// Noticed holds the model files already reported for an earlier ModelSpec
	// spelling, by path as written. A caller that checks several graphs in one
	// run shares one map between their Checkers, so that a model file listed by
	// more than one graph is reported once; when nil, the check keeps its own.
	Noticed map[string]bool
}

type Concept struct {
	ID, Kind                       string
	Of, Extends, ValuesOf, UnitsOf string
	Unit, Source                   string
	Labels                         map[string]string
	Synonyms                       map[string][]string
	Values                         []Value
	Measure                        *Measure
	Bindings                       []Binding
	Line                           int
	// contains filtered or unexported fields
}

type ConceptRef struct {
	// Repo is {host}/{org}/{repo}, empty for a bare id.
	Repo string
	ID   string
	// Pin is the ?ref= value, empty when there is none.
	Pin string
}

type EarlierSpelling struct {
	// Count is the number of earlier spellings the file uses.
	Count int
	// Line is the 1-based line of the first of them.
	Line int
}

type Entity struct {
	// Key is the names of the properties that form the entity's key.
	Key        []string
	Properties map[string]Property
}

type Entry struct {
	Concept *Concept
	File    *File
}

type FS interface {
	Stat(name string) (fs.FileInfo, error)
	ReadFile(name string) ([]byte, error)
	// ReadFileMax reads a file of at most max bytes without reading more of a
	// larger one, which is the error ErrTooLarge.
	ReadFileMax(name string, max int64) ([]byte, error)
	ReadDir(name string) ([]fs.DirEntry, error)
}

type File struct {
	// Path is the path as it was given.
	Path string
	// Root is the parsed document; nil when it could not be parsed.
	Root *Node
	// ParseErr is why Root is nil.
	ParseErr *SyntaxError

	ID, Name, License string
	// Models maps a module short name to the path of its source, relative to
	// the file.
	Models   map[string]string
	Sources  []Source
	Concepts []*Concept
}

type Finding struct {
	// File is the path of the file the finding is about, as it was given.
	File string `json:"file"`
	// Line is the 1-based line, or 0 when it is not known.
	Line int `json:"line,omitempty"`
	// Rule is a stable identifier of the rule that was broken.
	Rule     string   `json:"rule"`
	Severity Severity `json:"severity"`
	Message  string   `json:"message"`
}

type Graph struct {
	// Address is the graph's own address, {host}/{org}/{repo} (for example
	// github.com/meaninggraph/core), or empty when it is not known. Set it,
	// before the graph is checked or handed to GraphResolver, for every graph
	// whose files refer to the graph by its address: a meaning:// reference to
	// the address from inside the graph is a reference to itself, and without
	// the address it is a reference to another graph. Neither LoadDir nor
	// LoadFiles sets it.
	Address string
	// Dir is the directory the files were read from by LoadDir, else empty.
	Dir   string
	Files []*File

	// Concepts maps a concept id to its first declaration.
	Concepts map[string]*Entry
	// contains filtered or unexported fields
}

type HCLReader struct{}

type Kind int

type Measure struct {
	Formula, Aggregation string
	Inputs, Dimensions   []string
}

type Model struct {
	Entities map[string]*Entity
	// Earlier says which earlier spellings the model file uses (entity, property
	// and entity = for record, field and record =). They are read as the words
	// they were replaced by; this is how a check can report them.
	Earlier EarlierSpelling
}

type ModelReader interface {
	ReadModel(fsys FS, path string) (*Model, error)
}

type ModelRef struct {
	// Repo is {host}/{org}/{repo} for a model of another repository, empty
	// for one of the same repository.
	Repo, Module, Name, Pin string
}

type Node struct {
	Kind Kind
	Line int
	// Text is the value of a scalar: the string itself, or the canonical
	// text of a number or a boolean.
	Text string
	// Keys are the keys of a Map in document order.
	Keys []string
	// Fields are the values of a Map by key.
	Fields map[string]*Node
	// Items are the elements of a Seq.
	Items []*Node
}

type OSFS struct{}

type Profile string

type Property struct {
	// Type is the ModelSpec type ("string", "int", ...), empty for a
	// reference to another entity.
	Type string
	// Reference says the property is a reference to an entity, in the sense of
	// the reference checker: its `entity` attribute is set.
	Reference bool
	// Entity is the name of the entity a reference property points at. It is
	// empty when the property is no reference, or when the attribute is not a
	// string (and so names no entity).
	Entity string
}

type RefTarget struct {
	// Ref is the full name of the ref (refs/heads/main, refs/tags/v1, ...).
	Ref string
	// ID is what the ref file or packed-refs holds, or the commit an annotated
	// tag in packed-refs peels to.
	ID string
	// MaybeTagObject says that ID may be that of a tag object, not of the commit:
	// a loose refs/tags file holds the id of the tag object when the tag is
	// annotated, and so does a packed one when packed-refs does not say that it is
	// fully peeled and gives no peeled line for it. Telling the two apart means
	// reading the object, which this does not do.
	MaybeTagObject bool
}

type Resolver func(repo, pin string) (*Graph, error)

type Severity string

type Source struct {
	ID   string
	Line int
}

type SyntaxError struct {
	Line    int
	Column  int
	Rule    string
	Message string
}

type Validator interface {
	Validate(v any) error
}

type Value struct {
	ID      string
	Labels  map[string]string
	Aliases map[string][]string
	Codes   map[string]string
}