elasticsearch-model 0.0.1 → 0.1.0.rc1

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

@@ -0,0 +1,50 @@
+module Elasticsearch
+  module Model
+    module Response
+
+      # Encapsulates the "hit" returned from the Elasticsearch client
+      #
+      # Wraps the raw Hash with in a `Hashie::Mash` instance, providing
+      # access to the Hash properties by calling Ruby methods.
+      #
+      # @see https://github.com/intridea/hashie
+      #
+      class Result
+
+        # @param attributes [Hash] A Hash with document properties
+        #
+        def initialize(attributes={})
+          @result = Hashie::Mash.new(attributes)
+        end
+
+        # Delegate methods to `@result` or `@result._source`
+        #
+        def method_missing(method_name, *arguments)
+          case
+          when @result.respond_to?(method_name.to_sym)
+            @result.__send__ method_name.to_sym, *arguments
+          when @result._source && @result._source.respond_to?(method_name.to_sym)
+            @result._source.__send__ method_name.to_sym, *arguments
+          else
+            super
+          end
+        end
+
+        # Respond to methods from `@result` or `@result._source`
+        #
+        def respond_to?(method_name, include_private = false)
+          @result.respond_to?(method_name.to_sym) || \
+          @result._source && @result._source.respond_to?(method_name.to_sym) || \
+          super
+        end
+
+        def as_json(options={})
+          @result.as_json(options)
+        end
+
+        # TODO: #to_s, #inspect, with support for Pry
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Elasticsearch
+  module Model
+    module Response
+
+      # Encapsulates the collection of documents returned from Elasticsearch
+      #
+      # Implements Enumerable and forwards its methods to the {#results} object.
+      #
+      class Results
+        include Base
+        include Enumerable
+
+        extend  Support::Forwardable
+        forward :results, :each, :empty?, :size, :slice, :[], :to_a, :to_ary
+
+        # @see Base#initialize
+        #
+        def initialize(klass, response, options={})
+          super
+        end
+
+        # Returns the {Results} collection
+        #
+        def results
+          # TODO: Configurable custom wrapper
+          @results  = response.response['hits']['hits'].map { |hit| Result.new(hit) }
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/searching.rb

@@ -0,0 +1,107 @@
+module Elasticsearch
+  module Model
+
+    # Contains functionality related to searching.
+    #
+    module Searching
+
+      # Wraps a search request definition
+      #
+      class SearchRequest
+        attr_reader :klass, :definition
+
+        # @param klass [Class] The class of the model
+        # @param query_or_payload [String,Hash,Object] The search request definition
+        #                                              (string, JSON, Hash, or object responding to `to_hash`)
+        # @param options [Hash] Optional parameters to be passed to the Elasticsearch client
+        #
+        def initialize(klass, query_or_payload, options={})
+          @klass   = klass
+
+          __index_name    = options[:index] || klass.index_name
+          __document_type = options[:type]  || klass.document_type
+
+          case
+            # search query: ...
+            when query_or_payload.respond_to?(:to_hash)
+              body = query_or_payload.to_hash
+
+            # search '{ "query" : ... }'
+            when query_or_payload.is_a?(String) && query_or_payload =~ /^\s*{/
+              body = query_or_payload
+
+            # search '...'
+            else
+              q = query_or_payload
+          end
+
+          if body
+            @definition = { index: __index_name, type: __document_type, body: body }.update options
+          else
+            @definition = { index: __index_name, type: __document_type, q: q }.update options
+          end
+        end
+
+        # Performs the request and returns the response from client
+        #
+        # @return [Hash] The response from Elasticsearch
+        #
+        def execute!
+          klass.client.search(@definition)
+        end
+      end
+
+      module ClassMethods
+
+        # Provides a `search` method for the model to easily search within an index/type
+        # corresponding to the model settings.
+        #
+        # @param query_or_payload [String,Hash,Object] The search request definition
+        #                                              (string, JSON, Hash, or object responding to `to_hash`)
+        # @param options [Hash] Optional parameters to be passed to the Elasticsearch client
+        #
+        # @return [Elasticsearch::Model::Response::Response]
+        #
+        # @example Simple search in `Article`
+        #
+        #     Article.search 'foo'
+        #
+        # @example Search using a search definition as a Hash
+        #
+        #     response = Article.search \
+        #                  query: {
+        #                    match: {
+        #                      title: 'foo'
+        #                    }
+        #                  },
+        #                  highlight: {
+        #                    fields: {
+        #                      title: {}
+        #                    }
+        #                  }
+        #
+        #     response.results.first.title
+        #     # => "Foo"
+        #
+        #     response.results.first.highlight.title
+        #     # => ["<em>Foo</em>"]
+        #
+        #     response.records.first.title
+        #     #  Article Load (0.2ms)  SELECT "articles".* FROM "articles" WHERE "articles"."id" IN (1, 3)
+        #     # => "Foo"
+        #
+        # @example Search using a search definition as a JSON string
+        #
+        #     Article.search '{"query" : { "match_all" : {} }}'
+        #
+        def search(query_or_payload, options={})
+          search   = SearchRequest.new(self, query_or_payload, options={})
+
+          Response::Response.new(self, search)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/model/serializing.rb

@@ -0,0 +1,35 @@
+module Elasticsearch
+  module Model
+
+    # Contains functionality for serializing model instances for the client
+    #
+    module Serializing
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+
+        # Serialize the record as a Hash, to be passed to the client.
+        #
+        # Re-define this method to customize the serialization.
+        #
+        # @return [Hash]
+        #
+        # @example Return the model instance as a Hash
+        #
+        #     Article.first.__elasticsearch__.as_indexed_json
+        #     => {"title"=>"Foo"}
+        #
+        # @see Elasticsearch::Model::Indexing
+        #
+        def as_indexed_json(options={})
+          # TODO: Play with the `MyModel.indexes` method -- reject non-mapped attributes, `:as` options, etc
+          self.as_json(options.merge root: false)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/model/support/forwardable.rb

@@ -0,0 +1,44 @@
+module Elasticsearch
+  module Model
+    module Support
+
+      # Lightweight wrapper around "forwardable.rb" interface,
+      # to allow easy implementation changes in the future.
+      #
+      # Cf. https://github.com/mongoid/origin/blob/master/lib/origin/forwardable.rb
+      #
+      module Forwardable
+        def self.extended(base)
+          base.__send__ :extend, ::Forwardable
+          base.__send__ :extend, ::SingleForwardable
+        end
+
+        # Forwards specific method(s) to the provided receiver
+        #
+        # @example Forward the `each` method to `results` object
+        #
+        #   MyClass.forward(:results, :each)
+        #
+        # @example Forward the `include?` method to `ancestors` class method
+        #
+        #   MyClass.forward(:'self.ancestors', :include?)
+        #
+        # @param [ Symbol ] receiver        The name of the receiver method
+        # @param [ Symbol, Array ] methods  The forwarded methods
+        #
+        # @api private
+        #
+        def forward(receiver, *methods)
+          methods = Array(methods).flatten
+          target  = self.__send__ :eval, receiver.to_s rescue nil
+
+          if target
+            single_delegate   methods => receiver
+          else
+            instance_delegate methods => receiver
+          end
+        end; module_function :forward
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = "0.0.1"
+    VERSION = "0.1.0.rc1"
   end
 end

data/test/integration/active_record_associations_parent_child.rb

@@ -0,0 +1,138 @@
+require 'test_helper'
+
+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,306 @@
+require 'test_helper'
+
+# ----- 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
+
+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
+
+          # ----- 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