in languagetool-language-modules/ca/src/main/java/org/languagetool/rules/ca/AdjustVerbSuggestionsFilter.java [42:227]
public RuleMatch acceptRuleMatch(RuleMatch match, Map<String, String> arguments, int patternTokenPos,
AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions) throws IOException {
JLanguageTool lt = ((PatternRule) match.getRule()).getLanguage().createDefaultJLanguageTool();
List<String> replacements = new ArrayList<>();
boolean numberFromNextWords = getOptional("numberFromNextWords", arguments, "false").equalsIgnoreCase("true");
String forceNumber = getOptional("forceNumber", arguments, "");
Synthesizer synth = getSynthesizerFromRuleMatch(match);
int posWord = 0;
AnalyzedTokenReadings[] tokens = match.getSentence().getTokensWithoutWhitespace();
while (posWord < tokens.length
&& (tokens[posWord].getStartPos() < match.getFromPos() || tokens[posWord].isSentenceStart())) {
posWord++;
}
VerbSynthesizer verbSynthesizer = new VerbSynthesizer(tokens, posWord, getLanguageFromRuleMatch(match));
// verb found out of bounds
if (verbSynthesizer.isUndefined() || tokens[verbSynthesizer.getLastVerbIndex()].getEndPos() > match.getToPos()) {
return null;
}
for (String originalSuggestion : match.getSuggestedReplacements()) {
originalSuggestion = originalSuggestion.toLowerCase();
boolean makeIntrasitive = false;
String desiredNumber = "";
String desiredPersona = "";
String action = "removePronounReflexive";
if (originalSuggestion.endsWith(" [intr]")) {
originalSuggestion = originalSuggestion.substring(0, originalSuggestion.length() - 7);
makeIntrasitive = true;
}
if (originalSuggestion.endsWith(" [3s]")) {
originalSuggestion = originalSuggestion.substring(0, originalSuggestion.length() - 5);
desiredNumber = "S";
desiredPersona = "3";
}
if (originalSuggestion.startsWith("[datiu] ")) {
originalSuggestion = originalSuggestion.substring(8);
action = "addPronounDative";
}
int firstSpaceIndex = originalSuggestion.indexOf(" ");
String newLemma = originalSuggestion;
String afterLemma = "";
if (firstSpaceIndex != -1) {
newLemma = originalSuggestion.substring(0, firstSpaceIndex);
afterLemma = originalSuggestion.substring(firstSpaceIndex + 1);
List<AnalyzedSentence> tokensAfterLemma = lt.analyzeText(afterLemma);
if (numberFromNextWords) {
desiredNumber = (tokensAfterLemma.get(0).getTokensWithoutWhitespace()[1].hasPartialPosTag("S") ? "S" : "P");
}
}
if (newLemma.contains("haver-hi")) {
desiredNumber = "S";
}
if (!forceNumber.isEmpty()) {
desiredNumber = forceNumber;
}
if (newLemma.endsWith("-se'n")) {
newLemma = newLemma.substring(0, newLemma.length() - 5);
action = "addPronounReflexiveEn";
} else if (newLemma.endsWith("-se")) {
newLemma = newLemma.substring(0, newLemma.length() - 3);
action = "addPronounReflexive";
} else if (newLemma.endsWith("'s")) {
newLemma = newLemma.substring(0, newLemma.length() - 2);
action = "addPronounReflexive";
} else if (newLemma.endsWith("-hi")) {
newLemma = newLemma.substring(0, newLemma.length() - 3);
action = "addPronounHi";
} else if (newLemma.endsWith("-s'ho")) {
newLemma = newLemma.substring(0, newLemma.length() - 5);
action = "addPronounReflexiveHo";
} else if (newLemma.endsWith("-s'hi")) {
newLemma = newLemma.substring(0, newLemma.length() - 5);
action = "addPronounReflexiveHi";
}
// synthesize with new lemma
List<String> postags = new ArrayList<>();
for (AnalyzedToken reading : tokens[verbSynthesizer.getFirstVerbIndex()]) {
if (reading.getPOSTag() != null && reading.getPOSTag().startsWith("V")) {
String postag = reading.getPOSTag();
if (!desiredNumber.isEmpty()) {
if (!postag.substring(2, 3).equals("P") && (postag.substring(5, 6).equals("S") || postag.substring(5
, 6).equals("P"))) {
postag = postag.substring(0, 5) + desiredNumber + postag.substring(6);
}
}
if (!desiredPersona.isEmpty()) {
if (!postag.substring(2, 3).equals("P") && (postag.substring(4, 5).matches("[123]"))) {
postag = postag.substring(0, 4) + desiredPersona + postag.substring(5);
}
}
postags.add(postag);
}
}
String targetPostag = synth.getTargetPosTag(postags, "");
String verbStr = "";
if (!targetPostag.isEmpty()) {
verbSynthesizer.setLemmaAndPostag(newLemma, targetPostag);
verbStr = verbSynthesizer.synthesize();
}
String pronounsStr="";
boolean isPronounsAfter = verbSynthesizer.getNumPronounsAfter() > 0 || !verbSynthesizer.isFirstVerbIS();
if (verbSynthesizer.getNumPronounsBefore() > 0) {
pronounsStr = verbSynthesizer.getPronounsStrBefore();
} else if (verbSynthesizer.getNumPronounsAfter() > 0) {
pronounsStr = verbSynthesizer.getPronounsStrAfter();
}
pronounsStr = pronounsStr.toLowerCase();
String firstVerbPersonaNumber = verbSynthesizer.getFirstVerbPersonaNumber();
String replacement = "";
switch (action) {
case "addPronounEn":
String newPronoun = doAddPronounEn(pronounsStr, verbStr, !verbSynthesizer.isFirstVerbIS());
if (!newPronoun.isEmpty()) {
replacement = (verbSynthesizer.isFirstVerbIS() ? newPronoun + verbStr : verbStr + newPronoun);
}
break;
case "removePronounReflexive":
replacement = doRemovePronounReflexive(pronounsStr, verbStr, isPronounsAfter);
break;
case "addPronounReflexiveEn":
replacement = doAddPronounReflexiveEn(pronounsStr, verbStr, firstVerbPersonaNumber, isPronounsAfter);
break;
case "replaceEmEn": // not used
replacement = doReplaceEmEn(pronounsStr, verbStr, isPronounsAfter);
break;
case "addPronounReflexive":
replacement = doAddPronounReflexive(pronounsStr, verbStr, firstVerbPersonaNumber, isPronounsAfter);
break;
case "addPronounReflexiveHi":
replacement = doAddPronounReflexive("", "hi " + verbStr, firstVerbPersonaNumber, isPronounsAfter);
break;
case "addPronounDative":
String dativePronoun = getDativePronoun(firstVerbPersonaNumber);
if (isPronounsAfter) {
replacement = verbStr + transformDarrere(dativePronoun, verbStr);
} else {
replacement = transformDavant(dativePronoun, verbStr) + verbStr;
}
break;
case "addPronounReflexiveHo":
String reflexivePronoun = getReflexivePronoun(firstVerbPersonaNumber);
if (reflexivePronoun.isEmpty()) {
if (!pronounsStr.isEmpty()) {
String rp = transform(pronounsStr, PronounPosition.NORMALIZED);
if (lReflexivePronouns.contains(rp)) {
reflexivePronoun= rp;
}
}
}
if (reflexivePronoun.isEmpty()) {
reflexivePronoun = "es";
}
String pronounsNormalized = reflexivePronoun + " ho";
if (isPronounsAfter) {
replacement = verbStr + transformDarrere(pronounsNormalized, verbStr);
} else {
replacement = transformDavant(pronounsNormalized, verbStr) + verbStr;
}
break;
case "addPronounHi": // S'ignoren altres pronoms?
replacement = "hi " + verbStr;
break;
case "addPronounReflexiveImperative": //TODO
replacement = doAddPronounReflexiveImperative(pronounsStr, verbStr, firstVerbPersonaNumber);
break;
}
if (!replacement.isEmpty()) {
if (makeIntrasitive) {
replacement = convertPronounsForIntransitiveVerb(replacement);
}
replacement = fixApostrophes(replacement);
replacement = (replacement + " " + afterLemma).trim();
replacements.add(StringTools.preserveCase(replacement, verbSynthesizer.getCasingModel()));
}
}
if (replacements.isEmpty()) {
return null;
}
int posStartUnderline = verbSynthesizer.getFirstVerbIndex() - verbSynthesizer.getNumPronounsBefore();
RuleMatch ruleMatch = new RuleMatch(match.getRule(), match.getSentence(), tokens[posStartUnderline].getStartPos(),
match.getToPos(), match.getMessage(), match.getShortMessage());
ruleMatch.setType(match.getType());
ruleMatch.setSuggestedReplacements(getLanguageFromRuleMatch(match).adaptSuggestionsList(replacements, verbSynthesizer.getWholeOriginalStr()));
return ruleMatch;
}