Documentation
¶
Index ¶
- Variables
- func AllStringsInSlice(strings []string, slice []string) bool
- func CheckAndClose(file *os.File) bool
- func CheckError(err error, context string) bool
- func ExtFromSyntax(name string) 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 HasAnyPrefix(text string, slice []string) bool
- func IsDir(filename string) bool
- func NewLogger() *logrus.Logger
- func PrepText(txt string) string
- func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)
- func StringInSlice(a string, slice []string) bool
Constants ¶
This section is empty.
Variables ¶
var AlertLevels = []string{"suggestion", "warning", "error"}
AlertLevels holds the possible values for "level" in an external rule.
var CLConfig struct { Glob string // (optional) specifies formats to lint (e.g., "*.{md,py}") Output string // (optional) output style ("line" or "CLI") Wrap bool // (optional) wrap output when CLI style Debug bool // (optional) Prints dubugging info to stdout }
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 LookupSyntaxName = map[string]string{
`(?:(?i)C|C\+\+|C#|Java|JavaScript|js|Swift|Go|sass|less|scala)$`: ".c",
`(?:(?i)lua)$`: ".lua",
`(?:(?i)PHP)$`: ".php",
`(?:(?i)Python|py)$`: ".py",
`(?:(?i)R|perl)$`: ".r",
`(?:(?i)Rust)$`: ".rs",
`(?:(?i)Haskell|hs)$`: ".hs",
`(?:(?i)Ruby|rb)$`: ".rb",
}
LookupSyntaxName associates a syntax name with an extension used to get its comment delimiters from CommentsByNormedExt. An example use case is Markdown codeblocks: given a syntax (e.g., ```python), we use this to get its associated comments.
var MatchIgnoreByByExtension = map[string]string{
".md": "`([^`]+)`",
".rst": "``([^`]+)``|:.+:`[^`]+`",
".adoc": "`([^`]+)`",
}
MatchIgnoreByByExtension maps an inline ignore pattern to its format (such as `foo` in Markdown).
Functions ¶
func AllStringsInSlice ¶
AllStringsInSlice determines if `slice` contains the `strings`.
func CheckAndClose ¶
CheckAndClose closes `file` and prints any errors to stdout. A return value of true => no error.
func CheckError ¶
CheckError prints any errors to stdout. A return value of true => no error.
func ExtFromSyntax ¶
ExtFromSyntax takes a syntax's name (e.g., "Python") and returns its extension (if found).
func FileExists ¶
FileExists determines if the path given by `filename` exists.
func FormatFromExt ¶
FormatFromExt takes a file extension and returns its [normExt, format] list, if supported.
func HasAnyPrefix ¶
HasAnyPrefix determines if `text` has any prefix contained in `slice`.
func NewLogger ¶
NewLogger creates and returns an instance of logrus.Logger. If the `--debug` command flag was not provided, we set the level to Error.
func ScanLines ¶
ScanLines splits on CRLF, CR not followed by LF, and LF. See http://stackoverflow.com/questions/41433422/read-lines-from-a-file-with-variable-line-endings-in-go
func StringInSlice ¶
StringInSlice determines if `slice` contains the string `a`.
Types ¶
This section is empty.
Source Files