elasticsearch-model 0.1.9 → 2.0.0

data/lib/elasticsearch/model/response.rb

@@ -69,7 +69,7 @@ module Elasticsearch
         # Returns a Hashie::Mash of the aggregations
         #
         def aggregations
-          response['aggregations'] ? Hashie::Mash.new(response['aggregations']) : nil
+          Aggregations.new(response['aggregations'])
         end
 
         # Returns a Hashie::Mash of the suggestions

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

@@ -0,0 +1,36 @@
+module Elasticsearch
+  module Model
+    module Response
+
+      class Aggregations < Hashie::Mash
+        def initialize(attributes={})
+          __redefine_enumerable_methods super(attributes)
+        end
+
+        # Fix the problem of Hashie::Mash returning unexpected values for `min` and `max` methods
+        #
+        # People can define names for aggregations such as `min` and `max`, but these
+        # methods are defined in `Enumerable#min` and `Enumerable#max`
+        #
+        #     { foo: 'bar' }.min
+        #     # => [:foo, "bar"]
+        #
+        # Therefore, any Hashie::Mash instance value has the `min` and `max`
+        # methods redefined to return the real value
+        #
+        def __redefine_enumerable_methods(h)
+          if h.respond_to?(:each_pair)
+            h.each_pair { |k, v| v = __redefine_enumerable_methods(v) }
+          end
+          if h.is_a?(Hashie::Mash)
+            class << h
+              define_method(:min) { self[:min] }
+              define_method(:max) { self[:max] }
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = "0.1.9"
+    VERSION = "2.0.0"
   end
 end

data/test/integration/active_record_associations_parent_child.rb

@@ -1,6 +1,11 @@
 require 'test_helper'
 require 'active_record'
 
+# Needed for ActiveRecord 3.x ?
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
+
+::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+
 class Question < ActiveRecord::Base
   include Elasticsearch::Model
 
@@ -66,14 +71,17 @@ module Elasticsearch
               t.string     :title
               t.text       :text
               t.string     :author
-              t.timestamps
+              t.timestamps null: false
             end
+
             create_table :answers do |t|
               t.text       :text
               t.string     :author
               t.references :question
-              t.timestamps
-            end and add_index(:answers, :question_id)
+              t.timestamps null: false
+            end
+
+            add_index(:answers, :question_id) unless index_exists?(:answers, :question_id)
           end
 
           Question.delete_all

data/test/integration/active_record_associations_test.rb

@@ -1,10 +1,67 @@
 require 'test_helper'
 require 'active_record'
 
+# Needed for ActiveRecord 3.x ?
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
+
+::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+
 module Elasticsearch
   module Model
     class ActiveRecordAssociationsIntegrationTest < Elasticsearch::Test::IntegrationTestCase
 
+      # ----- 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
+
       context "ActiveRecord associations" do
         setup do
 
@@ -13,7 +70,7 @@ module Elasticsearch
           ActiveRecord::Schema.define(version: 1) do
             create_table :categories do |t|
               t.string     :title
-              t.timestamps
+              t.timestamps null: false
             end
 
             create_table :categories_posts, id: false do |t|
@@ -22,28 +79,30 @@ module Elasticsearch
 
             create_table :authors do |t|
               t.string     :first_name, :last_name
-              t.timestamps
+              t.timestamps null: false
             end
 
             create_table :authorships do |t|
               t.string     :first_name, :last_name
               t.references :post
               t.references :author
-              t.timestamps
+              t.timestamps null: false
             end
 
             create_table :comments do |t|
               t.string     :text
               t.string     :author
               t.references :post
-              t.timestamps
-            end and add_index(:comments, :post_id)
+              t.timestamps null: false
+            end
+
+            add_index(:comments, :post_id) unless index_exists?(:comments, :post_id)
 
             create_table :posts do |t|
               t.string     :title
               t.text       :text
               t.boolean    :published
-              t.timestamps
+              t.timestamps null: false
             end
           end
 
@@ -56,6 +115,8 @@ module Elasticsearch
           class Author < ActiveRecord::Base
             has_many :authorships
 
+            after_update { self.authorships.each(&:touch) }
+
             def full_name
               [first_name, last_name].compact.join(' ')
             end
@@ -74,60 +135,13 @@ module Elasticsearch
             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
+            has_many                :authors, through: :authorships,
+                                              after_add: [ lambda { |a,c| a.__elasticsearch__.index_document } ],
+                                              after_remove: [ lambda { |a,c| a.__elasticsearch__.index_document } ]
+            has_many                :comments, after_add:    [ lambda { |a,c| a.__elasticsearch__.index_document } ],
+                                               after_remove: [ lambda { |a,c| a.__elasticsearch__.index_document } ]
 
-              # 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
+            after_touch() { __elasticsearch__.index_document }
           end
 
           # Include the search integration

data/test/integration/active_record_basic_test.rb

@@ -3,45 +3,53 @@ require 'active_record'
 
 puts "ActiveRecord #{ActiveRecord::VERSION::STRING}", '-'*80
 
+# Needed for ActiveRecord 3.x ?
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
+
+::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+
 module Elasticsearch
   module Model
     class ActiveRecordBasicIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::Article < ActiveRecord::Base
+        include Elasticsearch::Model
+        include Elasticsearch::Model::Callbacks
+
+        settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+          mapping do
+            indexes :title,         type: 'string', analyzer: 'snowball'
+            indexes :body,          type: 'string'
+            indexes :clicks,        type: 'integer'
+            indexes :created_at,    type: 'date'
+          end
+        end
+
+        def as_indexed_json(options = {})
+          attributes
+            .symbolize_keys
+            .slice(:title, :body, :clicks, :created_at)
+            .merge(suggest_title: title)
+        end
+      end
+
       context "ActiveRecord basic integration" do
         setup do
           ActiveRecord::Schema.define(:version => 1) do
             create_table :articles do |t|
               t.string   :title
               t.string   :body
+              t.integer  :clicks, :default => 0
               t.datetime :created_at, :default => 'NOW()'
             end
           end
 
-          class ::Article < ActiveRecord::Base
-            include Elasticsearch::Model
-            include Elasticsearch::Model::Callbacks
-
-            settings index: { number_of_shards: 1, number_of_replicas: 0 } do
-              mapping do
-                indexes :title,         type: 'string', analyzer: 'snowball'
-                indexes :body,          type: 'string'
-                indexes :created_at,    type: 'date'
-              end
-            end
-
-            def as_indexed_json(options = {})
-              attributes
-                .symbolize_keys
-                .slice(:title, :body, :created_at)
-                .merge(suggest_title: title)
-            end
-          end
-
           Article.delete_all
           Article.__elasticsearch__.create_index! force: true
 
-          ::Article.create! title: 'Test',           body: ''
-          ::Article.create! title: 'Testing Coding', body: ''
-          ::Article.create! title: 'Coding',         body: ''
+          ::Article.create! title: 'Test',           body: '', clicks: 1
+          ::Article.create! title: 'Testing Coding', body: '', clicks: 2
+          ::Article.create! title: 'Coding',         body: '', clicks: 3
 
           Article.__elasticsearch__.refresh_index!
         end
@@ -98,7 +106,10 @@ module Elasticsearch
         end
 
         should "preserve the search results order for records" do
-          response = Article.search('title:code')
+          response = Article.search query: { match: { title: 'code' }}, sort: { clicks: :desc }
+
+          assert_equal response.records[0].clicks, 3
+          assert_equal response.records[1].clicks, 2
 
           response.records.each_with_hit do |r, h|
             assert_equal h._id, r.id.to_s
@@ -217,11 +228,17 @@ module Elasticsearch
 
         should "allow dot access to response" do
           response = Article.search query: { match: { title: { query: 'test' } } },
-                                    aggregations: { dates: { date_histogram: { field: 'created_at', interval: 'hour' } } },
+                                    aggregations: {
+                                      dates: { date_histogram: { field: 'created_at', interval: 'hour' } },
+                                      clicks: { global: {}, aggregations: { min: { min: { field: 'clicks' } } } }
+                                    },
                                     suggest: { text: 'tezt', title: { term: { field: 'title', suggest_mode: 'always' } } }
 
           response.response.respond_to?(:aggregations)
-          assert_equal 2, response.aggregations.dates.buckets.first.doc_count
+          assert_equal 2,   response.aggregations.dates.buckets.first.doc_count
+          assert_equal 3,   response.aggregations.clicks.doc_count
+          assert_equal 1.0, response.aggregations.clicks.min.value
+          assert_nil        response.aggregations.clicks.max
 
           response.response.respond_to?(:suggest)
           assert_equal 1, response.suggestions.title.first.options.size

data/test/integration/active_record_custom_serialization_test.rb

@@ -1,6 +1,11 @@
 require 'test_helper'
 require 'active_record'
 
+# Needed for ActiveRecord 3.x ?
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
+
+::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+
 module Elasticsearch
   module Model
     class ActiveRecordCustomSerializationTest < Elasticsearch::Test::IntegrationTestCase

data/test/integration/active_record_import_test.rb

@@ -1,9 +1,28 @@
 require 'test_helper'
 require 'active_record'
 
+# Needed for ActiveRecord 3.x ?
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
+
+::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+
 module Elasticsearch
   module Model
     class ActiveRecordImportIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::ImportArticle < ActiveRecord::Base
+        include Elasticsearch::Model
+
+        scope :popular, -> { where('views >= 50') }
+
+        mapping do
+          indexes :title,      type: 'string'
+          indexes :views,      type: 'integer'
+          indexes :numeric,    type: 'integer'
+          indexes :created_at, type: 'date'
+        end
+      end
+
       context "ActiveRecord importing" do
         setup do
           ActiveRecord::Schema.define(:version => 1) do
@@ -15,19 +34,6 @@ module Elasticsearch
             end
           end
 
-          class ::ImportArticle < ActiveRecord::Base
-            include Elasticsearch::Model
-
-            scope :popular, -> { where('views >= 50') }
-
-            mapping do
-              indexes :title,      type: 'string'
-              indexes :views,      type: 'integer'
-              indexes :numeric,    type: 'integer'
-              indexes :created_at, type: 'date'
-            end
-          end
-
           ImportArticle.delete_all
           ImportArticle.__elasticsearch__.create_index! force: true
           ImportArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'

data/test/integration/active_record_namespaced_model_test.rb

@@ -1,6 +1,11 @@
 require 'test_helper'
 require 'active_record'
 
+# Needed for ActiveRecord 3.x ?
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" ) unless ActiveRecord::Base.connected?
+
+::ActiveRecord::Base.raise_in_transactional_callbacks = true if ::ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ::ActiveRecord::VERSION::MAJOR.to_s < '5'
+
 module Elasticsearch
   module Model
     class ActiveRecordNamespacedModelIntegrationTest < Elasticsearch::Test::IntegrationTestCase