elasticsearch-model-queryable 0.1.5

data/lib/elasticsearch/model.rb

@@ -0,0 +1,157 @@
+require 'elasticsearch'
+
+require 'hashie'
+
+require 'active_support/core_ext/module/delegation'
+
+require 'elasticsearch/model/version'
+
+require 'elasticsearch/model/client'
+
+require 'elasticsearch/model/adapter'
+require 'elasticsearch/model/adapters/default'
+require 'elasticsearch/model/adapters/active_record'
+require 'elasticsearch/model/adapters/mongoid'
+
+require 'elasticsearch/model/importing'
+require 'elasticsearch/model/indexing'
+require 'elasticsearch/model/naming'
+require 'elasticsearch/model/serializing'
+require 'elasticsearch/model/searching'
+require 'elasticsearch/model/callbacks'
+
+require 'elasticsearch/model/proxy'
+
+require 'elasticsearch/model/response'
+require 'elasticsearch/model/response/base'
+require 'elasticsearch/model/response/result'
+require 'elasticsearch/model/response/results'
+require 'elasticsearch/model/response/records'
+require 'elasticsearch/model/response/pagination'
+
+require 'elasticsearch/model/ext/active_record'
+
+case
+when defined?(::Kaminari)
+  Elasticsearch::Model::Response::Response.__send__ :include, Elasticsearch::Model::Response::Pagination::Kaminari
+when defined?(::WillPaginate)
+  Elasticsearch::Model::Response::Response.__send__ :include, Elasticsearch::Model::Response::Pagination::WillPaginate
+end
+
+module Elasticsearch
+
+  # Elasticsearch integration for Ruby models
+  # =========================================
+  #
+  # `Elasticsearch::Model` contains modules for integrating the Elasticsearch search and analytical engine
+  # with ActiveModel-based classes, or models, for the Ruby programming language.
+  #
+  # It facilitates importing your data into an index, automatically updating it when a record changes,
+  # searching the specific index, setting up the index mapping or the model JSON serialization.
+  #
+  # When the `Elasticsearch::Model` module is included in your class, it automatically extends it
+  # with the functionality; see {Elasticsearch::Model.included}. Most methods are available via
+  # the `__elasticsearch__` class and instance method proxies.
+  #
+  # It is possible to include/extend the model with the corresponding
+  # modules directly, if that is desired:
+  #
+  #     MyModel.__send__ :extend,  Elasticsearch::Model::Client::ClassMethods
+  #     MyModel.__send__ :include, Elasticsearch::Model::Client::InstanceMethods
+  #     MyModel.__send__ :extend,  Elasticsearch::Model::Searching::ClassMethods
+  #     # ...
+  #
+  module Model
+    METHODS = [:search, :mapping, :mappings, :settings, :index_name, :document_type, :import]
+
+    # Adds the `Elasticsearch::Model` functionality to the including class.
+    #
+    # * Creates the `__elasticsearch__` class and instance methods, pointing to the proxy object
+    # * Includes the necessary modules in the proxy classes
+    # * Sets up delegation for crucial methods such as `search`, etc.
+    #
+    # @example Include the module in the `Article` model definition
+    #
+    #     class Article < ActiveRecord::Base
+    #       include Elasticsearch::Model
+    #     end
+    #
+    # @example Inject the module into the `Article` model during run time
+    #
+    #     Article.__send__ :include, Elasticsearch::Model
+    #
+    #
+    def self.included(base)
+      base.class_eval do
+        include Elasticsearch::Model::Proxy
+
+        Elasticsearch::Model::Proxy::ClassMethodsProxy.class_eval do
+          include Elasticsearch::Model::Client::ClassMethods
+          include Elasticsearch::Model::Naming::ClassMethods
+          include Elasticsearch::Model::Indexing::ClassMethods
+          include Elasticsearch::Model::Searching::ClassMethods
+        end
+
+        Elasticsearch::Model::Proxy::InstanceMethodsProxy.class_eval do
+          include Elasticsearch::Model::Client::InstanceMethods
+          include Elasticsearch::Model::Naming::InstanceMethods
+          include Elasticsearch::Model::Indexing::InstanceMethods
+          include Elasticsearch::Model::Serializing::InstanceMethods
+        end
+
+        Elasticsearch::Model::Proxy::InstanceMethodsProxy.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def as_indexed_json(options={})
+            target.respond_to?(:as_indexed_json) ? target.__send__(:as_indexed_json, options) : super
+          end
+        CODE
+
+        # Delegate important methods to the `__elasticsearch__` proxy, unless they are defined already
+        #
+        class << self
+          METHODS.each do |method|
+            delegate method, to: :__elasticsearch__ unless self.public_instance_methods.include?(method)
+          end
+        end
+
+        # Mix the importing module into the proxy
+        #
+        self.__elasticsearch__.class_eval do
+          include Elasticsearch::Model::Importing::ClassMethods
+          include Adapter.from_class(base).importing_mixin
+        end
+      end
+    end
+
+    module ClassMethods
+
+      # Get the client common for all models
+      #
+      # @example Get the client
+      #
+      #     Elasticsearch::Model.client
+      #     => #<Elasticsearch::Transport::Client:0x007f96a7d0d000 @transport=... >
+      #
+      def client
+        @client ||= Elasticsearch::Client.new
+      end
+
+      # Set the client for all models
+      #
+      # @example Configure (set) the client for all models
+      #
+      #     Elasticsearch::Model.client Elasticsearch::Client.new host: 'http://localhost:9200', tracer: true
+      #     => #<Elasticsearch::Transport::Client:0x007f96a6dd0d80 @transport=... >
+      #
+      # @note You have to set the client before you call Elasticsearch methods on the model,
+      #       or set it directly on the model; see {Elasticsearch::Model::Client::ClassMethods#client}
+      #
+      def client=(client)
+        @client = client
+      end
+
+    end
+    extend ClassMethods
+
+    class NotImplemented < NoMethodError; end
+  end
+end

data/test/integration/active_record_associations_parent_child.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+require 'active_record'
+
+class Question < ActiveRecord::Base
+  include Elasticsearch::Model
+
+  has_many :answers, dependent: :destroy
+
+  index_name 'questions_and_answers'
+
+  mapping do
+    indexes :title
+    indexes :text
+    indexes :author
+  end
+
+  after_commit lambda { __elasticsearch__.index_document  },  on: :create
+  after_commit lambda { __elasticsearch__.update_document },  on: :update
+  after_commit lambda { __elasticsearch__.delete_document },  on: :destroy
+end
+
+class Answer < ActiveRecord::Base
+  include Elasticsearch::Model
+
+  belongs_to :question
+
+  index_name 'questions_and_answers'
+
+  mapping _parent: { type: 'question', required: true } do
+    indexes :text
+    indexes :author
+  end
+
+  after_commit lambda { __elasticsearch__.index_document(parent: question_id)  },  on: :create
+  after_commit lambda { __elasticsearch__.update_document(parent: question_id) },  on: :update
+  after_commit lambda { __elasticsearch__.delete_document(parent: question_id) },  on: :destroy
+end
+
+module ParentChildSearchable
+  INDEX_NAME = 'questions_and_answers'
+
+  def create_index!(options={})
+    client = Question.__elasticsearch__.client
+    client.indices.delete index: INDEX_NAME rescue nil if options[:force]
+
+    settings = Question.settings.to_hash.merge Answer.settings.to_hash
+    mappings = Question.mappings.to_hash.merge Answer.mappings.to_hash
+
+    client.indices.create index: INDEX_NAME,
+                          body: {
+                            settings: settings.to_hash,
+                            mappings: mappings.to_hash }
+  end
+
+  extend self
+end
+
+module Elasticsearch
+  module Model
+    class ActiveRecordAssociationsParentChildIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      context "ActiveRecord associations with parent/child modelling" do
+        setup do
+          ActiveRecord::Schema.define(version: 1) do
+            create_table :questions do |t|
+              t.string     :title
+              t.text       :text
+              t.string     :author
+              t.timestamps
+            end
+            create_table :answers do |t|
+              t.text       :text
+              t.string     :author
+              t.references :question
+              t.timestamps
+            end and add_index(:answers, :question_id)
+          end
+
+          Question.delete_all
+          ParentChildSearchable.create_index! force: true
+
+          q_1 = Question.create! title: 'First Question',  author: 'John'
+          q_2 = Question.create! title: 'Second Question', author: 'Jody'
+
+          q_1.answers.create! text: 'Lorem Ipsum', author: 'Adam'
+          q_1.answers.create! text: 'Dolor Sit',   author: 'Ryan'
+
+          q_2.answers.create! text: 'Amet Et', author: 'John'
+
+          Question.__elasticsearch__.refresh_index!
+        end
+
+        should "find questions by matching answers" do
+          response = Question.search(
+                       { query: {
+                            has_child: {
+                              type: 'answer',
+                              query: {
+                                match: {
+                                  author: 'john'
+                                }
+                              }
+                            }
+                         }
+                       })
+
+          assert_equal 'Second Question', response.records.first.title
+        end
+
+        should "find answers for matching questions" do
+          response = Answer.search(
+                       { query: {
+                            has_parent: {
+                              parent_type: 'question',
+                              query: {
+                                match: {
+                                  author: 'john'
+                                }
+                              }
+                            }
+                         }
+                       })
+
+          assert_same_elements ['Adam', 'Ryan'], response.records.map(&:author)
+        end
+
+        should "delete answers when the question is deleted" do
+          Question.where(title: 'First Question').each(&:destroy)
+          Question.__elasticsearch__.refresh_index!
+
+          response = Answer.search query: { match_all: {} }
+
+          assert_equal 1, response.results.total
+        end
+      end
+
+    end
+  end
+end

data/test/integration/active_record_associations_test.rb

@@ -0,0 +1,307 @@
+require 'test_helper'
+require 'active_record'
+
+module Elasticsearch
+  module Model
+    class ActiveRecordAssociationsIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      context "ActiveRecord associations" do
+        setup do
+
+          # ----- Schema definition ---------------------------------------------------------------
+
+          ActiveRecord::Schema.define(version: 1) do
+            create_table :categories do |t|
+              t.string     :title
+              t.timestamps
+            end
+
+            create_table :categories_posts, id: false do |t|
+              t.references :post, :category
+            end
+
+            create_table :authors do |t|
+              t.string     :first_name, :last_name
+              t.timestamps
+            end
+
+            create_table :authorships do |t|
+              t.string     :first_name, :last_name
+              t.references :post
+              t.references :author
+              t.timestamps
+            end
+
+            create_table :comments do |t|
+              t.string     :text
+              t.string     :author
+              t.references :post
+              t.timestamps
+            end and add_index(:comments, :post_id)
+
+            create_table :posts do |t|
+              t.string     :title
+              t.text       :text
+              t.boolean    :published
+              t.timestamps
+            end
+          end
+
+          # ----- Models definition -------------------------------------------------------------------------
+
+          class Category < ActiveRecord::Base
+            has_and_belongs_to_many :posts
+          end
+
+          class Author < ActiveRecord::Base
+            has_many :authorships
+
+            def full_name
+              [first_name, last_name].compact.join(' ')
+            end
+          end
+
+          class Authorship < ActiveRecord::Base
+            belongs_to :author
+            belongs_to :post, touch: true
+          end
+
+          class Comment < ActiveRecord::Base
+            belongs_to :post, touch: true
+          end
+
+          class Post < ActiveRecord::Base
+            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
+            has_many                :authors, through: :authorships
+            has_many                :comments
+          end
+
+          # ----- Search integration via Concern module -----------------------------------------------------
+
+          module Searchable
+            extend ActiveSupport::Concern
+
+            included do
+              include Elasticsearch::Model
+              include Elasticsearch::Model::Callbacks
+
+              # Set up the mapping
+              #
+              settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+                mapping do
+                  indexes :title,      analyzer: 'snowball'
+                  indexes :created_at, type: 'date'
+
+                  indexes :authors do
+                    indexes :first_name
+                    indexes :last_name
+                    indexes :full_name, type: 'multi_field' do
+                      indexes :full_name
+                      indexes :raw, analyzer: 'keyword'
+                    end
+                  end
+
+                  indexes :categories, analyzer: 'keyword'
+
+                  indexes :comments, type: 'nested' do
+                    indexes :text
+                    indexes :author
+                  end
+                end
+              end
+
+              # Customize the JSON serialization for Elasticsearch
+              #
+              def as_indexed_json(options={})
+                {
+                  title: title,
+                  text:  text,
+                  categories: categories.map(&:title),
+                  authors:    authors.as_json(methods: [:full_name], only: [:full_name, :first_name, :last_name]),
+                  comments:   comments.as_json(only: [:text, :author])
+                }
+              end
+
+              # Update document in the index after touch
+              #
+              after_touch() { __elasticsearch__.index_document }
+            end
+          end
+
+          # Include the search integration
+          #
+          Post.__send__ :include, Searchable
+
+          # ----- Reset the index -----------------------------------------------------------------
+
+          Post.delete_all
+          Post.__elasticsearch__.create_index! force: true
+        end
+
+        should "index and find a document" do
+          Post.create! title: 'Test'
+          Post.create! title: 'Testing Coding'
+          Post.create! title: 'Coding'
+          Post.__elasticsearch__.refresh_index!
+
+          response = Post.search('title:test')
+
+          assert_equal 2, response.results.size
+          assert_equal 2, response.records.size
+
+          assert_equal 'Test', response.results.first.title
+          assert_equal 'Test', response.records.first.title
+        end
+
+        should "reindex a document after categories are changed" do
+          # Create categories
+          category_a = Category.where(title: "One").first_or_create!
+          category_b = Category.where(title: "Two").first_or_create!
+
+          # Create post
+          post = Post.create! title: "First Post", text: "This is the first post..."
+
+          # Assign categories
+          post.categories = [category_a,  category_b]
+
+          Post.__elasticsearch__.refresh_index!
+
+          query = { query: {
+                      filtered: {
+                        query: {
+                          multi_match: {
+                            fields: ['title'],
+                            query: 'first'
+                          }
+                        },
+                        filter: {
+                          terms: {
+                            categories: ['One']
+                          }
+                        }
+                      }
+                    }
+                  }
+
+          response = Post.search query
+
+          assert_equal 1, response.results.size
+          assert_equal 1, response.records.size
+
+          # Remove category "One"
+          post.categories = [category_b]
+
+          Post.__elasticsearch__.refresh_index!
+          response = Post.search query
+
+          assert_equal 0, response.results.size
+          assert_equal 0, response.records.size
+        end
+
+        should "reindex a document after authors are changed" do
+          # Create authors
+          author_a = Author.where(first_name: "John", last_name: "Smith").first_or_create!
+          author_b = Author.where(first_name: "Mary", last_name: "Smith").first_or_create!
+          author_c = Author.where(first_name: "Kobe", last_name: "Griss").first_or_create!
+
+          # Create posts
+          post_1 = Post.create! title: "First Post", text: "This is the first post..."
+          post_2 = Post.create! title: "Second Post", text: "This is the second post..."
+          post_3 = Post.create! title: "Third Post", text: "This is the third post..."
+
+          # Assign authors
+          post_1.authors = [author_a,  author_b]
+          post_2.authors = [author_a]
+          post_3.authors = [author_c]
+
+          Post.__elasticsearch__.refresh_index!
+
+          response = Post.search 'authors.full_name:john'
+
+          assert_equal 2, response.results.size
+          assert_equal 2, response.records.size
+
+          post_3.authors << author_a
+
+          Post.__elasticsearch__.refresh_index!
+
+          response = Post.search 'authors.full_name:john'
+
+          assert_equal 3, response.results.size
+          assert_equal 3, response.records.size
+        end if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
+
+        should "reindex a document after comments are added" do
+          # Create posts
+          post_1 = Post.create! title: "First Post", text: "This is the first post..."
+          post_2 = Post.create! title: "Second Post", text: "This is the second post..."
+
+          # Add comments
+          post_1.comments.create! author: 'John', text: 'Excellent'
+          post_1.comments.create! author: 'Abby', text: 'Good'
+
+          post_2.comments.create! author: 'John', text: 'Terrible'
+
+          Post.__elasticsearch__.refresh_index!
+
+          response = Post.search 'comments.author:john AND comments.text:good'
+          assert_equal 0, response.results.size
+
+          # Add comment
+          post_1.comments.create! author: 'John', text: 'Or rather just good...'
+
+          Post.__elasticsearch__.refresh_index!
+
+          response = Post.search 'comments.author:john AND comments.text:good'
+          assert_equal 0, response.results.size
+
+          response = Post.search \
+            query: {
+              nested: {
+                path: 'comments',
+                query: {
+                  bool: {
+                    must: [
+                      { match: { 'comments.author' => 'john' } },
+                      { match: { 'comments.text'   => 'good' } }
+                    ]
+                  }
+                }
+              }
+            }
+
+          assert_equal 1, response.results.size
+        end if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
+
+        should "reindex a document after Post#touch" do
+          # Create categories
+          category_a = Category.where(title: "One").first_or_create!
+
+          # Create post
+          post = Post.create! title: "First Post", text: "This is the first post..."
+
+          # Assign category
+          post.categories << category_a
+
+          Post.__elasticsearch__.refresh_index!
+
+          assert_equal 1, Post.search('categories:One').size
+
+          # Update category
+          category_a.update_attribute :title, "Updated"
+
+          # Trigger touch on posts in category
+          category_a.posts.each { |p| p.touch }
+
+          Post.__elasticsearch__.refresh_index!
+
+          assert_equal 0, Post.search('categories:One').size
+          assert_equal 1, Post.search('categories:Updated').size
+        end
+      end
+
+    end
+  end
+end