Revision: 7161
http://languagetool.svn.sourceforge.net/languagetool/?rev=7161&view=rev
Author: dnaber
Date: 2012-06-02 10:10:49 +0000 (Sat, 02 Jun 2012)
Log Message:
-----------
index searcher cleanup - now handles fallback for unsupported rules
transparently; some cleanups
Modified Paths:
--------------
trunk/JLanguageTool/src/dev/org/languagetool/dev/conversion/RuleCoverage.java
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
trunk/JLanguageTool/src/java/org/languagetool/JLanguageTool.java
trunk/JLanguageTool/src/java/org/languagetool/rules/patterns/PatternRuleLoader.java
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
Added Paths:
-----------
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/MatchingSentence.java
Modified:
trunk/JLanguageTool/src/dev/org/languagetool/dev/conversion/RuleCoverage.java
===================================================================
---
trunk/JLanguageTool/src/dev/org/languagetool/dev/conversion/RuleCoverage.java
2012-06-02 10:04:32 UTC (rev 7160)
+++
trunk/JLanguageTool/src/dev/org/languagetool/dev/conversion/RuleCoverage.java
2012-06-02 10:10:49 UTC (rev 7161)
@@ -189,7 +189,7 @@
/**
* Generates an error string that matches the given PatternRule object
- * @param pattern
+ * @param patternrule
* @return
*/
public String generateIncorrectExample(PatternRule patternrule) {
@@ -469,7 +469,6 @@
* Faster version of inExceptionList, because we don't have to re-compile
the Patterns for the exception elements
* @param word
* @param exceptionAttributes
- * @param numExceptions
* @return
*/
@SuppressWarnings("unchecked")
@@ -497,10 +496,6 @@
* @param word
* @param tokenPattern
* @param posPattern
- * @param isTokenEmpty
- * @param hasPosTag
- * @param negate
- * @param postagNegate
* @return
*/
public boolean isExampleOf(String word, Pattern tokenPattern, Pattern
posPattern, Element e) {
@@ -824,10 +819,11 @@
final PatternRuleLoader ruleLoader = new PatternRuleLoader();
InputStream is = this.getClass().getResourceAsStream(filename);
if (is == null) {
- // happens for external rules plugged in as an XML file:
- is = new FileInputStream(filename);
+ // happens for external rules plugged in as an XML file:
+ return ruleLoader.getRules(new File(filename));
+ } else {
+ return ruleLoader.getRules(is, filename);
}
- return ruleLoader.getRules(is, filename);
}
public List<PatternRule> parsePatternRule(final String ruleString) {
@@ -835,7 +831,7 @@
String ruleFileString = ruleFileHeader + categoriesString + ruleString
+ endCategoriesString + endRulesString;
InputStream is = new ByteArrayInputStream(ruleFileString.getBytes());
try {
- return ruleLoader.getRules(is,null);
+ return ruleLoader.getRules(is, null);
} catch (IOException e) {
return new ArrayList<PatternRule>();
}
@@ -849,7 +845,7 @@
String ruleFileString = ruleFileHeader + categoriesString + rs +
endCategoriesString + endRulesString;
InputStream is = new ByteArrayInputStream(ruleFileString.getBytes());
try {
- return ruleLoader.getRules(is,null);
+ return ruleLoader.getRules(is, null);
} catch (IOException e) {
return new ArrayList<PatternRule>();
}
Added:
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/MatchingSentence.java
===================================================================
---
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/MatchingSentence.java
(rev 0)
+++
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/MatchingSentence.java
2012-06-02 10:10:49 UTC (rev 7161)
@@ -0,0 +1,45 @@
+/* LanguageTool, a natural language style checker
+ * Copyright (C) 2012 Daniel Naber (http://www.danielnaber.de)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ */
+package org.languagetool.dev.index;
+
+import org.languagetool.rules.RuleMatch;
+
+import java.util.List;
+
+/**
+ * A sentence with rule matches.
+ */
+public class MatchingSentence {
+
+ private final String sentence;
+ private final List<RuleMatch> ruleMatches;
+
+ MatchingSentence(String sentence, List<RuleMatch> ruleMatches) {
+ this.sentence = sentence;
+ this.ruleMatches = ruleMatches;
+ }
+
+ public String getSentence() {
+ return sentence;
+ }
+
+ public List<RuleMatch> getRuleMatches() {
+ return ruleMatches;
+ }
+}
Modified: trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
===================================================================
--- trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
2012-06-02 10:04:32 UTC (rev 7160)
+++ trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
2012-06-02 10:10:49 UTC (rev 7161)
@@ -19,9 +19,7 @@
package org.languagetool.dev.index;
import java.io.File;
-import java.io.FileInputStream;
import java.io.IOException;
-import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
@@ -40,10 +38,13 @@
import org.languagetool.rules.patterns.PatternRuleLoader;
/**
- * A class with a main() method that takes a rule id (of a simple rule) and
the location of the
- * index that runs the query on that index and prints all matches
+ * A class with a main() method that takes a rule id and the location of the
+ * index that runs the query on that index and prints all matches.
+ * Will transparently handle rules that are not supported, i.e. run on the
candidate matches
+ * up to a limit.
*
* @author Tao Lin
+ * @author Daniel Naber
*/
public class Searcher {
@@ -62,7 +63,7 @@
this.maxHits = maxHits;
}
- public List<RuleMatch> findRuleMatchesOnIndex(PatternRule rule, Language
language, File indexDir) throws IOException {
+ public List<MatchingSentence> findRuleMatchesOnIndex(PatternRule rule,
Language language, File indexDir) throws IOException {
final IndexSearcher indexSearcher = new
IndexSearcher(FSDirectory.open(indexDir));
try {
return findRuleMatchesOnIndex(rule, language, indexSearcher);
@@ -71,18 +72,37 @@
}
}
- public List<RuleMatch> findRuleMatchesOnIndex(PatternRule rule, Language
language, IndexSearcher indexSearcher) throws IOException {
- final List<RuleMatch> matches = new ArrayList<RuleMatch>();
+ public List<MatchingSentence> findRuleMatchesOnIndex(PatternRule rule,
Language language, IndexSearcher indexSearcher) throws IOException {
final Query query = createQuery(rule);
final TopDocs topDocs = indexSearcher.search(query, maxHits);
final JLanguageTool languageTool = getLanguageToolWithOneRule(language,
rule);
+ final List<MatchingSentence> matchingSentences =
findMatchingSentences(indexSearcher, topDocs, languageTool);
+ return matchingSentences;
+ }
+
+ PatternRule getRuleById(String ruleId, File xmlRuleFile) throws IOException {
+ final PatternRuleLoader ruleLoader = new PatternRuleLoader();
+ final List<PatternRule> rules = ruleLoader.getRules(xmlRuleFile);
+ for (PatternRule rule : rules) {
+ if (rule.getId().equals(ruleId)) {
+ return rule;
+ }
+ }
+ throw new PatternRuleNotFoundException(ruleId, xmlRuleFile);
+ }
+
+ private List<MatchingSentence> findMatchingSentences(IndexSearcher
indexSearcher, TopDocs topDocs, JLanguageTool languageTool) throws IOException {
+ final List<MatchingSentence> matchingSentences = new
ArrayList<MatchingSentence>();
for (ScoreDoc match : topDocs.scoreDocs) {
final Document doc = indexSearcher.doc(match.doc);
final String sentence = doc.get(PatternRuleQueryBuilder.FIELD_NAME);
final List<RuleMatch> ruleMatches = languageTool.check(sentence);
- matches.addAll(ruleMatches);
+ if (ruleMatches.size() > 0) {
+ final MatchingSentence matchingSentence = new
MatchingSentence(sentence, ruleMatches);
+ matchingSentences.add(matchingSentence);
+ }
}
- return matches;
+ return matchingSentences;
}
private Query createQuery(PatternRule rule) {
@@ -96,34 +116,6 @@
return query;
}
- public TopDocs run(PatternRule rule, IndexSearcher searcher, boolean
throwExceptionOnUnsupportedRule)
- throws IOException, UnsupportedPatternRuleException {
- final PatternRuleQueryBuilder patternRuleQueryBuilder = new
PatternRuleQueryBuilder();
- final Query query;
- if (throwExceptionOnUnsupportedRule) {
- query = patternRuleQueryBuilder.buildQuery(rule);
- } else {
- query = patternRuleQueryBuilder.buildPossiblyRelaxedQuery(rule);
- }
- return searcher.search(query, maxHits);
- }
-
- public TopDocs run(String ruleId, File xmlRuleFile, IndexSearcher searcher,
boolean checkUnsupportedRule) throws IOException,
UnsupportedPatternRuleException {
- final PatternRule rule = getRuleById(ruleId, xmlRuleFile);
- final TopDocs topDocs = run(rule, searcher, checkUnsupportedRule);
- return topDocs;
- }
-
- private PatternRule getRuleById(String ruleId, File xmlRuleFile) throws
IOException {
- final List<PatternRule> rules = loadRules(xmlRuleFile);
- for (PatternRule rule : rules) {
- if (rule.getId().equals(ruleId)) {
- return rule;
- }
- }
- throw new PatternRuleNotFoundException(ruleId, xmlRuleFile);
- }
-
private JLanguageTool getLanguageToolWithOneRule(Language lang, PatternRule
patternRule) throws IOException {
final JLanguageTool langTool = new JLanguageTool(lang);
for (Rule rule : langTool.getAllActiveRules()) {
@@ -133,81 +125,13 @@
return langTool;
}
- private List<PatternRule> loadRules(File xmlRuleFile) throws IOException {
- final InputStream xmlRulesStream = new FileInputStream(xmlRuleFile);
- try {
- final PatternRuleLoader ruleLoader = new PatternRuleLoader();
- return ruleLoader.getRules(xmlRulesStream,
xmlRuleFile.getAbsolutePath());
- } finally {
- xmlRulesStream.close();
- }
- }
-
- private void run(String ruleId, File xmlRuleFile, File indexDir)
- throws IOException, UnsupportedPatternRuleException {
- if (!xmlRuleFile.exists() || !xmlRuleFile.canRead()) {
- System.out.println("Rule XML file '" + xmlRuleFile.getAbsolutePath()
- + "' does not exist or is not readable, please check the path");
- System.exit(1);
- }
- final IndexSearcher searcher = new
IndexSearcher(FSDirectory.open(indexDir));
-
- try {
- final TopDocs topDocs = run(ruleId, xmlRuleFile, searcher, true);
- printResult(topDocs, searcher, null);
- } catch (UnsupportedPatternRuleException e) {
- System.out.println(e.getMessage() + " Will run checking on potential
matches (this can be slow):");
- final TopDocs topDocs = run(ruleId, xmlRuleFile, searcher, false);
- final JLanguageTool languageTool = getLanguageToolWithOneRule(ruleId,
xmlRuleFile);
- printResult(topDocs, searcher, languageTool);
- }
- searcher.close();
- }
-
- private JLanguageTool getLanguageToolWithOneRule(String ruleId, File
xmlRuleFile) throws IOException {
- final JLanguageTool languageTool = new JLanguageTool(Language.DEMO);
- final List<PatternRule> patternRules = loadRules(xmlRuleFile);
- for (PatternRule patternRule : patternRules) {
- if (ruleId.equals(patternRule.getId())) {
- languageTool.addRule(patternRule);
- }
- }
- return languageTool;
- }
-
- private void printResult(TopDocs docs, IndexSearcher searcher, JLanguageTool
languageTool)
- throws IOException {
-
- final ScoreDoc[] hits = docs.scoreDocs;
- if (languageTool != null) {
- System.out.println("Potential search results: " + docs.totalHits);
- } else {
- System.out.println("Search results: " + docs.totalHits);
- }
-
- for (int i = 0; i < Math.min(docs.totalHits, maxHits);) {
- final Document doc = searcher.doc(hits[i++].doc);
- final String sentence = doc.get(PatternRuleQueryBuilder.FIELD_NAME);
- if (languageTool != null) {
- final List<RuleMatch> ruleMatches = languageTool.check(sentence);
- if (ruleMatches.size() > 0) {
- System.out.println(i + ": " + sentence);
- }
- } else {
- System.out.println(i + ": " + sentence);
- }
- }
- if (docs.totalHits > maxHits) {
- System.out.println("NOTE: matches skipped due to maximum hit limit of "
+ maxHits);
- }
- }
-
private static void ensureCorrectUsageOrExit(String[] args) {
- if (args.length != 3) {
- System.err.println("Usage: Searcher <ruleId> <ruleXML> <indexDir>");
- System.err.println("\truleId Id of the rule to search");
- System.err.println("\truleXML path to a rule file, e.g. en/grammar.xml");
- System.err.println("\tindexDir path to a directory containing the
index");
+ if (args.length != 4) {
+ System.err.println("Usage: Searcher <ruleId> <ruleXML> <languageCode>
<indexDir>");
+ System.err.println("\truleId Id of the rule to search for");
+ System.err.println("\truleXML path to a rule file, e.g.
en/grammar.xml");
+ System.err.println("\tlanguageCode short language code, e.g. en for
English");
+ System.err.println("\tindexDir path to a directory containing the
index");
System.exit(1);
}
}
@@ -215,7 +139,21 @@
public static void main(String[] args) throws Exception {
ensureCorrectUsageOrExit(args);
final Searcher searcher = new Searcher();
- searcher.run(args[0], new File(args[1]), new File(args[2]));
+ final String ruleId = args[0];
+ final File ruleFile = new File(args[1]);
+ final String languageCode = args[2];
+ final Language language = Language.getLanguageForShortName(languageCode);
+ if (language == null) {
+ throw new RuntimeException("Unknown language code '" + languageCode +
"'");
+ }
+ final File indexDir = new File(args[3]);
+ final PatternRule rule = searcher.getRuleById(ruleId, ruleFile);
+ final List<MatchingSentence> ruleMatchesOnIndex =
searcher.findRuleMatchesOnIndex(rule, language, indexDir);
+ int i = 1;
+ for (MatchingSentence ruleMatch : ruleMatchesOnIndex) {
+ System.out.println(i + ": " + ruleMatch.getSentence());
+ i++;
+ }
}
}
Modified: trunk/JLanguageTool/src/java/org/languagetool/JLanguageTool.java
===================================================================
--- trunk/JLanguageTool/src/java/org/languagetool/JLanguageTool.java
2012-06-02 10:04:32 UTC (rev 7160)
+++ trunk/JLanguageTool/src/java/org/languagetool/JLanguageTool.java
2012-06-02 10:10:49 UTC (rev 7161)
@@ -311,12 +311,13 @@
public List<PatternRule> loadPatternRules(final String filename)
throws IOException {
final PatternRuleLoader ruleLoader = new PatternRuleLoader();
- InputStream is = this.getClass().getResourceAsStream(filename);
+ final InputStream is = this.getClass().getResourceAsStream(filename);
if (is == null) {
// happens for external rules plugged in as an XML file:
- is = new FileInputStream(filename);
+ return ruleLoader.getRules(new File(filename));
+ } else {
+ return ruleLoader.getRules(is, filename);
}
- return ruleLoader.getRules(is, filename);
}
/**
Modified:
trunk/JLanguageTool/src/java/org/languagetool/rules/patterns/PatternRuleLoader.java
===================================================================
---
trunk/JLanguageTool/src/java/org/languagetool/rules/patterns/PatternRuleLoader.java
2012-06-02 10:04:32 UTC (rev 7160)
+++
trunk/JLanguageTool/src/java/org/languagetool/rules/patterns/PatternRuleLoader.java
2012-06-02 10:10:49 UTC (rev 7161)
@@ -18,6 +18,8 @@
*/
package org.languagetool.rules.patterns;
+import java.io.File;
+import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
@@ -27,8 +29,6 @@
import org.xml.sax.helpers.DefaultHandler;
-import org.languagetool.JLanguageTool;
-
/**
* Loads {@link PatternRule}s from an XML file.
*
@@ -37,11 +37,23 @@
public class PatternRuleLoader extends DefaultHandler {
/**
+ * @param file XML file with pattern rules
+ */
+ public final List<PatternRule> getRules(final File file) throws IOException {
+ final InputStream inputStream = new FileInputStream(file);
+ try {
+ final PatternRuleLoader ruleLoader = new PatternRuleLoader();
+ return ruleLoader.getRules(inputStream, file.getAbsolutePath());
+ } finally {
+ inputStream.close();
+ }
+ }
+
+ /**
* @param is stream with the XML rules
- * @param filename used only for verbose exception message
+ * @param filename used only for verbose exception message - should refer to
where the stream comes from
*/
- public final List<PatternRule> getRules(final InputStream is,
- final String filename) throws IOException {
+ public final List<PatternRule> getRules(final InputStream is, final String
filename) throws IOException {
try {
final PatternRuleHandler handler = new PatternRuleHandler();
final SAXParserFactory factory = SAXParserFactory.newInstance();
@@ -50,17 +62,9 @@
saxParser.parse(is, handler);
return handler.getRules();
} catch (final Exception e) {
- throw new IOException("Cannot load or parse '" + filename + "'", e);
+ throw new IOException("Cannot load or parse input stream of '" +
filename + "'", e);
}
}
- /** Testing only. */
- public final void main(final String[] args) throws IOException {
- final PatternRuleLoader prg = new PatternRuleLoader();
- final String name = "/de/grammar.xml";
- final List<PatternRule> l =
prg.getRules(JLanguageTool.getDataBroker().getFromRulesDirAsStream(name), name);
- System.out.println(l);
- }
-
}
Modified:
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
===================================================================
---
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
2012-06-02 10:04:32 UTC (rev 7160)
+++
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
2012-06-02 10:10:49 UTC (rev 7161)
@@ -19,20 +19,24 @@
package org.languagetool.dev.index;
import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.LuceneTestCase;
import org.languagetool.Language;
+import org.languagetool.rules.Rule;
import org.languagetool.rules.RuleMatch;
import org.languagetool.rules.patterns.Element;
import org.languagetool.rules.patterns.PatternRule;
import java.io.File;
+import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class IndexerSearcherTest extends LuceneTestCase {
+ private final File ruleFile = new File("src/rules/en/grammar.xml");
+ private final Searcher errorSearcher = new Searcher();
+
private IndexSearcher searcher;
private Directory directory;
@@ -40,6 +44,10 @@
public void setUp() throws Exception {
super.setUp();
directory = newDirectory();
+ // Note that the second sentence ends with "lid" instead of "lids" (the
inflated one)
+ final String content = "How to move back and fourth from linux to xmb?
Calcium deposits on eye lid.";
+ Indexer.run(content, directory, Language.ENGLISH, false);
+ searcher = new IndexSearcher(directory);
}
@Override
@@ -52,60 +60,27 @@
}
public void testIndexerSearcher() throws Exception {
- // Note that the second sentence ends with "lid" instead of "lids" (the
inflated one)
- final String content = "How to move back and fourth from linux to xmb?
Calcium deposits on eye lid.";
+ List<MatchingSentence> matchingSentences =
+ errorSearcher.findRuleMatchesOnIndex(getRule("BACK_AND_FOURTH"),
Language.ENGLISH, searcher);
+ assertEquals(1, matchingSentences.size());
- Indexer.run(content, directory, Language.ENGLISH, false);
+ matchingSentences =
errorSearcher.findRuleMatchesOnIndex(getRule("EYE_BROW"), Language.ENGLISH,
searcher);
+ assertEquals(1, matchingSentences.size());
- searcher = new IndexSearcher(directory);
- final Searcher errorSearcher = new Searcher();
- final File ruleFile = new File("src/rules/en/grammar.xml");
- TopDocs topDocs = errorSearcher.run("BACK_AND_FOURTH", ruleFile, searcher,
true);
- assertEquals(1, topDocs.totalHits);
+ matchingSentences =
errorSearcher.findRuleMatchesOnIndex(getRule("ALL_OVER_THE_WORD"),
Language.ENGLISH, searcher);
+ assertEquals(0, matchingSentences.size());
- topDocs = errorSearcher.run("BACK_AND_FOURTH", ruleFile, searcher, false);
- assertEquals(1, topDocs.totalHits);
-
- topDocs = errorSearcher.run("ALL_OVER_THE_WORD", ruleFile, searcher, true);
- assertEquals(0, topDocs.totalHits);
-
- topDocs = errorSearcher.run("ALL_OVER_THE_WORD", ruleFile, searcher,
false);
- assertEquals(0, topDocs.totalHits);
-
try {
- errorSearcher.run("Invalid Rule Id", ruleFile, searcher, true);
+ errorSearcher.findRuleMatchesOnIndex(getRule("Invalid Rule Id"),
Language.ENGLISH, searcher);
fail("Exception should be thrown for invalid rule id.");
- } catch (PatternRuleNotFoundException expected) {
- try {
- errorSearcher.run("Invalid Rule Id", ruleFile, searcher, false);
- fail("Exception should be thrown for invalid rule id.");
- } catch (PatternRuleNotFoundException expected2) {}
- }
+ } catch (PatternRuleNotFoundException expected) {}
+ }
- try {
- errorSearcher.run("EYE_BROW", ruleFile, searcher, true);
- fail("Exception should be thrown for unsupported PatternRule");
- } catch (UnsupportedPatternRuleException expected) {}
-
- topDocs = errorSearcher.run("EYE_BROW", ruleFile, searcher, false);
- assertEquals(1, topDocs.totalHits);
-
-
- try {
- errorSearcher.run("ALL_FOR_NOT", ruleFile, searcher, true);
- fail("Exception should be thrown for unsupported PatternRule");
- } catch (UnsupportedPatternRuleException expected) {
- topDocs = errorSearcher
- .run("ALL_FOR_NOT", ruleFile, searcher, false);
- assertEquals(0, topDocs.totalHits);
- }
+ private PatternRule getRule(String ruleId) throws IOException {
+ return errorSearcher.getRuleById(ruleId, ruleFile);
}
- public void testIndexerSearcher2() throws Exception {
- final String content = "How to move back and fourth from linux to xmb?";
-
- Indexer.run(content, directory, Language.ENGLISH, false);
-
+ public void testIndexerSearcherWithNewRule() throws Exception {
final Searcher errorSearcher = new Searcher();
final List<Element> elements = Arrays.asList(
new Element("move", false, false, false),
@@ -114,9 +89,12 @@
final PatternRule rule1 = new PatternRule("RULE1", Language.ENGLISH,
elements, "desc", "msg", "shortMsg");
final IndexSearcher indexSearcher = new IndexSearcher(directory);
try {
- final List<RuleMatch> matches =
errorSearcher.findRuleMatchesOnIndex(rule1, Language.ENGLISH, indexSearcher);
- assertEquals(1, matches.size());
- assertEquals("RULE1", matches.get(0).getRule().getId());
+ final List<MatchingSentence> matchingSentences =
errorSearcher.findRuleMatchesOnIndex(rule1, Language.ENGLISH, indexSearcher);
+ assertEquals(1, matchingSentences.size());
+ final List<RuleMatch> ruleMatches =
matchingSentences.get(0).getRuleMatches();
+ assertEquals(1, ruleMatches.size());
+ final Rule rule = ruleMatches.get(0).getRule();
+ assertEquals("RULE1", rule.getId());
} finally {
indexSearcher.close();
}
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and
threat landscape has changed and how IT managers can respond. Discussions
will include endpoint security, mobile security and the latest in malware
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Languagetool-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/languagetool-cvs
