small code cleanups

languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/MultiWordChunker.java

@@ -39,32 +39,26 @@
 public class MultiWordChunker implements Disambiguator {
 
   private final String filename;
+  private final boolean allowFirstCapitalized;
 
   private Map<String, Integer> mStartSpace;
   private Map<String, Integer> mStartNoSpace;
   private Map<String, String> mFull;
-
-  private boolean bAllowFirstCapitalized=false;
-
+
   /**
-   * @param filename
-   *          file text with multiwords and tags
+   * @param filename file text with multiwords and tags
    */
   public MultiWordChunker(final String filename) {
-    super();
-    this.filename = filename;
+    this(filename, false);
   }
 
   /**
-   * @param filename
-   *          file text with multiwords and tags
-   * @param bAllowFirstUpperCase
-   *          if set to {@code true}, first word of the multiword can be capitalized
+   * @param filename file text with multiwords and tags
+   * @param allowFirstCapitalized if set to {@code true}, first word of the multiword can be capitalized
    */
   public MultiWordChunker(final String filename, boolean allowFirstCapitalized) {
-    super();
     this.filename = filename;
-    bAllowFirstCapitalized = allowFirstCapitalized;
+    this.allowFirstCapitalized = allowFirstCapitalized;
   }
 
   /*
@@ -144,7 +138,7 @@ public final AnalyzedSentence disambiguate(final AnalyzedSentence input) {
       }
       // If the second token is not whitespace, concatenate it
       if (i + 1 < anTokens.length && !anTokens[i+1].isWhitespace()) {
-        tok=tok.concat(output[i+1].getToken());
+        tok = tok.concat(output[i+1].getToken());
       }
       // If it is a capitalized word, the second time try with lowercase word.
       int myCount = 0;
@@ -169,7 +163,7 @@ public final AnalyzedSentence disambiguate(final AnalyzedSentence input) {
                     anTokens[finalLen].getToken(), output[finalLen], true);
               }
             } else {
-              if (j>1 && !anTokens[j-1].isWhitespace()) { //avoid multiple whitespaces
+              if (j > 1 && !anTokens[j-1].isWhitespace()) { //avoid multiple whitespaces
                 tokens.append(' ');
                 lenCounter++;
               }
@@ -202,7 +196,7 @@ public final AnalyzedSentence disambiguate(final AnalyzedSentence input) {
         }
         // If it is a capitalized word, try with lowercase word.
         myCount++;
-        if (bAllowFirstCapitalized && StringTools.isCapitalizedWord(tok) 
+        if (allowFirstCapitalized && StringTools.isCapitalizedWord(tok)
             && myCount == 1) {
             tok = tok.toLowerCase();
         } else {

languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/DisambXMLRuleHandler.java

@@ -22,8 +22,6 @@
 import java.util.List;
 
 import org.languagetool.rules.patterns.XMLRuleHandler;
-import org.xml.sax.SAXException;
-import org.xml.sax.SAXParseException;
 
 /**
  * XML rule handler that loads disambiguation rules from XML and throws
@@ -35,20 +33,8 @@ class DisambXMLRuleHandler extends XMLRuleHandler {
 
   final List<DisambiguationPatternRule> rules = new ArrayList<>();
 
-  boolean inDisambiguation;
-
   List<DisambiguationPatternRule> getDisambRules() {
     return rules;
   }
 
-  @Override
-  public void warning(final SAXParseException e) throws SAXException {
-    throw e;
-  }
-
-  @Override
-  public void error(final SAXParseException e) throws SAXException {
-    throw e;
-  }
-
 }

languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/DisambiguationPatternRule.java

@@ -19,7 +19,10 @@
 package org.languagetool.tagging.disambiguation.rules;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 import org.languagetool.AnalyzedSentence;
 import org.languagetool.AnalyzedToken;
@@ -46,8 +49,8 @@ public enum DisambiguatorAction {
   private final DisambiguatorAction disAction;
 
   private AnalyzedToken[] newTokenReadings;
-  private List<DisambiguatedExample> examples;
-  private List<String> untouchedExamples;
+  private List<DisambiguatedExample> examples = new ArrayList<>();
+  private List<String> untouchedExamples = new ArrayList<>();
 
   /**
    * @param id Id of the Rule
@@ -106,35 +109,35 @@ public final AnalyzedSentence replace(final AnalyzedSentence sentence) throws IO
    * @param examples the examples to set
    */
   public void setExamples(final List<DisambiguatedExample> examples) {
-    this.examples = examples;
+    this.examples = Objects.requireNonNull(examples);
   }
 
   /**
    * @return the examples
    */
   public List<DisambiguatedExample> getExamples() {
-    return examples;
+    return Collections.unmodifiableList(examples);
   }
 
   /**
    * @param untouchedExamples the untouchedExamples to set
    */
   public void setUntouchedExamples(final List<String> untouchedExamples) {
-    this.untouchedExamples = untouchedExamples;
+    this.untouchedExamples = Objects.requireNonNull(untouchedExamples);
   }
 
   /**
    * @return the untouchedExamples
    */
   public List<String> getUntouchedExamples() {
-    return untouchedExamples;
+    return Collections.unmodifiableList(untouchedExamples);
   }
 
   /**
    * For testing only.
    */
   public final List<Element> getElements() {
-    return patternElements;
+    return Collections.unmodifiableList(patternElements);
   }
 
   /**

languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/DisambiguationPatternRuleReplacer.java

@@ -37,7 +37,7 @@
  */
 class DisambiguationPatternRuleReplacer extends AbstractPatternRulePerformer {
 
-  List<Boolean> elementsMatched;
+  private final List<Boolean> elementsMatched;
 
   public DisambiguationPatternRuleReplacer(DisambiguationPatternRule rule) {
     super(rule, rule.getLanguage().getDisambiguationUnifier());

languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/DisambiguationRuleLoader.java

@@ -69,6 +69,7 @@ class DisambiguationRuleHandler extends DisambXMLRuleHandler {
   private static final String ACTION = "action";
   private static final String DISAMBIG = "disambig";
 
+  private boolean inDisambiguation;
   private int subId;
   private String name;
   private String ruleGroupId;

languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/XmlRuleDisambiguator.java

@@ -41,26 +41,23 @@
 public class XmlRuleDisambiguator implements Disambiguator {
 
   private static final String DISAMBIGUATION_FILE = "disambiguation.xml";
-
-  private List<DisambiguationPatternRule> disambiguationRules;
-  private final Language language;
+
+  private final List<DisambiguationPatternRule> disambiguationRules;
 
   public XmlRuleDisambiguator(final Language language) {
-    this.language = Objects.requireNonNull(language);
+    Objects.requireNonNull(language);
+    final String disambiguationFile =
+            JLanguageTool.getDataBroker().getResourceDir() + "/" + language.getShortName() + "/" + DISAMBIGUATION_FILE;
+    try {
+      disambiguationRules = loadPatternRules(disambiguationFile);
+    } catch (Exception e) {
+      throw new RuntimeException("Problems with loading disambiguation file: " + disambiguationFile, e);
+    }
   }
 
   @Override
   public AnalyzedSentence disambiguate(final AnalyzedSentence input) throws IOException {
     AnalyzedSentence sentence = input;
-    if (disambiguationRules == null) {
-      final String disambiguationFile =
-        JLanguageTool.getDataBroker().getResourceDir() + "/" + language.getShortName() + "/" + DISAMBIGUATION_FILE;
-      try {
-        disambiguationRules = loadPatternRules(disambiguationFile);
-      } catch (final Exception e) {
-        throw new RuntimeException("Problems with loading disambiguation file: " + disambiguationFile, e);
-      }
-    }
     for (final DisambiguationPatternRule patternRule : disambiguationRules) {
       sentence = patternRule.replace(sentence);
     }

languagetool-core/src/main/java/org/languagetool/tokenizers/LocalSRXSentenceTokenizer.java

@@ -20,7 +20,9 @@
 
 import net.sourceforge.segment.srx.SrxDocument;
 import org.languagetool.Language;
+import org.languagetool.tools.Tools;
 
+import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;
 import java.util.Objects;
@@ -44,11 +46,12 @@ public class LocalSRXSentenceTokenizer implements SentenceTokenizer {
    */
   public LocalSRXSentenceTokenizer(Language language, String srxInClassPath) {
     this.language = Objects.requireNonNull(language);
-    InputStream stream = this.getClass().getResourceAsStream(srxInClassPath);
-    if (stream == null) {
-      throw new RuntimeException("Could not find SRX file in classpath: " + srxInClassPath);
+    try {
+      InputStream stream = Tools.getStream(srxInClassPath);
+      this.srxDocument = SrxTools.createSrxDocument(stream);  // will close the stream on its own
+    } catch (IOException e) {
+      throw new RuntimeException(e);
     }
-    this.srxDocument = SrxTools.createSrxDocument(stream);  // will close the stream on its own
     setSingleLineBreaksMarksParagraph(false);
   }
 

languagetool-core/src/main/java/org/languagetool/tokenizers/SimpleSentenceTokenizer.java

@@ -28,7 +28,7 @@
 
 /**
  * A very simple sentence tokenizer that splits on {@code [.!?…]} followed by whitespace
- * or an uppercase letter. You probably want ot use an adapted {@link LocalSRXSentenceTokenizer} instead.
+ * or an uppercase letter. You probably want to use an adapted {@link LocalSRXSentenceTokenizer} instead.
  * @since 2.6
  */
 public class SimpleSentenceTokenizer extends LocalSRXSentenceTokenizer {

languagetool-core/src/main/java/org/languagetool/tools/Tools.java

@@ -242,16 +242,16 @@ public static String getFullStackTrace(final Throwable e) {
 
   /**
    * Load a file from the classpath using {@link Class#getResourceAsStream(String)}.
-   * 
+   *
    * @return the stream of the file
    */
-  public static InputStream getStream(final String filename) throws IOException {
+  public static InputStream getStream(final String path) throws IOException {
     // the other ways to load the stream like
     // "Tools.class.getClass().getResourceAsStream(filename)"
     // don't work in a web context (using Grails):
-    final InputStream is = Tools.class.getResourceAsStream(filename);
+    final InputStream is = Tools.class.getResourceAsStream(path);
     if (is == null) {
-      throw new IOException("Could not load file from classpath : " + filename);
+      throw new IOException("Could not load file from classpath: '" + path + "'");
     }
     return is;
   }

languagetool-core/src/main/java/org/languagetool/tools/UnsyncStack.java

@@ -27,6 +27,7 @@
  * this one is based on ArrayList). Usage is the same as the java.util.Stack.
  * 
  * @author Marcin Miłkowski.
+ * @deprecated will be made non-public in the future (deprecated since 2.9)
  */
 public class UnsyncStack<E> extends ArrayList<E> {
 

languagetool-core/src/test/java/org/languagetool/tokenizers/SimpleSentenceTokenizerTest.java

@@ -23,14 +23,13 @@
 
 public class SimpleSentenceTokenizerTest {
 
-  private static final SimpleSentenceTokenizer tokenizer = new SimpleSentenceTokenizer();
-
   @Test
   public void testTokenize() throws Exception {
     testSplit("Hi! ", "This is a test. ", "Here's more. ", "And even more?? ", "Yes.");
   }
 
   private void testSplit(String... sentences) {
+    SimpleSentenceTokenizer tokenizer = new SimpleSentenceTokenizer();
     TestTools.testSplit(sentences, tokenizer);
   }