Grammalecte  Artifact [3e9971cb59]

Artifact 3e9971cb59335de0c31773ed70aeb79e47048a1f96417e7c5849a036ac63bf80:

# Writing rules for Grammalecte #

Note: This documentation is a __draft__. Information may be obsolete or incomplete.


The rules file for your language must be named `rules.grx` in the folder `gc_lang/<lang>/`.
The settings file must be named `config.ini`.

These files are simple UTF-8 text files.


Grammalecte is a bi-passes grammar checker engine. On the first pass, the
engine checks the text paragraph by paragraph. On the second pass, the engine
check the text sentence by sentence.

You may alter how sentences are split by removing punctuation marks during the first pass.

The command to switch to the second pass is `[++]`.

In each pass, you can write as many rules as you need.

There are two kinds of rules:

* regex rules (triggered by a regular expression)
* token rules (triggered by a succession of tokens)

A regex rule is defined by:

* flags “LCR” for the regex word boundaries and case sensitiveness
* [optional] option name (the rule is active only if the option defined by user or config is active)
* [optional] rule name (named rules can be disabled by user or by config)
* [optional] priority number
* a regex pattern trigger
* a list of actions

A token rule is defined by:

* rule name
* [optional] priority number
* one or several lists of tokens
* a list of actions (the action is active only if the option defined by user or config is active)

Token rules must be defined within a graph.

Each graph is defined within the second pass with the command:

    @@@@GRAPH: graph_name|graph_code

A graph ends when another graph is defined or when is found the command:


There is no limit to the number of actions and the type of actions a rule can
launch. Each action has its own condition to be triggered.

There are several kinds of actions:

* Error warning, with a message, and optionally suggestions, and optionally a URL
* Text transformation, modifying internally the checked text
* Disambiguation action
* [second pass only] Tagging token
* [second pass only] Immunity rules

On the first pass, you can only write regex rules.
On the second pass, you can write regex rules and token rules. All tokens rules must be written within a graph.


            <<- condition ->> error_suggestions             # message_error|URL
            <<- condition ~>> text_rewriting
            <<- condition =>> commands_for_disambiguation

Patterns are written with the Python syntax for regular expressions:

There can be one or several actions for each rule, executed following the order they are

Optional: option, rulename, priority, condition, URL

LCR flags means:

* L: Left boundary for the regex
* C: Case sensitiveness
* R: Right boundary for the regex

Left boundary (L):

>   `[`     word boundary

>   `<`     no word boundary

right boundary (R):

>   `]`     word boundary

>   `>`     no word boundary

Case sensitiveness (C):

>   `i`     case insensitive

>   `s`     case sensitive

>   `u`     uppercase allowed for lowercase characters

>>          i.e.:  "Word"  becomes  "W[oO][rR][dD]"



User option activating/deactivating is possible with an option name placed
just after the LCR flags, i.e.:


Rules can be named:


Each rule name must be unique.

The LCR flags are also optional. If you don’t set these flags, the default LCR
flags will be:


Example. Report “foo” in the text and suggest “bar”:

    foo <<- ->> bar         # Use bar instead of foo.

Example. Recognize and suggest missing hyphen and rewrite internally the text
with the hyphen:

        foo bar
            <<- ->> foo-bar     # Missing hyphen.
            <<- ~>> foo-bar

### Simple-line or multi-line rules

Rules can be break to multiple lines by leading spaces.
You should use 4 spaces.


    __<s>__ pattern <<- condition ->> replacement # message

            <<- condition ->> replacement
            # message
            <<- condition ->> suggestion # message
            <<- condition ~>> text_rewriting
            <<- =>> disambiguation

### Whitespaces at the border of patterns or suggestions

Example: Recognize double or more spaces and suggests a single space:

    __<s>__  "  +" <<- ->> " "      # Remove extra space(s).

Characters `"` protect spaces in the pattern and in the replacement text.

### Pattern groups and back references

It is usually useful to retrieve parts of the matched pattern. We simply use
parenthesis in pattern to get groups with back references.

Example. Suggest a word with correct quotation marks:

    \"(\w+)\" <<- ->> “\1”      # Correct quotation marks.

Example. Suggest the missing space after the signs `!`, `?` or `.`:

    __<i]__  \b([?!.])([A-Z]+) <<- ->> \1 \2     # Missing space?

Example. Back reference in messages.

    (fooo) bar <<- ->> foo      # “\1” should be:

### Group positioning codes for JavaScript:

There is no way in JavaScript to know where a captured group starts and ends. To avoid misplacement, regex rules may specify group positioning codes which indicate to the grammar checker where is the position of the captured groups.

A group positioning code always begins by `@@`. If there is several codes, they are separated by a comma `,`.

Other codes:

    0 1 2 3 ... n       left boundary position from left
    -1 -2 -2 ... -n     right boundary position from right
    $                   extreme right boundary
    w                   somewhere with word boundaries
    *                   something somewhere
    **                  something somewhere after previous group


    ([A-ZÉÈÂÎ][\w-]+) [A-ZÉÈÂ]([.]) ([A-ZÉÈÂ][\w-]+)  @@0,*,$
    " ([?!;])"  @@1

### Pattern matching

Repeating pattern matching of a single rule continues after the previous matching, so instead of general multiword patterns, like

        (\w+) (\w+) <<- some_check(\1, \2) ->> \1, \2 # foo


        (\w+) <<- some_check(\1, word(1)) ->> \1, # foo


Token rules must be defined within a graph.

### Token rules syntax

            <<- /option/ condition ->> suggestions|URL
            <<- /option/ condition ~>> rewriting
            <<- /option/ condition =>> disambiguation
            <<- /option/ condition />> tagging
            <<- /option/ condition !>> <immunity>
            <<- action1
            <<- action2

With token rules, for one rule name, you can define several blocks of list of tokens with different kinds of actions. Each block must be separated by an empty line.

Optional: priority, option, condition, URL

### Tokens

Tokens can be defined in several ways:

* Value (the text of the token). Examples: `word`, `<start>`, `<end>`, `,`.
* Lemma: `>lemma`.
* Regex: `~pattern`, `~pattern¬antipattern`.
* Regex on morphologies: `@pattern`, `@pattern¬antipattern`.
* Tags: `/tag`.
* Metatags: *NAME. Examples: `*WORD`, `*NUM`, `*SIGN`, etc.
* Jump over token: `<>`

Selection of tokens: `[value1|value2||>lemma|~pattern|@pattern|*META|/tag|…]`

Conditional token: `?token¿`

Conditional selection of token: `?[token1|token2|…]¿`

### Token references

Positive references are defined by a positive integer (> 0). Examples: `\1`, `\2`, `\3`, etc.
If there is at least one token set between parenthesis, these numbers refer to tokens between parenthesis, ignoring all others.
If there is no token between parenthesis, these numbers refer to tokens found in order defined by the rule triggered.

Negative references are defined by a negative integer (< 0). Examples: `\-1`, `\-2`, `\-3`, etc.
These numbers refer to the tokens beginning by the last one found by the rule triggered.


    tokens:             alpha       beta        gamma       delta       epsilon
    positive refs:      1           2           3           4           5
    negative refs:      -5          -4          -3          -2          -1

    tokens:             alpha       (beta)      gamma       (delta)     epsilon
    positive refs:                  1                       2
    negative refs:      -5          -4          -3          -2          -1

    tokens:             alpha       (beta)      ?gamma¿     (delta)     epsilon
    positive refs:                  1                       2
    negative refs:      (-5/-4)     (-4/-3)     (-3/none)   -2          -1


Conditions are Python expressions, they must return a value, which will be
evaluated as boolean. You can use the usual Python syntax and libraries.

With regex rules, you can call pattern subgroups via `\1`, `\2`… `\0` is the full pattern.


    these (\w+)
        <<- \1 == "man" -1>> men        # Man is a singular noun.

You can also apply functions to subgroups like: `\1.startswith("a")` or `\3.islower()` or `"pattern", \2)`.

With token rules, you can also call each token with their reference, like `\1`, `\2`... or `\-1`, `\-2`...


    foo [really|often|sometimes] bar
        <<- ->> \1 \-1                  # We say “foo bar”.

### Functions for regex rules


>   Catches the nth next word after the pattern (separated only by white spaces).
>   Returns None if no word caught


>   Catches the nth next word before the pattern (separated only by white spaces).
>   Returns None if no word caught

`textarea(regex[, neg_regex])`

>    Checks if the full text of the checked area (paragraph or sentence) matches the regex.

`morph(n, regex[, neg_regex][, no_word=False])`

>   Checks if all tags of the word in group n match the regex.
>   If neg_regex = "*", returns True only if all morphologies match the regex.
>   If there is no word at position n, returns the value of no_word.

`analyse(n, regex[, neg_regex][, no_word=False])`

>   Checks if all tags of the word in group n match the regex.
>   If neg_regex = "*", returns True only if all morphologies match the regex.
>   If there is no word at position n, returns the value of no_word.

### Functions for token rules

`value(n, values_string)`

>   Analyses the value of the nth token.
>   The <values_string> contains values separated by the sign `|`.
>   Example: `"|foo|bar|"`

`morph(n, "regex"[, "neg_regex"][, trim_left=0][, trim_right=0])`
`analyse(n, "regex"[, "neg_regex"][, trim_left=0][, trim_right=0])`

>   Same action with `morph()` and `morph0()` for regex rules.
>   Parameters <trim_left> and <trim_right> removed n characters at left or the right of the token before performing an analyse.

`space_after(n, min_space[, max_space])`

>   Returns True if the next token after token n is separated with at least <min_space> blank spaces and at most with <max_space> blank spaces.

`tag(n, tag)`

>   Returns True if <tag> exists on taken the nth token.

`tag_before(n, tag)`

>   Returns True if <tag> is found any token before the nth tag.
`tag_after(n, tag)`

>   Returns True if <tag> is found any token after the nth tag.

### Functions for regex and token rules


>   Returns True if the previous condition returned True.
>   Example: `<<- __also__ and condition2 ->>`


>   Returns False if the previous condition returned False.
>   Example: `<<- __else__ and condition2 ->>`


>   Returns True if <option_name> is activated else False

Note: the analysis is done on the preprocessed text.

`after(regex[, neg_regex])`

>   Checks if the text after the pattern matches the regex.

`before(regex[, neg_regex])`

>   Checks if the text before the pattern matches the regex.

### Default variables


>   Contains the current country locale of the checked paragraph.

    colour <<- sCountry == "US" ->> color   # Use American English spelling.


There are 5 kinds of actions:

1. Suggestions. The grammar checker suggests corrections.
2. Text processor. A internal process to modify the text internally. This is used to simplify grammar checking.
     * text rewriting
     * text deletion
     * token rewriting
     * token merging
     * token deletion
3. Disambiguation. Select, exclude or define morphologies of tokens.
4. Tagging. Add information on token.
5. Immunity. Prevent suggestions to be triggered.

### Positioning

Positioning is valid for suggestions, text processing, tagging and immunity.

By default, rules apply on the full text triggered. You can shorten the
effect of rules by specifying a back reference group of the pattern or token references.

Instead of writing `->>`, write `-n>>`  n being the number of a back reference
group. Actually,  `->>`  is similar to  `-0>>`.


    (ying) and yang <<- -1>> yin # Did you mean:

    __[s]__ (Mr.) [A-Z]\w+ <<- ~1>> Mr


Rule A:

    ying and yang       <<- ->>     yin and yang        # Did you mean:

Rule B:

    (ying) and yang     <<- -1>>    yin                 # Did you mean:

With the rule A, the full pattern is underlined:

    ying and yang

With the rule B, only the first group is underlined:

    ying and yang

### Errors and suggestions

The command to suggest something is: `->>`.

#### Multiple suggestions

Use `|` in the replacement text to add multiple suggestions:

Example. Foo, FOO, Bar and BAR suggestions for the input word "foo".

    foo <<- ->> Foo|FOO|Bar|BAR         # Did you mean:

#### No suggestion

You can display message without making suggestions. For this purpose,
use a single character _ in the suggestion field.

Example. No suggestion.

    foobar <<- ->> _                    # Message

#### Longer explanations with URLs

Warning messages can contain optional URL for longer explanations.

        <<- ->> yours
            # Possessive pronoun:|

#### Expressions in suggestion or replacement

Suggestions started by an equal sign are Python string expressions extended with possible back references and named definitions:


    <<- ->> ='"' + \1.upper() + '"'      # With uppercase letters and quotation marks
    <<- ~>> =\1.upper()

### Text rewriting

**WARNING**: The replacing text must be shorter than the replaced text or have the same length. Breaking this rule will misplace following error reports.
You have to ensure yourself the rules comply with this constraint, the text processor won’t do it for you.

The command for text rewriting is: `~>>`.

Example. Replacing a string by another.

    Mr. [A-Z]\w+ <<- ~>> Mister

Specific commands for text rewriting:

`~>> *`

>   Replace by whitespaces

`~>> @`

>   Replace with the at sign, useful mostly at first pass, where it is advised to check usage of punctuations and whitespaces.
>   Successions of @ are automatically removed at the beginning of the second pass.

`~>> _`

>   Replace with underscores. Just a filler.
>   These characters won’t be removed at the beginning of the second pass.

You can use positioning with text rewriting actions.

    Mr(. [A-Z]\w+) <<- ~1>> *

You can also call Python expressions.

    __[s]__ Mr. ([a-z]\w+) <<- ~1>> =\1.upper()

The text processor is useful to simplify texts and write simpler checking

For example, sentences with the same grammar mistake:

    These “cats” are blacks.
    These cats are “blacks”.
    These cats are absolutely blacks.
    These stupid “cats” are all blacks.
    These unknown cats are as per usual blacks.

Instead of writing complex rules or several rules to find mistakes for all possible cases, you can use the text preprocessor to simplify the text.

To remove the chars “”, write:

    [“”] ~>> *

The * means: replace text by whitespaces.

Similarly to grammar rules, you can add conditions:

    \w+ly <<- morph(\0, "adverb") ~>> *

You can also remove a group reference:

    these (\w+) (\w+) <<- morph(\1, "adjective") and morph(\2, "noun") ~1>> *
    (am|are|is|were|was) (all) <<- ~2>> *
    as per usual <<- ~>> *

With these rules, you get the following sentences:

    These  cats  are blacks.
    These cats are  blacks .
    These cats are            blacks.
    These         cats  are     blacks.
    These         cats are              blacks.

These grammar mistakes can be detected with one simple rule:

    these +(\w+) +are +(\w+s)
        <<- morph(\1, "noun") and morph(\2, "plural")
        -2>> _              # Adjectives are invariable.

Instead of replacing text with whitespaces, you can replace text with @.

    https?://\S+ <<- ~>> @

This is useful if at first pass you write rules to check successive whitespaces.
@ are automatically removed at the second pass.

You can also replace any text as you wish.

    Mister <<- ~>> Mr
    (Mrs?)[.] <<- ~>> \1

### Disambiguation

When the grammar checker analyses a token with `morph()`, before requesting the POS tags to the dictionary, it checks if there is a stored marker for the position of the token. If a marker is found, it uses the stored data and don’t make request to the dictionary.

The command for disambiguation is: `=>>`. No positioning allowed.

There are 4 commands for disambiguation.

`select(n, pattern)`

>   At reference n, select morphologies that match the pattern.

`exclude(n, pattern)`

>   At reference n, exclude morphologies that match the pattern.

`define(n, [morph_list])`

>   At reference n, set the listed morphologies (a list of strings).

`add_morph(n, [morph_list])`

>   At reference n, add the listed morphologies (a list of strings).


    =>> select(\1, "po:noun is:pl")
    =>> exclude(\1, "po:verb")
    =>> exclude(\1, "po:verb") and define(\2, ["po:adv"]) and select(\3, "po:adv")

Note: All these functions ALWAYS return True.

If `select()` and `exclude()` generate an empty list, nothing change.

With `define()` and `add_morph()`, you must set a list of POS tags. Example:

    =>> define(\1, ["po:nom is:plur", "po:adj is:sing", "po:adv"])
    =>> add_morph(\1, ["po:adv"])

### Tagging

**Only for token rules**. Tagging can be done with the command `/>>`. You can set one or several tags at once. Use `|` as a separator.

Example: `/>> a_tag` to set the same tag on all takens of the rule.
Example: `/3>> a_tag` to set the tag on the third token.
Example: `/>> a_tag|another_tag` to set two tags.

You can know if a token is tagged with eh function `tag()` and you can know if tags have been set on previous or following tokens with `tag_before()` and `tag_after()`.

### Immunity

**Only for token rules**. A immunity rule set a flag on token(s) who are not supposed to be considered as an error. If any other rules find an error, it will be ignored. If an error has already been found, it will be removed.

Example: `!2>>` means no error can be set on the second token.
Example: `!>>` means all tokens will be considered as correct.

The immunity rules are useful to create simple antipattern that will simplify writing of other rules.


### Comments

Lines beginning with `#` are comments.

### End of parsing

With the command `#END` at the beginning of a line, the parser won’t go further.
Whatever is written after will be considered as comments.

### Definitions

Grammalecte supports definitions to simplify the description of complex rules.


    DEF: name definition

Usage: `{name}` will be replaced by its definition


    DEF: word_3_letters     \w\w\w+  
    DEF: uppercase_token    ~^[A-Z]+$
    DEF: month_token        [January|February|March|April|May|June|July|August|September|October|November|december]

    ({word_3_letters}) (\w+) <<- condition ->> suggestion     # message|URL

    {uppercase_token} {month_token}
        <<- condition ->> message                             # message|URL