Package org.languagetool.rules.de

Class GermanSpellerRule

java.lang.Object

org.languagetool.rules.Rule

org.languagetool.rules.spelling.SpellingCheckRule

org.languagetool.rules.spelling.hunspell.HunspellRule

org.languagetool.rules.spelling.hunspell.CompoundAwareHunspellRule

org.languagetool.rules.de.GermanSpellerRule

Direct Known Subclasses:

AustrianGermanSpellerRule, SwissGermanSpellerRule

public class GermanSpellerRule
extends CompoundAwareHunspellRule

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	GermanSpellerRule.ExpandingReader

Field Summary

Fields

Modifier and Type	Field	Description
private static final Map<StringMatcher,Function<String,List<String>>>	ADDITIONAL_SUGGESTIONS
private static final String	adjSuffix
private static final Pattern	ALLMAHLLIG
private static final Pattern	ARBEIT_COMP
private static final Pattern	AUTENTISCH_WITH_CASES
private static final Pattern	BACH_COMP
private static final Pattern	BAD_COMP
private static final Pattern	BRILLIANT_WITH_CASES
private static final Pattern	CAMEL_CASE
private static final Pattern	CITIES_EXCEPTIONS
private static final Pattern	COMPOUND_END_TYPOS
private static final Pattern	COMPOUND_TYPOS
private static final Pattern	compoundPatternSpecialEnding
private static final Pattern	compoundPatternWithAction
private static final Pattern	compoundPatternWithFirst
private static final Pattern	compoundPatternWithHeit
private final GermanCompoundTokenizer	compoundTokenizer
private static final Pattern	CONFUSED_PREFIXES
private static final Pattern	CONTAINS_MASZNAME
private static final Pattern	CONTAINS_MAYONNAISE
private static final Pattern	CONTAINS_NEGER
private static final Pattern	CONTAINS_NEGER_2
private static final Pattern	CONTAINS_RESERVIERUNG
private static final Pattern	CONTAINS_UNCOMMON_LOWERCASED_NOUN_AT_BEGINNING
private static final Pattern	CONTAINS_UNCOMMON_LOWERCASED_NOUN_AT_END
private static final Pattern	DIRECTION
private static final Pattern	END_WITH_SCHAFTE
private static final Pattern	ENDS_WITH_IBELKEIT_IBLICHKEIT
private static final Pattern	ENDS_WITH_LABORANTS
private static final Pattern	EXPAND_PATTERN
private static final Pattern	FILE_UNDERLINE_PATTERN
private static final Pattern	FIRST_UPPER_CASE
private static final Pattern	GENDER_NEUTRAL_SLASH_HYPHEN
private static final Pattern	GENDER_NEUTRAL_SPECIAL_CHRS_PLU
private static final Pattern	GENDER_NEUTRAL_SPECIAL_CHRS_SIN
private static final Pattern	GENDER_STAR
private static final Pattern	GENDER_STAR_PATTERN
private static final Pattern	GENDER2_STAR2
private static final Pattern	HOLZ_SPIEGEL_PANEL_COMPOUND
private static final Pattern	HYPHENED_UPPER_WORD
private static final Pattern	HYPHENED_WORD
private static final Pattern	INFIX_S_SUFFIXES
private static final Pattern	INVALID_COMP_PART_1
private static final Pattern	INVALID_COMP_PART_2
private static final Set<String>	lcDoNotSuggestWords
private final LineExpander	lineExpander
private static final Pattern	LINK_COMP
private static final Pattern	LINKS_COMP
private static final Pattern	LOWER_CASE_WORD
private static final int	MAX_EDIT_DISTANCE
private static final int	MAX_TOKEN_LENGTH
private static final int	MAX_WORD_LENGTH
private static final Pattern	MENTION_UNDERLINE_PATTERN
private static final int	MIN_WORD_LENGTH
private static final Pattern	missingAdjPattern
private static final Pattern	NEEDS_TO_BE_PLURAL
private final GermanCompoundTokenizer	nonStrictCompoundTokenizer
private static final Set<String>	oldSpelling
private static final Set<String>	otherPrefixes
private static final Pattern	PERSON_SUFFIXES
private static final Pattern	POTENTIAL_BINNEN_I
private static final List<Pattern>	PREVENT_SUGGESTION_PATTERNS
private static final Pattern	PROFESSIONELL
private static final Pattern	RECHT_COMP
private static final Pattern	RECHTMASIG_WITH_CASES
private static final Pattern	RECHTS_COMP
static final String	RULE_ID
private static final Pattern	SBHAN_PREFIX
private static final Pattern	SCHAF_PATTERN
private static final Pattern	SCHAFE_PATTERN
private static final Pattern	SPECIAL_CASE
private static final Pattern	SPECIAL_CASE_THIRD
private static final Pattern	SPECIAL_CASE_WITH_S
private static final de.danielnaber.jwordsplitter.GermanWordSplitter	splitter
private static final Pattern	START_WITH_NEGER
private static final Pattern	START_WITH_SPIEL
private static final Pattern	STARTING_WITH_SINGLE_CHAR
private static final Pattern	STARTS_WITH_DIAGNOSZIER
private static final Pattern	STARTS_WITH_RESCHASCHIER
private static final Pattern	STARTS_WITH_ZB
private static final Pattern	SUBINF_SINGULAR_OBJECT
private static final Pattern	SUBNOMPLUFEM_EXCEPTIONS
private static final Pattern	SYMPHATISCH
private final Synthesizer	synthesizer
private static final Pattern	UBAHN_PREFIX
private static final Pattern	VERBAND_COMP
private static final Pattern	VERBANDS_COMP
private static final Set<String>	verbPrefixes
private static final Set<String>	verbStems
private static final Pattern	VERSTANDNIS
private static final Pattern	WECHSELINFIX
private static final Pattern	WECHSELNUMERUS
private static final Pattern	WELTEN_COMP
private static final Pattern	WIDER_COMP
private static final Pattern	WOCHENTAG_COMP
private static final Pattern	WOCHENTAGE
private static final Pattern	WOCHENTAGE_S
private static final Pattern	WOERTER_COMP
private static final Pattern	WORD_WITH_PUNCT
private final Set<String>	wordEndingsToBeProhibited
private final Set<String>	wordsNeedingInfixS
private final Set<String>	wordStartsToBeProhibited
private final Set<String>	wordsToBeIgnoredInCompounds
private static final Pattern	ZB

Fields inherited from class org.languagetool.rules.spelling.hunspell.HunspellRule

FILE_EXTENSION, hunspell, nonWordPattern

Fields inherited from class org.languagetool.rules.spelling.SpellingCheckRule

CUSTOM_SPELLING_FILE, GLOBAL_SPELLING_FILE, HIGH_CONFIDENCE, ignoreWordsWithLength, language, languageModel, LANGUAGETOOL, LANGUAGETOOLER, wordListLoader, wordsToBeIgnored

Fields inherited from class org.languagetool.rules.Rule

messages

Constructor Summary

Constructors

Constructor	Description
GermanSpellerRule(ResourceBundle messages, German language)
GermanSpellerRule(ResourceBundle messages, German language, UserConfig userConfig, String languageVariantPlainTextDict)
GermanSpellerRule(ResourceBundle messages, German language, UserConfig userConfig, String languageVariantPlainTextDict, List<Language> altLanguages, LanguageModel languageModel)

Method Summary

Modifier and Type	Method	Description
protected boolean	acceptSuggestion(String s)
protected void	addIgnoreWords(String origLine)
protected void	addProhibitedWords(List<String> words)
private List<String>	avoidInfixSAsSingleToken(List<String> parts)
private String	baseForThirdPersonSingularVerb(String word)
private boolean	checkConfusionForPart1Part2Combination(String part1, String part2)
private boolean	checkInfixSForPart1Part2Combination(String part1, String part2)
private boolean	checkPluralForPart1Part2Combination(String part1, String part2)
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 void	filterForLanguage(List<String> suggestions)
protected List<SuggestedReplacement>	filterNoSuggestWords(List<SuggestedReplacement> l)
private String	findLemmaForNoun(String word)
private String	getAbbreviationSuggestion(String word)
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).
private List<String>	getAdditionalTopSuggestionsString(List<String> suggestions, String word)
List<String>	getCandidates(String word)	Find potential corrections - it's okay if some of these are not valid words, this list will be filtered against the spellchecker before being returned to the user.
protected List<String>	getFilteredSuggestions(List<String> wordsOrPhrases)
String	getId()	A string used to identify the rule in e.g.
protected String	getMessage(String origWord, SuggestedReplacement firstSuggestion)
protected List<SuggestedReplacement>	getOnlySuggestions(String word)	Get suggestions that will replace all other suggestions.
private String	getParticipleForBaseform(String baseform)
private String	getParticipleSuggestion(String word)
private String	getPastTenseVerbSuggestion(String word)
protected static MorfologikMultiSpeller	getSpeller(Language language, UserConfig userConfig, String languageVariantPlainTextDict)
protected static List<String>	getSpellingFilePaths(String langCode)
private static de.danielnaber.jwordsplitter.GermanWordSplitter	getSplitter()
List<String>	getSuggestions(String word)	As a hunspell-based approach is too slow, we use Morfologik to create suggestions.
private Tagger	getTagger()
private static BufferedReader	getVariantReader(String languageVariantPlainTextDict)
private String	getWordAfterEnumerationOrNull(List<String> words, int idx)
private boolean	ignoreByHangingHyphen(List<String> words, int idx)
private boolean	ignoreCompoundWithIgnoredWord(String word)
private boolean	ignoreElative(String word)
protected boolean	ignorePotentiallyMisspelledWord(String word)	Like SpellingCheckRule.ignoreWord(String), but will only be called after the standard spell check has run and considered this word to be incorrect.
protected boolean	ignoreWord(List<String> words, int idx)	Returns true iff the word at the given position should be ignored by the spell checker.
private List<Integer>	indexOfInfixS(List<String> parts)
protected void	init()
private boolean	isAdjBaseForm(String word)
private boolean	isAdjective(String word)
private boolean	isAdjOrNounOrUnknown(String word)
private boolean	isCountryOrRegionNomSin(String word)
protected boolean	isIgnoredNoCase(String word)
boolean	isMisspelled(String word)
private boolean	isNeedingFugenS(String word)
private boolean	isNoun(String word)
private boolean	isNounNom(String word)
private boolean	isNounNomPlu(String word)
private boolean	isNounNomSin(String word)
private boolean	isNounOrProperNoun(String word)
private boolean	isNounOrUnknown(String word)
private boolean	isOldSpelling(List<String> parts)
private boolean	isOnlyNoun(String word)
private boolean	isOtherPrefix(String word)
private boolean	isProbablyTypo(String word)
protected boolean	isProhibited(String word)	Whether the word is prohibited, i.e.
protected boolean	isQuotedCompound(AnalyzedSentence analyzedSentence, int idx, String token)	Is the given token part of a hyphenated compound preceded by a quoted token (e.g., „Spiegel“-Magazin) and should be treated as an ordinary hyphenated compound (e.g., „Spiegel-Magazin“)
private boolean	isSubVerInf(String word)
private boolean	isValidCamelCase(String input)
private boolean	isValidGenderNeutralWord(List<String> parts, String word)
private boolean	isValidPartLength(List<String> parts)
private boolean	isValidWordLength(String word)
private boolean	isVerbPrefix(String word)
private boolean	isVerbStem(String word)
private void	loadFile(String fileInClasspath, Set<String> set)
RuleMatch[]	match(AnalyzedSentence sentence)	Check whether the given sentence matches this error rule, i.e.
private boolean	needsInfixS(String word)
private boolean	needsToBePlural(String lemma)
protected boolean	processThreePartCompound(List<String> parts)
private boolean	processTwoPartCompounds(String part1, String part2)
private static void	put(String pattern, String replacement)
private static void	put(String pattern, Function<String,List<String>> f)
private static void	putRepl(String wordPattern, String pattern, String replacement)
private RuleMatch[]	removeGenderCompoundMatches(AnalyzedSentence sentence, RuleMatch[] matches)
private String	removeTrailingHyphen(String part1)
private String	removeTrailingS(String part1)
private String	removeTrailingSAndHyphen(String part1)
private List<String>	restoreRemovedHyphens(List<String> parts, String word)
protected List<String>	sortSuggestionByQuality(String misspelling, List<String> suggestions)
private List<String>	splitPartsByHyphen(List<String> originalParts)

Methods inherited from class org.languagetool.rules.spelling.hunspell.CompoundAwareHunspellRule

getCandidates, getStreams

Methods inherited from class org.languagetool.rules.spelling.hunspell.HunspellRule

ensureInitialized, getActiveChecks, getDescription, getDictFilenameInResources, getSentenceTextWithoutUrlsAndImmunizedTokens, getShortMessage, isInIgnoredSet, tokenizeText

Methods inherited from class org.languagetool.rules.spelling.SpellingCheckRule

acceptPhrases, addIgnoreTokens, addSuggestionsToRuleMatch, filterDupes, filterSuggestions, getAdditionalProhibitFileNames, getAdditionalSpellingFileNames, getAdditionalSuggestions, getAntiPatterns, getIgnoreFileName, getLanguageVariantSpellingFileName, getProhibitFileName, getSpellingFileName, ignoreToken, ignoreWord, isDictionaryBasedSpellingRule, isEMail, isLatinScript, isUrl, setConsiderIgnoreWords, setConvertsCase, startsWithIgnoredWord, tokenizeNewWords

Methods inherited from class org.languagetool.rules.Rule

addExamplePair, addTags, addToneTags, cacheAntiPatterns, estimateContextForSureMatch, getCategory, getCorrectExamples, getDistanceTokens, getErrorTriggeringExamples, getFullId, getIncorrectExamples, getLocQualityIssueType, getMinPrevMatches, getPriority, getRuleOptions, getSentenceWithImmunization, getSourceFile, getSubId, getTags, getToneTags, getUrl, hasTag, hasToneTag, isDefaultOff, isDefaultTempOff, isGoalSpecific, isIncludedInHiddenMatches, isOfficeDefaultOff, isOfficeDefaultOn, isPremium, makeAntiPatterns, setCategory, setCorrectExamples, setDefaultOff, setDefaultOn, setDefaultTempOff, setDistanceTokens, setErrorTriggeringExamples, setExamplePair, setGoalSpecific, setIncludedInHiddenMatches, setIncorrectExamples, setLocQualityIssueType, setMinPrevMatches, setOfficeDefaultOff, setOfficeDefaultOn, setPremium, setPriority, 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 Details

RULE_ID

public static final String RULE_ID

See Also:

• Constant Field Values

MIN_WORD_LENGTH

private static final int MIN_WORD_LENGTH

See Also:

• Constant Field Values

MAX_WORD_LENGTH

private static final int MAX_WORD_LENGTH

See Also:

• Constant Field Values

MAX_EDIT_DISTANCE

private static final int MAX_EDIT_DISTANCE

See Also:

• Constant Field Values

adjSuffix

private static final String adjSuffix

See Also:

• Constant Field Values

missingAdjPattern

private static final Pattern missingAdjPattern

compoundPatternWithHeit

private static final Pattern compoundPatternWithHeit

compoundPatternWithAction

private static final Pattern compoundPatternWithAction

compoundPatternWithFirst

private static final Pattern compoundPatternWithFirst

compoundPatternSpecialEnding

private static final Pattern compoundPatternSpecialEnding

lcDoNotSuggestWords

private static final Set<String> lcDoNotSuggestWords

MAX_TOKEN_LENGTH

private static final int MAX_TOKEN_LENGTH

See Also:

• Constant Field Values

GENDER_STAR_PATTERN

private static final Pattern GENDER_STAR_PATTERN

FILE_UNDERLINE_PATTERN

private static final Pattern FILE_UNDERLINE_PATTERN

MENTION_UNDERLINE_PATTERN

private static final Pattern MENTION_UNDERLINE_PATTERN

FIRST_UPPER_CASE

private static final Pattern FIRST_UPPER_CASE

HYPHENED_UPPER_WORD

private static final Pattern HYPHENED_UPPER_WORD

HYPHENED_WORD

private static final Pattern HYPHENED_WORD

START_WITH_SPIEL

private static final Pattern START_WITH_SPIEL

END_WITH_SCHAFTE

private static final Pattern END_WITH_SCHAFTE

WORD_WITH_PUNCT

private static final Pattern WORD_WITH_PUNCT

LOWER_CASE_WORD

private static final Pattern LOWER_CASE_WORD

SPECIAL_CASE

private static final Pattern SPECIAL_CASE

SPECIAL_CASE_WITH_S

private static final Pattern SPECIAL_CASE_WITH_S

AUTENTISCH_WITH_CASES

private static final Pattern AUTENTISCH_WITH_CASES

SYMPHATISCH

private static final Pattern SYMPHATISCH

BRILLIANT_WITH_CASES

private static final Pattern BRILLIANT_WITH_CASES

RECHTMASIG_WITH_CASES

private static final Pattern RECHTMASIG_WITH_CASES

HOLZ_SPIEGEL_PANEL_COMPOUND

private static final Pattern HOLZ_SPIEGEL_PANEL_COMPOUND

SBHAN_PREFIX

private static final Pattern SBHAN_PREFIX

UBAHN_PREFIX

private static final Pattern UBAHN_PREFIX

SCHAF_PATTERN

private static final Pattern SCHAF_PATTERN

SCHAFE_PATTERN

private static final Pattern SCHAFE_PATTERN

START_WITH_NEGER

private static final Pattern START_WITH_NEGER

CONTAINS_NEGER

private static final Pattern CONTAINS_NEGER

CONTAINS_NEGER_2

private static final Pattern CONTAINS_NEGER_2

CONTAINS_UNCOMMON_LOWERCASED_NOUN_AT_BEGINNING

private static final Pattern CONTAINS_UNCOMMON_LOWERCASED_NOUN_AT_BEGINNING

CONTAINS_UNCOMMON_LOWERCASED_NOUN_AT_END

private static final Pattern CONTAINS_UNCOMMON_LOWERCASED_NOUN_AT_END

ENDS_WITH_IBELKEIT_IBLICHKEIT

private static final Pattern ENDS_WITH_IBELKEIT_IBLICHKEIT

ALLMAHLLIG

private static final Pattern ALLMAHLLIG

CONTAINS_MAYONNAISE

private static final Pattern CONTAINS_MAYONNAISE

CONTAINS_MASZNAME

private static final Pattern CONTAINS_MASZNAME

CONTAINS_RESERVIERUNG

private static final Pattern CONTAINS_RESERVIERUNG

STARTS_WITH_RESCHASCHIER

private static final Pattern STARTS_WITH_RESCHASCHIER

ENDS_WITH_LABORANTS

private static final Pattern ENDS_WITH_LABORANTS

PROFESSIONELL

private static final Pattern PROFESSIONELL

VERSTANDNIS

private static final Pattern VERSTANDNIS

STARTS_WITH_DIAGNOSZIER

private static final Pattern STARTS_WITH_DIAGNOSZIER

STARTING_WITH_SINGLE_CHAR

private static final Pattern STARTING_WITH_SINGLE_CHAR

SPECIAL_CASE_THIRD

private static final Pattern SPECIAL_CASE_THIRD

ZB

private static final Pattern ZB

STARTS_WITH_ZB

private static final Pattern STARTS_WITH_ZB

DIRECTION

private static final Pattern DIRECTION

WOCHENTAGE

private static final Pattern WOCHENTAGE

WOCHENTAGE_S

private static final Pattern WOCHENTAGE_S

CAMEL_CASE

private static final Pattern CAMEL_CASE

COMPOUND_TYPOS

private static final Pattern COMPOUND_TYPOS

COMPOUND_END_TYPOS

private static final Pattern COMPOUND_END_TYPOS

INFIX_S_SUFFIXES

private static final Pattern INFIX_S_SUFFIXES

WECHSELINFIX

private static final Pattern WECHSELINFIX

CONFUSED_PREFIXES

private static final Pattern CONFUSED_PREFIXES

NEEDS_TO_BE_PLURAL

private static final Pattern NEEDS_TO_BE_PLURAL

SUBNOMPLUFEM_EXCEPTIONS

private static final Pattern SUBNOMPLUFEM_EXCEPTIONS

CITIES_EXCEPTIONS

private static final Pattern CITIES_EXCEPTIONS

INVALID_COMP_PART_1

private static final Pattern INVALID_COMP_PART_1

INVALID_COMP_PART_2

private static final Pattern INVALID_COMP_PART_2

SUBINF_SINGULAR_OBJECT

private static final Pattern SUBINF_SINGULAR_OBJECT

ARBEIT_COMP

private static final Pattern ARBEIT_COMP

BACH_COMP

private static final Pattern BACH_COMP

BAD_COMP

private static final Pattern BAD_COMP

LINK_COMP

private static final Pattern LINK_COMP

LINKS_COMP

private static final Pattern LINKS_COMP

PERSON_SUFFIXES

private static final Pattern PERSON_SUFFIXES

RECHT_COMP

private static final Pattern RECHT_COMP

RECHTS_COMP

private static final Pattern RECHTS_COMP

VERBAND_COMP

private static final Pattern VERBAND_COMP

VERBANDS_COMP

private static final Pattern VERBANDS_COMP

WIDER_COMP

private static final Pattern WIDER_COMP

WOCHENTAG_COMP

private static final Pattern WOCHENTAG_COMP

POTENTIAL_BINNEN_I

private static final Pattern POTENTIAL_BINNEN_I

GENDER_NEUTRAL_SPECIAL_CHRS_SIN

private static final Pattern GENDER_NEUTRAL_SPECIAL_CHRS_SIN

GENDER_NEUTRAL_SPECIAL_CHRS_PLU

private static final Pattern GENDER_NEUTRAL_SPECIAL_CHRS_PLU

GENDER_NEUTRAL_SLASH_HYPHEN

private static final Pattern GENDER_NEUTRAL_SLASH_HYPHEN

GENDER_STAR

private static final Pattern GENDER_STAR

GENDER2_STAR2

private static final Pattern GENDER2_STAR2

WECHSELNUMERUS

private static final Pattern WECHSELNUMERUS

WELTEN_COMP

private static final Pattern WELTEN_COMP

WOERTER_COMP

private static final Pattern WOERTER_COMP

PREVENT_SUGGESTION_PATTERNS

private static final List<Pattern> PREVENT_SUGGESTION_PATTERNS

EXPAND_PATTERN

private static final Pattern EXPAND_PATTERN

wordsToBeIgnoredInCompounds

private final Set<String> wordsToBeIgnoredInCompounds

wordStartsToBeProhibited

private final Set<String> wordStartsToBeProhibited

wordEndingsToBeProhibited

private final Set<String> wordEndingsToBeProhibited

wordsNeedingInfixS

private final Set<String> wordsNeedingInfixS

verbStems

private static final Set<String> verbStems

verbPrefixes

private static final Set<String> verbPrefixes

otherPrefixes

private static final Set<String> otherPrefixes

oldSpelling

private static final Set<String> oldSpelling

ADDITIONAL_SUGGESTIONS

private static final Map<StringMatcher,Function<String,List<String>>> ADDITIONAL_SUGGESTIONS

splitter

private static final de.danielnaber.jwordsplitter.GermanWordSplitter splitter

lineExpander

private final LineExpander lineExpander

compoundTokenizer

private final GermanCompoundTokenizer compoundTokenizer

nonStrictCompoundTokenizer

private final GermanCompoundTokenizer nonStrictCompoundTokenizer

synthesizer

private final Synthesizer synthesizer

Constructor Details

GermanSpellerRule

public GermanSpellerRule(ResourceBundle messages,
 German language)

GermanSpellerRule

public GermanSpellerRule(ResourceBundle messages,
 German language,
 UserConfig userConfig,
 String languageVariantPlainTextDict)

Since:

4.2

GermanSpellerRule

public GermanSpellerRule(ResourceBundle messages,
 German language,
 UserConfig userConfig,
 String languageVariantPlainTextDict,
 List<Language> altLanguages,
 LanguageModel languageModel)

Since:

4.3

Method Details

match

public 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.

Overrides:

match in class HunspellRule

Parameters:

sentence - a pre-analyzed sentence

Returns:

an array of RuleMatch objects

Throws:

IOException

removeGenderCompoundMatches

@NotNull
private RuleMatch[] removeGenderCompoundMatches(AnalyzedSentence sentence,
 RuleMatch[] matches)

putRepl

private static void putRepl(String wordPattern,
 String pattern,
 String replacement)

put

private static void put(String pattern,
 String replacement)

put

private static void put(String pattern,
 Function<String,List<String>> f)

getSplitter

private static de.danielnaber.jwordsplitter.GermanWordSplitter getSplitter()

loadFile

private void loadFile(String fileInClasspath,
 Set<String> set)

init

protected void init()
             throws IOException

Overrides:

init in class HunspellRule

Throws:

IOException

getId

public 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.

Overrides:

getId in class HunspellRule

isIgnoredNoCase

protected boolean isIgnoredNoCase(String word)

Overrides:

isIgnoredNoCase in class SpellingCheckRule

getMessage

@NotNull
protected String getMessage(String origWord,
 SuggestedReplacement firstSuggestion)

Overrides:

getMessage in class HunspellRule

getCandidates

public List<String> getCandidates(String word)

Description copied from class: CompoundAwareHunspellRule

Find potential corrections - it's okay if some of these are not valid words, this list will be filtered against the spellchecker before being returned to the user.

Overrides:

getCandidates in class CompoundAwareHunspellRule

isProhibited

protected boolean isProhibited(String word)

Description copied from class: SpellingCheckRule

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.)

Overrides:

isProhibited in class SpellingCheckRule

addIgnoreWords

protected void addIgnoreWords(String origLine)

Overrides:

addIgnoreWords in class SpellingCheckRule

Parameters:

origLine - the line as read from spelling.txt.

expandLine

protected List<String> expandLine(String line)

Description copied from class: SpellingCheckRule

Expand suffixes in a line. By default, the line is not expanded. Implementations might e.g. turn bicycle/S into [bicycle, bicycles].

Overrides:

expandLine in class SpellingCheckRule

createWrongSplitMatch

protected RuleMatch createWrongSplitMatch(AnalyzedSentence sentence,
 List<RuleMatch> ruleMatchesSoFar,
 int pos,
 String coveredWord,
 String suggestion1,
 String suggestion2,
 int prevPos)

Overrides:

createWrongSplitMatch in class SpellingCheckRule

getSuggestions

public List<String> getSuggestions(String word)
                            throws IOException

Description copied from class: CompoundAwareHunspellRule

As a hunspell-based approach is too slow, we use Morfologik to create suggestions. As this won't work for compounds not in the dictionary, we split the word and also get suggestions on the compound parts. In the end, all candidates are filtered against Hunspell again (which supports compounds).

Overrides:

getSuggestions in class CompoundAwareHunspellRule

Throws:

IOException

acceptSuggestion

protected boolean acceptSuggestion(String s)

Overrides:

acceptSuggestion in class HunspellRule

getSpellingFilePaths

@NotNull
protected static List<String> getSpellingFilePaths(String langCode)

getSpeller

@Nullable
protected static MorfologikMultiSpeller getSpeller(Language language,
 UserConfig userConfig,
 String languageVariantPlainTextDict)

getVariantReader

@Nullable
private static BufferedReader getVariantReader(String languageVariantPlainTextDict)

filterForLanguage

protected void filterForLanguage(List<String> suggestions)

Specified by:

filterForLanguage in class CompoundAwareHunspellRule

sortSuggestionByQuality

protected List<String> sortSuggestionByQuality(String misspelling,
 List<String> suggestions)

Overrides:

sortSuggestionByQuality in class CompoundAwareHunspellRule

getFilteredSuggestions

protected List<String> getFilteredSuggestions(List<String> wordsOrPhrases)

Overrides:

getFilteredSuggestions in class CompoundAwareHunspellRule

isNounOrUnknown

private boolean isNounOrUnknown(String word)

isOnlyNoun

private boolean isOnlyNoun(String word)

isAdjOrNounOrUnknown

private boolean isAdjOrNounOrUnknown(String word)

isNounOrProperNoun

private boolean isNounOrProperNoun(String word)

isSubVerInf

private boolean isSubVerInf(String word)

isAdjBaseForm

private boolean isAdjBaseForm(String word)

ignoreElative

private boolean ignoreElative(String word)

isMisspelled

public boolean isMisspelled(String word)

Overrides:

isMisspelled in class HunspellRule

ignoreWord

protected boolean ignoreWord(List<String> words,
 int idx)
                      throws IOException

Description copied from class: SpellingCheckRule

Returns true iff the word at the given position should be ignored by the spell checker. If possible, use SpellingCheckRule.ignoreToken(AnalyzedTokenReadings[], int) instead.

Overrides:

ignoreWord in class SpellingCheckRule

Throws:

IOException

ignorePotentiallyMisspelledWord

protected boolean ignorePotentiallyMisspelledWord(String word)
                                           throws IOException

Description copied from class: SpellingCheckRule

Like SpellingCheckRule.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.

Overrides:

ignorePotentiallyMisspelledWord in class SpellingCheckRule

Throws:

IOException

isValidWordLength

private boolean isValidWordLength(String word)

isValidPartLength

private boolean isValidPartLength(List<String> parts)

isOldSpelling

private boolean isOldSpelling(List<String> parts)

isValidGenderNeutralWord

private boolean isValidGenderNeutralWord(List<String> parts,
 String word)

removeTrailingS

private String removeTrailingS(String part1)

removeTrailingHyphen

private String removeTrailingHyphen(String part1)

removeTrailingSAndHyphen

private String removeTrailingSAndHyphen(String part1)

isAdjective

private boolean isAdjective(String word)
                     throws IOException

Throws:

IOException

isNoun

private boolean isNoun(String word)
                throws IOException

Throws:

IOException

processTwoPartCompounds

private boolean processTwoPartCompounds(String part1,
 String part2)
                                 throws IOException

Throws:

IOException

processThreePartCompound

protected boolean processThreePartCompound(List<String> parts)
                                    throws IOException

Throws:

IOException

checkInfixSForPart1Part2Combination

private boolean checkInfixSForPart1Part2Combination(String part1,
 String part2)
                                             throws IOException

Throws:

IOException

checkConfusionForPart1Part2Combination

private boolean checkConfusionForPart1Part2Combination(String part1,
 String part2)
                                                throws IOException

Throws:

IOException

checkPluralForPart1Part2Combination

private boolean checkPluralForPart1Part2Combination(String part1,
 String part2)
                                             throws IOException

Throws:

IOException

findLemmaForNoun

private String findLemmaForNoun(String word)
                         throws IOException

Throws:

IOException

isProbablyTypo

private boolean isProbablyTypo(String word)

isValidCamelCase

private boolean isValidCamelCase(String input)

restoreRemovedHyphens

private List<String> restoreRemovedHyphens(List<String> parts,
 String word)

avoidInfixSAsSingleToken

private List<String> avoidInfixSAsSingleToken(List<String> parts)

splitPartsByHyphen

private List<String> splitPartsByHyphen(List<String> originalParts)

indexOfInfixS

private List<Integer> indexOfInfixS(List<String> parts)

needsInfixS

private boolean needsInfixS(String word)
                     throws IOException

Throws:

IOException

needsToBePlural

private boolean needsToBePlural(String lemma)
                         throws IOException

Throws:

IOException

isNounNom

private boolean isNounNom(String word)
                   throws IOException

Throws:

IOException

isNounNomSin

private boolean isNounNomSin(String word)
                      throws IOException

Throws:

IOException

isNounNomPlu

private boolean isNounNomPlu(String word)
                      throws IOException

Throws:

IOException

isCountryOrRegionNomSin

private boolean isCountryOrRegionNomSin(String word)
                                 throws IOException

Throws:

IOException

isOtherPrefix

private boolean isOtherPrefix(String word)
                       throws IOException

Throws:

IOException

isVerbPrefix

private boolean isVerbPrefix(String word)
                      throws IOException

Throws:

IOException

isVerbStem

private boolean isVerbStem(String word)
                    throws IOException

Throws:

IOException

getAdditionalTopSuggestions

protected List<SuggestedReplacement> getAdditionalTopSuggestions(List<SuggestedReplacement> suggestions,
 String word)
                                                          throws IOException

Description copied from class: SpellingCheckRule

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.

Overrides:

getAdditionalTopSuggestions in class SpellingCheckRule

Throws:

IOException

getAdditionalTopSuggestionsString

private List<String> getAdditionalTopSuggestionsString(List<String> suggestions,
 String word)
                                                throws IOException

Throws:

IOException

getPastTenseVerbSuggestion

@Nullable
private String getPastTenseVerbSuggestion(String word)

baseForThirdPersonSingularVerb

@Nullable
private String baseForThirdPersonSingularVerb(String word)
                                       throws IOException

Throws:

IOException

getParticipleSuggestion

@Nullable
private String getParticipleSuggestion(String word)

getParticipleForBaseform

@Nullable
private String getParticipleForBaseform(String baseform)
                                 throws IOException

Throws:

IOException

getAbbreviationSuggestion

private String getAbbreviationSuggestion(String word)
                                  throws IOException

Throws:

IOException

ignoreByHangingHyphen

private boolean ignoreByHangingHyphen(List<String> words,
 int idx)
                               throws IOException

Throws:

IOException

isNeedingFugenS

private boolean isNeedingFugenS(String word)

getWordAfterEnumerationOrNull

@Nullable
private String getWordAfterEnumerationOrNull(List<String> words,
 int idx)

ignoreCompoundWithIgnoredWord

private boolean ignoreCompoundWithIgnoredWord(String word)
                                       throws IOException

Throws:

IOException

getTagger

private Tagger getTagger()

isQuotedCompound

protected boolean isQuotedCompound(AnalyzedSentence analyzedSentence,
 int idx,
 String token)

Description copied from class: HunspellRule

Is the given token part of a hyphenated compound preceded by a quoted token (e.g., „Spiegel“-Magazin) and should be treated as an ordinary hyphenated compound (e.g., „Spiegel-Magazin“)

Overrides:

isQuotedCompound in class HunspellRule

addProhibitedWords

protected void addProhibitedWords(List<String> words)

Overrides:

addProhibitedWords in class SpellingCheckRule

Parameters:

words - list of words to be prohibited.

filterNoSuggestWords

protected List<SuggestedReplacement> filterNoSuggestWords(List<SuggestedReplacement> l)

Overrides:

filterNoSuggestWords in class SpellingCheckRule

getOnlySuggestions

protected List<SuggestedReplacement> getOnlySuggestions(String word)

Description copied from class: SpellingCheckRule

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.

Overrides:

getOnlySuggestions in class SpellingCheckRule