core

type Action struct {
	Name   string   // the name of the action -- e.g, 'replace'
	Params []string // a slice of parameters for the given action
}

type Alert struct {
	Action         Action   // a possible solution
	Suggestions    []string // what Action resolves to, when known at lint time
	Groups         []string `json:",omitempty"` // the matched token's capture groups
	Span           []int    // the [begin, end] location within a line
	Offset         []string `json:"-"` // tokens to ignore before this match
	Check          string   // the name of the check
	Description    string   // why `Message` is meaningful
	Link           string   // reference material
	Message        string   // the output message
	Severity       string   // 'suggestion', 'warning', or 'error'
	Match          string   // the actual matched text
	Line           int      // the source line
	Limit          int      `json:"-"` // the max times to report
	Hide           bool     `json:"-"` // should we hide this alert?
	HasByteOffsets bool     `json:"-"` // Span holds byte offsets into the raw document
	// contains filtered or unexported fields
}

type ByName []*File

type ByPosition []Alert

type CLIFlags struct {
	AlertLevel    string
	Built         string
	Glob          string
	InExt         string
	InPath        string
	Output        string
	Path          string
	Sources       string
	Filter        string
	Apply         bool
	Counts        bool
	Coverage      bool
	Local         bool
	NoExit        bool
	NoColor       bool
	PlainProgress bool
	Normalize     bool
	Relative      bool
	Remote        bool
	Simple        bool
	Sorted        bool
	Wrap          bool
	Version       bool
	Help          bool
	IgnoreGlobal  bool
}

type Cell struct {
	// Type is `markdown`, `code`, or `raw`.
	Type string

	// Lang is the extension of the code's language, such as `.py`, and
	// empty for a language Vale has no grammar for.
	Lang string

	Value ScopedValue
}

type Condition struct {
	Source string
	// contains filtered or unexported fields
}

type Config struct {
	// General configuration
	BlockIgnores      map[string][]string          // A list of blocks to ignore
	Checks            []string                     // All checks to load
	Formats           map[string]string            // A map of unknown -> known formats
	Asciidoctor       map[string]string            // A map of asciidoctor attributes
	Sphinx            map[string]string            // The `[sphinx]` section: a project's directives and roles
	FormatToLang      map[string]string            // A map of format to lang ID
	GBaseStyles       []string                     // Global base style
	GChecks           map[string]bool              // Global checks
	IgnoredClasses    []string                     // A list of HTML classes to ignore
	IgnoredScopes     []string                     // A list of HTML tags to ignore
	MinAlertLevel     int                          // Lowest alert level to display
	Vocab             []string                     // The active project
	RuleToLevel       map[string]string            // Single-rule level changes
	RuleToParams      map[string]map[string]string // Single-rule scalar overrides
	SBaseStyles       map[string][]string          // Syntax-specific base styles
	SChecks           map[string]map[string]bool   // Syntax-specific checks
	SLevels           map[string]map[string]string // Syntax-specific level changes
	SUnsets           map[string][]string          // Keys a section marked UNSET
	SVocab            map[string][]string          // Vocabularies a section names
	StyleSources      map[string]string            // The file each section's BasedOnStyles comes from
	Vocabularies      map[string]*Vocabulary       // Every vocabulary loaded, by name
	SkippedScopes     []string                     // A list of HTML blocks to ignore
	Stylesheets       map[string]string            // XSLT stylesheet
	TokenIgnores      map[string][]string          // A list of tokens to ignore
	CommentDelimiters map[string][2]string         // Strings to treat as comment delimiters. Indicates the start and end delimiters.
	WordTemplate      string                       // The template used in YAML -> regexp list conversions
	RootINI           string                       // the path to the project's .vale.ini file
	RootDir           string                       // the directory the search found RootINI at
	Paths             []string                     // A list of paths to search for styles
	ConfigFiles       []string                     // A list of configuration files to load

	AcceptedTokens []string `json:"-"` // Project-specific vocabulary (okay)
	RejectedTokens []string `json:"-"` // Project-specific vocabulary (avoid)

	FallbackPath string `json:"-"`

	SecToPat map[string]glob.Glob `json:"-"`
	// SecToCond holds the condition of a section written `[glob if expr]`.
	SecToCond map[string]*Condition `json:"-"`
	Styles    []string              `json:"-"`
	Views     map[string]*View      `json:"-"`

	// Scopes are the named scopes found under `config/scopes`, by name.
	Scopes map[string]string `json:"-"`

	NLPEndpoint string // An external API to call for NLP-related work.

	// Command-line configuration
	Flags *CLIFlags `json:"-"`

	StyleKeys []string `json:"-"`
	RuleKeys  []string `json:"-"`
	// contains filtered or unexported fields
}

type ConfigSrc int

type DaselValue = any

type Error struct {
	Code string // E100 or E201

	// Context says where an E100 came from: a command, or the file being
	// linted. An E201 has a position instead.
	Context string

	Path string // the file holding the invalid value
	Line int    // 1-based; 0 when the value couldn't be placed
	Span int    // 1-based column of the value

	// Excerpt is the lines around Line, shown above the message.
	Excerpt []ExcerptLine

	Msg string
}

type ExcerptLine struct {
	Number int
	Text   string
	Marked bool // the line the error is about
}

type ExpandFunc func(word, flags string) ([]string, error)

type File struct {
	NLP     nlp.Info     // -
	Summary bytes.Buffer // holds content to be included in summarization checks

	// SummaryRuns place the summary's text in Content: each piece of prose
	// written to Summary records where it came from, so that a match found in
	// the summary can be reported at the text that was counted. Without them
	// the match is located by searching Content for its text, and a copy in
	// front matter, a code block or a heading -- none of which the summary
	// holds -- takes the alert. See #1191.
	SummaryRuns []nlp.Run

	Alerts     []Alert           // all alerts associated with this file
	BaseStyles []string          // base style assigned in .vale
	Lines      []string          // the File's Content split into lines
	Sequences  []string          // tracks various info (e.g., defined abbreviations)
	Content    string            // the raw file contents
	Format     string            // 'code', 'markup' or 'prose'
	NormedExt  string            // the normalized extension (see util/format.go)
	Path       string            // the full path
	NormedPath string            // the normalized path
	Transform  string            // XLST transform
	Held       map[string]bool   // the conditional sections whose `if` held
	RealExt    string            // actual file extension
	Checks     map[string]bool   // syntax-specific checks assigned in .vale
	Unset      map[string]bool   // keys a section marked UNSET; no global setting applies
	Vocab      []string          // vocabularies the file's sections name
	ChkToCtx   map[string]string // maps a temporary context to a particular check

	// Levels holds the level each rule was given by the sections matching this
	// file, which is not the same as the level it was compiled with: the same
	// rule can be an error in one format and a warning in another. See #965.
	Levels map[string]string

	Comments map[string]bool // comment control statements
	Metrics  map[string]int  // count-based metrics

	Lookup    bool   // -
	MetaScope string // extra scope context, e.g. a YAML key or comment

	// Scoped holds the text of every value a View found, by scope name, so
	// a rule can ask about a scope other than the one it runs in.
	Scoped map[string][]string
	// contains filtered or unexported fields
}

type FileFields struct {
	Path string // relative to the root .vale.ini, with forward slashes
	Dir  string
	Name string
	Ext  string
	Meta map[string]any // the front matter, keyed as written
}

type Part struct {
	Offset int // rune offset in the value
	Line   int
	Column int

	// Quote is the scalar's quote character, or 0 for a plain or block
	// scalar. A quoted scalar decodes escapes, so a column in its text is
	// not a column in the source.
	Quote byte

	// Raw is the source line from Column on; the walk through its escapes
	// stops there, so a quoted scalar folded over several lines is placed
	// by its first.
	Raw string
}

type Scope struct {
	Name string `yaml:"name"`
	Expr string `yaml:"expr"`
	Type string `yaml:"type"`

	// Join, when set, is the separator a selected list of strings is
	// joined with, so the list reads as one value rather than one value
	// per element. A notebook cell's source is such a list.
	Join *string `yaml:"join"`
}

type ScopedValue struct {
	Text   string
	Line   int
	Column int

	// Joined marks a value made from a list, so its own line breaks are
	// real ones and not an escape in a scalar.
	Joined bool

	// Parts maps the value back to the scalars it was decoded from. It is
	// empty when the parser gave no positions.
	Parts []Part
}

type ScopedValues struct {
	Scope  string
	Format string
	Values []ScopedValue
}

type View struct {
	Engine string  `yaml:"engine"`
	Scopes []Scope `yaml:"scopes"`

	// Template is the TextFSM template a `textfsm` view reads with. Each
	// scope's `expr` names one of its values.
	Template string `yaml:"template"`
	// contains filtered or unexported fields
}

type Vocabulary struct {
	Accepted []string
	Rejected []string
}