elasticsearch-model-globalize 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1ca50ca38311f893fa8b213704174c16a2facc3
+  data.tar.gz: 069ef0416c36d6bedc84b0702d8fe096bdd7524a
+SHA512:
+  metadata.gz: f23d21df326bf57c9ef150e4e73f13a4703bf137f572441083f964ee7dc2f7ede3a30c3dce9af50289324b1343990fd078e9957b01cde0b683d1c0bc2dcde0d0
+  data.tar.gz: 31876715ab920f987f01847eb028dd592b44619a40df017daae1d520d07b378aa3011a1432918a2caca8d8aaa349ed2b917dc113bda89042e3a91a06f57341dc

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+/vendor

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elasticsearch-model-globalize.gemspec
+gemspec
+
+gem 'pry-byebug', github: 'lencioni/pry-byebug', branch: '3.0.0'

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2014 Kentaro Imai
+
+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.

data/README.md

@@ -0,0 +1,150 @@
+# Elasticsearch::Model::Globalize
+
+`elasticsearch-model-globalize` library allows you to use `elasticsearch-model` library
+with `Globalize` gem.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'elasticsearch-model-globalize'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elasticsearch-model-globalize
+
+
+## Usage
+
+There are a few ways to use `elasticsearch-model` with `Globalize`.
+
+This gem has two modules, one is `MultipleFields` and the other is `OneIndexPerLanguage`.
+You can choose one for each model to fit your needs by simply including a module.
+
+```ruby
+class Item < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+  include Elasticsearch::Model::Globalize::MultipleFields
+  # Or
+  # include Elasticsearch::Model::Globalize::OneIndexPerLanguage
+end
+```
+
+
+### MultipleFields
+
+`MultipleFields` module creates additional fields for each language.
+For example, you have a model like:
+
+```ruby
+class Item < ActiveRecord::Base
+  translates :name, :description
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+  include Elasticsearch::Model::Globalize::MultipleFields
+
+  mapping do
+    indexes :id,             type: 'integer'
+    indexes :name_ja,        analyzer: 'kuromoji'
+    indexes :name_en,        analyzer: 'snowball'
+    indexes :description_ja, analyzer: 'kuromoji'
+    indexes :description_en, analyzer: 'snowball'
+  end
+end
+```
+
+and you have `:en` and `:ja` for available locales.
+
+`MultipleFields` module creates `name_en`, `name_ja`, `description_en` and `description_ja`
+field and stores these fields instead of `name` and `description` fields into Elasticsearch.
+
+You can customize the way to localize field names.
+
+```ruby
+# Put this in config/initializers/elasticsearch-model-globalize.rb
+Elasticsearch::Model::Globalize::MultipleFields.localized_name do |name, locale|
+  "#{locale}_#{name}"
+end
+```
+
+One thing you have to care about is that put `translates` line before includeing
+`Elasticsearch::Model::Globalize::MultipleFields`, otherwise `MultipleFields` module are not able to
+know from which fields to derive localized fields.
+
+
+### OneIndexPerLanguage
+
+`OneIndexPerLanguage` module creates one index per language.
+For example, you have a model like:
+
+```ruby
+class Item < ActiveRecord::Base
+  translates :name, :description
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+  include Elasticsearch::Model::Globalize::OneIndexPerLanguage
+end
+```
+
+and you have `:en` and `:ja` for available locales,
+
+`OneIndexPerLanguage` module creates `items-en` and `items-ja` indices.
+
+You can customize the way to localize index names and document types.
+
+```ruby
+# Put this in config/initializers/elasticsearch-model-globalize.rb
+Elasticsearch::Model::Globalize::OneIndexPerLanguage.localized_name do |name, locale|
+  "#{locale}-#{name}"
+end
+```
+
+You can use `index_name_base` and `documenty_type_base` in addition to `index_name` and
+`document_type`.
+
+
+You can define mappings using `globalized_maping` as follows:
+
+```ruby
+class Item < ActiveRecord::Base
+  translates :name, :description
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+  include Elasticsearch::Model::OneIndexPerLanguage
+
+  globalized_mapping do |locale|
+    analyzer = locale == :ja ? 'kuromoji' : 'snowball'
+
+    indexes :id,          type: 'integer'
+    indexes :name,        analyzer: analyzer
+    indexes :description, analyzer: analyzer
+  end
+end
+```
+
+
+## Development and Community
+
+For local development, clone the repository and run bundle install.
+
+To run all tests against a test Elasticsearch cluster, use a command like this:
+
+```sh
+curl -# https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.2.1.tar.gz | tar xz -C tmp/
+SERVER=start TEST_CLUSTER_COMMAND=$PWD/tmp/elasticsearch-1.2.1/bin/elasticsearch bundle exec rake test
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/kentaroi/elasticsearch-model-globalize/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Goma'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/elasticsearch-model-globalize.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elasticsearch/model/globalize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "elasticsearch-model-globalize"
+  spec.version       = Elasticsearch::Model::Globalize::VERSION
+  spec.authors       = ["Kentaro Imai"]
+  spec.email         = ["kentaroi@gmail.com"]
+  spec.summary       = %q{A library for using elasticsearch-model with globalize}
+  spec.description   = %q{A library for using elasticsearch-model with globalize}
+  spec.homepage      = "https://github.com/kentaroi/elastic-search-model-globalize"
+  spec.license       = "Apache 2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'elasticsearch-model'
+  spec.add_dependency 'globalize'
+  spec.add_dependency 'activerecord'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "minitest", "~> 4.0"
+  spec.add_development_dependency "shoulda-context"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "pry-alias"
+  spec.add_development_dependency "elasticsearch-extensions"
+end

data/lib/elasticsearch/model/globalize.rb

@@ -0,0 +1,10 @@
+require "elasticsearch/model/globalize/version"
+
+module Elasticsearch
+  module Model
+    module Globalize
+      autoload :MultipleFields,      'elasticsearch/model/globalize/multiple_fields'
+      autoload :OneIndexPerLanguage, 'elasticsearch/model/globalize/one_index_per_language'
+    end
+  end
+end

data/lib/elasticsearch/model/globalize/multiple_fields.rb

@@ -0,0 +1,81 @@
+module Elasticsearch
+  module Model
+    module Globalize
+      module MultipleFields
+        def self.included(base)
+          base.class_eval do
+            class << self
+              def locales
+                @locales ||= I18n.available_locales
+              end
+            end
+
+            locales.each do |locale|
+              translated_attribute_names.each do |name|
+                localized_name = MultipleFields.localized_name(name, locale)
+
+                class_eval <<-METHOD, __FILE__, __LINE__ + 1 # Define getter
+                def #{localized_name}
+                  globalize.stash.contains?(:#{locale}, '#{name}') ? globalize.stash[:#{locale}]['#{name}']
+                                                                   : translation_for(:#{locale}, false).try(:read_attribute, '#{name}')
+                end
+                METHOD
+
+                class_eval <<-METHOD, __FILE__, __LINE__ + 1 # Define setter
+                def #{localized_name}=(val)
+                  attribute_will_change!(:#{localized_name})
+                  write_attribute('#{name}', val, locale: :#{locale})
+                end
+                METHOD
+              end
+            end
+
+            translated_attribute_names.each do |name|
+              class_eval <<-METHOD, __FILE__, __LINE__ + 1
+              def #{name}=(val)
+                attribute_will_change!(::Elasticsearch::Model::Globalize::MultipleFields.localized_name('#{name}', ::Globalize.locale))
+                write_attribute('#{name}', val)
+              end
+              METHOD
+            end
+
+            def __elasticsearch__ &block
+              unless @__elasticsearch__
+                @__elasticsearch__ = ::Elasticsearch::Model::Proxy::InstanceMethodsProxy.new(self)
+                @__elasticsearch__.extend Elasticsearch::Model::Globalize::MultipleFields::InstanceMethods
+              end
+              @__elasticsearch__.instance_eval(&block) if block_given?
+              @__elasticsearch__
+            end
+          end
+        end
+
+        def self.localized_name(name=nil, locale=nil, &block)
+          @localizer = block if block_given?
+
+          @localizer ? @localizer.call(name, locale) : "#{name}_#{locale}"
+        end
+
+        module InstanceMethods
+          def as_globalized_json(options={})
+            h = self.as_json
+
+            translated_attribute_names.each do |name|
+              h.delete(name.to_s)
+
+              self.class.locales.each do |locale|
+                localized_name = Elasticsearch::Model::Globalize::MultipleFields.localized_name(name, locale)
+                h[localized_name] = send(localized_name)
+              end
+            end
+            h
+          end
+
+          def as_indexed_json(options={})
+            self.as_globalized_json(options.merge root: false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/globalize/one_index_per_language.rb

@@ -0,0 +1,235 @@
+module Elasticsearch
+  module Model
+    module Globalize
+      module OneIndexPerLanguage
+
+        def self.included(base)
+          base.class_eval do
+            self.__elasticsearch__.class_eval do
+              include Elasticsearch::Model::Globalize::OneIndexPerLanguage::ClassMethods
+            end
+
+            class << self
+              [:globalized_mapping, :globalized_mappings, :import_globally, :index_name_base, :index_name_base=, :document_type_base, :document_type_base=].each do |m|
+                delegate m, to: :__elasticsearch__
+              end
+            end
+
+            def __elasticsearch__ &block
+              unless @__elasticsearch__
+                @__elasticsearch__ = ::Elasticsearch::Model::Proxy::InstanceMethodsProxy.new(self)
+                @__elasticsearch__.extend Elasticsearch::Model::Globalize::OneIndexPerLanguage::InstanceMethods
+              end
+              @__elasticsearch__.instance_eval(&block) if block_given?
+              @__elasticsearch__
+            end
+
+            before_update :update_existence_of_documents
+            before_save   :update_changed_attributes_by_locale
+          end
+        end
+
+        def self.localized_name(name=nil, locale=nil, &block)
+          @localizer = block if block_given?
+
+          @localizer ? @localizer.call(name, locale) : "#{name}-#{locale}"
+        end
+
+        module ClassMethods
+          def index_name_base name=nil
+            @index_name_base = name and index_names.clear if name
+            @index_name_base || self.model_name.collection.gsub(/\//, '-')
+          end
+
+          def index_name_base=(name)
+            index_names.clear
+            @index_name_base = name
+          end
+
+          def document_type_base name=nil
+            @document_type_base = name and document_types.clear if name
+            @document_type_base || self.model_name.element
+          end
+
+          def document_type_base=(name)
+            document_types.clear
+            @document_type_base = name
+          end
+
+          def index_name name=nil
+            @index_name = name if name
+            @index_name || index_names[::Globalize.locale] ||=
+              ::Elasticsearch::Model::Globalize::OneIndexPerLanguage.localized_name(index_name_base, ::Globalize.locale)
+          end
+
+          def index_names
+            @index_names ||= {}
+          end
+
+          def document_type name=nil
+            @document_type = name if name
+            @document_type || document_types[::Globalize.locale] ||=
+              ::Elasticsearch::Model::Globalize::OneIndexPerLanguage.localized_name(document_type_base, ::Globalize.locale)
+          end
+
+          def document_types
+            @document_types ||= {}
+          end
+
+          def globalized_mapping(options={}, &block)
+            unless @globalized_mapping
+              @globalized_mapping = ActiveSupport::HashWithIndifferentAccess.new
+              target.__elasticsearch__.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def mapping
+                @globalized_mapping[::Globalize.locale]
+              end
+              alias :mappings :mapping
+              RUBY
+            end
+            I18n.available_locales.each do |locale|
+              @globalized_mapping[locale] ||= ::Elasticsearch::Model::Indexing::Mappings.new(
+                ::Elasticsearch::Model::Globalize::OneIndexPerLanguage.localized_name(document_type_base, locale), options)
+
+              if block_given?
+                @globalized_mapping[locale].options.update(options)
+
+                @globalized_mapping[locale].instance_exec(locale, &block)
+              end
+            end
+            @globalized_mapping
+          end
+          alias :globalized_mappings :globalized_mapping
+
+          def import(options={}, &block)
+            current_locale_only = options.delete(:current_locale_only)
+            if current_locale_only
+              super(options, &block)
+            else
+              errors = Hash.new
+              I18n.available_locales.each do |locale|
+                ::Globalize.with_locale(locale) do
+                  errors[locale] = super(options, &block)
+                end
+              end
+              self.find_each do |record|
+                (I18n.available_locales - record.translations.pluck(:locale).map(&:to_sym)).each do |locale|
+                  ::Globalize.with_locale(locale) do
+                    record.__elasticsearch__.delete_document(current_locale_only: true)
+                  end
+                end
+              end
+              errors
+            end
+          end
+        end
+
+        module InstanceMethods
+          attr_accessor :existence_of_documents, :changed_attributes_by_locale
+
+          def changed_attributes_by_locale
+            @changed_attributes_by_locale ||= ActiveSupport::HashWithIndifferentAccess.new
+          end
+
+          def existence_of_documents
+            @existence_of_documents ||= ActiveSupport::HashWithIndifferentAccess.new
+          end
+
+          def index_name_base name=nil
+            @index_name_base = name || @index_name_base || self.class.index_name_base
+          end
+
+          def index_name_base=(name)
+            @index_name_base = name
+          end
+
+          def document_type_base name=nil
+            @document_type_base = name || @document_type_base || self.class.document_type_base
+          end
+
+          def document_type_base=(name)
+            @document_type_base = name
+          end
+
+          def index_name
+            self.class.index_name
+          end
+
+          def document_type
+            self.class.document_type
+          end
+
+          def index_document(options={})
+            current_locale_only = options.delete(:current_locale_only)
+            if current_locale_only
+              super(options)
+            else
+              changed_attributes_by_locale.keys.each do |locale|
+                ::Globalize.with_locale(locale) do
+                  super(options)
+                end
+              end
+            end
+          end
+
+          def update_document(options={})
+            changed_attributes_by_locale.keys.each do |locale|
+              ::Globalize.with_locale(locale) do
+                if existence_of_documents[locale]
+                  attributes = if respond_to?(:as_indexed_json)
+                    changed_attributes_by_locale[locale].select{ |k, v| as_indexed_json.keys.include? k }
+                  else
+                    changed_attributes_by_locale[locale]
+                  end
+
+                  client.update(
+                    { index: index_name,
+                      type: document_type,
+                      id: self.id,
+                      body: { doc: attributes } }.merge(options)
+                  )
+                else
+                  index_document(current_locale_only: true)
+                end
+              end
+            end
+          end
+
+          def delete_document(options={})
+            current_locale_only = options.delete(:current_locale_only)
+            if current_locale_only
+              super(options)
+            else
+              translations.pluck(:locale).each do |locale|
+                ::Globalize.with_locale(locale) do
+                  super(options)
+                end
+              end
+            end
+          end
+        end
+
+        # This method actually checks existence of translations in database
+        # Therefore, database and elasticsearch must be synced.
+        def update_existence_of_documents
+          __elasticsearch__.existence_of_documents.clear
+          translations.each do |t|
+            __elasticsearch__.existence_of_documents[t.locale] = true if t.persisted?
+          end
+          true
+        end
+
+        def update_changed_attributes_by_locale
+          __elasticsearch__.changed_attributes_by_locale.clear
+
+          common_changed_attributes = Hash[ changes.map{ |key, value| [key, value.last] } ]
+          translated_attribute_names.each { |k| common_changed_attributes.delete(k) }
+
+          globalize.stash.reject{ |locale, attrs| attrs.empty? }.each do |locale, attrs|
+            __elasticsearch__.changed_attributes_by_locale[locale] = attrs.merge(common_changed_attributes)
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/globalize/version.rb

@@ -0,0 +1,7 @@
+module Elasticsearch
+  module Model
+    module Globalize
+      VERSION = "0.0.1"
+    end
+  end
+end

data/test/integration/multiple_fields_integration_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+require 'elasticsearch/model/globalize/multiple_fields'
+
+class MultipleFieldsIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+  class Article < ActiveRecord::Base
+    translates :title
+    @locales = [:en, :ja]
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+    include Elasticsearch::Model::Globalize::MultipleFields
+
+    settings index: {number_of_shards: 1, number_of_replicas: 1} do
+      mapping do
+        indexes :title_en, analyzer: 'snowball'
+        indexes :title_ja, analyzer: 'cjk'
+      end
+    end
+  end
+
+  context "Mulfield module" do
+    setup do
+      ActiveRecord::Schema.define(version: 1) do
+        create_table :articles do |t|
+          t.string :title
+        end
+        Article.create_translation_table! title: :string
+      end
+      Article.destroy_all
+      Article.__elasticsearch__.create_index! force: true
+      a = Article.new
+      a.title = 'Search engine'
+      Globalize.with_locale(:ja) { a.title = '検索エンジン' }
+      a.save!
+      Globalize.with_locale(:ja) { Article.create! title: '世界貿易機関 World Trade Organization' }
+      Article.create! title: 'Testing code'
+      Article.__elasticsearch__.refresh_index!
+    end
+
+    should 'search' do
+      assert_equal 1, Article.search('search').results.total
+      assert_equal 1, Article.search('検索').results.total
+    end
+
+    should 'mapping' do
+      assert_equal 1, Article.search('title_en:testing').results.total
+      assert_equal 1, Article.search('title_en:test').results.total, 'Should be snowball analyzer'
+      assert_equal 1, Article.search('title_ja:organization').results.total
+      assert_equal 0, Article.search('title_ja:organ').results.total, 'Should not be snowball analyzer'
+    end
+  end
+end

data/test/integration/one_index_per_language_integration_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'elasticsearch/model/globalize/one_index_per_language'
+
+class OneIndexPerLanguageIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+  class Article < ActiveRecord::Base
+    translates :title
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+    include Elasticsearch::Model::Globalize::OneIndexPerLanguage
+
+    settings index: {number_of_shards: 1, number_of_replicas: 1} do
+      globalized_mapping do |locale|
+        if locale == :en
+          indexes :title, analyzer: 'snowball'
+        else
+          indexes :title, analyzer: 'cjk'
+        end
+      end
+    end
+  end
+
+  context "OneIndexPerLanguage module" do
+    setup do
+      ActiveRecord::Schema.define(version: 1) do
+        create_table :articles do |t|
+          t.string :title
+        end
+        Article.create_translation_table! title: :string
+      end
+      Article.destroy_all
+      Article.__elasticsearch__.create_index! force: true
+      a = Article.new
+      a.title = 'Search engine'
+      Globalize.with_locale(:ja) { a.title = '検索エンジン' }
+      a.save!
+      Globalize.with_locale(:ja) { Article.create! title: '世界貿易機関 World Trade Organization' }
+      Article.create! title: 'Testing code'
+      Article.__elasticsearch__.refresh_index!
+      sleep 1
+    end
+
+    should 'search' do
+      Globalize.with_locale(:en) do
+        assert_equal 1, Article.search('search').results.total
+        assert_equal 0, Article.search('検索').results.total
+      end
+
+      Globalize.with_locale(:ja) do
+        assert_equal 0, Article.search('search').results.total
+        assert_equal 1, Article.search('検索').results.total
+      end
+    end
+
+    should 'mapping' do
+      Globalize.with_locale(:en) do
+        assert_equal 1, Article.search('title:testing').results.total
+        assert_equal 1, Article.search('title:test').results.total, 'Should be snowball analyzer'
+      end
+
+      Globalize.with_locale(:ja) do
+        assert_equal 1, Article.search('title:organization').results.total
+        assert_equal 0, Article.search('title:organ').results.total, 'Should not be snowball analyzer'
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,56 @@
+RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+
+exit(0) if RUBY_1_8
+
+# Register `at_exit` handler for integration tests shutdown
+# MUST be called before requiring 'test/unit'
+if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
+  at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks }
+end
+
+require 'test/unit'
+require 'shoulda-context'
+require 'mocha/setup'
+require 'pry-byebug'
+require 'pry-alias'
+
+require 'active_record'
+require 'active_model'
+
+require 'elasticsearch/model'
+
+require 'elasticsearch/extensions/test/cluster'
+require 'elasticsearch/extensions/test/startup_shutdown'
+
+require 'globalize'
+
+
+module Elasticsearch
+  module Test
+    class IntegrationTestCase < ::Test::Unit::TestCase
+      extend Elasticsearch::Extensions::Test::StartupShutdown
+
+      startup  { Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running? }
+      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? }
+
+      def setup
+        ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+        logger = ::Logger.new(STDERR)
+        logger.formatter = lambda { |s, d, p, m| "#{m.ansi(:faint, :cyan)}\n" }
+        ActiveRecord::Base.logger = logger unless ENV['QUIET']
+
+        ActiveRecord::LogSubscriber.colorize_logging = false
+        ActiveRecord::Migration.verbose = false
+
+        tracer = ::Logger.new(STDERR)
+        tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
+
+        Elasticsearch::Model.client = Elasticsearch::Client.new host: "localhost:#{(ENV['TEST_CLUSTER_PORT'] || 9250)}",
+                                                                tracer: (ENV['QUIET'] ? nil : tracer)
+
+        I18n.enforce_available_locales = true
+        I18n.available_locales = [:en, :ja]
+      end
+    end
+  end
+end

data/test/unit/multiple_fields_test.rb

@@ -0,0 +1,126 @@
+require 'test_helper'
+require 'elasticsearch/model/globalize/multiple_fields'
+
+class MultipleFieldsTest < Test::Unit::TestCase
+  class Article < ActiveRecord::Base
+    translates :title, :body
+    @locales = [:en, :ja]
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+    include Elasticsearch::Model::Globalize::MultipleFields
+  end
+
+  def setup
+    ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+    logger = ::Logger.new(STDERR)
+    logger.formatter = lambda { |s, d, p, m| "#{m.ansi(:faint, :cyan)}\n" }
+    ActiveRecord::Base.logger = logger unless ENV['QUIET']
+
+    ActiveRecord::LogSubscriber.colorize_logging = false
+    ActiveRecord::Migration.verbose = false
+
+    tracer = ::Logger.new(STDERR)
+    tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
+
+
+    ActiveRecord::Schema.define(version: 1) do
+      create_table :articles do |t|
+        t.string :title
+        t.text :body
+        t.string :code
+      end
+      Article.create_translation_table! title: :string, body: :text
+    end
+    I18n.enforce_available_locales = true
+    I18n.available_locales = [:en, :ja]
+  end
+
+  def test_multiple_fields_attribute
+    a = Article.new
+    assert_nil a.title
+    a.title = 'English'
+    assert_equal 'English', a.title
+    assert_equal 'English', a.title_en
+    assert_nil a.title_ja
+    assert_equal 2, a.changes.keys.count
+    assert a.changes.has_key?(:title_en)
+    assert a.changes.has_key?(:title)
+
+    Globalize.with_locale(:ja) {
+      assert_nil a.title
+      a.title = '日本語'
+      assert_equal '日本語', a.title
+      assert_equal '日本語', a.title_ja
+      assert_equal 'English', a.title_en
+      assert_equal 3, a.changes.keys.count
+      assert a.changes.has_key?(:title_en)
+      assert a.changes.has_key?(:title_ja)
+      assert a.changes.has_key?(:title)
+    }
+    assert_equal 'English', a.title
+    assert_equal 'English', a.title_en
+    assert_equal '日本語', a.title_ja
+
+    a.title_en = 'English title'
+    assert_equal 'English title', a.title_en
+    a.title_ja = '日本語タイトル'
+    assert_equal '日本語タイトル', a.title_ja
+    assert_equal 'English title', a.title
+    assert_equal '日本語タイトル', Globalize.with_locale(:ja){ a.title }
+  end
+
+  def test_create
+    a = Article.new
+    a.title = 'title'
+    assert_equal 'title', a.title_en
+    a.__elasticsearch__.client.expects(:index).with { |value|
+      value[:index] == 'multiple_fields_test-articles' &&
+      value[:type] == 'article' &&
+      value[:body].count == 6 &&
+      value[:body].has_key?('id') &&
+      value[:body]['title_en'] == 'title' &&
+      value[:body]['title_ja'] == nil &&
+      value[:body]['body_en'] == nil &&
+      value[:body]['body_ja'] == nil &&
+      value[:body]['code'] == nil
+    }
+    a.save
+  end
+
+  def test_update
+    a = Article.new
+    a.__elasticsearch__.stubs(:index_document)
+    a.title = 'title'
+    a.body = 'body'
+    a.save
+    a.title = 'new title'
+    a.__elasticsearch__.client.expects(:update).with { |value|
+      value[:index] == 'multiple_fields_test-articles' &&
+      value[:type] == 'article' &&
+      value[:id] == a.id &&
+      value[:body][:doc].count == 1 &&
+      value[:body][:doc]['title_en'] == 'new title'
+    }
+    a.save
+  end
+
+  def test_update_with_no_translation_field
+    a = Article.new
+    a.__elasticsearch__.stubs(:index_document)
+    a.title = 'title'
+    a.body = 'body'
+    a.code = 'code'
+    a.save
+    a.title = 'new title'
+    a.code = 'no derived fields'
+    a.__elasticsearch__.client.expects(:update).with { |value|
+      value[:index] == 'multiple_fields_test-articles' &&
+      value[:type] == 'article' &&
+      value[:id] == a.id &&
+      value[:body][:doc].count == 2 &&
+      value[:body][:doc]['title_en'] == 'new title'
+      value[:body][:doc]['code'] == 'no derived fields'
+    }
+    a.save
+  end
+end

data/test/unit/one_index_per_language_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+require 'elasticsearch/model/globalize/one_index_per_language'
+
+class OneIndexPerLanguageTest < Test::Unit::TestCase
+  class Article < ActiveRecord::Base
+    translates :title, :body
+    @locales = [:en, :ja]
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+    include Elasticsearch::Model::Globalize::OneIndexPerLanguage
+  end
+
+  def setup
+    ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+    logger = ::Logger.new(STDERR)
+    logger.formatter = lambda { |s, d, p, m| "#{m.ansi(:faint, :cyan)}\n" }
+    ActiveRecord::Base.logger = logger unless ENV['QUIET']
+
+    ActiveRecord::LogSubscriber.colorize_logging = false
+    ActiveRecord::Migration.verbose = false
+
+    tracer = ::Logger.new(STDERR)
+    tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
+
+
+    ActiveRecord::Schema.define(version: 1) do
+      create_table :articles do |t|
+        t.string :title
+        t.text :body
+        t.string :code
+      end
+      Article.create_translation_table! title: :string, body: :text
+    end
+    I18n.enforce_available_locales = true
+    I18n.available_locales = [:en, :ja]
+  end
+
+  def test_create
+    a = Article.new
+    a.title = 'title'
+    a.__elasticsearch__.client.expects(:index).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-en' &&
+      value[:type] == 'article-en' &&
+      value[:body].count == 4 &&
+      value[:body].has_key?('id') &&
+      value[:body]['title'] == 'title' &&
+      value[:body]['body'] == nil &&
+      value[:body]['code'] == nil
+    }
+    a.save
+  end
+
+  def test_create_multiple_locales
+    a = Article.new
+    a.title = 'title'
+    Globalize.with_locale(:ja) { a.title = 'タイトル' }
+    a.__elasticsearch__.client.expects(:index).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-en' &&
+      value[:type] == 'article-en' &&
+      value[:body].count == 4 &&
+      value[:body].has_key?('id') &&
+      value[:body]['title'] == 'title' &&
+      value[:body]['body'] == nil &&
+      value[:body]['code'] == nil
+    }
+    a.__elasticsearch__.client.expects(:index).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-ja' &&
+      value[:type] == 'article-ja' &&
+      value[:body].count == 4 &&
+      value[:body].has_key?('id') &&
+      value[:body]['title'] == 'タイトル' &&
+      value[:body]['body'] == nil &&
+      value[:body]['code'] == nil
+    }
+    a.save
+  end
+
+  def test_create_with_no_translation_field
+    a = Article.new
+    a.title = 'title'
+    a.code = 'code'
+    a.__elasticsearch__.client.expects(:index).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-en' &&
+      value[:type] == 'article-en' &&
+      value[:body].count == 4 &&
+      value[:body].has_key?('id') &&
+      value[:body]['title'] == 'title' &&
+      value[:body]['body'] == nil &&
+      value[:body]['code'] == 'code'
+    }
+    a.save
+  end
+
+  def test_update
+    a = Article.new
+    a.__elasticsearch__.stubs(:index_document)
+    a.title = 'title'
+    a.body = 'body'
+    a.save
+    a.title = 'new title'
+    a.__elasticsearch__.client.expects(:update).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-en' &&
+      value[:type] == 'article-en' &&
+      value[:id] == a.id &&
+      value[:body][:doc].count == 1 &&
+      value[:body][:doc]['title'] == 'new title'
+    }
+    a.save
+  end
+
+  def test_update_with_new_locale
+    a = Article.new
+    a.__elasticsearch__.client.stubs(:index)
+    a.title = 'title'
+    a.body = 'body'
+    a.save
+    a.title = 'new title'
+    Globalize.with_locale(:ja) { a.title = 'タイトル' }
+    a.__elasticsearch__.client.expects(:update).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-en' &&
+      value[:type] == 'article-en' &&
+      value[:id] == a.id &&
+      value[:body][:doc].count == 1 &&
+      value[:body][:doc]['title'] == 'new title'
+    }
+    a.__elasticsearch__.client.expects(:index).with { |value|
+      value[:index] == 'one_index_per_language_test-articles-ja' &&
+      value[:type] == 'article-ja' &&
+      value[:body].count == 4 &&
+      value[:body].has_key?('id') &&
+      value[:body]['title'] == 'タイトル' &&
+      value[:body]['body'] == nil &&
+      value[:body]['code'] == nil
+    }
+    a.save
+  end
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification
+name: elasticsearch-model-globalize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kentaro Imai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: globalize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-alias
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A library for using elasticsearch-model with globalize
+email:
+- kentaroi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- elasticsearch-model-globalize.gemspec
+- lib/elasticsearch/model/globalize.rb
+- lib/elasticsearch/model/globalize/multiple_fields.rb
+- lib/elasticsearch/model/globalize/one_index_per_language.rb
+- lib/elasticsearch/model/globalize/version.rb
+- test/integration/multiple_fields_integration_test.rb
+- test/integration/one_index_per_language_integration_test.rb
+- test/test_helper.rb
+- test/unit/multiple_fields_test.rb
+- test/unit/one_index_per_language_test.rb
+homepage: https://github.com/kentaroi/elastic-search-model-globalize
+licenses:
+- Apache 2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A library for using elasticsearch-model with globalize
+test_files:
+- test/integration/multiple_fields_integration_test.rb
+- test/integration/one_index_per_language_integration_test.rb
+- test/test_helper.rb
+- test/unit/multiple_fields_test.rb
+- test/unit/one_index_per_language_test.rb