cleanup the additional analysis components

LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -14,3 +14,23 @@ In order to install the plugin, simply run: `bin/plugin -install elasticsearch/e
     --------------------------------------------------
 
 The plugin includes the `kuromoji` analyzer.
+
+h1. License
+
+<pre>
+This software is licensed under the Apache 2 license, quoted below.
+
+Copyright 2009-2011 Shay Banon and ElasticSearch <http://www.elasticsearch.org>
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License. You may obtain a copy of
+the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.
+</pre>

pom.xml

@@ -35,6 +35,10 @@
     </properties>
 
     <repositories>
+        <repository>
+            <id>sonatype</id>
+            <url>http://oss.sonatype.org/content/repositories/releases/</url>
+        </repository>
     </repositories>
 
     <dependencies>

src/main/java/org/elasticsearch/index/analysis/KuromojiAnalysisBinderProcessor.java

@@ -1,39 +0,0 @@
-/*
- * Licensed to ElasticSearch and Shay Banon under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. ElasticSearch licenses this
- * file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.elasticsearch.index.analysis;
-
-
-/**
- */
-public class KuromojiAnalysisBinderProcessor extends AnalysisModule.AnalysisBinderProcessor {
-
-    @Override
-    public void processTokenizers(TokenizersBindings tokenizersBindings) {
-      tokenizersBindings.processTokenizer("kuromoji_tokenizer", KuromojiTokenizerFactory.class);
-    }
-
-    @Override
-    public void processTokenFilters(TokenFiltersBindings tokenFiltersBindings) {
-        tokenFiltersBindings.processTokenFilter("kuromoji_baseform", KuromojiBaseFormFilterFactory.class);
-        tokenFiltersBindings.processTokenFilter("kuromoji_part_of_speech", KuromojiPartOfSpeechFilterFactory.class);
-        tokenFiltersBindings.processTokenFilter("kuromoji_readingform", KuromojiReadingFormFilterFactory.class);
-        tokenFiltersBindings.processTokenFilter("kuromoji_stemmer", KuromojiKatakanaStemmerFactory.class);
-    }
-}

src/main/java/org/elasticsearch/index/analysis/KuromojiAnalyzerProvider.java

@@ -51,6 +51,6 @@ public class KuromojiAnalyzerProvider extends AbstractIndexAnalyzerProvider<Japa
     public JapaneseAnalyzer get() {
         return this.analyzer;
     }
-    
+
-    
+
 }

src/main/java/org/elasticsearch/index/analysis/KuromojiBaseFormFilterFactory.java

@@ -29,13 +29,13 @@ import org.elasticsearch.index.settings.IndexSettings;
 
 public class KuromojiBaseFormFilterFactory extends AbstractTokenFilterFactory {
 
-  @Inject
+    @Inject
-  public KuromojiBaseFormFilterFactory(Index index, @IndexSettings Settings indexSettings, @Assisted String name, @Assisted Settings settings) {
+    public KuromojiBaseFormFilterFactory(Index index, @IndexSettings Settings indexSettings, @Assisted String name, @Assisted Settings settings) {
-      super(index, indexSettings, name, settings);
+        super(index, indexSettings, name, settings);
-  }
+    }
 
-  @Override
+    @Override
-  public TokenStream create(TokenStream tokenStream) {
+    public TokenStream create(TokenStream tokenStream) {
-      return new JapaneseBaseFormFilter(tokenStream);
+        return new JapaneseBaseFormFilter(tokenStream);
-  }
+    }
 }

src/main/java/org/elasticsearch/index/analysis/KuromojiKatakanaStemmerFactory.java

@@ -32,12 +32,9 @@ public class KuromojiKatakanaStemmerFactory extends AbstractTokenFilterFactory {
     private final int minimumLength;
 
     @Inject
-    public KuromojiKatakanaStemmerFactory(Index index,
+    public KuromojiKatakanaStemmerFactory(Index index, @IndexSettings Settings indexSettings, @Assisted String name, @Assisted Settings settings) {
-            @IndexSettings Settings indexSettings, @Assisted String name,
-            @Assisted Settings settings) {
         super(index, indexSettings, name, settings);
-        minimumLength = settings.getAsInt("minimum_length",
+        minimumLength = settings.getAsInt("minimum_length", JapaneseKatakanaStemFilter.DEFAULT_MINIMUM_LENGTH);
-                JapaneseKatakanaStemFilter.DEFAULT_MINIMUM_LENGTH).intValue();
     }
 
     @Override

src/main/java/org/elasticsearch/index/analysis/KuromojiPartOfSpeechFilterFactory.java

@@ -19,10 +19,6 @@
 
 package org.elasticsearch.index.analysis;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.ja.JapanesePartOfSpeechStopFilter;
 import org.elasticsearch.common.inject.Inject;
@@ -32,29 +28,28 @@ import org.elasticsearch.env.Environment;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.settings.IndexSettings;
 
-public class KuromojiPartOfSpeechFilterFactory extends
+import java.util.HashSet;
-        AbstractTokenFilterFactory {
+import java.util.List;
+import java.util.Set;
+
+public class KuromojiPartOfSpeechFilterFactory extends AbstractTokenFilterFactory {
 
     private final boolean enablePositionIncrements;
     private final Set<String> stopTags = new HashSet<String>();
 
     @Inject
-    public KuromojiPartOfSpeechFilterFactory(Index index,
+    public KuromojiPartOfSpeechFilterFactory(Index index, @IndexSettings Settings indexSettings, Environment env, @Assisted String name, @Assisted Settings settings) {
-            @IndexSettings Settings indexSettings, Environment env,
-            @Assisted String name, @Assisted Settings settings) {
         super(index, indexSettings, name, settings);
         List<String> wordList = Analysis.getWordList(env, settings, "stoptags");
         if (wordList != null) {
             stopTags.addAll(wordList);
         }
-        this.enablePositionIncrements = settings.getAsBoolean(
+        this.enablePositionIncrements = settings.getAsBoolean("enable_position_increments", true);
-                "enable_position_increments", true);
     }
 
     @Override
     public TokenStream create(TokenStream tokenStream) {
-        return new JapanesePartOfSpeechStopFilter(enablePositionIncrements,
+        return new JapanesePartOfSpeechStopFilter(enablePositionIncrements, tokenStream, stopTags);
-                tokenStream, stopTags);
     }
 
 }

src/main/java/org/elasticsearch/index/analysis/KuromojiReadingFormFilterFactory.java

@@ -27,14 +27,12 @@ import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.settings.IndexSettings;
 
-public class KuromojiReadingFormFilterFactory extends
+public class KuromojiReadingFormFilterFactory extends AbstractTokenFilterFactory {
-        AbstractTokenFilterFactory {
+
     private final boolean useRomaji;
 
     @Inject
-    public KuromojiReadingFormFilterFactory(Index index,
+    public KuromojiReadingFormFilterFactory(Index index, @IndexSettings Settings indexSettings, @Assisted String name, @Assisted Settings settings) {
-            @IndexSettings Settings indexSettings, @Assisted String name,
-            @Assisted Settings settings) {
         super(index, indexSettings, name, settings);
         useRomaji = settings.getAsBoolean("use_romaji", false);
     }

src/main/java/org/elasticsearch/index/analysis/KuromojiTokenizerFactory.java

@@ -18,9 +18,6 @@
  */
 package org.elasticsearch.index.analysis;
 
-import java.io.IOException;
-import java.io.Reader;
-
 import org.apache.lucene.analysis.Tokenizer;
 import org.apache.lucene.analysis.ja.JapaneseTokenizer;
 import org.apache.lucene.analysis.ja.JapaneseTokenizer.Mode;
@@ -33,6 +30,9 @@ import org.elasticsearch.env.Environment;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.settings.IndexSettings;
 
+import java.io.IOException;
+import java.io.Reader;
+
 /**
  */
 public class KuromojiTokenizerFactory extends AbstractTokenizerFactory {
@@ -45,20 +45,16 @@ public class KuromojiTokenizerFactory extends AbstractTokenizerFactory {
     private boolean discartPunctuation;
 
     @Inject
-    public KuromojiTokenizerFactory(Index index,
+    public KuromojiTokenizerFactory(Index index, @IndexSettings Settings indexSettings, Environment env, @Assisted String name, @Assisted Settings settings) {
-            @IndexSettings Settings indexSettings, Environment env,
-            @Assisted String name, @Assisted Settings settings) {
         super(index, indexSettings, name, settings);
         mode = getMode(settings);
         userDictionary = getUserDictionary(env, settings);
         discartPunctuation = settings.getAsBoolean("discard_punctuation", true);
     }
 
-    public static UserDictionary getUserDictionary(Environment env,
+    public static UserDictionary getUserDictionary(Environment env, Settings settings) {
-            Settings settings) {
         try {
-            final Reader reader = Analysis.getReaderFromFile(env, settings,
+            final Reader reader = Analysis.getReaderFromFile(env, settings, USER_DICT_OPTION);
-                    USER_DICT_OPTION);
             if (reader == null) {
                 return null;
             } else {
@@ -69,8 +65,7 @@ public class KuromojiTokenizerFactory extends AbstractTokenizerFactory {
                 }
             }
         } catch (IOException e) {
-            throw new ElasticSearchException(
+            throw new ElasticSearchException("failed to load kuromoji user dictionary", e);
-                    "failed to load kuromoji user dictionary", e);
         }
     }
 

src/main/java/org/elasticsearch/plugin/analysis/kuromoji/AnalysisKuromojiPlugin.java

@@ -19,9 +19,7 @@
 
 package org.elasticsearch.plugin.analysis.kuromoji;
 
-import org.elasticsearch.index.analysis.KuromojiAnalysisBinderProcessor;
+import org.elasticsearch.index.analysis.*;
-import org.elasticsearch.index.analysis.KuromojiAnalyzerProvider;
-import org.elasticsearch.index.analysis.AnalysisModule;
 import org.elasticsearch.plugins.AbstractPlugin;
 
 /**
@@ -41,7 +39,10 @@ public class AnalysisKuromojiPlugin extends AbstractPlugin {
 
     public void onModule(AnalysisModule module) {
         module.addAnalyzer("kuromoji", KuromojiAnalyzerProvider.class);
-        module.addProcessor(new KuromojiAnalysisBinderProcessor());
+        module.addTokenizer("kuromoji_tokenizer", KuromojiTokenizerFactory.class);
-
+        module.addTokenFilter("kuromoji_baseform", KuromojiBaseFormFilterFactory.class);
+        module.addTokenFilter("kuromoji_part_of_speech", KuromojiPartOfSpeechFilterFactory.class);
+        module.addTokenFilter("kuromoji_readingform", KuromojiReadingFormFilterFactory.class);
+        module.addTokenFilter("kuromoji_stemmer", KuromojiKatakanaStemmerFactory.class);
     }
 }

src/test/java/org/elasticsearch/index/analysis/KuromojiAnalysisTests.java

@@ -19,13 +19,6 @@
 
 package org.elasticsearch.index.analysis;
 
-import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
-import static org.elasticsearch.common.settings.ImmutableSettings.Builder.EMPTY_SETTINGS;
-import static org.hamcrest.Matchers.instanceOf;
-
-import java.io.IOException;
-import java.io.StringReader;
-
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.Tokenizer;
 import org.apache.lucene.analysis.ja.JapaneseAnalyzer;
@@ -33,6 +26,7 @@ import org.apache.lucene.analysis.ja.JapaneseTokenizer;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
 import org.elasticsearch.common.inject.Injector;
 import org.elasticsearch.common.inject.ModulesBuilder;
+import org.elasticsearch.common.settings.ImmutableSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.settings.SettingsModule;
 import org.elasticsearch.env.Environment;
@@ -43,176 +37,128 @@ import org.elasticsearch.index.settings.IndexSettingsModule;
 import org.elasticsearch.indices.analysis.IndicesAnalysisModule;
 import org.elasticsearch.indices.analysis.IndicesAnalysisService;
 import org.elasticsearch.plugin.analysis.kuromoji.AnalysisKuromojiPlugin;
-import org.elasticsearch.plugins.PluginsModule;
-import org.elasticsearch.plugins.PluginsService;
-import org.hamcrest.MatcherAssert;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
+import java.io.IOException;
+import java.io.StringReader;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+
 /**
  */
 public class KuromojiAnalysisTests {
 
     @Test
     public void testDefaultsKuromojiAnalysis() {
-        Index index = new Index("test");
+        AnalysisService analysisService = createAnalysisService();
 
-        Injector parentInjector = new ModulesBuilder().add(
+        TokenizerFactory tokenizerFactory = analysisService.tokenizer("kuromoji_tokenizer");
-                new SettingsModule(EMPTY_SETTINGS),
+        assertThat(tokenizerFactory, instanceOf(KuromojiTokenizerFactory.class));
-                new EnvironmentModule(new Environment(EMPTY_SETTINGS)),
-                new IndicesAnalysisModule()).createInjector();
-        AnalysisModule analysisModule = new AnalysisModule(EMPTY_SETTINGS,
-                parentInjector.getInstance(IndicesAnalysisService.class));
-        new AnalysisKuromojiPlugin().onModule(analysisModule);
-        Injector injector = new ModulesBuilder().add(
-                new IndexSettingsModule(index, EMPTY_SETTINGS),
-                new IndexNameModule(index), analysisModule)
-                .createChildInjector(parentInjector);
 
-        AnalysisService analysisService = injector
+        TokenFilterFactory filterFactory = analysisService.tokenFilter("kuromoji_part_of_speech");
-                .getInstance(AnalysisService.class);
+        assertThat(filterFactory, instanceOf(KuromojiPartOfSpeechFilterFactory.class));
-
-        TokenizerFactory tokenizerFactory = analysisService
-                .tokenizer("kuromoji_tokenizer");
-        MatcherAssert.assertThat(tokenizerFactory,
-                instanceOf(KuromojiTokenizerFactory.class));
-
-        TokenFilterFactory filterFactory = analysisService
-                .tokenFilter("kuromoji_part_of_speech");
-        MatcherAssert.assertThat(filterFactory,
-                instanceOf(KuromojiPartOfSpeechFilterFactory.class));
 
         filterFactory = analysisService.tokenFilter("kuromoji_readingform");
-        MatcherAssert.assertThat(filterFactory,
+        assertThat(filterFactory, instanceOf(KuromojiReadingFormFilterFactory.class));
-                instanceOf(KuromojiReadingFormFilterFactory.class));
 
         filterFactory = analysisService.tokenFilter("kuromoji_baseform");
-        MatcherAssert.assertThat(filterFactory,
+        assertThat(filterFactory, instanceOf(KuromojiBaseFormFilterFactory.class));
-                instanceOf(KuromojiBaseFormFilterFactory.class));
 
         filterFactory = analysisService.tokenFilter("kuromoji_stemmer");
-        MatcherAssert.assertThat(filterFactory,
+        assertThat(filterFactory, instanceOf(KuromojiKatakanaStemmerFactory.class));
-                instanceOf(KuromojiKatakanaStemmerFactory.class));
 
         NamedAnalyzer analyzer = analysisService.analyzer("kuromoji");
-        MatcherAssert.assertThat(analyzer.analyzer(),
+        assertThat(analyzer.analyzer(), instanceOf(JapaneseAnalyzer.class));
-                instanceOf(JapaneseAnalyzer.class));
     }
 
     @Test
     public void testBaseFormFilterFactory() throws IOException {
         AnalysisService analysisService = createAnalysisService();
-        TokenFilterFactory tokenFilter = analysisService
+        TokenFilterFactory tokenFilter = analysisService.tokenFilter("kuromoji_pos");
-                .tokenFilter("kuromoji_pos");
+        assertThat(tokenFilter, instanceOf(KuromojiPartOfSpeechFilterFactory.class));
-        MatcherAssert.assertThat(tokenFilter,
-                instanceOf(KuromojiPartOfSpeechFilterFactory.class));
         String source = "私は制限スピードを超える。";
-        String[] expected = new String[] { "私", "は", "制限", "スピード", "を" };
+        String[] expected = new String[]{"私", "は", "制限", "スピード", "を"};
-        Tokenizer tokenizer = new JapaneseTokenizer(new StringReader(source),
+        Tokenizer tokenizer = new JapaneseTokenizer(new StringReader(source), null, true, JapaneseTokenizer.Mode.SEARCH);
-                null, true, JapaneseTokenizer.Mode.SEARCH);
         assertSimpleTSOutput(tokenFilter.create(tokenizer), expected);
-
     }
 
     @Test
     public void testReadingFormFilterFactory() throws IOException {
         AnalysisService analysisService = createAnalysisService();
-        TokenFilterFactory tokenFilter = analysisService
+        TokenFilterFactory tokenFilter = analysisService.tokenFilter("kuromoji_rf");
-                .tokenFilter("kuromoji_rf");
+        assertThat(tokenFilter, instanceOf(KuromojiReadingFormFilterFactory.class));
-        MatcherAssert.assertThat(tokenFilter,
-                instanceOf(KuromojiReadingFormFilterFactory.class));
         String source = "今夜はロバート先生と話した";
-        String[] expected_tokens_romanji = new String[] { "kon'ya", "ha",
+        String[] expected_tokens_romanji = new String[]{"kon'ya", "ha", "robato", "sensei", "to", "hanashi", "ta"};
-                "robato", "sensei", "to", "hanashi", "ta" };
 
-        Tokenizer tokenizer = new JapaneseTokenizer(new StringReader(source),
+        Tokenizer tokenizer = new JapaneseTokenizer(new StringReader(source), null, true, JapaneseTokenizer.Mode.SEARCH);
-                null, true, JapaneseTokenizer.Mode.SEARCH);
 
-        assertSimpleTSOutput(tokenFilter.create(tokenizer),
+        assertSimpleTSOutput(tokenFilter.create(tokenizer), expected_tokens_romanji);
-                expected_tokens_romanji);
 
-        tokenizer = new JapaneseTokenizer(new StringReader(source), null, true,
+        tokenizer = new JapaneseTokenizer(new StringReader(source), null, true, JapaneseTokenizer.Mode.SEARCH);
-                JapaneseTokenizer.Mode.SEARCH);
+        String[] expected_tokens_katakana = new String[]{"コンヤ", "ハ", "ロバート", "センセイ", "ト", "ハナシ", "タ"};
-        String[] expected_tokens_katakana = new String[] { "コンヤ", "ハ", "ロバート",
-                "センセイ", "ト", "ハナシ", "タ" };
         tokenFilter = analysisService.tokenFilter("kuromoji_readingform");
-        MatcherAssert.assertThat(tokenFilter,
+        assertThat(tokenFilter, instanceOf(KuromojiReadingFormFilterFactory.class));
-                instanceOf(KuromojiReadingFormFilterFactory.class));
+        assertSimpleTSOutput(tokenFilter.create(tokenizer), expected_tokens_katakana);
-        assertSimpleTSOutput(tokenFilter.create(tokenizer),
-                expected_tokens_katakana);
     }
 
     @Test
     public void testKatakanaStemFilter() throws IOException {
         AnalysisService analysisService = createAnalysisService();
-        TokenFilterFactory tokenFilter = analysisService
+        TokenFilterFactory tokenFilter = analysisService.tokenFilter("kuromoji_stemmer");
-                .tokenFilter("kuromoji_stemmer");
+        assertThat(tokenFilter, instanceOf(KuromojiKatakanaStemmerFactory.class));
-        MatcherAssert.assertThat(tokenFilter,
-                instanceOf(KuromojiKatakanaStemmerFactory.class));
         String source = "明後日パーティーに行く予定がある。図書館で資料をコピーしました。";
-        ;
+
-        Tokenizer tokenizer = new JapaneseTokenizer(new StringReader(source),
+        Tokenizer tokenizer = new JapaneseTokenizer(new StringReader(source), null, true, JapaneseTokenizer.Mode.SEARCH);
-                null, true, JapaneseTokenizer.Mode.SEARCH);
 
         // パーティー should be stemmed by default
         // (min len) コピー should not be stemmed
-        String[] expected_tokens_katakana = new String[] { "明後日", "パーティ", "に",
+        String[] expected_tokens_katakana = new String[]{"明後日", "パーティ", "に", "行く", "予定", "が", "ある", "図書館", "で", "資料", "を", "コピー", "し", "まし", "た"};
-                "行く", "予定", "が", "ある", "図書館", "で", "資料", "を", "コピー", "し", "まし",
+        assertSimpleTSOutput(tokenFilter.create(tokenizer), expected_tokens_katakana);
-                "た" };
-        assertSimpleTSOutput(tokenFilter.create(tokenizer),
-                expected_tokens_katakana);
 
         tokenFilter = analysisService.tokenFilter("kuromoji_ks");
-        MatcherAssert.assertThat(tokenFilter,
+        assertThat(tokenFilter, instanceOf(KuromojiKatakanaStemmerFactory.class));
-                instanceOf(KuromojiKatakanaStemmerFactory.class));
+        tokenizer = new JapaneseTokenizer(new StringReader(source), null, true, JapaneseTokenizer.Mode.SEARCH);
-        tokenizer = new JapaneseTokenizer(new StringReader(source), null, true,
-                JapaneseTokenizer.Mode.SEARCH);
 
         // パーティー should not be stemmed since min len == 6
         // コピー should not be stemmed
-        expected_tokens_katakana = new String[] { "明後日", "パーティー", "に", "行く",
+        expected_tokens_katakana = new String[]{"明後日", "パーティー", "に", "行く", "予定", "が", "ある", "図書館", "で", "資料", "を", "コピー", "し", "まし", "た"};
-                "予定", "が", "ある", "図書館", "で", "資料", "を", "コピー", "し", "まし", "た" };
+        assertSimpleTSOutput(tokenFilter.create(tokenizer), expected_tokens_katakana);
-        assertSimpleTSOutput(tokenFilter.create(tokenizer),
-                expected_tokens_katakana);
-
     }
 
     public AnalysisService createAnalysisService() {
+        Settings settings = ImmutableSettings.settingsBuilder().loadFromClasspath("org/elasticsearch/index/analysis/kuromoji_analysis.json").build();
+
         Index index = new Index("test");
-        Settings settings = settingsBuilder().loadFromClasspath(
+
-                "org/elasticsearch/index/analysis/kuromoji_analysis.json")
+        Injector parentInjector = new ModulesBuilder().add(new SettingsModule(settings),
-                .build();
-        Injector parentInjector = new ModulesBuilder().add(
-                new SettingsModule(settings),
                 new EnvironmentModule(new Environment(settings)),
-                new IndicesAnalysisModule()).createInjector();
+                new IndicesAnalysisModule())
-        AnalysisModule analysisModule = new AnalysisModule(settings,
+                .createInjector();
-                parentInjector.getInstance(IndicesAnalysisService.class));
+
+        AnalysisModule analysisModule = new AnalysisModule(settings, parentInjector.getInstance(IndicesAnalysisService.class));
+        new AnalysisKuromojiPlugin().onModule(analysisModule);
+
         Injector injector = new ModulesBuilder().add(
                 new IndexSettingsModule(index, settings),
-                new PluginsModule(settings, parentInjector
+                new IndexNameModule(index),
-                        .getInstance(PluginsService.class)),
+                analysisModule)
-                new IndexNameModule(index), analysisModule)
                 .createChildInjector(parentInjector);
 
-        AnalysisService analysisService = injector
+        return injector.getInstance(AnalysisService.class);
-                .getInstance(AnalysisService.class);
-        return analysisService;
     }
 
     public static void assertSimpleTSOutput(TokenStream stream,
-            String[] expected) throws IOException {
+                                            String[] expected) throws IOException {
         stream.reset();
-        CharTermAttribute termAttr = stream
+        CharTermAttribute termAttr = stream.getAttribute(CharTermAttribute.class);
-                .getAttribute(CharTermAttribute.class);
         Assert.assertNotNull(termAttr);
         int i = 0;
         while (stream.incrementToken()) {
             Assert.assertTrue(i < expected.length);
-            Assert.assertEquals(expected[i++], termAttr.toString(),
+            Assert.assertEquals(expected[i++], termAttr.toString(), "expected different term at index " + i);
-                    "expected different term at index " + i);
         }
         Assert.assertEquals(i, expected.length, "not all tokens produced");
     }
-
 }

src/test/resources/es-plugin.properties

@@ -1 +0,0 @@
-plugin=org.elasticsearch.plugin.analysis.kuromoji.AnalysisKuromojiPlugin