core

Documentation

Index

• Variables
• func AllStringsInSlice(strings []string, slice []string) bool
• func CheckAndClose(file *os.File) bool
• func CheckError(err error, message string) bool
• func DumpConfig() string
• func FileExists(filename string) bool
• func FindLoc(count int, ctx string, s string, ext string, loc []int, pad int) (int, []int)
• func FormatFromExt(path string) (string, string)
• func FormatMessage(msg string, subs ...string) string
• func HasAnyPrefix(text string, slice []string) bool
• func IsDir(filename string) bool
• func PrepText(txt string) string
• func StringInSlice(a string, slice []string) bool
• func StringsToInterface(strings []string) []interface{}
• func Substitute(src string, repl string, char string) string
• func Which(cmds []string) string
• type Alert
• type ByName
  • func (a ByName) Len() int
  • func (a ByName) Less(i, j int) bool
  • func (a ByName) Swap(i, j int)
• type ByPosition
  • func (a ByPosition) Len() int
  • func (a ByPosition) Less(i, j int) bool
  • func (a ByPosition) Swap(i, j int)
• type File
  • func (f *File) AddAlert(a Alert, ctx string, txt string, lines int, pad int)
  • func (f *File) SortedAlerts() []Alert
• type Glob
• type Selector
  • func (s Selector) Contains(sel Selector) bool
  • func (s Selector) Equal(sel Selector) bool
  • func (s Selector) Has(scope string) bool
  • func (s Selector) Sections() []string

Variables

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

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

var CLConfig struct {
	Output string // (optional) output style ("line" or "CLI")
	Wrap   bool   // (optional) wrap output when CLI style
	NoExit bool   // (optional) don't return a nonzero exit code on lint errors
	Sorted bool   // (optional) sort files by their name for output
}

CLConfig holds our command-line configuration.

var CommentsByNormedExt = map[string]map[string]string{
	".c": {
		"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})`,
	},
	".php": {
		"inline":     `(//.+)|(/\*.+\*/)|(#.+)`,
		"blockStart": `(/\*.*)`,
		"blockEnd":   `(.*\*/)`,
	},
	".lua": {
		"inline":     `(-- .+)`,
		"blockStart": `(-{2,3}\[\[.*)`,
		"blockEnd":   `(.*\]\])`,
	},
	".hs": {
		"inline":     `(-- .+)`,
		"blockStart": `(\{-.*)`,
		"blockEnd":   `(.*-\})`,
	},
	".rb": {
		"inline":     `(#.+)`,
		"blockStart": `(^=begin)`,
		"blockEnd":   `(^=end)`,
	},
}

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

var Config = loadOptions()

Config holds our .vale configuration.

var ExeDir string

ExeDir is our starting location.

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

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

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

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

var SentenceTokenizer = tokenize.NewPunktSentenceTokenizer()

SentenceTokenizer splits text into sentences.

Functions

func AllStringsInSlice

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

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

func CheckAndClose

func CheckAndClose(file *os.File) bool

CheckAndClose closes `file` and prints any errors to stdout. A return value of true => no error.

func CheckError

func CheckError(err error, message string) bool

CheckError prints any errors to stdout. A return value of true => no error.

func DumpConfig

func DumpConfig() string

DumpConfig returns Vale's configuration in JSON format.

func FileExists

func FileExists(filename string) bool

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

func FindLoc

func FindLoc(count int, ctx string, s string, ext string, loc []int, pad int) (int, []int)

FindLoc calculates the line and span of an Alert.

func FormatFromExt

func FormatFromExt(path 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 HasAnyPrefix

func HasAnyPrefix(text string, slice []string) bool

HasAnyPrefix determines if `text` has any prefix contained in `slice`.

func IsDir

func IsDir(filename string) bool

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

func PrepText

func PrepText(txt string) string

PrepText prepares text for our check functions.

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 Substitute

func Substitute(src string, repl string, char string) string

Substitute replaces the substring `repl` with `char`s.

func Which

func Which(cmds []string) string

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

Types

type Alert

type Alert struct {
	Check       string // the name of the check
	Description string // why `Message` is meaningful
	Line        int    // the source line
	Link        string // reference material
	Message     string // the output message
	Severity    string // 'suggestion', 'warning', or 'error'
	Span        []int  // the [begin, end] location within a line
}

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 File

type File struct {
	Alerts     []Alert         // all alerts associated with this file
	BaseStyles []string        // base style assigned in .vale
	Checks     map[string]bool // syntax-specific checks assigned in .txtint
	Counts     map[string]int  // word counts
	Format     string          // 'code', 'markup' or 'prose'
	NormedExt  string          // the normalized extension (see util/format.go)
	Path       string          // the full path
	RealExt    string          // actual file extension
	Scanner    *bufio.Scanner  // used by lintXXX functions
	Sequences  []string        // tracks various info (e.g., defined abbreviations)
}

A File represents a linted text file.

func (*File) AddAlert

func (f *File) AddAlert(a Alert, ctx string, txt string, lines int, pad int)

func (*File) SortedAlerts

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

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

type Glob

type Glob struct {
	Negated bool
	Pattern glob.Glob
}

Glob represents a glob pattern passed via `--glob`.

type Selector

type Selector struct {
	Value string // e.g., text.comment.line.py
}

A Selector represents a named section of text.

func (Selector) Contains

func (s Selector) Contains(sel Selector) bool

Contains determines if all if sel's sections are in s.

func (Selector) Equal

func (s Selector) Equal(sel Selector) bool

Equal determines if sel == s.

func (Selector) Has

func (s Selector) Has(scope string) bool

Has determines if s has a part equal to scope.

func (Selector) Sections

func (s Selector) Sections() []string

Sections splits a Selector into its parts -- e.g., text.comment.line.py -> []string{"text", "comment", "line", "py"}.