SpellingCheckRule (LanguageTool 6.4-SNAPSHOT API)

java.lang.Object
- org.languagetool.rules.Rule
- - org.languagetool.rules.spelling.SpellingCheckRule

Direct Known Subclasses:

HunspellRule, MorfologikSpellerRule, SymSpellRule
```
public abstract class SpellingCheckRule
extends Rule
```
An abstract rule for spellchecking rules.

Author:

Marcin Miłkowski

Field Summary

Fields
Modifier and Type	Field and Description
`protected static String`	`CUSTOM_SPELLING_FILE`
`protected static String`	`GLOBAL_SPELLING_FILE`
`static float`	`HIGH_CONFIDENCE` The confidence value for a suggestion with high confidence.
`protected int`	`ignoreWordsWithLength`
`protected Language`	`language`
`protected LanguageModel`	`languageModel`
`static String`	`LANGUAGETOOL` The string `LanguageTool`.
`static String`	`LANGUAGETOOLER` The string `LanguageTooler`.
`static int`	`MAX_TOKEN_LENGTH`
`protected CachingWordListLoader`	`wordListLoader`
`protected Set<String>`	`wordsToBeIgnored`

Fields inherited from class org.languagetool.rules.Rule
messages

Constructor Summary

Constructors
Constructor and Description
`SpellingCheckRule(ResourceBundle messages, Language language, UserConfig userConfig)`
`SpellingCheckRule(ResourceBundle messages, Language language, UserConfig userConfig, List<Language> altLanguages)`
`SpellingCheckRule(ResourceBundle messages, Language language, UserConfig userConfig, List<Language> altLanguages, LanguageModel languageModel)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`acceptPhrases(List<String> phrases)` Accept (case-sensitively, unless at the start of a sentence) the given phrases even though they are not in the built-in dictionary.
`void`	`addIgnoreTokens(List<String> tokens)` Add the given words to the list of words to be ignored during spell check.
`protected void`	`addIgnoreWords(String line)`
`protected void`	`addProhibitedWords(List<String> words)`
`protected static void`	`addSuggestionsToRuleMatch(String word, List<SuggestedReplacement> userCandidatesList, List<SuggestedReplacement> candidatesList, SuggestionsOrderer orderer, RuleMatch match)`
`protected RuleMatch`	`createWrongSplitMatch(AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int pos, String coveredWord, String suggestion1, String suggestion2, int prevPos)`
`protected List<String>`	`expandLine(String line)` Expand suffixes in a line.
`protected static <T> List<T>`	`filterDupes(List<T> words)`
`protected List<SuggestedReplacement>`	`filterNoSuggestWords(List<SuggestedReplacement> l)`
`protected List<SuggestedReplacement>`	`filterSuggestions(List<SuggestedReplacement> suggestions)` Remove prohibited words from suggestions.
`protected List<String>`	`getAdditionalProhibitFileNames()` Get the name of the prohibit file, which lists words not to be accepted, even when the spell checker would accept them.
`List<String>`	`getAdditionalSpellingFileNames()` Get the name of additional spelling file, which lists words to be accepted and used for suggestions, even when the spell checker would not accept them.
`protected List<SuggestedReplacement>`	`getAdditionalSuggestions(List<SuggestedReplacement> suggestions, String word)` Get additional suggestions added after other suggestions (note the rule may choose to re-order the suggestions anyway).
`protected List<SuggestedReplacement>`	`getAdditionalTopSuggestions(List<SuggestedReplacement> suggestions, String word)` Get additional suggestions added before other suggestions (note the rule may choose to re-order the suggestions anyway).
`List<DisambiguationPatternRule>`	`getAntiPatterns()` Overwrite this to avoid false alarms by ignoring these patterns - note that your `Rule.match(AnalyzedSentence)` method needs to call `Rule.getSentenceWithImmunization(org.languagetool.AnalyzedSentence)` for this to be used and you need to check `AnalyzedTokenReadings.isImmunized()`
`abstract String`	`getDescription()` A short description of the error this rule can detect, usually in the language of the text that is checked.
`abstract String`	`getId()` A string used to identify the rule in e.g. configuration files.
`protected String`	`getIgnoreFileName()` Get the name of the ignore file, which lists words to be accepted, even when the spell checker would not accept them.
`String`	`getLanguageVariantSpellingFileName()` Get the name of the spelling file for a language variant (e.g., en-US or de-AT), which lists words to be accepted and used for suggestions, even when the spell checker would not accept them.
`protected List<SuggestedReplacement>`	`getOnlySuggestions(String word)` Get suggestions that will replace all other suggestions.
`protected String`	`getProhibitFileName()` Get the name of the prohibit file, which lists words not to be accepted, even when the spell checker would accept them.
`String`	`getSpellingFileName()` Get the name of the spelling file, which lists words to be accepted and used for suggestions, even when the spell checker would not accept them.
`protected boolean`	`ignorePotentiallyMisspelledWord(String words)` Like `ignoreWord(String)`, but will only be called after the standard spell check has run and considered this word to be incorrect.
`protected boolean`	`ignoreToken(AnalyzedTokenReadings[] tokens, int idx)` Returns true iff the token at the given position should be ignored by the spell checker.
`protected boolean`	`ignoreWord(List<String> words, int idx)` Returns true iff the word at the given position should be ignored by the spell checker.
`protected boolean`	`ignoreWord(String word)` Returns true iff the word should be ignored by the spell checker.
`protected void`	`init()`
`boolean`	`isDictionaryBasedSpellingRule()` Whether this is a spelling rule that uses a dictionary.
`protected static boolean`	`isEMail(String token)`
`protected boolean`	`isIgnoredNoCase(String word)`
`protected boolean`	`isInIgnoredSet(String word)`
`protected boolean`	`isLatinScript()`
`abstract boolean`	`isMisspelled(String word)`
`protected boolean`	`isProhibited(String word)` Whether the word is prohibited, i.e. whether it should be marked as a spelling error even if the spell checker would accept it.
`protected static boolean`	`isUrl(String token)`
`abstract RuleMatch[]`	`match(AnalyzedSentence sentence)` Check whether the given sentence matches this error rule, i.e. whether it contains the error detected by this rule.
`void`	`setConsiderIgnoreWords(boolean considerIgnoreWords)` Set whether the list of words to be explicitly ignored (set with `addIgnoreTokens(List)`) is considered at all.
`void`	`setConvertsCase(boolean convertsCase)` Used to determine whether the dictionary will use case conversions for spell checking.
`protected int`	`startsWithIgnoredWord(String word, boolean caseSensitive)` Checks whether a `word` starts with an ignored word.
`protected boolean`	`tokenizeNewWords()`

Methods inherited from class org.languagetool.rules.Rule
addExamplePair, addTags, addToneTags, cacheAntiPatterns, estimateContextForSureMatch, getCategory, getConfigureText, getCorrectExamples, getDefaultValue, getDistanceTokens, getErrorTriggeringExamples, getFullId, getIncorrectExamples, getLocQualityIssueType, getMaxConfigurableValue, getMinConfigurableValue, getMinPrevMatches, getSentenceWithImmunization, getSourceFile, getSubId, getTags, getToneTags, getUrl, hasConfigurableValue, hasTag, hasToneTag, isDefaultOff, isDefaultTempOff, isGoalSpecific, isOfficeDefaultOff, isOfficeDefaultOn, isPremium, makeAntiPatterns, setCategory, setCorrectExamples, setDefaultOff, setDefaultOn, setDefaultTempOff, setDistanceTokens, setErrorTriggeringExamples, setExamplePair, setGoalSpecific, setIncorrectExamples, setLocQualityIssueType, setMinPrevMatches, setOfficeDefaultOff, setOfficeDefaultOn, setPremium, setTags, setToneTags, setUrl, supportsLanguage, toRuleMatchArray, useInOffice

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - HIGH_CONFIDENCE
```
public static final float HIGH_CONFIDENCE
```
    The confidence value for a suggestion with high confidence. Not 1.0, as even with a high confidence, we might still be wrong.
    
    See Also:
    
    Constant Field Values
  - LANGUAGETOOL
```
public static final String LANGUAGETOOL
```
    The string LanguageTool.
    
    Since:
    
    2.3
    
    See Also:
    
    Constant Field Values
  - LANGUAGETOOLER
```
public static final String LANGUAGETOOLER
```
    The string LanguageTooler.
    
    Since:
    
    4.4
    
    See Also:
    
    Constant Field Values
  - MAX_TOKEN_LENGTH
```
public static final int MAX_TOKEN_LENGTH
```
    See Also:
    
    Constant Field Values
  - language
```
protected final Language language
```
  - languageModel
```
@Nullable
protected LanguageModel languageModel
```
    Since:
    
    4.5 For rules from @see Language.getRelevantLanguageModelCapableRules Optional, allows e.g. better suggestions when set
  - wordListLoader
```
protected final CachingWordListLoader wordListLoader
```
  - CUSTOM_SPELLING_FILE
```
protected static final String CUSTOM_SPELLING_FILE
```
    See Also:
    
    Constant Field Values
  - GLOBAL_SPELLING_FILE
```
protected static final String GLOBAL_SPELLING_FILE
```
    See Also:
    
    Constant Field Values
  - wordsToBeIgnored
```
protected final Set<String> wordsToBeIgnored
```
  - ignoreWordsWithLength
```
protected int ignoreWordsWithLength
```
- Constructor Detail
  - SpellingCheckRule
```
public SpellingCheckRule(ResourceBundle messages,
                         Language language,
                         UserConfig userConfig)
```
  - SpellingCheckRule
```
public SpellingCheckRule(ResourceBundle messages,
                         Language language,
                         UserConfig userConfig,
                         List<Language> altLanguages)
```
    Since:
    
    4.4
  - SpellingCheckRule
```
public SpellingCheckRule(ResourceBundle messages,
                         Language language,
                         UserConfig userConfig,
                         List<Language> altLanguages,
                         @Nullable
                         LanguageModel languageModel)
```
    Since:
    
    4.5
- Method Detail
  - addSuggestionsToRuleMatch
```
protected static void addSuggestionsToRuleMatch(String word,
                                                List<SuggestedReplacement> userCandidatesList,
                                                List<SuggestedReplacement> candidatesList,
                                                @Nullable
                                                SuggestionsOrderer orderer,
                                                RuleMatch match)
```
    Parameters:
    
    word - misspelled word that suggestions should be generated for
    
    userCandidatesList - candidates from personal dictionary
    
    candidatesList - candidates from default dictionary
    
    orderer - model to rank suggestions / extract features, or null
    
    match - rule match to add suggestions to
  - createWrongSplitMatch
```
protected RuleMatch createWrongSplitMatch(AnalyzedSentence sentence,
                                          List<RuleMatch> ruleMatchesSoFar,
                                          int pos,
                                          String coveredWord,
                                          String suggestion1,
                                          String suggestion2,
                                          int prevPos)
```
  - getId
```
public abstract String getId()
```
    Description copied from class: Rule
    
    A string used to identify the rule in e.g. configuration files. This string is supposed to be unique and to stay the same in all upcoming versions of LanguageTool. It's supposed to contain only the characters A-Z and the underscore.
    
    Specified by:
    
    getId in class Rule
  - getDescription
```
public abstract String getDescription()
```
    Description copied from class: Rule
    
    A short description of the error this rule can detect, usually in the language of the text that is checked.
    
    Specified by:
    
    getDescription in class Rule
  - match
```
public abstract RuleMatch[] match(AnalyzedSentence sentence)
                           throws IOException
```
    Description copied from class: Rule
    
    Check whether the given sentence matches this error rule, i.e. whether it contains the error detected by this rule. Note that the order in which this method is called is not always guaranteed, i.e. the sentence order in the text may be different from the order in which you get the sentences (this may be the case when LanguageTool is used as a LibreOffice/OpenOffice add-on, for example). In other words, implementations must be stateless, so that a previous call to this method has no influence on later calls.
    
    Specified by:
    
    match in class Rule
    
    Parameters:
    
    sentence - a pre-analyzed sentence
    
    Returns:
    
    an array of RuleMatch objects
    
    Throws:
    
    IOException
  - isMisspelled
```
@Experimental
public abstract boolean isMisspelled(String word)
                                            throws IOException
```
    Throws:
    
    IOException
    
    Since:
    
    4.8
  - isDictionaryBasedSpellingRule
```
public boolean isDictionaryBasedSpellingRule()
```
    Description copied from class: Rule
    
    Whether this is a spelling rule that uses a dictionary. Rules that return true here are basically rules that work like a simple hunspell-like spellchecker: they check words without considering the words' context.
    
    Overrides:
    
    isDictionaryBasedSpellingRule in class Rule
  - addIgnoreTokens
```
public void addIgnoreTokens(List<String> tokens)
```
    Add the given words to the list of words to be ignored during spell check. You might want to use acceptPhrases(List) instead, as only that can also deal with phrases.
  - setConsiderIgnoreWords
```
public void setConsiderIgnoreWords(boolean considerIgnoreWords)
```
    Set whether the list of words to be explicitly ignored (set with addIgnoreTokens(List)) is considered at all.
  - getAdditionalTopSuggestions
```
protected List<SuggestedReplacement> getAdditionalTopSuggestions(List<SuggestedReplacement> suggestions,
                                                                 String word)
                                                          throws IOException
```
    Get additional suggestions added before other suggestions (note the rule may choose to re-order the suggestions anyway). Only add suggestions here that you know are spelled correctly, they will not be checked again before being shown to the user.
    
    Throws:
    
    IOException
  - getOnlySuggestions
```
protected List<SuggestedReplacement> getOnlySuggestions(String word)
```
    Get suggestions that will replace all other suggestions. Only add suggestions here that you know are spelled correctly, they will not be checked again before being shown to the user.
  - getAdditionalSuggestions
```
protected List<SuggestedReplacement> getAdditionalSuggestions(List<SuggestedReplacement> suggestions,
                                                              String word)
```
    Get additional suggestions added after other suggestions (note the rule may choose to re-order the suggestions anyway).
  - ignoreToken
```
protected boolean ignoreToken(AnalyzedTokenReadings[] tokens,
                              int idx)
                       throws IOException
```
    Returns true iff the token at the given position should be ignored by the spell checker. Use ignorePotentiallyMisspelledWord(String) if the check you want to implement is slightly computationally expensive.
    
    Throws:
    
    IOException
  - ignoreWord
```
protected boolean ignoreWord(String word)
                      throws IOException
```
    Returns true iff the word should be ignored by the spell checker. If possible, use ignoreToken(AnalyzedTokenReadings[], int) instead.
    
    Throws:
    
    IOException
  - isInIgnoredSet
```
protected boolean isInIgnoredSet(String word)
```
  - isIgnoredNoCase
```
protected boolean isIgnoredNoCase(String word)
```
  - ignoreWord
```
protected boolean ignoreWord(List<String> words,
                             int idx)
                      throws IOException
```
    Returns true iff the word at the given position should be ignored by the spell checker. If possible, use ignoreToken(AnalyzedTokenReadings[], int) instead.
    
    Throws:
    
    IOException
    
    Since:
    
    2.6
  - ignorePotentiallyMisspelledWord
```
protected boolean ignorePotentiallyMisspelledWord(String words)
                                           throws IOException
```
    Like ignoreWord(String), but will only be called after the standard spell check has run and considered this word to be incorrect. This way, tests run here can be a bit more computationally expensive.
    
    Throws:
    
    IOException
  - setConvertsCase
```
public void setConvertsCase(boolean convertsCase)
```
    Used to determine whether the dictionary will use case conversions for spell checking.
    
    Parameters:
    
    convertsCase - if true, then conversions are used.
    
    Since:
    
    2.5
  - isUrl
```
protected static boolean isUrl(String token)
```
  - isEMail
```
protected static boolean isEMail(String token)
```
  - filterDupes
```
protected static <T> List<T> filterDupes(List<T> words)
```
  - init
```
protected void init()
             throws IOException
```
    Throws:
    
    IOException
  - getIgnoreFileName
```
protected String getIgnoreFileName()
```
    Get the name of the ignore file, which lists words to be accepted, even when the spell checker would not accept them. Unlike with getSpellingFileName() the words in this file will not be used for creating suggestions for misspelled words.
    
    Since:
    
    2.7
  - getSpellingFileName
```
public String getSpellingFileName()
```
    Get the name of the spelling file, which lists words to be accepted and used for suggestions, even when the spell checker would not accept them.
    
    Since:
    
    2.9, public since 3.5
  - getAdditionalSpellingFileNames
```
public List<String> getAdditionalSpellingFileNames()
```
    Get the name of additional spelling file, which lists words to be accepted and used for suggestions, even when the spell checker would not accept them.
    
    Since:
    
    4.8
  - getLanguageVariantSpellingFileName
```
public String getLanguageVariantSpellingFileName()
```
    Get the name of the spelling file for a language variant (e.g., en-US or de-AT), which lists words to be accepted and used for suggestions, even when the spell checker would not accept them.
    
    Since:
    
    4.3
  - getProhibitFileName
```
protected String getProhibitFileName()
```
    Get the name of the prohibit file, which lists words not to be accepted, even when the spell checker would accept them.
    
    Since:
    
    2.8
  - getAdditionalProhibitFileNames
```
protected List<String> getAdditionalProhibitFileNames()
```
    Get the name of the prohibit file, which lists words not to be accepted, even when the spell checker would accept them.
    
    Since:
    
    2.8
  - isProhibited
```
protected boolean isProhibited(String word)
```
    Whether the word is prohibited, i.e. whether it should be marked as a spelling error even if the spell checker would accept it. (This is useful to improve our spell checker without waiting for the upstream checker to be updated.)
    
    Since:
    
    2.8
  - filterSuggestions
```
protected List<SuggestedReplacement> filterSuggestions(List<SuggestedReplacement> suggestions)
```
    Remove prohibited words from suggestions.
    
    Since:
    
    2.8
  - filterNoSuggestWords
```
protected List<SuggestedReplacement> filterNoSuggestWords(List<SuggestedReplacement> l)
```
  - addIgnoreWords
```
protected void addIgnoreWords(String line)
```
    Parameters:
    
    line - the line as read from spelling.txt.
    
    Since:
    
    2.9, signature modified in 3.9
  - addProhibitedWords
```
protected void addProhibitedWords(List<String> words)
```
    Parameters:
    
    words - list of words to be prohibited.
    
    Since:
    
    4.2
  - expandLine
```
protected List<String> expandLine(String line)
```
    Expand suffixes in a line. By default, the line is not expanded. Implementations might e.g. turn bicycle/S into [bicycle, bicycles].
    
    Since:
    
    3.0
  - acceptPhrases
```
public void acceptPhrases(List<String> phrases)
```
    Accept (case-sensitively, unless at the start of a sentence) the given phrases even though they are not in the built-in dictionary. Use this to avoid false alarms on e.g. names and technical terms. Unlike addIgnoreTokens(List) this can deal with phrases. A way to call this is like this: rule.acceptPhrases(Arrays.asList("duodenal atresia")) This way, checking would not create an error for "duodenal atresia", but it would still create and error for "duodenal" or "atresia" if they appear on their own.
    
    Since:
    
    3.3
  - getAntiPatterns
```
public List<DisambiguationPatternRule> getAntiPatterns()
```
    Description copied from class: Rule
    
    Overwrite this to avoid false alarms by ignoring these patterns - note that your Rule.match(AnalyzedSentence) method needs to call Rule.getSentenceWithImmunization(org.languagetool.AnalyzedSentence) for this to be used and you need to check AnalyzedTokenReadings.isImmunized()
    
    Overrides:
    
    getAntiPatterns in class Rule
  - startsWithIgnoredWord
```
protected int startsWithIgnoredWord(String word,
                                    boolean caseSensitive)
```
    Checks whether a word starts with an ignored word. Note that a minimum word-length of 4 characters is expected. (This is for better performance. Moreover, such short words are most likely contained in the dictionary.)
    
    Parameters:
    
    word - - entire word
    
    caseSensitive - - determines whether the check is case-sensitive
    
    Returns:
    
    length of the ignored word (i.e., return value is 0, if the word does not start with an ignored word). If there are several matches from the set of ignored words, the length of the longest matching word is returned.
    
    Since:
    
    3.5
  - tokenizeNewWords
```
protected boolean tokenizeNewWords()
```
  - isLatinScript
```
protected boolean isLatinScript()
```

Class SpellingCheckRule

Field Summary

Fields inherited from class org.languagetool.rules.Rule

Constructor Summary

Method Summary

Methods inherited from class org.languagetool.rules.Rule

Methods inherited from class java.lang.Object

Field Detail

HIGH_CONFIDENCE

LANGUAGETOOL

LANGUAGETOOLER

MAX_TOKEN_LENGTH

language

languageModel

wordListLoader

CUSTOM_SPELLING_FILE

GLOBAL_SPELLING_FILE

wordsToBeIgnored

ignoreWordsWithLength

Constructor Detail

SpellingCheckRule

SpellingCheckRule

SpellingCheckRule

Method Detail

addSuggestionsToRuleMatch

createWrongSplitMatch

getId

getDescription

match

isMisspelled

isDictionaryBasedSpellingRule

addIgnoreTokens

setConsiderIgnoreWords

getAdditionalTopSuggestions

getOnlySuggestions

getAdditionalSuggestions

ignoreToken

ignoreWord

isInIgnoredSet

isIgnoredNoCase

ignoreWord

ignorePotentiallyMisspelledWord

setConvertsCase

isUrl

isEMail

filterDupes

init

getIgnoreFileName

getSpellingFileName

getAdditionalSpellingFileNames

getLanguageVariantSpellingFileName

getProhibitFileName

getAdditionalProhibitFileNames

isProhibited

filterSuggestions

filterNoSuggestWords

addIgnoreWords

addProhibitedWords

expandLine

acceptPhrases

getAntiPatterns

startsWithIgnoredWord

tokenizeNewWords

isLatinScript