core

package
v2.30.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 6, 2023 License: MIT Imports: 22 Imported by: 0

Documentation

Overview

Package core contains configuration and utility internals.

Index

Constants

This section is empty.

Variables

View Source 
var AlertLevels = []string{"suggestion", "warning", "error"}

AlertLevels holds the possible values for "level" in an external rule.

View Source 
var CommentsByNormedExt = map[string]map[string]string{
	".c": {
		"inline":     `(?:^|\s)(?:(//.+)|(/\*.+\*/))`,
		"blockStart": `(/\*.*)`,
		"blockEnd":   `(.*\*/)`,
	},
	".clj": {
		"inline":     `(;+.+)`,
		"blockStart": `$^`,
		"blockEnd":   `$^`,
	},
	".css": {
		"inline":     `(/\*.+\*/)`,
		"blockStart": `(/\*.*)`,
		"blockEnd":   `(.*\*/)`,
	},
	".rs": {
		"inline":     `(//.+)`,
		"blockStart": `$^`,
		"blockEnd":   `$^`,
	},
	".r": {
		"inline":     `(#.+)`,
		"blockStart": `$^`,
		"blockEnd":   `$^`,
	},
	".py": {
		"inline":     `(#.*)|('{3}.+'{3})|("{3}.+"{3})`,
		"blockStart": `(?m)^((?:\s{4,})?[r]?["']{3}.*)$`,
		"blockEnd":   `(.*["']{3})`,
	},
	".ps1": {
		"inline":     `(#.+)`,
		"blockStart": `(<#.*)`,
		"blockEnd":   `(.*#>)`,
	},
	".php": {
		"inline":     `(//.+)|(/\*.+\*/)|(#.+)`,
		"blockStart": `(/\*.*)`,
		"blockEnd":   `(.*\*/)`,
	},
	".lua": {
		"inline":     `(-- .+)`,
		"blockStart": `(-{2,3}\[\[.*)`,
		"blockEnd":   `(.*\]\])`,
	},
	".hs": {
		"inline":     `(-- .+)`,
		"blockStart": `(\{-.*)`,
		"blockEnd":   `(.*-\})`,
	},
	".rb": {
		"inline":     `(#.+)`,
		"blockStart": `(^=begin)`,
		"blockEnd":   `(^=end)`,
	},
	".jl": {
		"inline":     `(# .+)`,
		"blockStart": `(^#=)|(^(?:@doc )?(?:raw)?["']{3}.*)`,
		"blockEnd":   `(^=#)|(.*["']{3})`,
	},
}

CommentsByNormedExt determines what parts of a file we should lint -- e.g., we only want to lint // or /* comments in a C++ file. Multiple formats are mapped to a single extension (e.g., .java -> .c) because many languages use the same comment delimiters.

View Source 
var FormatByExtension = map[string][]string{
	`\.(?:[rc]?py[3w]?|[Ss][Cc]onstruct)$`:        {".py", "code"},
	`\.(?:adoc|asciidoc|asc)$`:                    {".adoc", "markup"},
	`\.(?:cpp|cc|c|cp|cxx|c\+\+|h|hpp|h\+\+)$`:    {".c", "code"},
	`\.(?:cs|csx)$`:                               {".c", "code"},
	`\.(?:clj|cljs|cljc|cljd)$`:                   {".clj", "code"},
	`\.(?:css)$`:                                  {".css", "code"},
	`\.(?:go)$`:                                   {".c", "code"},
	`\.(?:html|htm|shtml|xhtml)$`:                 {".html", "markup"},
	`\.(?:rb|Gemfile|Rakefile|Brewfile|gemspec)$`: {".rb", "code"},
	`\.(?:java|bsh)$`:                             {".c", "code"},
	`\.(?:js|jsx)$`:                               {".c", "code"},
	`\.(?:lua)$`:                                  {".lua", "code"},
	`\.(?:md|mdown|markdown|markdn)$`:             {".md", "markup"},
	`\.(?:php)$`:                                  {".php", "code"},
	`\.(?:pl|pm|pod)$`:                            {".r", "code"},
	`\.(?:ps1|psm1|psd1)$`:                        {".ps1", "code"},
	`\.(?:r|R)$`:                                  {".r", "code"},
	`\.(?:rs)$`:                                   {".rs", "code"},
	`\.(?:rst|rest)$`:                             {".rst", "markup"},
	`\.(?:swift)$`:                                {".c", "code"},
	`\.(?:ts|tsx)$`:                               {".c", "code"},
	`\.(?:txt)$`:                                  {".txt", "text"},
	`\.(?:sass|less)$`:                            {".c", "code"},
	`\.(?:scala|sbt)$`:                            {".c", "code"},
	`\.(?:hs)$`:                                   {".hs", "code"},
	`\.(?:xml)$`:                                  {".xml", "markup"},
	`\.(?:dita)$`:                                 {".dita", "markup"},
	`\.(?:org)$`:                                  {".org", "markup"},
	`\.(?:jl)$`:                                   {".jl", "code"},
}

FormatByExtension associates a file extension with its "normed" extension and its format (markup, code or text).

View Source 
var LevelToInt = map[string]int{
	"suggestion": 0,
	"warning":    1,
	"error":      2,
}

LevelToInt allows us to easily compare levels in lint.go.

Functions

func AllStringsInSlice 

func AllStringsInSlice(strings []string, slice []string) bool

AllStringsInSlice determines if `slice` contains the `strings`.

func CapFirst added in v2.29.2 

func CapFirst(s string) string

CapFirst capitalizes the first letter of a string.

func CondSprintf 

func CondSprintf(format string, v ...interface{}) string

CondSprintf is sprintf, ignores extra arguments.

func FileExists 

func FileExists(filename string) bool

FileExists determines if the path given by `filename` exists.

func FindAsset 

func FindAsset(cfg *Config, path string) string

FindAsset tries to locate a Vale-related resource by looking in the user-defined StylesPath.

func FormatAlert 

func FormatAlert(a *Alert, limit int, level, name string)

FormatAlert ensures that all required fields have data.

func FormatFromExt 

func FormatFromExt(path string, mapping map[string]string) (string, string)

FormatFromExt takes a file extension and returns its [normExt, format] list, if supported.

func FormatMessage 

func FormatMessage(msg string, subs ...string) string

FormatMessage inserts `subs` into `msg`.

func FromFile added in v2.30.0 

func FromFile(cfg *Config, dry bool) (*ini.File, error)

FromFile loads an INI configuration from a file.

func FromString added in v2.30.0 

func FromString(src string, cfg *Config, dry bool) (*ini.File, error)

FromString loads an INI configuration from a string.

func GetPackages added in v2.16.0 

func GetPackages(src string) ([]string, error)

Get the user-defined packages from a `.vale.ini` file.

func HasAnySuffix added in v2.29.3 

func HasAnySuffix(s string, suffixes []string) bool

func InRange 

func InRange(n int, r []int) bool

InRange determines if the range r contains the integer n.

func Indent 

func Indent(text, indent string) string

Indent adds padding to every line of `text`.

func IntInSlice 

func IntInSlice(a int, slice []int) bool

IntInSlice determines if `slice` contains the int `a`.

func IsDir 

func IsDir(filename string) bool

IsDir determines if the path given by `filename` is a directory.

func IsLetter 

func IsLetter(s string) bool

IsLetter returns `true` if s contains all letter characters and false if not.

func IsPhrase 

func IsPhrase(s string) bool

IsPhrase returns `true` is s is a phrase-like token.

This is used to differentiate regex tokens from non-regex.

func NewE100 

func NewE100(context string, err error) error

NewE100 creates a new, formatted "unexpected" error.

Since E100 errors can occur anywhere, we include a "context" that makes it clear where exactly the error was generated.

func NewE201 

func NewE201(msg, value, path string, finder errorCondition) error

NewE201 creates a formatted user-generated error.

201 errors involve a specific configuration asset and should contain parsable location information on their last line of the form:

<path>:<line>:<start>:<end>

func NewE201FromPosition 

func NewE201FromPosition(msg, file string, goal int) error

NewE201FromPosition creates a new E201 error from an in-file location.

func NewE201FromTarget 

func NewE201FromTarget(msg, value, file string) error

NewE201FromTarget creates a new E201 error from a target string.

func NewError 

func NewError(code, title, msg string) error

NewError creates a colored error from the given information.

The standard format is

``` <code> [<context>] <title>

<msg> ```

func ReplaceAllStringSubmatchFunc added in v2.16.1 

func ReplaceAllStringSubmatchFunc(re *regexp.Regexp, str string, repl func([]string) string) string

func Sanitize 

func Sanitize(txt string) string

Sanitize prepares text for our check functions.

func ShouldIgnoreDirectory 

func ShouldIgnoreDirectory(directoryName string) bool

ShouldIgnoreDirectory will check if directory should be ignored

func SplitLines 

func SplitLines(data []byte, atEOF bool) (adv int, token []byte, err error)

SplitLines splits on CRLF, CR not followed by LF, and LF.

func StringInSlice 

func StringInSlice(a string, slice []string) bool

StringInSlice determines if `slice` contains the string `a`.

func StringsToInterface 

func StringsToInterface(strings []string) []interface{}

StringsToInterface converts a slice of strings to an interface.

func StripANSI 

func StripANSI(s string) string

StripANSI removes all ANSI characters from the given string.

func Substitute 

func Substitute(src, sub string, char rune) (string, bool)

Substitute replaces the substring `sub` with a string of asterisks.

func TextToContext added in v2.10.3 

func TextToContext(text string, meta *nlp.Info) []nlp.TaggedWord

func ToSentence 

func ToSentence(words []string, andOrOr string) string

ToSentence converts a slice of terms into sentence.

func Which 

func Which(cmds []string) string

Which checks for the existence of any command in `cmds`.

func WhitespaceToSpace 

func WhitespaceToSpace(msg string) string

WhitespaceToSpace converts newlines and multiple spaces (e.g., " ") into a single space.

Types

type Action 

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

An Action represents a possible solution to an Alert.

type Alert 

type Alert struct {
	Action      Action   // a possible solution
	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?
}

An Alert represents a potential error in prose.

type ByName 

type ByName []*File

ByName sorts Files by their path.

func (ByName) Len 

func (a ByName) Len() int

func (ByName) Less 

func (a ByName) Less(i, j int) bool

func (ByName) Swap 

func (a ByName) Swap(i, j int)

type ByPosition 

type ByPosition []Alert

ByPosition sorts Alerts by line and column.

func (ByPosition) Len 

func (a ByPosition) Len() int

func (ByPosition) Less 

func (a ByPosition) Less(i, j int) bool

func (ByPosition) Swap 

func (a ByPosition) Swap(i, j int)

type CLIFlags 

type CLIFlags struct {
	AlertLevel string
	Built      string
	Glob       string
	InExt      string
	Output     string
	Path       string
	Sources    string
	Filter     string
	Local      bool
	NoExit     bool
	Normalize  bool
	Relative   bool
	Remote     bool
	Simple     bool
	Sorted     bool
	Wrap       bool
	Version    bool
	Help       bool
}

CLIFlags holds the values that are defined at runtime by the user.

For example, `vale --minAlertLevel=error`.

type Config 

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
	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
	SBaseStyles    map[string][]string        // Syntax-specific base styles
	SChecks        map[string]map[string]bool // Syntax-specific checks
	SkippedScopes  []string                   // A list of HTML blocks to ignore
	Stylesheets    map[string]string          // XSLT stylesheet
	StylesPath     string                     // Directory with Rule.yml files
	TokenIgnores   map[string][]string        // A list of tokens to ignore
	WordTemplate   string                     // The template used in YAML -> regexp list conversions
	RootINI        string                     // the path to the project's .vale.ini file

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

	DictionaryPath string // Location to search for dictionaries.

	FallbackPath string               `json:"-"`
	SecToPat     map[string]glob.Glob `json:"-"`
	Styles       []string             `json:"-"`
	Paths        []string             `json:"-"`
	Root         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:"-"`
}

Config holds the configuration values from both the CLI and `.vale.ini`.

func NewConfig 

func NewConfig(flags *CLIFlags) (*Config, error)

NewConfig initializes a Config with its default values.

func ReadPipeline added in v2.16.0 

func ReadPipeline(flags *CLIFlags, dry bool) (*Config, error)

func (*Config) AddWordListFile 

func (c *Config) AddWordListFile(name string, accept bool) error

AddWordListFile adds vocab terms from a provided file.

func (*Config) String 

func (c *Config) String() string

type ConfigSrc added in v2.30.0 

type ConfigSrc int
const (
	FileSrc ConfigSrc = iota
	StringSrc
)

type File 

type File struct {
	NLP        nlp.Info          // -
	Summary    bytes.Buffer      // holds content to be included in summarization checks
	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
	Transform  string            // XLST transform
	RealExt    string            // actual file extension
	Checks     map[string]bool   // syntax-specific checks assigned in .vale
	ChkToCtx   map[string]string // maps a temporary context to a particular check
	Comments   map[string]bool   // comment control statements
	Metrics    map[string]int    // count-based metrics

	Lookup bool // -
	// contains filtered or unexported fields
}

A File represents a linted text file.

func NewFile 

func NewFile(src string, config *Config) (*File, error)

NewFile initializes a File.

func (*File) AddAlert 

func (f *File) AddAlert(a Alert, blk nlp.Block, lines, pad int, lookup bool)

AddAlert calculates the in-text location of an Alert and adds it to a File.

func (*File) ComputeMetrics added in v2.12.0 

func (f *File) ComputeMetrics() (map[string]interface{}, error)

ComputeMetrics returns all of f's metrics.

func (*File) FindLoc 

func (f *File) FindLoc(ctx, s string, pad, count int, a Alert) (int, []int)

FindLoc calculates the line and span of an Alert.

func (*File) QueryComments 

func (f *File) QueryComments(check string) bool

QueryComments checks if there has been an in-text comment for this check.

func (*File) ResetComments 

func (f *File) ResetComments()

ResetComments resets the state of all checks back to active.

func (*File) SetText added in v2.19.0 

func (f *File) SetText(s string)

SetText updates the file's content, lines, and history.

func (*File) SortedAlerts 

func (f *File) SortedAlerts() []Alert

SortedAlerts returns all of f's alerts sorted by line and column.

func (*File) UpdateComments 

func (f *File) UpdateComments(comment string)

UpdateComments sets a new status based on comment.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.