elasticsearch-model 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b66840bcd1e2b9f877f0c21c6e6c69c61bcc988
-  data.tar.gz: 7ddc2b0fc4089fa9079cdaf771d6f947950d90c4
+  metadata.gz: 62d28c182c4b21b048ad496387e6cc139a79ee1b
+  data.tar.gz: f4bdb161bc448d38ba4fd2da0e7eb8c74fdebd15
 SHA512:
-  metadata.gz: bf83de14e369c4acb429559fd1e6f4522e45b0b275fcf594df185a96593ae9d4791ff3f7214d6a19f7a8e10ee073da897424c0d44571f5369cca2b39abf4b131
-  data.tar.gz: 345b76b6c9b3bacc5eab1538040188d7a622a9469dbfc89e4495392448d8a5c77dbf0cca0e0af678c916ebceb0fc2347eaf08d5aec26da7fe5bc8ffff26ebcf3
+  metadata.gz: ce7abb8673ae21d515c48f64e07a057ea82302132cedce60eeade565a44f9743fc0e811903df29aa93fa7cb55b96011d52ec25287064df5c846d5474da5125a4
+  data.tar.gz: 0eb48de6a8a1f7b264582b764de7013727d8909fa024a1777a9bad4304fa57649957dbc54b92fff24aa140364ee38f1ad35ddfc35da552cbab1ee4b0064e07f2

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.1.7
+
+* Improved examples and instructions in README and code annotations
+* Prevented index methods to swallow all exceptions
+* Added the `:validate` option to the `save` method for models
+* Added support for searching across multiple models (elastic/elasticsearch-rails#345),
+  including documentation, examples and tests
+
 ## 0.1.6
 
 * Improved documentation

data/README.md

@@ -216,8 +216,9 @@ response.records.to_a
 ```
 
 The returned object is the genuine collection of model instances returned by your database,
-i.e. `ActiveRecord::Relation` for ActiveRecord, or `Mongoid::Criteria` in case of MongoDB. This allows you to
-chain other methods on top of search results, as you would normally do:
+i.e. `ActiveRecord::Relation` for ActiveRecord, or `Mongoid::Criteria` in case of MongoDB.
+
+This allows you to chain other methods on top of search results, as you would normally do:
 
 ```ruby
 response.records.where(title: 'Quick brown fox').to_a
@@ -252,11 +253,35 @@ response.records.each_with_hit { |record, hit| puts "* #{record.title}: #{hit._s
 # * Fast black dogs: 0.02250402
 ```
 
+#### Searching multiple models
+
+It is possible to search across multiple models with the module method:
+
+```ruby
+Elasticsearch::Model.search('fox', [Article, Comment]).results.to_a.map(&:to_hash)
+# => [
+#      {"_index"=>"articles", "_type"=>"article", "_id"=>"1", "_score"=>0.35136628, "_source"=>...},
+#      {"_index"=>"comments", "_type"=>"comment", "_id"=>"1", "_score"=>0.35136628, "_source"=>...}
+#    ]
+
+Elasticsearch::Model.search('fox', [Article, Comment]).records.to_a
+# Article Load (0.3ms)  SELECT "articles".* FROM "articles" WHERE "articles"."id" IN (1)
+# Comment Load (0.2ms)  SELECT "comments".* FROM "comments" WHERE "comments"."id" IN (1,5)
+# => [#<Article id: 1, title: "Quick brown fox">, #<Comment id: 1, body: "Fox News">,  ...]
+```
+
+By default, all models which include the `Elasticsearch::Model` module are searched.
+
+NOTE: It is _not_ possible to chain other methods on top of the `records` object, since it
+      is a heterogenous collection, with models potentially backed by different databases.
+
 #### Pagination
 
 You can implement pagination with the `from` and `size` search parameters. However, search results
 can be automatically paginated with the [`kaminari`](http://rubygems.org/gems/kaminari) or
 [`will_paginate`](https://github.com/mislav/will_paginate) gems.
+(The pagination gems must be added before the Elasticsearch gems in your Gemfile,
+or loaded first in your application.)
 
 If Kaminari or WillPaginate is loaded, use the familiar paging methods:
 
@@ -430,15 +455,15 @@ class Article < ActiveRecord::Base
   include Elasticsearch::Model
 
   after_commit on: [:create] do
-    index_document if self.published?
+    __elasticsearch__.index_document if self.published?
   end
 
   after_commit on: [:update] do
-    update_document if self.published?
+    __elasticsearch__.update_document if self.published?
   end
 
   after_commit on: [:destroy] do
-    delete_document if self.published?
+    __elasticsearch__.delete_document if self.published?
   end
 end
 ```

data/examples/activerecord_associations.rb

@@ -59,9 +59,43 @@ ActiveRecord::Schema.define(version: 1) do
   add_index(:comments, :article_id)
 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" }
+
+# ----- Search integration ------------------------------------------------------------------------
+
+module Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+
+    include Indexing
+    after_touch() { __elasticsearch__.index_document }
+  end
+
+  module Indexing
+
+    # Customize the JSON serialization for Elasticsearch
+    def as_indexed_json(options={})
+      self.as_json(
+        include: { categories: { only: :title},
+                   authors:    { methods: [:full_name], only: [:full_name] },
+                   comments:   { only: :text }
+                 })
+    end
+  end
+end
+
 # ----- Model definitions -------------------------------------------------------------------------
 
 class Category < ActiveRecord::Base
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
+
   has_and_belongs_to_many :articles
 end
 
@@ -81,6 +115,8 @@ class Authorship < ActiveRecord::Base
 end
 
 class Article < ActiveRecord::Base
+  include Searchable
+
   has_and_belongs_to_many :categories, after_add:    [ lambda { |a,c| a.__elasticsearch__.index_document } ],
                                        after_remove: [ lambda { |a,c| a.__elasticsearch__.index_document } ]
   has_many                :authorships
@@ -88,43 +124,13 @@ class Article < ActiveRecord::Base
   has_many                :comments
 end
 
-class Article < ActiveRecord::Base; delegate :size, to: :comments, prefix: true; end
-
 class Comment < ActiveRecord::Base
-  belongs_to :article, touch: true
-end
-
-# ----- Search integration ------------------------------------------------------------------------
-
-module Searchable
-  extend ActiveSupport::Concern
-
-  included do
-    include Elasticsearch::Model
-    include Elasticsearch::Model::Callbacks
-
-    __elasticsearch__.client = Elasticsearch::Client.new log: true
-    __elasticsearch__.client.transport.logger.formatter = proc { |s, d, p, m| "\e[32m#{m}\n\e[0m" }
-
-    include Indexing
-    after_touch() { __elasticsearch__.index_document }
-  end
-
-  module Indexing
+  include Elasticsearch::Model
+  include Elasticsearch::Model::Callbacks
 
-    # Customize the JSON serialization for Elasticsearch
-    def as_indexed_json(options={})
-      self.as_json(
-        include: { categories: { only: :title},
-                   authors:    { methods: [:full_name], only: [:full_name] },
-                   comments:   { only: :text }
-                 })
-    end
-  end
+  belongs_to :article, touch: true
 end
 
-Article.__send__ :include, Searchable
-
 # ----- Insert data -------------------------------------------------------------------------------
 
 # Create category
@@ -149,14 +155,23 @@ article.authors << author
 
 # Add comment
 #
-article.comments.create text: 'First comment'
+article.comments.create text: 'First comment for article One'
+article.comments.create text: 'Second comment for article One'
 
-# Load
+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), ""
+
+puts "\n\e[1mModels containing 'one':\e[0m", Elasticsearch::Model.search('one').records.to_a.map(&:inspect), ""
+
+# Load model
 #
 article = Article.all.includes(:categories, :authors, :comments).first
 
 # ----- Pry ---------------------------------------------------------------------------------------
 
+puts '', '-'*Pry::Terminal.width!
+
 Pry.start(binding, prompt: lambda { |obj, nest_level, _| '> ' },
-                   input: StringIO.new('puts "\n\narticle.as_indexed_json\n"; article.as_indexed_json'),
+                   input: StringIO.new("article.as_indexed_json\n"),
                    quiet: true)

data/lib/elasticsearch/model.rb

@@ -8,10 +8,13 @@ require 'elasticsearch/model/version'
 
 require 'elasticsearch/model/client'
 
+require 'elasticsearch/model/multimodel'
+
 require 'elasticsearch/model/adapter'
 require 'elasticsearch/model/adapters/default'
 require 'elasticsearch/model/adapters/active_record'
 require 'elasticsearch/model/adapters/mongoid'
+require 'elasticsearch/model/adapters/multiple'
 
 require 'elasticsearch/model/importing'
 require 'elasticsearch/model/indexing'
@@ -119,6 +122,9 @@ module Elasticsearch
           include Elasticsearch::Model::Importing::ClassMethods
           include Adapter.from_class(base).importing_mixin
         end
+
+        # Add to the registry if it's a class (and not in intermediate module)
+        Registry.add(base) if base.is_a?(Class)
       end
     end
 
@@ -149,6 +155,30 @@ module Elasticsearch
         @client = client
       end
 
+      # Search across multiple models
+      #
+      # By default, all models which include the `Elasticsearch::Model` module are searched
+      #
+      # @param query_or_payload [String,Hash,Object] The search request definition
+      #                                              (string, JSON, Hash, or object responding to `to_hash`)
+      # @param models [Array] The Array of Model objects to search
+      # @param options [Hash] Optional parameters to be passed to the Elasticsearch client
+      #
+      # @return [Elasticsearch::Model::Response::Response]
+      #
+      # @example Search across specific models
+      #
+      #     Elasticsearch::Model.search('foo', [Author, Article])
+      #
+      # @example Search across all models which include the `Elasticsearch::Model` module
+      #
+      #     Elasticsearch::Model.search('foo')
+      #
+      def search(query_or_payload, models=[], options={})
+        models = Multimodel.new(models)
+        request = Searching::SearchRequest.new(models, query_or_payload, options)
+        Response::Response.new(models, request)
+      end
     end
     extend ClassMethods
 

data/lib/elasticsearch/model/adapters/active_record.rb

@@ -7,7 +7,7 @@ module Elasticsearch
       module ActiveRecord
 
         Adapter.register self,
-                         lambda { |klass| !!defined?(::ActiveRecord::Base) && klass.ancestors.include?(::ActiveRecord::Base) }
+                         lambda { |klass| !!defined?(::ActiveRecord::Base) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::ActiveRecord::Base) }
 
         module Records
           # Returns an `ActiveRecord::Relation` instance

data/lib/elasticsearch/model/adapters/mongoid.rb

@@ -9,7 +9,7 @@ module Elasticsearch
       module Mongoid
 
         Adapter.register self,
-                         lambda { |klass| !!defined?(::Mongoid::Document) && klass.ancestors.include?(::Mongoid::Document) }
+                         lambda { |klass| !!defined?(::Mongoid::Document) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::Mongoid::Document) }
 
         module Records
 

data/lib/elasticsearch/model/adapters/multiple.rb

@@ -0,0 +1,110 @@
+module Elasticsearch
+  module Model
+    module Adapter
+
+      # An adapter to be used for deserializing results from multiple models,
+      # retrieved through `Elasticsearch::Model.search`
+      #
+      # @see Elasticsearch::Model.search
+      #
+      module Multiple
+        Adapter.register self, lambda { |klass| klass.is_a? Multimodel }
+
+        module Records
+          # Returns a collection of model instances, possibly of different classes (ActiveRecord, Mongoid, ...)
+          #
+          # @note The order of results in the Elasticsearch response is preserved
+          #
+          def records
+            records_by_type = __records_by_type
+
+            response.response["hits"]["hits"].map do |hit|
+              records_by_type[ __type_for_hit(hit) ][ hit[:_id] ]
+            end
+          end
+
+          # Returns the collection of records grouped by class based on `_type`
+          #
+          # Example:
+          #
+          # {
+          #   Foo  => {"1"=> #<Foo id: 1, title: "ABC"}, ...},
+          #   Bar  => {"1"=> #<Bar id: 1, name: "XYZ"}, ...}
+          # }
+          #
+          # @api private
+          #
+          def __records_by_type
+            result = __ids_by_type.map do |klass, ids|
+              records = __records_for_klass(klass, ids)
+              ids     = records.map(&:id).map(&:to_s)
+              [ klass, Hash[ids.zip(records)] ]
+            end
+
+            Hash[result]
+          end
+
+          # Returns the collection of records for a specific type based on passed `klass`
+          #
+          # @api private
+          #
+          def __records_for_klass(klass, ids)
+            adapter = __adapter_name_for_klass(klass)
+
+            case adapter
+              when Elasticsearch::Model::Adapter::ActiveRecord
+                klass.where(klass.primary_key => ids)
+              when Elasticsearch::Model::Adapter::Mongoid
+                klass.where(:id.in => ids)
+              else
+                klass.find(ids)
+            end
+          end
+
+          # Returns the record IDs grouped by class based on type `_type`
+          #
+          # Example:
+          #
+          #   { Foo => ["1"], Bar => ["1", "5"] }
+          #
+          # @api private
+          #
+          def __ids_by_type
+            ids_by_type = {}
+
+            response.response["hits"]["hits"].each do |hit|
+              type = __type_for_hit(hit)
+              ids_by_type[type] ||= []
+              ids_by_type[type] << hit[:_id]
+            end
+            ids_by_type
+          end
+
+          # Returns the class of the model corresponding to a specific `hit` in Elasticsearch results
+          #
+          # @see Elasticsearch::Model::Registry
+          #
+          # @api private
+          #
+          def __type_for_hit(hit)
+            @@__types ||= {}
+
+            @@__types[ "#{hit[:_index]}::#{hit[:_type]}" ] ||= begin
+              Registry.all.detect do |model|
+                model.index_name == hit[:_index] && model.document_type == hit[:_type]
+              end
+            end
+          end
+
+          # Returns the adapter registered for a particular `klass` or `nil` if not available
+          #
+          # @api private
+          #
+          def __adapter_name_for_klass(klass)
+            Adapter.adapters.select { |name, checker| checker.call(klass) }.keys.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/indexing.rb

@@ -187,17 +187,10 @@ module Elasticsearch
           delete_index!(options.merge index: target_index) if options[:force]
 
           unless ( self.client.indices.exists(index: target_index) rescue false )
-            begin
-              self.client.indices.create index: target_index,
-                                         body: {
-                                           settings: self.settings.to_hash,
-                                           mappings: self.mappings.to_hash }
-            rescue Exception => e
-              unless e.class.to_s =~ /NotFound/ && options[:force]
-                STDERR.puts "[!!!] Error when creating the index: #{e.class}", "#{e.message}"
-              end
-            end
-          else
+            self.client.indices.create index: target_index,
+                                       body: {
+                                         settings: self.settings.to_hash,
+                                         mappings: self.mappings.to_hash }
           end
         end
 
@@ -217,8 +210,10 @@ module Elasticsearch
           begin
             self.client.indices.delete index: target_index
           rescue Exception => e
-            unless e.class.to_s =~ /NotFound/ && options[:force]
-              STDERR.puts "[!!!] Error when deleting the index: #{e.class}", "#{e.message}"
+            if e.class.to_s =~ /NotFound/ && options[:force]
+              STDERR.puts "[!!!] Index does not exist (#{e.class})"
+            else
+              raise e
             end
           end
         end
@@ -241,8 +236,10 @@ module Elasticsearch
           begin
             self.client.indices.refresh index: target_index
           rescue Exception => e
-            unless e.class.to_s =~ /NotFound/ && options[:force]
-              STDERR.puts "[!!!] Error when refreshing the index: #{e.class}", "#{e.message}"
+            if e.class.to_s =~ /NotFound/ && options[:force]
+              STDERR.puts "[!!!] Index does not exist (#{e.class})"
+            else
+              raise e
             end
           end
         end

data/lib/elasticsearch/model/multimodel.rb

@@ -0,0 +1,83 @@
+module Elasticsearch
+  module Model
+
+    # Keeps a global registry of classes that include `Elasticsearch::Model`
+    #
+    class Registry
+      def initialize
+        @models = []
+      end
+
+      # Returns the unique instance of the registry (Singleton)
+      #
+      # @api private
+      #
+      def self.__instance
+        @instance ||= new
+      end
+
+      # Adds a model to the registry
+      #
+      def self.add(klass)
+        __instance.add(klass)
+      end
+
+      # Returns an Array of registered models
+      #
+      def self.all
+        __instance.models
+      end
+
+      # Adds a model to the registry
+      #
+      def add(klass)
+        @models << klass
+      end
+
+      # Returns a copy of the registered models
+      #
+      def models
+        @models.dup
+      end
+    end
+
+    # Wraps a collection of models when querying multiple indices
+    #
+    # @see Elasticsearch::Model.search
+    #
+    class Multimodel
+      attr_reader :models
+
+      # @param models [Class] The list of models across which the search will be performed
+      #
+      def initialize(*models)
+        @models = models.flatten
+        @models = Model::Registry.all if @models.empty?
+      end
+
+      # Get an Array of index names used for retrieving documents when doing a search across multiple models
+      #
+      # @return [Array] the list of index names used for retrieving documents
+      #
+      def index_name
+        models.map { |m| m.index_name }
+      end
+
+      # Get an Array of document types used for retrieving documents when doing a search across multiple models
+      #
+      # @return [Array] the list of document types used for retrieving documents
+      #
+      def document_type
+        models.map { |m| m.document_type }
+      end
+
+      # Get the client common for all models
+      #
+      # @return Elasticsearch::Transport::Client
+      #
+      def client
+        Elasticsearch::Model.client
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/searching.rb

@@ -79,7 +79,8 @@ module Elasticsearch
         #                    fields: {
         #                      title: {}
         #                    }
-        #                  }
+        #                  },
+        #                  size: 50
         #
         #     response.results.first.title
         #     # => "Foo"

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = "0.1.6"
+    VERSION = "0.1.7"
   end
 end

data/test/integration/mongoid_basic_test.rb

@@ -1,25 +1,9 @@
 require 'test_helper'
 
-begin
-  require 'mongoid'
-  session = Moped::Connection.new("localhost", 27017, 0.5)
-  session.connect
-  ENV["MONGODB_AVAILABLE"] = 'yes'
-rescue LoadError, Moped::Errors::ConnectionFailure => e
-  $stderr.puts "MongoDB not installed or running: #{e}"
-end
-
-if ENV["MONGODB_AVAILABLE"]
-  $stderr.puts "Mongoid #{Mongoid::VERSION}", '-'*80
-
-  logger = ::Logger.new($stderr)
-  logger.formatter = lambda { |s, d, p, m| " #{m.ansi(:faint, :cyan)}\n" }
-  logger.level = ::Logger::DEBUG
-
-  Mongoid.logger = logger unless ENV['QUIET']
-  Moped.logger   = logger unless ENV['QUIET']
+Mongo.setup!
 
-  Mongoid.connect_to 'mongoid_articles'
+if Mongo.available?
+  Mongo.connect_to 'mongoid_articles'
 
   module Elasticsearch
     module Model
@@ -50,7 +34,7 @@ if ENV["MONGODB_AVAILABLE"]
           setup do
             Elasticsearch::Model::Adapter.register \
               Elasticsearch::Model::Adapter::Mongoid,
-              lambda { |klass| !!defined?(::Mongoid::Document) && klass.ancestors.include?(::Mongoid::Document) }
+              lambda { |klass| !!defined?(::Mongoid::Document) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::Mongoid::Document) }
 
             MongoidArticle.__elasticsearch__.create_index! force: true
 

data/test/integration/multiple_models_test.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+require 'active_record'
+
+Mongo.setup!
+
+module Elasticsearch
+  module Model
+    class MultipleModelsIntegration < Elasticsearch::Test::IntegrationTestCase
+      context "Multiple models" do
+        setup do
+          ActiveRecord::Schema.define(:version => 1) do
+            create_table :episodes do |t|
+              t.string :name
+              t.datetime :created_at, :default => 'NOW()'
+            end
+
+            create_table :series do |t|
+              t.string :name
+              t.datetime :created_at, :default => 'NOW()'
+            end
+          end
+
+          class ::Episode < ActiveRecord::Base
+            include Elasticsearch::Model
+            include Elasticsearch::Model::Callbacks
+
+            settings index: {number_of_shards: 1, number_of_replicas: 0} do
+              mapping do
+                indexes :name, type: 'string', analyzer: 'snowball'
+                indexes :created_at, type: 'date'
+              end
+            end
+          end
+
+          class ::Series < ActiveRecord::Base
+            include Elasticsearch::Model
+            include Elasticsearch::Model::Callbacks
+
+            settings index: {number_of_shards: 1, number_of_replicas: 0} do
+              mapping do
+                indexes :name, type: 'string', analyzer: 'snowball'
+                indexes :created_at, type: 'date'
+              end
+            end
+          end
+
+          [::Episode, ::Series].each do |model|
+            model.delete_all
+            model.__elasticsearch__.create_index! force: true
+            model.create name: "The #{model.name}"
+            model.create name: "A great #{model.name}"
+            model.create name: "The greatest #{model.name}"
+            model.__elasticsearch__.refresh_index!
+          end
+
+        end
+
+        should "find matching documents across multiple models" do
+          response = Elasticsearch::Model.search("greatest", [Series, Episode])
+
+          assert response.any?, "Response should not be empty: #{response.to_a.inspect}"
+
+          assert_equal 2, response.results.size
+          assert_equal 2, response.records.size
+
+          assert_instance_of Elasticsearch::Model::Response::Result, response.results.first
+          assert_instance_of Episode, response.records.first
+          assert_instance_of Series, response.records.last
+
+          assert_equal 'The greatest Episode', response.results[0].name
+          assert_equal 'The greatest Episode', response.records[0].name
+
+          assert_equal 'The greatest Series', response.results[1].name
+          assert_equal 'The greatest Series', response.records[1].name
+        end
+
+        should "provide access to results" do
+          q = {query: {query_string: {query: 'A great *'}}, highlight: {fields: {name: {}}}}
+          response = Elasticsearch::Model.search(q, [Series, Episode])
+
+          assert_equal 'A great Episode', response.results[0].name
+          assert_equal true,              response.results[0].name?
+          assert_equal false,             response.results[0].boo?
+          assert_equal true,              response.results[0].highlight?
+          assert_equal true,              response.results[0].highlight.name?
+          assert_equal false,             response.results[0].highlight.boo?
+
+          assert_equal 'A great Series', response.results[1].name
+          assert_equal true,             response.results[1].name?
+          assert_equal false,            response.results[1].boo?
+          assert_equal true,             response.results[1].highlight?
+          assert_equal true,             response.results[1].highlight.name?
+          assert_equal false,            response.results[1].highlight.boo?
+        end
+
+        if Mongo.available?
+          Mongo.connect_to 'mongoid_collections'
+
+          context "Across mongoid models" do
+            setup do
+              class ::Image
+                include Mongoid::Document
+                include Elasticsearch::Model
+                include Elasticsearch::Model::Callbacks
+
+                field :name, type: String
+                attr_accessible :name if respond_to? :attr_accessible
+
+                settings index: {number_of_shards: 1, number_of_replicas: 0} do
+                  mapping do
+                    indexes :name, type: 'string', analyzer: 'snowball'
+                    indexes :created_at, type: 'date'
+                  end
+                end
+
+                def as_indexed_json(options={})
+                  as_json(except: [:_id])
+                end
+              end
+
+              Image.delete_all
+              Image.__elasticsearch__.create_index! force: true
+              Image.create! name: "The Image"
+              Image.create! name: "A great Image"
+              Image.create! name: "The greatest Image"
+              Image.__elasticsearch__.refresh_index!
+              Image.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
+            end
+
+            should "find matching documents across multiple models" do
+              response = Elasticsearch::Model.search("greatest", [Episode, Image])
+
+              assert response.any?, "Response should not be empty: #{response.to_a.inspect}"
+
+              assert_equal 2, response.results.size
+              assert_equal 2, response.records.size
+
+              assert_instance_of Elasticsearch::Model::Response::Result, response.results.first
+              assert_instance_of Image, response.records.first
+              assert_instance_of Episode, response.records.last
+
+              assert_equal 'The greatest Image', response.results[0].name
+              assert_equal 'The greatest Image', response.records[0].name
+
+              assert_equal 'The greatest Episode', response.results[1].name
+              assert_equal 'The greatest Episode', response.records[1].name
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -61,3 +61,33 @@ module Elasticsearch
     end
   end
 end
+
+class Mongo
+  def self.setup!
+    begin
+      require 'mongoid'
+      session = Moped::Connection.new("localhost", 27017, 0.5)
+      session.connect
+      ENV['MONGODB_AVAILABLE'] = 'yes'
+    rescue LoadError, Moped::Errors::ConnectionFailure => e
+      $stderr.puts "MongoDB not installed or running: #{e}"
+    end
+  end
+
+  def self.available?
+    !!ENV['MONGODB_AVAILABLE']
+  end
+
+  def self.connect_to(source)
+    $stderr.puts "Mongoid #{Mongoid::VERSION}", '-'*80
+
+    logger = ::Logger.new($stderr)
+    logger.formatter = lambda { |s, d, p, m| " #{m.ansi(:faint, :cyan)}\n" }
+    logger.level = ::Logger::DEBUG
+
+    Mongoid.logger = logger unless ENV['QUIET']
+    Moped.logger   = logger unless ENV['QUIET']
+
+    Mongoid.connect_to source
+  end
+end

data/test/unit/adapter_multiple_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+class Elasticsearch::Model::MultipleTest < Test::Unit::TestCase
+
+  context "Adapter for multiple models" do
+
+    class ::DummyOne
+      include Elasticsearch::Model
+
+      index_name 'dummy'
+      document_type 'dummy_one'
+
+      def self.find(ids)
+        ids.map { |id| new(id) }
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id.to_i
+      end
+    end
+
+    module ::Namespace
+      class DummyTwo
+        include Elasticsearch::Model
+
+        index_name 'dummy'
+        document_type 'dummy_two'
+
+        def self.find(ids)
+          ids.map { |id| new(id) }
+        end
+
+        attr_reader :id
+
+        def initialize(id)
+          @id = id.to_i
+        end
+      end
+    end
+
+    class ::DummyTwo
+      include Elasticsearch::Model
+
+      index_name 'other_index'
+      document_type 'dummy_two'
+
+      def self.find(ids)
+        ids.map { |id| new(id) }
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id.to_i
+      end
+    end
+
+    HITS = [{_index: 'dummy',
+             _type: 'dummy_two',
+             _id: '2',
+            }, {
+              _index: 'dummy',
+              _type: 'dummy_one',
+              _id: '2',
+            }, {
+              _index: 'other_index',
+              _type: 'dummy_two',
+              _id: '1',
+            }, {
+              _index: 'dummy',
+              _type: 'dummy_two',
+              _id: '1',
+            }, {
+              _index: 'dummy',
+              _type: 'dummy_one',
+              _id: '3'}]
+
+    setup do
+      @multimodel = Elasticsearch::Model::Multimodel.new(DummyOne, DummyTwo, Namespace::DummyTwo)
+    end
+
+    context "when returning records" do
+      setup do
+        @multimodel.class.send :include, Elasticsearch::Model::Adapter::Multiple::Records
+        @multimodel.expects(:response).at_least_once.returns(stub(response: { 'hits' => { 'hits' => HITS } }))
+      end
+
+      should "keep the order from response" do
+        assert_instance_of Module, Elasticsearch::Model::Adapter::Multiple::Records
+        records = @multimodel.records
+
+        assert_equal 5, records.count
+
+        assert_kind_of ::Namespace::DummyTwo, records[0]
+        assert_kind_of ::DummyOne,            records[1]
+        assert_kind_of ::DummyTwo,            records[2]
+        assert_kind_of ::Namespace::DummyTwo, records[3]
+        assert_kind_of ::DummyOne,            records[4]
+
+        assert_equal [2, 2, 1, 1, 3], records.map(&:id)
+      end
+    end
+  end
+end

data/test/unit/indexing_test.rb

@@ -12,6 +12,8 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
       end
     end
 
+    class NotFound < Exception; end
+
     context "Settings class" do
       should "be convertible to hash" do
         hash     = { foo: 'bar' }
@@ -336,6 +338,7 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
           assert_equal 'bar',  payload[:type]
           assert_equal '1',    payload[:id]
           assert_equal({title: 'green'}, payload[:body][:doc])
+          true
         end
 
         instance.expects(:client).returns(client)
@@ -356,6 +359,7 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
           assert_equal '1',    payload[:id]
           assert_equal({title: 'green'}, payload[:body][:doc])
           assert_equal true,   payload[:refresh]
+          true
         end
 
         instance.expects(:client).returns(client)
@@ -380,19 +384,40 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         end
       end
 
-      should "delete the index without raising exception" do
+      should "delete the index without raising exception when the index is not found" do
         client  = stub('client')
         indices = stub('indices')
         client.stubs(:indices).returns(indices)
 
-        indices.expects(:delete).returns({}).then.raises(Exception).at_least_once
+        indices.expects(:delete).returns({}).then.raises(NotFound).at_least_once
 
         DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
 
-        assert_nothing_raised do
-          DummyIndexingModelForRecreate.delete_index!
-          DummyIndexingModelForRecreate.delete_index!
-        end
+        assert_nothing_raised { DummyIndexingModelForRecreate.delete_index! force: true }
+      end
+
+      should "raise an exception without the force option" do
+        client  = stub('client')
+        indices = stub('indices')
+        client.stubs(:indices).returns(indices)
+
+        indices.expects(:delete).raises(NotFound)
+
+        DummyIndexingModelForRecreate.expects(:client).returns(client)
+
+        assert_raise(NotFound) { DummyIndexingModelForRecreate.delete_index! }
+      end
+
+      should "raise a regular exception when deleting the index" do
+        client  = stub('client')
+
+        indices = stub('indices')
+        indices.expects(:delete).raises(Exception)
+        client.stubs(:indices).returns(indices)
+
+        DummyIndexingModelForRecreate.expects(:client).returns(client)
+
+        assert_raise(Exception) { DummyIndexingModelForRecreate.delete_index! force: true }
       end
 
       should "create the index with correct settings and mappings when it doesn't exist" do
@@ -428,19 +453,18 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         assert_nothing_raised { DummyIndexingModelForRecreate.create_index! }
       end
 
-      should "not raise exception during index creation" do
+      should "raise exception during index creation" do
         client  = stub('client')
         indices = stub('indices')
         client.stubs(:indices).returns(indices)
 
+        indices.expects(:delete).returns({})
         indices.expects(:exists).returns(false)
-        indices.expects(:create).raises(Exception).at_least_once
+        indices.expects(:create).raises(Exception)
 
         DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
 
-        assert_nothing_raised do
-          DummyIndexingModelForRecreate.create_index!
-        end
+        assert_raise(Exception) { DummyIndexingModelForRecreate.create_index! force: true }
       end
 
       should "delete the index first with the force option" do
@@ -459,7 +483,19 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         end
       end
 
-      should "refresh the index without raising exception" do
+      should "refresh the index without raising exception with the force option" do
+        client  = stub('client')
+        indices = stub('indices')
+        client.stubs(:indices).returns(indices)
+
+        indices.expects(:refresh).returns({}).then.raises(NotFound).at_least_once
+
+        DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+
+        assert_nothing_raised { DummyIndexingModelForRecreate.refresh_index! force: true }
+      end
+
+      should "raise a regular exception when refreshing the index" do
         client  = stub('client')
         indices = stub('indices')
         client.stubs(:indices).returns(indices)
@@ -468,10 +504,7 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
 
         DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
 
-        assert_nothing_raised do
-          DummyIndexingModelForRecreate.refresh_index!
-          DummyIndexingModelForRecreate.refresh_index!
-        end
+        assert_nothing_raised { DummyIndexingModelForRecreate.refresh_index! force: true }
       end
 
       context "with a custom index name" do

data/test/unit/multimodel_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class Elasticsearch::Model::MultimodelTest < Test::Unit::TestCase
+
+  context "Multimodel class" do
+    setup do
+      title  = stub('Foo', index_name: 'foo_index', document_type: 'foo')
+      series = stub('Bar', index_name: 'bar_index', document_type: 'bar')
+      @multimodel = Elasticsearch::Model::Multimodel.new(title, series)
+    end
+
+    should "have an index_name" do
+      assert_equal ['foo_index', 'bar_index'], @multimodel.index_name
+    end
+
+    should "have a document_type" do
+      assert_equal ['foo', 'bar'], @multimodel.document_type
+    end
+
+    should "have a client" do
+      assert_equal Elasticsearch::Model.client, @multimodel.client
+    end
+
+    should "include models in the registry" do
+      class ::JustAModel
+        include Elasticsearch::Model
+      end
+
+      class ::JustAnotherModel
+        include Elasticsearch::Model
+      end
+
+      multimodel = Elasticsearch::Model::Multimodel.new
+      assert multimodel.models.include?(::JustAModel)
+      assert multimodel.models.include?(::JustAnotherModel)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-model
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Karel Minarik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-01 00:00:00.000000000 Z
+date: 2015-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elasticsearch
@@ -348,11 +348,13 @@ files:
 - lib/elasticsearch/model/adapters/active_record.rb
 - lib/elasticsearch/model/adapters/default.rb
 - lib/elasticsearch/model/adapters/mongoid.rb
+- lib/elasticsearch/model/adapters/multiple.rb
 - lib/elasticsearch/model/callbacks.rb
 - lib/elasticsearch/model/client.rb
 - lib/elasticsearch/model/ext/active_record.rb
 - lib/elasticsearch/model/importing.rb
 - lib/elasticsearch/model/indexing.rb
+- lib/elasticsearch/model/multimodel.rb
 - lib/elasticsearch/model/naming.rb
 - lib/elasticsearch/model/proxy.rb
 - lib/elasticsearch/model/response.rb
@@ -373,16 +375,19 @@ files:
 - test/integration/active_record_pagination_test.rb
 - test/integration/dynamic_index_name_test.rb
 - test/integration/mongoid_basic_test.rb
+- test/integration/multiple_models_test.rb
 - test/test_helper.rb
 - test/unit/adapter_active_record_test.rb
 - test/unit/adapter_default_test.rb
 - test/unit/adapter_mongoid_test.rb
+- test/unit/adapter_multiple_test.rb
 - test/unit/adapter_test.rb
 - test/unit/callbacks_test.rb
 - test/unit/client_test.rb
 - test/unit/importing_test.rb
 - test/unit/indexing_test.rb
 - test/unit/module_test.rb
+- test/unit/multimodel_test.rb
 - test/unit/naming_test.rb
 - test/unit/proxy_test.rb
 - test/unit/response_base_test.rb
@@ -430,16 +435,19 @@ test_files:
 - test/integration/active_record_pagination_test.rb
 - test/integration/dynamic_index_name_test.rb
 - test/integration/mongoid_basic_test.rb
+- test/integration/multiple_models_test.rb
 - test/test_helper.rb
 - test/unit/adapter_active_record_test.rb
 - test/unit/adapter_default_test.rb
 - test/unit/adapter_mongoid_test.rb
+- test/unit/adapter_multiple_test.rb
 - test/unit/adapter_test.rb
 - test/unit/callbacks_test.rb
 - test/unit/client_test.rb
 - test/unit/importing_test.rb
 - test/unit/indexing_test.rb
 - test/unit/module_test.rb
+- test/unit/multimodel_test.rb
 - test/unit/naming_test.rb
 - test/unit/proxy_test.rb
 - test/unit/response_base_test.rb