Styles

Vale has a powerful extension system that doesn't require knowledge of any programming language. Instead, it uses collections of individual YAML files (or "rules") to enforce particular writing constructs.

HeadingPunctuation.yml

# An example rule from the "Microsoft" style.
extends: existence
message: "Don't use end punctuation in headings."
link: https://docs.microsoft.com/en-us/style-guide/punctuation/periods
nonword: true
level: warning
scope: heading
action:
  name: edit
  params:
    - remove
    - '.?!'
tokens:
  - '[a-z0-9][.?!](?:\s|$)'

These collections are referred to as styles and are organized in a nested folder structure at a user-specified location (see Configuration). For example,

styles/
├── base/
│   ├── ComplexWords.yml
│   ├── SentenceLength.yml
│   ...
├── blog/
│   ├── TechTerms.yml
│   ...
└── docs/
    ├── Branding.yml
    ...

where base, blog, and docs are your styles that each contain certain rules.

Extension points

Heads up!

As of v2.10.0, you can specify an array of scopes to match against:

scope:
  - heading.h1
  - heading.h2
  - heading.h3

The building blocks of styles are rules (YAML files ending in .yml), which utilize extension points to perform specific tasks.

The basic structure of a rule consists of a small header (shown below) followed by extension-specific arguments.

# All rules should define the following header keys:
#
# `extends` indicates the extension point being used (see below for information
# on the possible values).
extends: existence
# `message` is shown to the user when the rule is broken.
#
# Many extension points accept format specifiers (%s), which are replaced by
# extracted values. See the extension-specific sections below for more details.
message: "Consider removing '%s'"
# `level` assigns the rule's severity.
#
# The accepted values are suggestion, warning, and error.
level: warning
# `scope` specifies where this rule should apply -- e.g., headings, sentences, etc.
#
# See the Markup section for more information on scoping.
scope: heading
# `link` gives the source for this rule.
link: 'https://errata.ai/'
# The number of times this rule should raise an alert.
#
# By default, there is no limit.
limit: 1

The available extension points are discussed below.

`existence`

Example definition

extends: existence
message: Consider removing '%s'
level: warning
code: false
ignorecase: true
tokens:
    - appears to be
    - arguably

Key summary

Name	Type	Description
`append`	`bool`	Adds `raw` to the end of `tokens`, assuming both are defined.
`ignorecase`	`bool`	Makes all matches case-insensitive.
`nonword`	`bool`	Removes the default word boundaries (`\b`).
`raw`	`array`	A list of tokens to be concatenated into a pattern.
`tokens`	`array`	A list of tokens to be transformed into a non-capturing group.
`exceptions`	`array`	An array of strings to be ignored.

The most general extension point is existence. As its name implies, it looks for the "existence" of particular tokens.

These tokens can be anything from simple phrases (as in the above example) to complex regular expressions—e.g., the number of spaces between sentences or the position of punctuation after quotes.

You may define the tokens as elements of lists named either tokens (shown above) or raw. The former converts its elements into a word-bounded, non-capturing group. For instance,

tokens:
  - appears to be
  - arguably

becomes \b(?:appears to be|arguably)\b.

raw, on the other hand, simply concatenates its elements—so, something like

raw:
  - '(?:foo)\sbar'
  - '(baz)'

becomes (?:foo)\sbar(baz).

`substitution`

Example definition

extends: substitution
message: Consider using '%s' instead of '%s'
level: warning
ignorecase: false
# swap maps tokens in form of bad: good
swap:
  abundance: plenty
  accelerate: speed up

Key summary

Name	Type	Description
`append`	`bool`	Adds `raw` to the end of `tokens`, assuming both are defined.
`ignorecase`	`bool`	Makes all matches case-insensitive.
`nonword`	`bool`	Removes the default word boundaries (`\b`).
`swap`	`map`	A sequence of `observed: expected` pairs.
`exceptions`	`array`	An array of strings to be ignored.

substitution associates a string with a preferred form. If we want to suggest the use of "plenty" instead of "abundance," for example, we'd write:

swap:
  abundance: plenty

The keys may be regular expressions, but they can't include nested capture groups:

swap:
  '(?:give|gave) rise to': lead to # this is okay
  '(give|gave) rise to': lead to # this is bad!

Like existence, substitution accepts the keys ignorecase and nonword.

substitution can have one or two %s format specifiers in its message. This allows us to do either of the following:

message: "Consider using '%s' instead of '%s'"
# or
message: "Consider using '%s'"

`occurrence`

Example definition

extends: occurrence
message: "More than 3 commas!"
level: error
# Here, we're counting the number of times a comma appears
# in a sentence.
#
# If it occurs more than 3 times, we'll flag it.
scope: sentence
ignorecase: false
max: 3
token: ','

Key summary

Name	Type	Description
`max`	`int`	The maximum amount of times `token` may appear in a given scope.
`min`	`int`	The minimum amount of times `token` has to appear in a given scope.
`token`	`string`	The token of interest.

occurrence enforces the maximum or minimum number of times a particular token can appear in a given scope.

In the example above, we're limiting the number of commas per sentence.

This is the only extension point that doesn't accept a format specifier in its message.

`repetition`

Example definition

extends: repetition
message: "'%s' is repeated!"
level: error
alpha: true
tokens:
  - '[^\s]+'

Key summary

Name	Type	Description
`ignorecase`	`bool`	Makes all matches case-insensitive.
`alpha`	`bool`	Limits all matches to alphanumeric tokens.
`tokens`	`array`	A list of tokens to be transformed into a non-capturing group.

repetition looks for repeated occurrences of its tokens. If ignorecase is set to true, it'll convert all tokens to lower case for comparison purposes.

`consistency`

Example definition

extends: consistency
message: "Inconsistent spelling of '%s'"
level: error
scope: text
ignorecase: true
nonword: false
# We only want one of these to appear.
either:
  advisor: adviser
  centre: center

Key summary

Name	Type	Description
`nonword`	`bool`	Removes the default word boundaries (`\b`).
`ignorecase`	`bool`	Makes all matches case-insensitive.
`either`	`array`	A map of `option 1: option 2` pairs of which only one may appear.

consistency will ensure that a key and its value (e.g., "advisor" and "adviser") don't both occur in its scope.

`conditional`

Example definition

extends: conditional
message: "'%s' has no definition"
level: error
scope: text
ignorecase: false
# Ensures that the existence of 'first' implies the existence of 'second'.
first: '\b([A-Z]{3,5})\b'
second: '(?:\b[A-Z][a-z]+ )+\(([A-Z]{3,5})\)'
# ... with the exception of these:
exceptions:
  - ABC
  - ADD

Key summary

Name	Type	Description
`ignorecase`	`bool`	Makes all matches case-insensitive.
`first`	`string`	The antecedent of the statement.
`second`	`string`	The consequent of the statement.
`exceptions`	`array`	An array of strings to be ignored.

conditional ensures that the existence of first implies the existence of second. For example, consider the following text:

According to Wikipedia, the World Health Organization (WHO) is a specialized agency of the United Nations that is concerned with international public health. We can now use WHO because it has been defined, but we can't use DAFB because people may not know what it represents. We can use DAFB when it's presented as code, though.

Using the above text with our example rule yields the following:

test.md:1:224:style.UnexpandedAcronyms:'DAFB' has no definition

conditional also takes an optional exceptions list. Any token listed as an exception won't be flagged.

`capitalization`

Example definition

extends: capitalization
message: "'%s' should be in title case"
level: warning
scope: heading
# $title, $sentence, $lower, $upper, or a pattern.
match: $title
style: AP # AP or Chicago; only applies when match is set to $title.
exceptions:
  - ABC
  - add

Key summary

Name	Type	Description
`match`	`string`	`$title`, `$sentence`, `$lower`, `$upper`, or a pattern.
`style`	`string`	AP or Chicago; only applies when match is set to `$title`.
`exceptions`	`array`	An array of strings to be ignored.

capitalization checks that the text in the specified scope matches the case of match. There are a few pre-defined variables that can be passed as matches:

$title: "The Quick Brown Fox Jumps Over the Lazy Dog."
$sentence: "The quick brown fox jumps over the lazy dog."
$lower: "the quick brown fox jumps over the lazy dog."
$upper: "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG."

Additionally, when using match: $title, you can specify a style of either AP or Chicago.

`metric`

Heads up!

With the introduction of the metric extension point in v2.13.0, the readability extension point has been officially deprecated.

While all readability-based rules will continue to work in future versions of Vale, using metric is recommended going forward.

Example definition

extends: metric
message: "Try to keep the Flesch-Kincaid grade level (%s) below 8."
link: https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests

formula: |
  (0.39 * (words / sentences)) + (11.8 * (syllables / words)) - 15.59

condition: "> 8"

Key summary

Name	Type	Description
`formula`	`string`	A formula of pre-defined variables to be evaluated.
`condition`	`string`	A binary condition upon which `formula` will trigger an alert.

metric enforces arbitrary formulas based on pre-defined, built-in variables. The table below summarizes all available variables:

Variable	Description
`blockquote`	The number of `blockquote` tags.
`characters`	The number of characters.
`complex_words`	The number of polysyllabic words without common suffixes (`es`, `ed`, `ing`, ...).
`heading.h{n}`	The number of headings at the specified level (for example, `heading.h1`).
`list`	The number of `ol` and `ul` tags.
`long_words`	The number of words with more than 6 characters.
`paragraphs`	The number of paragraphs.
`polysyllabic_words`	The number of words with more than 2 syllables.
`pre`	The number of `pre` tags.
`sentences`	The number of sentences.
`syllables`	The number of syllables.
`words`	The number of words.

Since the pre-defined variables are calculated using the entire document, all metric-based rules are summary-scoped.

In addition to using the variables listed above, a formula may also use the following operators:

Operator	Description
`+`	Addition
`-`	Subtraction
`*`	Multiplication
`/`	Division
`math.sqrt(x)`	Square root of `x`
`math.abs(x)`	Absolute value of `x`

A condition may use one of >, <, =, >=, and <=.

The result of a formula will be compared to its condition and inserted into its message format specifier (%s).

`spelling`

Heads up!

The dic and aff keys, while still supported, have been deprecated in favor of using the dictionaries key (introduced in v2.8.0).

Example definition

# Uses the built-in dictionary and filters.
extends: spelling
message: "Did you really mean '%s'?"
level: error

Key summary

Name	Type	Description
`custom`	`bool`	Turn off the default filters for acronyms, abbreviations, and numbers.
`filters`	`array`	An array of patterns to ignore during spell checking.
`ignore`	`string`	A relative path (from `StylesPath`) to a file consisting of one word per line to ignore.
`dicpath`	`string`	The location to look for `.dic` and `.aff` files.
`dictionaries`	`array`	An array of dictionaries to load.

spelling implements spell checking based on Hunspell-compatible dictionaries.

Choosing a dictionary

By default, spelling includes a custom, open-source dictionary for American English. You may instead use the dictionaries key to list multiple custom dictionaries:

extends: spelling
message: "'%s' is a typo!"
dicpath: ../../fixtures/spelling/dics
dictionaries:
  - en_US
  - en_medical

The spelling extension point will look for en_US.{dic,aff} and en_medical.{dic,aff} files in $DICPATH, which you can set through an environment variable or the dicpath key.

Ignoring non-dictionary words

spelling offers two different ways of ignoring non-dictionary words:

Using ignore files: Ignore files are plain-text files that list words to be ignored during spell check (one case-insensitive entry per line) . For example,
ignore.txt
```
destructuring
transpiler
```
Here, we're instructing spelling to ignore both [Dd]estructuring and [Tt]ranspiler.
You can name these files anything you'd like and reference them relative to the active StylesPath:
```
extends: spelling
message: "Did you really mean '%s'?"
level: error
ignore:
  # Located at StylesPath/ignore1.txt
  - ignore1.txt
  - ignore2.txt
```

Using filters: You can also customize the spell-checking experience by defining filters, which are Go-compatible regular expressions to applied to individual words:

extends: spelling
message: "Did you really mean '%s'?"
level: error
# This disables the built-in filters. If you omit this
# key or set it to false, custom filters (see below) are
# added on top of the built-in ones.
#
# By default, filters for acronyms, abbreviations, and
# numbers are included.
custom: true
# A "filter" is a regular expression specifying words
# to ignore during spell checking.
filters:
  # Ignore all words starting with 'py'.
  #
  # e.g., 'PyYAML'.
  - '[pP]y.*\b'

`sequence`

Example definition

extends: sequence
message: "The infinitive '%[4]s' after 'be' requries 'to'. Did you mean '%[2]s %[3]s *to* %[4]s'?"
tokens:
  - tag: MD
  - pattern: be
  - tag: JJ
  - tag: VB|VBN

Key summary

Name	Type	Description
`tokens`	`[]NLPToken`	A list of tokens with associated NLP metadata.
`ignorecase`	`bool`	Makes all matches case-insensitive.

Unlike the other extension points, sequence aims to support grammar-focused rules (rather than "style"). Its built on top of prose (an open-source natural language processing library) and makes significant use of part-of-speech tagging.

An individual NLPToken has the following structure:

# [optional]: A regular expression (required
# if `tag` isn't given).
pattern: '...'

# [optional]: If true, indicates that we
# *shouldn't* match this token.
negate: true   # or false

# [optional]: A part-of-speech tag (required
# if `pattern` isn't given).
tag: '...'

# [optional]: An integer meaning that there may
# be up to `n` (3, in this case) tokens between
# this token and the next one.
skip: 3

The example rule illustrates the basics of the extension point: we're looking for a particular sequence of tokens (which can either be a regular expression or a part-of-speech tag). The | notation means that we'll accept VB or VBN in position 4.

There's also new notation in the message: %[4]s is like %s, but specifically refers to the 4th token in our sequence.

`script`

Example definition

extends: script
message: "Consider inserting a new section heading at this point."
link: https://tengolang.com/
# The unprocessed file contents.
#
# We need this to access heading markup.
scope: raw
script: |
  text := import("text")
  matches := []
  p_limit := 3 // at most 3 paragraphs per section
  // Remove all instances of code blocks since we don't want to count
  // inter-block newlines as a new paragraph.
  document := text.re_replace("(?s) *(\n```.*?```\n)", scope, "")
  count := 0
  for line in text.split(document, "\n") {
    if text.has_prefix(line, "#") {
      count = 0 // New section; reset count
    } else if count > p_limit {
      start := text.index(scope, line)
      matches = append(matches, {begin: start, end: start + len(line)})
      count = 0
    } else if text.trim_space(line) == "" {
      count += 1
    }
  }

Key summary

Name	Type	Description
`script`	`string`	The Tengo script to execute.

script allows for the creation of arbitrary logic-based rules using Tengo, a Go-like scripting language.

All scripts have access to Tengo's text module, which provides a number of string- and regex-related utility functions.

Additionally, all scripts are passed a global variable, scope, that contains the text of value of the rule's scope:. In our example definition, for instance, scope will be the entire, unprocessed document since the rule used scope: raw.

See Scoping for more information.

Built-in style

Heads up!

The built-in Vale.Spelling rule will respect an ignore file stored at StylesPath/vocab.txt. However, the recommended approach is to use a custom Vocab instead.

Vale comes with a single built-in style named Vale that implements three rules, as described in the table below.

Rule	Scope	Level	Description
`Vale.Spelling`	`text`	`error`	Spell checks text while respecting the active project's vocabulary.
`Vale.Terms`	`text`	`error`	Enforces the current project's `Preferred` vocabulary terms.
`Vale.Avoid`	`text`	`error`	Enforces the current project's `Do not use` vocabulary terms.

Third-party styles

Vale has a growing selection of pre-made styles available for download from its style library, and community-maintained styles you can find by searching for the "vale-linter-style" tag on GitHub.

Extension points​

Heads up!

existence​

Example definition​

Key summary​

substitution​

Example definition​

Key summary​

occurrence​

Example definition​

Key summary​

repetition​

Example definition​

Key summary​

consistency​

Example definition​

Key summary​

conditional​

Example definition​

Key summary​

capitalization​

Example definition​

Key summary​

metric​

Heads up!

Example definition​

Key summary​

spelling​

Heads up!

Example definition​

Key summary​

Choosing a dictionary​

Ignoring non-dictionary words​

sequence​

Example definition​

Key summary​

script​

Example definition​

Key summary​

Built-in style​

Heads up!

Third-party styles​

Extension points

`existence`

Example definition

Key summary

`substitution`

Example definition

Key summary

`occurrence`

Example definition

Key summary

`repetition`

Example definition

Key summary

`consistency`

Example definition

Key summary

`conditional`

Example definition

Key summary

`capitalization`

Example definition

Key summary

`metric`

Example definition

Key summary

`spelling`

Example definition

Key summary

Choosing a dictionary

Ignoring non-dictionary words

`sequence`

Example definition

Key summary

`script`

Example definition

Key summary

Built-in style

Third-party styles