elasticsearch-model 2.0.1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13167e8201d321dd4799a378c6980f10011512e6
-  data.tar.gz: 5e39e63bf6e3f452455d1a886d7ec07531445d49
+  metadata.gz: 578a444488ef68a50e4f19c87bf43c3c3d950a39
+  data.tar.gz: c602b0f07801e4dc864921a067a94a8fc482da75
 SHA512:
-  metadata.gz: 426602ea75b972789acc0e51ab3a15bb16b29d6b0929fdc8907e171f7f2b41343438179e18c59a21adbf195cc7608072e9f89b6ba5811420e6bd76555465d8d8
-  data.tar.gz: 89a06131b99b1e6f24bf585a7d2f019efe91196aa8049dc40c6ed43cf567aefefc54e0ff250582c384ffdac98e4c0b216683a8b3eebdf181b22d395bc8955437
+  metadata.gz: fe1dc3d34dd8cd3447160f0eaf2c0941e57058f80a5e8334b6a058bb0e3acab4b960070c0402f81d2dd976b939951e675cb907eb9a828b9a70f9853cf65c5ff9
+  data.tar.gz: a366fbee0a6ff94ec51202fecfcb63b159d4cc169bc4b38debb3df032cf1dd5a94514fde0da6d4c92e2f5f2ddbaef44dc5487b75e749d762136d905c963836f7

data/README.md

@@ -302,7 +302,7 @@ response.page(2).results
 response.page(2).records
 ```
 
-In a Rails controller, use the the `params[:page]` parameter to paginate through results:
+In a Rails controller, use the `params[:page]` parameter to paginate through results:
 
 ```ruby
 @articles = Article.search(params[:q]).page(params[:page]).records
@@ -377,6 +377,10 @@ response.results.first.title
 For proper search engine function, it's often necessary to configure the index properly.
 The `Elasticsearch::Model` integration provides class methods to set up index settings and mappings.
 
+**NOTE**: Elasticsearch will automatically create an index when a document is indexed,
+          with default settings and mappings. Create the index in advance with the `create_index!`
+          method, so your index configuration is respected.
+
 ```ruby
 class Article
   settings index: { number_of_shards: 1 } do

data/elasticsearch-model.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = ">= 1.9.3"
 
-  s.add_dependency "elasticsearch",       '~> 2'
+  s.add_dependency "elasticsearch",       '> 1'
   s.add_dependency "activesupport",       '> 3'
   s.add_dependency "hashie"
 

data/examples/activerecord_associations.rb

@@ -12,12 +12,12 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
 require 'pry'
-Pry.config.history.file = File.expand_path('../../tmp/elasticsearch_development.pry', __FILE__)
 
 require 'logger'
 require 'ansi/core'
 require 'active_record'
 
+require 'json'
 require 'elasticsearch/model'
 
 ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
@@ -33,6 +33,7 @@ ActiveRecord::Schema.define(version: 1) do
 
   create_table :authors do |t|
     t.string     :first_name, :last_name
+    t.string     :department
     t.timestamps null: false
   end
 
@@ -63,7 +64,7 @@ end
 # ----- Elasticsearch client setup ----------------------------------------------------------------
 
 Elasticsearch::Model.client = Elasticsearch::Client.new log: true
-Elasticsearch::Model.client.transport.logger.formatter = proc { |s, d, p, m| "\e[32m#{m}\n\e[0m" }
+Elasticsearch::Model.client.transport.logger.formatter = proc { |s, d, p, m| "\e[2m#{m}\n\e[0m" }
 
 # ----- Search integration ------------------------------------------------------------------------
 
@@ -84,7 +85,7 @@ module Searchable
     def as_indexed_json(options={})
       self.as_json(
         include: { categories: { only: :title},
-                   authors:    { methods: [:full_name], only: [:full_name] },
+                   authors:    { methods: [:full_name, :department], only: [:full_name, :department] },
                    comments:   { only: :text }
                  })
     end
@@ -140,7 +141,7 @@ category = Category.create title: 'One'
 
 # Create author
 #
-author = Author.create first_name: 'John', last_name: 'Smith'
+author = Author.create first_name: 'John', last_name: 'Smith', department: 'Business'
 
 # Create article
 
@@ -161,18 +162,52 @@ article.comments.create text: 'Second comment for article One'
 
 Elasticsearch::Model.client.indices.refresh index: Elasticsearch::Model::Registry.all.map(&:index_name)
 
-puts "\n\e[1mArticles containing 'one':\e[0m", Article.search('one').records.to_a.map(&:inspect), ""
+# Search for a term and return records
+#
+puts "",
+     "Articles containing 'one':".ansi(:bold),
+     Article.search('one').records.to_a.map(&:inspect),
+     ""
 
-puts "\n\e[1mModels containing 'one':\e[0m", Elasticsearch::Model.search('one').records.to_a.map(&:inspect), ""
+puts "",
+     "All Models containing 'one':".ansi(:bold),
+     Elasticsearch::Model.search('one').records.to_a.map(&:inspect),
+     ""
 
-# Load model
+# Difference between `records` and `results`
 #
-article = Article.all.includes(:categories, :authors, :comments).first
+response = Article.search query: { match: { title: 'first' } }
 
-# ----- Pry ---------------------------------------------------------------------------------------
+puts "",
+     "Search results are wrapped in the <#{response.class}> class",
+     ""
+
+puts "",
+     "Access the <ActiveRecord> instances with the `#records` method:".ansi(:bold),
+     response.records.map { |r| "* #{r.title} | Authors: #{r.authors.map(&:full_name) } | Comment count: #{r.comments.size}" }.join("\n"),
+     ""
+
+puts "",
+     "Access the Elasticsearch documents with the `#results` method (without touching the database):".ansi(:bold),
+     response.results.map { |r| "* #{r.title} | Authors: #{r.authors.map(&:full_name) } | Comment count: #{r.comments.size}" }.join("\n"),
+     ""
+
+puts "",
+     "The whole indexed document (according to `Article#as_indexed_json`):".ansi(:bold),
+     JSON.pretty_generate(response.results.first._source.to_hash),
+     ""
 
-puts '', '-'*Pry::Terminal.width!
+# Retrieve only selected fields from Elasticsearch
+#
+response = Article.search query: { match: { title: 'first' } }, _source: ['title', 'authors.full_name']
+
+puts "",
+     "Retrieve only selected fields from Elasticsearch:".ansi(:bold),
+     JSON.pretty_generate(response.results.first._source.to_hash),
+     ""
+
+# ----- Pry ---------------------------------------------------------------------------------------
 
 Pry.start(binding, prompt: lambda { |obj, nest_level, _| '> ' },
-                   input: StringIO.new("article.as_indexed_json\n"),
+                   input: StringIO.new('response.records.first'),
                    quiet: true)

data/examples/activerecord_mapping_completion.rb

@@ -18,17 +18,16 @@ class Article < ActiveRecord::Base
   include Elasticsearch::Model::Callbacks
 
   mapping do
-    indexes :title
-    indexes :title_suggest, type: 'completion', payloads: true
+    indexes :title, type: 'text' do
+      indexes :suggest, type: 'completion'
+    end
+    indexes :url, type: 'keyword'
   end
 
   def as_indexed_json(options={})
     as_json.merge \
-    title_suggest: {
-      input:  title,
-      output: title,
-      payload: { url: "/articles/#{id}" }
-    }
+    title_suggest: { input:  title },
+    url: "/articles/#{id}"
   end
 end
 
@@ -58,12 +57,28 @@ response_2 = Article.__elasticsearch__.client.suggest \
   body: {
     articles: {
       text: 'foo',
-      completion: { field: 'title_suggest', size: 25 }
+      completion: { field: 'title.suggest' }
     }
   };
 
 puts "Article suggest:".ansi(:bold),
-     response_2['articles'].first['options'].map { |d| "#{d['text']} -> #{d['payload']['url']}" }.
+     response_2['articles'].first['options'].map { |d| "#{d['text']} -> #{d['_source']['url']}" }.
      inspect.ansi(:bold, :green)
 
+response_3 = Article.search \
+  query: {
+    match: { title: 'foo' }
+  },
+  suggest: {
+    articles: {
+      text: 'foo',
+      completion: { field: 'title.suggest' }
+    }
+  },
+  _source: ['title', 'url']
+
+puts "Article search with suggest:".ansi(:bold),
+     response_3.response['suggest']['articles'].first['options'].map { |d| "#{d['text']} -> #{d['_source']['url']}" }.
+     inspect.ansi(:bold, :blue)
+
 require 'pry'; binding.pry;

data/examples/activerecord_mapping_edge_ngram.rb

@@ -0,0 +1,101 @@
+require 'ansi'
+require 'sqlite3'
+require 'active_record'
+require 'elasticsearch/model'
+
+ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
+ActiveRecord::Base.establish_connection( adapter: 'sqlite3', database: ":memory:" )
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table :articles do |t|
+    t.string :title
+    t.date   :published_at
+    t.timestamps
+  end
+end
+
+class Article < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
+  article_es_settings = {
+    index: {
+      analysis: {
+        filter: {
+          autocomplete_filter: {
+            type: "edge_ngram",
+            min_gram: 1,
+            max_gram: 20
+          }
+        },
+        analyzer:{
+          autocomplete: {
+            type: "custom",
+            tokenizer: "standard",
+            filter: ["lowercase", "autocomplete_filter"]
+          }
+        }
+      }
+    }
+  }
+
+  settings article_es_settings do
+    mapping do
+      indexes :title
+      indexes :suggestable_title, type: 'string', analyzer: 'autocomplete'
+    end
+  end
+
+  def as_indexed_json(options={})
+    as_json.merge(suggestable_title: title)
+  end
+end
+
+Article.__elasticsearch__.client = Elasticsearch::Client.new log: true
+
+# Create index
+
+Article.__elasticsearch__.create_index! force: true
+
+# Store data
+
+Article.delete_all
+Article.create title: 'Foo'
+Article.create title: 'Bar'
+Article.create title: 'Foo Foo'
+Article.__elasticsearch__.refresh_index!
+
+# Search and suggest
+fulltext_search_response = Article.search(query: { match: { title: 'foo'} } )
+
+puts "", "Article search for 'foo':".ansi(:bold),
+     fulltext_search_response.to_a.map { |d| "Title: #{d.title}" }.inspect.ansi(:bold, :yellow),
+     ""
+
+fulltext_search_response_2 = Article.search(query: { match: { title: 'fo'} } )
+
+puts "", "Article search for 'fo':".ansi(:bold),
+     fulltext_search_response_2.to_a.map { |d| "Title: #{d.title}" }.inspect.ansi(:bold, :red),
+     ""
+
+autocomplete_search_response = Article.search(query: { match: { suggestable_title: { query: 'fo', analyzer: 'standard'} } } )
+
+puts "", "Article autocomplete for 'fo':".ansi(:bold),
+     autocomplete_search_response.to_a.map { |d| "Title: #{d.suggestable_title}" }.inspect.ansi(:bold, :green),
+     ""
+
+puts "", "Text 'Foo Bar' analyzed with the default analyzer:".ansi(:bold),
+     Article.__elasticsearch__.client.indices.analyze(
+      index: Article.__elasticsearch__.index_name,
+      field: 'title',
+      text: 'Foo Bar')['tokens'].map { |t| t['token'] }.inspect.ansi(:bold, :yellow),
+     ""
+
+puts "", "Text 'Foo Bar' analyzed with the autocomplete filter:".ansi(:bold),
+     Article.__elasticsearch__.client.indices.analyze(
+      index: Article.__elasticsearch__.index_name,
+      field: 'suggestable_title',
+      text: 'Foo Bar')['tokens'].map { |t| t['token'] }.inspect.ansi(:bold, :yellow),
+     ""
+
+require 'pry'; binding.pry;

data/lib/elasticsearch/model.rb

@@ -1,11 +1,12 @@
-require 'elasticsearch'
-
-require 'hashie'
+require 'hashie/mash'
 
 require 'active_support/core_ext/module/delegation'
 
+require 'elasticsearch'
+
 require 'elasticsearch/model/version'
 
+require 'elasticsearch/model/hash_wrapper'
 require 'elasticsearch/model/client'
 
 require 'elasticsearch/model/multimodel'

data/lib/elasticsearch/model/hash_wrapper.rb

@@ -0,0 +1,15 @@
+module Elasticsearch
+  module Model
+
+    # Subclass of `Hashie::Mash` to wrap Hash-like structures
+    # (responses from Elasticsearch, search definitions, etc)
+    #
+    # The primary goal of the subclass is to disable the
+    # warning being printed by Hashie for re-defined
+    # methods, such as `sort`.
+    #
+    class HashWrapper < ::Hashie::Mash
+      disable_warnings if respond_to?(:disable_warnings)
+    end
+  end
+end

data/lib/elasticsearch/model/indexing.rb

@@ -65,8 +65,8 @@ module Elasticsearch
             end
           end
 
-          # Set the type to `string` by default
-          @mapping[name][:type] ||= 'string'
+          # Set the type to `text` by default
+          @mapping[name][:type] ||= 'text'
 
           self
         end
@@ -220,15 +220,19 @@ module Elasticsearch
         #     Article.__elasticsearch__.create_index! index: 'my-index'
         #
         def create_index!(options={})
-          target_index = options.delete(:index) || self.index_name
+          options = options.clone
+
+          target_index = options.delete(:index)    || self.index_name
+          settings     = options.delete(:settings) || self.settings.to_hash
+          mappings     = options.delete(:mappings) || self.mappings.to_hash
 
           delete_index!(options.merge index: target_index) if options[:force]
 
           unless index_exists?(index: target_index)
             self.client.indices.create index: target_index,
                                        body: {
-                                         settings: self.settings.to_hash,
-                                         mappings: self.mappings.to_hash }
+                                         settings: settings,
+                                         mappings: mappings }
           end
         end
 

data/lib/elasticsearch/model/response.rb

@@ -28,7 +28,7 @@ module Elasticsearch
         #
         def response
           @response ||= begin
-            Hashie::Mash.new(search.execute!)
+            HashWrapper.new(search.execute!)
           end
         end
 
@@ -63,7 +63,7 @@ module Elasticsearch
         # Returns the statistics on shards
         #
         def shards
-          Hashie::Mash.new(response['_shards'])
+          HashWrapper.new(response['_shards'])
         end
 
         # Returns a Hashie::Mash of the aggregations

data/lib/elasticsearch/model/response/aggregations.rb

@@ -3,6 +3,8 @@ module Elasticsearch
     module Response
 
       class Aggregations < Hashie::Mash
+        disable_warnings if respond_to?(:disable_warnings)
+
         def initialize(attributes={})
           __redefine_enumerable_methods super(attributes)
         end

data/lib/elasticsearch/model/response/result.rb

@@ -14,7 +14,7 @@ module Elasticsearch
         # @param attributes [Hash] A Hash with document properties
         #
         def initialize(attributes={})
-          @result = Hashie::Mash.new(attributes)
+          @result = HashWrapper.new(attributes)
         end
 
         # Return document `_id` as `id`

data/lib/elasticsearch/model/response/suggestions.rb

@@ -3,6 +3,8 @@ module Elasticsearch
     module Response
 
       class Suggestions < Hashie::Mash
+        disable_warnings if respond_to?(:disable_warnings)
+
         def terms
           self.to_a.map { |k,v| v.first['options'] }.flatten.map {|v| v['text']}.uniq
         end

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = "2.0.1"
+    VERSION = "5.0.0"
   end
 end

data/test/integration/{active_record_associations_parent_child.rb → active_record_associations_parent_child_test.rb}

@@ -31,7 +31,7 @@ class Answer < ActiveRecord::Base
 
   index_name 'questions_and_answers'
 
-  mapping _parent: { type: 'question', required: true } do
+  mapping _parent: { type: 'question' }, _routing: { required: true } do
     indexes :text
     indexes :author
   end

data/test/integration/active_record_associations_test.rb

@@ -29,13 +29,12 @@ module Elasticsearch
               indexes :authors do
                 indexes :first_name
                 indexes :last_name
-                indexes :full_name, type: 'multi_field' do
-                  indexes :full_name
-                  indexes :raw, analyzer: 'keyword'
+                indexes :full_name, type: 'text' do
+                  indexes :raw, type: 'keyword'
                 end
               end
 
-              indexes :categories, analyzer: 'keyword'
+              indexes :categories, type: 'keyword'
 
               indexes :comments, type: 'nested' do
                 indexes :text
@@ -188,8 +187,8 @@ module Elasticsearch
           Post.__elasticsearch__.refresh_index!
 
           query = { query: {
-                      filtered: {
-                        query: {
+                      bool: {
+                        must: {
                           multi_match: {
                             fields: ['title'],
                             query: 'first'

data/test/integration/active_record_basic_test.rb

@@ -18,8 +18,8 @@ module Elasticsearch
 
         settings index: { number_of_shards: 1, number_of_replicas: 0 } do
           mapping do
-            indexes :title,         type: 'string', analyzer: 'snowball'
-            indexes :body,          type: 'string'
+            indexes :title,         type: 'text', analyzer: 'snowball'
+            indexes :body,          type: 'text'
             indexes :clicks,        type: 'integer'
             indexes :created_at,    type: 'date'
           end

data/test/integration/active_record_import_test.rb

@@ -16,7 +16,7 @@ module Elasticsearch
         scope :popular, -> { where('views >= 50') }
 
         mapping do
-          indexes :title,      type: 'string'
+          indexes :title,      type: 'text'
           indexes :views,      type: 'integer'
           indexes :numeric,    type: 'integer'
           indexes :created_at, type: 'date'

data/test/integration/active_record_pagination_test.rb

@@ -16,7 +16,7 @@ module Elasticsearch
 
         settings index: { number_of_shards: 1, number_of_replicas: 0 } do
           mapping do
-            indexes :title,      type: 'string', analyzer: 'snowball'
+            indexes :title,      type: 'text', analyzer: 'snowball'
             indexes :created_at, type: 'date'
           end
         end

data/test/integration/mongoid_basic_test.rb

@@ -20,7 +20,7 @@ if Mongo.available?
 
           settings index: { number_of_shards: 1, number_of_replicas: 0 } do
             mapping do
-              indexes :title,      type: 'string', analyzer: 'snowball'
+              indexes :title,      type: 'text', analyzer: 'snowball'
               indexes :created_at, type: 'date'
             end
           end

data/test/integration/multiple_models_test.rb

@@ -20,7 +20,7 @@ module Elasticsearch
 
           settings index: {number_of_shards: 1, number_of_replicas: 0} do
             mapping do
-              indexes :name, type: 'string', analyzer: 'snowball'
+              indexes :name, type: 'text', analyzer: 'snowball'
               indexes :created_at, type: 'date'
             end
           end
@@ -130,7 +130,7 @@ module Elasticsearch
 
                 settings index: {number_of_shards: 1, number_of_replicas: 0} do
                   mapping do
-                    indexes :name, type: 'string', analyzer: 'snowball'
+                    indexes :name, type: 'text', analyzer: 'snowball'
                     indexes :created_at, type: 'date'
                   end
                 end

data/test/unit/hash_wrapper_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+require 'hashie/version'
+
+class Elasticsearch::Model::HashWrapperTest < Test::Unit::TestCase
+  context "The HashWrapper class" do
+    should "not print the warning for re-defined methods" do
+      Hashie.logger.expects(:warn).never
+
+      subject = Elasticsearch::Model::HashWrapper.new(:foo => 'bar', :sort => true)
+    end if Hashie::VERSION >= '3.5.3'
+  end
+end

data/test/unit/indexing_test.rb

@@ -83,33 +83,23 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         assert_equal 'boolean', mappings.to_hash[:mytype][:properties][:foo][:type]
       end
 
-      should "define type as string by default" do
+      should "define type as 'text' by default" do
         mappings = Elasticsearch::Model::Indexing::Mappings.new :mytype
 
-        mappings.indexes :bar, {}
-        assert_equal 'string', mappings.to_hash[:mytype][:properties][:bar][:type]
+        mappings.indexes :bar
+        assert_equal 'text', mappings.to_hash[:mytype][:properties][:bar][:type]
       end
 
       should "define multiple fields" do
         mappings = Elasticsearch::Model::Indexing::Mappings.new :mytype
 
-        mappings.indexes :foo_1, type: 'string' do
-          indexes :raw, analyzer: 'keyword'
+        mappings.indexes :my_field, type: 'text' do
+          indexes :raw, type: 'keyword'
         end
 
-        mappings.indexes :foo_2, type: 'multi_field' do
-          indexes :raw, analyzer: 'keyword'
-        end
-
-        assert_equal 'string',  mappings.to_hash[:mytype][:properties][:foo_1][:type]
-        assert_equal 'string',  mappings.to_hash[:mytype][:properties][:foo_1][:fields][:raw][:type]
-        assert_equal 'keyword', mappings.to_hash[:mytype][:properties][:foo_1][:fields][:raw][:analyzer]
-        assert_nil              mappings.to_hash[:mytype][:properties][:foo_1][:properties]
-
-        assert_equal 'multi_field',  mappings.to_hash[:mytype][:properties][:foo_2][:type]
-        assert_equal 'string',  mappings.to_hash[:mytype][:properties][:foo_2][:fields][:raw][:type]
-        assert_equal 'keyword', mappings.to_hash[:mytype][:properties][:foo_2][:fields][:raw][:analyzer]
-        assert_nil              mappings.to_hash[:mytype][:properties][:foo_2][:properties]
+        assert_equal 'text',    mappings.to_hash[:mytype][:properties][:my_field][:type]
+        assert_equal 'keyword', mappings.to_hash[:mytype][:properties][:my_field][:fields][:raw][:type]
+        assert_nil              mappings.to_hash[:mytype][:properties][:my_field][:properties]
       end
 
       should "define embedded properties" do
@@ -134,15 +124,15 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         # Object is the default when `type` is missing and there's a block passed
         #
         assert_equal 'object', mappings.to_hash[:mytype][:properties][:foo][:type]
-        assert_equal 'string', mappings.to_hash[:mytype][:properties][:foo][:properties][:bar][:type]
+        assert_equal 'text',   mappings.to_hash[:mytype][:properties][:foo][:properties][:bar][:type]
         assert_nil             mappings.to_hash[:mytype][:properties][:foo][:fields]
 
         assert_equal 'object', mappings.to_hash[:mytype][:properties][:foo_object][:type]
-        assert_equal 'string', mappings.to_hash[:mytype][:properties][:foo_object][:properties][:bar][:type]
+        assert_equal 'text',   mappings.to_hash[:mytype][:properties][:foo_object][:properties][:bar][:type]
         assert_nil             mappings.to_hash[:mytype][:properties][:foo_object][:fields]
 
         assert_equal 'nested', mappings.to_hash[:mytype][:properties][:foo_nested][:type]
-        assert_equal 'string', mappings.to_hash[:mytype][:properties][:foo_nested][:properties][:bar][:type]
+        assert_equal 'text',   mappings.to_hash[:mytype][:properties][:foo_nested][:properties][:bar][:type]
         assert_nil             mappings.to_hash[:mytype][:properties][:foo_nested][:fields]
 
         assert_equal :nested, mappings.to_hash[:mytype][:properties][:foo_nested_as_symbol][:type]
@@ -538,6 +528,27 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         assert_nothing_raised { DummyIndexingModelForRecreate.create_index! }
       end
 
+      should "get the index settings and mappings from options" do
+        client  = stub('client')
+        indices = stub('indices')
+        client.stubs(:indices).returns(indices)
+
+        indices.expects(:create).with do |payload|
+          assert_equal 'foobar', payload[:index]
+          assert_equal 3,        payload[:body][:settings][:index][:number_of_shards]
+          assert_equal 'bar', payload[:body][:mappings][:foobar][:properties][:foo][:analyzer]
+          true
+        end.returns({})
+
+        DummyIndexingModelForRecreate.expects(:index_exists?).returns(false)
+        DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+
+        DummyIndexingModelForRecreate.create_index! \
+          index: 'foobar',
+          settings: { index: { number_of_shards: 3 } },
+          mappings: { foobar: { properties: { foo: { analyzer: 'bar' } } } }
+      end
+
       should "not create the index when it exists" do
         client  = stub('client')
         indices = stub('indices')

data/test/unit/response_test.rb

@@ -27,7 +27,7 @@ class Elasticsearch::Model::ResponseTest < Test::Unit::TestCase
       assert_equal 'OK',        response.shards.one
     end
 
-    should "wrap the raw Hash response in Hashie::Mash" do
+    should "wrap the raw Hash response in a HashWrapper" do
       @search  = Elasticsearch::Model::Searching::SearchRequest.new OriginClass, '*'
       @search.stubs(:execute!).returns({'hits' => { 'hits' => [] }, 'aggregations' => { 'dates' => 'FOO' }})
 

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-model
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 5.0.0
 platform: ruby
 authors:
 - Karel Minarik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-04 00:00:00.000000000 Z
+date: 2017-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -337,6 +337,7 @@ files:
 - examples/activerecord_article.rb
 - examples/activerecord_associations.rb
 - examples/activerecord_mapping_completion.rb
+- examples/activerecord_mapping_edge_ngram.rb
 - examples/couchbase_article.rb
 - examples/datamapper_article.rb
 - examples/mongoid_article.rb
@@ -354,6 +355,7 @@ files:
 - lib/elasticsearch/model/callbacks.rb
 - lib/elasticsearch/model/client.rb
 - lib/elasticsearch/model/ext/active_record.rb
+- lib/elasticsearch/model/hash_wrapper.rb
 - lib/elasticsearch/model/importing.rb
 - lib/elasticsearch/model/indexing.rb
 - lib/elasticsearch/model/multimodel.rb
@@ -370,7 +372,7 @@ files:
 - lib/elasticsearch/model/searching.rb
 - lib/elasticsearch/model/serializing.rb
 - lib/elasticsearch/model/version.rb
-- test/integration/active_record_associations_parent_child.rb
+- test/integration/active_record_associations_parent_child_test.rb
 - test/integration/active_record_associations_test.rb
 - test/integration/active_record_basic_test.rb
 - test/integration/active_record_custom_serialization_test.rb
@@ -390,6 +392,7 @@ files:
 - test/unit/adapter_test.rb
 - test/unit/callbacks_test.rb
 - test/unit/client_test.rb
+- test/unit/hash_wrapper_test.rb
 - test/unit/importing_test.rb
 - test/unit/indexing_test.rb
 - test/unit/module_test.rb
@@ -434,7 +437,7 @@ signing_key:
 specification_version: 4
 summary: ActiveModel/Record integrations for Elasticsearch.
 test_files:
-- test/integration/active_record_associations_parent_child.rb
+- test/integration/active_record_associations_parent_child_test.rb
 - test/integration/active_record_associations_test.rb
 - test/integration/active_record_basic_test.rb
 - test/integration/active_record_custom_serialization_test.rb
@@ -454,6 +457,7 @@ test_files:
 - test/unit/adapter_test.rb
 - test/unit/callbacks_test.rb
 - test/unit/client_test.rb
+- test/unit/hash_wrapper_test.rb
 - test/unit/importing_test.rb
 - test/unit/indexing_test.rb
 - test/unit/module_test.rb