Java RuleMatch类代码示例

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
public static void main(String[] args) {
	System.out.println("start...");
	try {
		JLanguageTool langTool = new JLanguageTool(Language.ENGLISH);
		langTool.activateDefaultPatternRules();
		List<RuleMatch> matches = langTool.check("A sentence "
				+ "with a error in the Hitchhiker's Guide tot he Galaxy");
		for (RuleMatch match : matches) {
			System.out.println("Potential error at line "
					+ match.getEndLine() + ", column " + match.getColumn()
					+ ": " + match.getMessage());
			System.out.println("Suggested correction: "
					+ match.getSuggestedReplacements());
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	System.out.println("finished.");
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
public boolean spellcheckDocument() {
    editorToolBar.setActionText("Spell checking document \'" + file.getName() + "\'");
    Platform.runLater(() -> {
        try {
            timer.start();
            List<RuleMatch> matches = spellcheck.check(getContent());
            MarkdownHighligher.computeSpellcheckHighlighting(matches, this);
            editorToolBar.setActionText("Found " + matches.size() + " misspellings in the document \'" + file.getName() + "\' (" + timer.end() + "ms)");
        } catch (IOException e) {
            dialogFactory.buildExceptionDialogBox(
                    dict.DIALOG_EXCEPTION_TITLE,
                    dict.DIALOG_EXCEPTION_SPELLCHECK_CONTENT,
                    e.getMessage(),
                    e
            );
        }
    });

    return true;
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
public List<RuleMatch> check(String text) throws IOException {
    List<RuleMatch> matches = languageTool.check(text);
    matches = matches.stream().filter(match -> {
        String str = text.substring(match.getFromPos(), match.getToPos());
        if(Lists.newArrayList(spellcheckExcluded).contains(str)){
            return false;
        }
        for(String ex : spellcheckExcludedTags){
            if(str.startsWith(ex) || str.endsWith(ex)){
                return false;
            }
        }
        logger.debug("Found misspelling \'{}\' at {} to {}", str, match.getFromPos(), match.getToPos());
        return true;
    }).collect(Collectors.toList());
    logger.debug("Found " + matches.size() + " misspellings in current document");
    return matches;
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
private String sanitizeText(String message) {
    String result = message;
    try {
        List<RuleMatch> matches = helper.getLanguageTool().check(message);
        for (RuleMatch match : matches) {
            String error = message.substring(match.getFromPos(), match.getToPos());
            List<String> replacements = match.getSuggestedReplacements();
            if(replacements.size() > 0) {
                result = result.replace(error, match.getSuggestedReplacements().get(0));
            }
        }
    }
    catch(Exception e) {
        e.printStackTrace();
    }
    return result;
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
/**
 * Tdestings
 * 
 * @param collector
 * @param matches
 */

private void processMatches(ISpellingProblemCollector collector, List<RuleMatch> matches) {
	WorkspaceModifyOperation workspaceRunnable = new WorkspaceModifyOperation() {
		@Override
		protected void execute(IProgressMonitor monitor)
				throws CoreException, InvocationTargetException, InterruptedException {
			// TODO
			deleteMarkers();
			matches.forEach(match -> {
				collector.accept(new LTSpellingProblem(match));
				addMarker(match);
			});
		}

	};

	try {
		workspaceRunnable.run(null);
	} catch (InvocationTargetException | InterruptedException e) {
		e.printStackTrace();
	}
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
public void onViewPortChanged(Object editor, int from, int to)
{
    logger.debug("viewport changed");
    Platform.runLater(() -> {
        int fromIndex = (int) webview.getEngine().executeScript("editor.indexFromPos({line:" + from + ",ch: 0});");
        int toIndex = (int) webview.getEngine().executeScript("editor.indexFromPos({line:" + (to + 1) +",ch: 0});");

        String text = getCode();
        text = text.substring(fromIndex, toIndex);
        List<RuleMatch> results = checkText(text);
        for (RuleMatch result : results)
        {
            int resultFromIndex = result.getFromPos();
            int resultToIndex = result.getToPos();
            webview.getEngine().executeScript("editor.markText(editor.posFromIndex(" + (fromIndex + resultFromIndex) + "), editor.posFromIndex(" + (fromIndex + resultToIndex) + ")," +
                    "{\"className\": \"cm-spell-error\"})");
        }
    });
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
public void spellCheckAllText() throws BadLocationException {   
    Document doc = etc.getrSyntaxTextArea().getDocument();   
    if (doc != null) {                                                
        String editorText = etc.getrSyntaxTextArea().getText(0, doc.getLength());            
        if (editorText != null) {  
            Highlighter highlighter = etc.getrSyntaxTextArea().getHighlighter();                                      
            if(etc.getEditorState().isHighlighted()) {  
                List<RuleMatch> matches = null;  
                try {
                    matches = etc.getLangTool().check(editorText);
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }

                //Highlight the spelling check results
                for (RuleMatch match : matches) {
                    highlighter.addHighlight(match.getFromPos(), match.getToPos(), etc.getPainter());   
                }                        
            } else {  
                highlighter.removeAllHighlights();
            }
        }
    }        
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
@Test
public void testIgnoreSuggestionsWithMorfologik() throws IOException {
  JLanguageTool lt = new JLanguageTool(new AmericanEnglish());

  assertThat(lt.check("This is anArtificialTestWordForLanguageTool.").size(), is(0));   // no error, as this word is in ignore.txt
  assertThat(lt.check("How an ab initio calculation works.").size(), is(0));   // As a multi-word entry in spelling.txt "ab initio" must be accepted
  assertThat(lt.check("Test adjoint").size(), is(0));   // in spelling.txt
  assertThat(lt.check("Test Adjoint").size(), is(0));   // in spelling.txt (lowercase)

  List<RuleMatch> matches2 = lt.check("This is a real typoh.");
  assertThat(matches2.size(), is(1));
  assertThat(matches2.get(0).getRule().getId(), is("MORFOLOGIK_RULE_EN_US"));

  List<RuleMatch> matches3 = lt.check("This is anotherArtificialTestWordForLanguageTol.");  // note the typo
  assertThat(matches3.size(), is(1));
  assertThat(matches3.get(0).getSuggestedReplacements().toString(), is("[anotherArtificialTestWordForLanguageTool]"));
}
 

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; i++) {
    String token = tokens[i].getToken();
    if (getSubjects().contains(token)) {
      String[] context = getContext(tokens, i);
      float[] y = classifier.getScores(context);
      Suggestion suggestion = getSuggestion(y);
      if (!suggestion.matches(token)) {
        if (!suggestion.isUnsure()) {
          ruleMatches.add(createRuleMatch(tokens[i], suggestion, y));
        } else {
          if (DEBUG) {
            System.out.println("unsure: " + getMessage(suggestion, y) + Arrays.toString(context));
          }
        }
      }
    }
  }
  return toRuleMatchArray(ruleMatches);
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
@Test
public void testRule() throws IOException {

  // correct sentences:
  assertEquals(0, rule.match(langTool.getAnalyzedSentence("It wasn't me.")).length);
  assertEquals(0, rule.match(langTool.getAnalyzedSentence("I'm ill.")).length);
  assertEquals(0, rule.match(langTool.getAnalyzedSentence("Staatszerfall im südlichen Afrika.")).length);

  // incorrect sentences:

  // at the beginning of a sentence
  checkSimpleReplaceRule("Wasnt this great", "Wasn't");
  checkSimpleReplaceRule("YOURE WRONG", "YOU'RE");
  checkSimpleReplaceRule("Dont do this", "Don't");
  // inside sentence
  checkSimpleReplaceRule("It wasnt me", "wasn't");
  checkSimpleReplaceRule("You neednt do this", "needn't");
  checkSimpleReplaceRule("I know Im wrong", "I'm");

  //two suggestions
  final RuleMatch[] matches = rule.match(langTool.getAnalyzedSentence("Whereve you are"));
  assertEquals(2, matches[0].getSuggestedReplacements().size());
  assertEquals("Where've", matches[0].getSuggestedReplacements().get(0));
  assertEquals("Wherever", matches[0].getSuggestedReplacements().get(1));

}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
private void checkCorrections(Rule rule, IncorrectExample incorrectExample, List<String> xmlLines, JLanguageTool tool) throws IOException {
  List<String> corrections = incorrectExample.getCorrections();
  if (corrections.isEmpty()) {
    for (Rule r : tool.getAllActiveRules()) {
      tool.disableRule(r.getId());
    }
    tool.enableRule(rule.getId());
    String incorrectSentence = incorrectExample.getExample().replaceAll("</?marker>", "");
    List<RuleMatch> matches = tool.check(incorrectSentence);
    System.err.println("no corrections: " + rule.getId() + ", " + matches.size() + " matches");
    if (matches.size() == 0) {
      throw new RuntimeException("Got no rule match: " + incorrectSentence);
    }
    List<String> suggestedReplacements = matches.get(0).getSuggestedReplacements();
    String newAttribute = "correction=\"" + String.join("|", suggestedReplacements) + "\"";
    addAttribute(rule, newAttribute, xmlLines);
  }
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
protected List<RuleMatch> getRuleMatches(String word, int startPos, AnalyzedSentence sentence) throws IOException {
  List<RuleMatch> ruleMatches = new ArrayList<>();
  if (isMisspelled(speller1, word) || isProhibited(word)) {
    RuleMatch ruleMatch = new RuleMatch(this, sentence, startPos, startPos
        + word.length(), messages.getString("spelling"),
        messages.getString("desc_spelling_short"));
    List<String> suggestions = speller1.getSuggestions(word);
    if (suggestions.isEmpty() && word.length() >= 5) {
      // speller1 uses a maximum edit distance of 1, it won't find suggestion for "garentee", "greatful" etc.
      suggestions.addAll(speller2.getSuggestions(word));
      if (suggestions.isEmpty()) {
        suggestions.addAll(speller3.getSuggestions(word));
      }
    }
    suggestions.addAll(0, getAdditionalTopSuggestions(suggestions, word));
    suggestions.addAll(getAdditionalSuggestions(suggestions, word));
    if (!suggestions.isEmpty()) {
      filterSuggestions(suggestions);
      ruleMatch.setSuggestedReplacements(orderSuggestions(suggestions, word));
    }
    ruleMatches.add(ruleMatch);
  }
  return ruleMatches;
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
public void testWithException() throws Exception {
  createIndex("How to move back and fourth from linux to xmb?");
  PatternToken exceptionElem = new PatternToken("forth|back", false, true, false);
  exceptionElem.setStringPosException("exception", false, false, false, false, false, "POS", false, false, null);
  List<PatternToken> patternTokens = Arrays.asList(
      new PatternToken("move", false, false, false),
      exceptionElem
      );
  PatternRule rule1 = new PatternRule("RULE1", new English(), patternTokens, "desc", "msg", "shortMsg");
  Searcher errorSearcher = new Searcher(directory);
  SearcherResult searcherResult = errorSearcher.findRuleMatchesOnIndex(rule1, new English());
  assertEquals(1, searcherResult.getCheckedSentences());
  assertEquals(1, searcherResult.getMatchingSentences().size());
  List<RuleMatch> ruleMatches = searcherResult.getMatchingSentences().get(0).getRuleMatches();
  assertEquals(1, ruleMatches.size());
  Rule rule = ruleMatches.get(0).getRule();
  assertEquals("RULE1", rule.getId());
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
@Override
protected List<RuleMatch> performCheck(List<AnalyzedSentence> analyzedSentences, List<String> sentences,
     List<Rule> allRules, ParagraphHandling paraMode, 
     AnnotatedText annotatedText, RuleMatchListener listener) throws IOException {
  int charCount = 0;
  int lineCount = 0;
  int columnCount = 1;

  List<RuleMatch> ruleMatches = new ArrayList<>();
  
  ExecutorService executorService = getExecutorService();
  try {
    List<Callable<List<RuleMatch>>> callables =
            createTextCheckCallables(paraMode, annotatedText, analyzedSentences, sentences, allRules, charCount, lineCount, columnCount, listener);
    List<Future<List<RuleMatch>>> futures = executorService.invokeAll(callables);
    for (Future<List<RuleMatch>> future : futures) {
      ruleMatches.addAll(future.get());
    }
  } catch (InterruptedException | ExecutionException e) {
    throw new RuntimeException(e);
  }
  
  return ruleMatches;
}
 

import org.languagetool.rules.RuleMatch; //导入依赖的package包/类
/**
 * Check the text against the compound rule.
 * @param expectedErrors the number of expected errors
 * @param text the text to check
 * @param expSuggestions the expected suggestions
 */
private void check(int expectedErrors, String text, String[] expSuggestions) throws IOException {
  assertNotNull("Please initialize langTool!", langTool);
  assertNotNull("Please initialize 'rule'!", rule);
  RuleMatch[] ruleMatches = rule.match(langTool.getAnalyzedSentence(text));
  assertEquals("Expected " + expectedErrors + "errors, but got: " + Arrays.toString(ruleMatches),
      expectedErrors, ruleMatches.length);
  if (expSuggestions != null && expectedErrors != 1) {
    throw new RuntimeException("Sorry, test case can only check suggestion if there's one rule match");
  }
  if (expSuggestions != null) {
    RuleMatch ruleMatch = ruleMatches[0];
    String errorMessage =
        String.format("Got these suggestions: %s, expected %s ", ruleMatch.getSuggestedReplacements(),
            Arrays.toString(expSuggestions));
    assertEquals(errorMessage, expSuggestions.length, ruleMatch.getSuggestedReplacements().size());
    int i = 0;
    for (Object element : ruleMatch.getSuggestedReplacements()) {
      String suggestion = (String) element;
      assertEquals(expSuggestions[i], suggestion);
      i++;
    }
  }
}