Java RuleMatch.setSuggestedReplacement方法代码示例

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
private List<RuleMatch> getRuleMatches(String resultXml, AnnotatedText text) throws XPathExpressionException {
  List<RuleMatch> matches = new ArrayList<>();
  Document document = getDocument(resultXml);
  XPath xPath = XPathFactory.newInstance().newXPath();
  NodeList errors = (NodeList)xPath.evaluate("//error", document, XPathConstants.NODESET);
  for (int i = 0; i < errors.getLength(); i++) {
    Node error = errors.item(i);
    String string = xPath.evaluate("string", error);
    String description = xPath.evaluate("description", error);
    String preContext = xPath.evaluate("precontext", error);
    String errorText = preContext + " " + string;
    int fromPos = text.getPlainText().indexOf(errorText) + preContext.length() + 1;
    int toPos = fromPos + string.length();
    NodeList suggestions = (NodeList)xPath.evaluate("suggestions", error, XPathConstants.NODESET);
    RuleMatch ruleMatch = new RuleMatch(new AtdRule(), null, 
            text.getOriginalTextPositionFor(fromPos), text.getOriginalTextPositionFor(toPos), description);
    for (int j = 0; j < suggestions.getLength(); j++) {
      Node option = suggestions.item(j);
      String optionStr = xPath.evaluate("option", option);
      ruleMatch.setSuggestedReplacement(optionStr);
    }
    matches.add(ruleMatch);
  }
  return matches;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@NotNull
private RuleMatch createRuleMatch(AnalyzedTokenReadings token, Suggestion suggestion, float[] y) {
  String msg = getMessage(suggestion, y);
  int pos = token.getStartPos();
  RuleMatch ruleMatch = new RuleMatch(this, pos, pos + token.getToken().length(), msg);
  ruleMatch.setSuggestedReplacement(suggestion.toString());
  return ruleMatch;
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Test
public void testCorrectTextFromMatches() {
  RuleMatch match1 = new RuleMatch(new FakeRule(), null, 0, 9, "msg1");
  match1.setSuggestedReplacement("I've had");
  RuleMatch match2 = new RuleMatch(new FakeRule(), null, 0, 9, "msg2");
  match2.setSuggestedReplacement("I have");
  List<RuleMatch> matches = Arrays.asList(match1, match2);
  assertThat(Tools.correctTextFromMatches("I've have", matches), is("I've had"));
}
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
  public RuleMatch[] match(AnalyzedSentence sentence) throws IOException {
    List<RuleMatch> ruleMatches = new ArrayList<>();
    AnalyzedTokenReadings[] tokens = sentence.getTokensWithoutWhitespace();    

    for (int i = 1; i < tokens.length-1; i++) {
      AnalyzedTokenReadings tokenReadings = tokens[i];
      AnalyzedTokenReadings nextTokenReadings = tokens[i + 1];
      
      boolean isCapitalized = Character.isUpperCase(tokenReadings.getToken().charAt(0));
      
      if (isInPrefixes(tokenReadings, isCapitalized)
          && PosTagHelper.hasPosTagPart(nextTokenReadings, "noun")
//          && ! PosTagHelper.hasPosTag(nextTokenReadings, Pattern.compile("^(?!noun).*"))
          && ALL_LOWER.matcher(nextTokenReadings.getToken()).matches() ) {
    
        String hyphenedWord = tokenReadings.getToken() + "-" + nextTokenReadings.getToken();
        String tokenToCheck = isCapitalized ? StringUtils.uncapitalize(hyphenedWord) : hyphenedWord;
        
        if ( wordTagger.tag(tokenToCheck).size() > 0 ) {
          RuleMatch potentialRuleMatch = new RuleMatch(this, sentence, tokenReadings.getStartPos(), nextTokenReadings.getEndPos(), "Можливо, пропущено дефіс?", getDescription());
          potentialRuleMatch.setSuggestedReplacement(hyphenedWord);

          ruleMatches.add(potentialRuleMatch);
        }
      }
      
    }
    
    return ruleMatches.toArray(new RuleMatch[0]);
  }
 

import org.languagetool.rules.RuleMatch; //导入方法依赖的package包/类
@Override
public RuleMatch[] match(List<AnalyzedSentence> sentences) throws IOException {
  String firstUse = null;
  List<RuleMatch> ruleMatches = new ArrayList<>();
  int pos = 0;
  for (AnalyzedSentence sentence : sentences) {
    AnalyzedTokenReadings[] tokens = sentence.getTokensWithoutWhitespace();
    for (int i = 0; i < tokens.length; i++) {
      if (i > 0 && (tokens[i-1].isSentenceStart() || tokens[i-1].getToken().matches("[\"„:]"))) {
        continue;
      }
      AnalyzedTokenReadings token = tokens[i];
      String word = token.getToken();
      String lcWord = word.toLowerCase();
      if (lowerWords.contains(lcWord) || ambiguousWords.contains(lcWord)) {
        if (firstUse == null) {
          if (!ambiguousWords.contains(word)) {
            firstUse = word;
          }
        } else {
          boolean firstUseIsUpper = StringTools.startsWithUppercase(firstUse);
          String msg = null;
          String replacement = null;
          if (firstUseIsUpper && !StringTools.startsWithUppercase(word)) {
            replacement =  StringTools.uppercaseFirstChar(word);
            if (ambiguousWords.contains(word)) {
              msg = "Vorher wurde bereits '" + firstUse + "' großgeschrieben. " +
                      "Nur falls es sich hier auch um eine Anrede handelt: Aus Gründen der Einheitlichkeit '" + replacement + "' hier auch großschreiben?";
            } else {
              msg = "Vorher wurde bereits '" + firstUse + "' großgeschrieben. " +
                      "Aus Gründen der Einheitlichkeit '" + replacement + "' hier auch großschreiben?";
            }
          } else if (!firstUseIsUpper && StringTools.startsWithUppercase(word)) {
            replacement = StringTools.lowercaseFirstChar(word);
            msg = "Vorher wurde bereits '" + firstUse + "' kleingeschrieben. " +
                    "Aus Gründen der Einheitlichkeit '" + replacement + "' hier auch kleinschreiben?";
          }
          if (replacement != null) {
            RuleMatch ruleMatch = new RuleMatch(this, sentence, pos + token.getStartPos(), pos + token.getEndPos(), msg);
            ruleMatch.setSuggestedReplacement(replacement);
            ruleMatches.add(ruleMatch);
          }
        }
      }
    }
    pos += sentence.getText().length();
  }
  return toRuleMatchArray(ruleMatches);
}