chewy 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b9ce5f8bf5d9ad285ee36e1196ebd0516e7ded43
-  data.tar.gz: 9f4bc4e97c744d020cd33529a6aeb9d8ee8a4e7a
+  metadata.gz: 600f8bb51476db3d8d55a156cd6c8d5a955f02b0
+  data.tar.gz: bad3af9a8e5038c08518b9cfa87dcacb12b6085a
 SHA512:
-  metadata.gz: 647b9df1cc80287dc95525ac8f55a94130eb1f94e91c5d1d72c370d47047a2055d9c751be3277fe93791fdbd36f083aa4af873a31a88a758c702c603806b4dbc
-  data.tar.gz: eddd0288baab2431ee08cb61d47e2a2bdbfc7453d4b3891f4b12d8af7c897f63415e01c56fedbc9fbb7f5eeceb48a7f79799b73cca797c6f8d876be6cee5ee2d
+  metadata.gz: faba93331adeff1f6cbbedff24e0d47beb76f217399954c38e68d5a944e35fc5c1a7d9f494d731c10f0d5ca59687c7d093c360cc44131e5daa96eff2b434eec1
+  data.tar.gz: 33c3bc5b12a6d9e5410ad826120ad982e82c7369cc68d9c87c883faa4a69eb74f0ea91a26cde400769fd9a3e786026a674e088dc244f7c9bdedee8c13aabe36d

data/.travis.yml

@@ -9,6 +9,6 @@ gemfile:
   - gemfiles/Gemfile.rails-3.2
   - gemfiles/Gemfile.rails-4.0
 before_install:
-  - curl -# https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.2.1.tar.gz | tar xz -C /tmp
+  - curl -# https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.3.0.tar.gz | tar xz -C /tmp
 before_script:
-  - TEST_CLUSTER_COMMAND="/tmp/elasticsearch-1.2.1/bin/elasticsearch" rake elasticsearch:start
+  - TEST_CLUSTER_COMMAND="/tmp/elasticsearch-1.3.0/bin/elasticsearch" rake elasticsearch:start

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # master
 
+# Version 0.5.1
+
+## Changes:
+
+  * `chewy.yml` Rails generator (@jirikolarik)
+
+  * Parent-child mappings feature support (@inbeom)
+
+  * `Chewy::Index.total_count` and `Chewy::Type::Base.total_count`
+
+  * `Chewy::Type::Base.reset` method. Deletes all the type documents and performs import (@jondavidford)
+
+  * Added `Chewy::Query#delete_all` scope method using delete by query ES feature (@jondavidford)
+
+  * Rspec 3 `update_index` matcher support (@jimmybaker)
+
+  * Implemented function scoring (@averell23)
+
+## Bugfixes:
+
+  * Indexed eager-loading fix (@leemhenson)
+
+  * Field type deriving nested type support fix (@rschellhorn)
+
 # Version 0.5.0
 
 ## Incompatible changes:

data/Guardfile

@@ -1,7 +1,7 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard :rspec do
+guard :rspec, cmd: 'rspec' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
@@ -21,4 +21,3 @@ guard :rspec do
   watch(%r{^spec/acceptance/(.+)\.feature$})
   watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
 end
-

data/README.md

@@ -43,6 +43,8 @@ Or install it yourself as:
 
 There are 2 ways to configure Chewy client: `Chewy.configuration` hash and `chewy.yml`
 
+You can create this file manually or run `rails g chewy:install` to do that with yaml way
+
 ```ruby
 # config/initializers/chewy.rb
 Chewy.configuration = {host: 'localhost:9250'} # do not use environments
@@ -55,7 +57,7 @@ test:
   host: 'localhost:9250'
   prefix: 'test'
 development:
-  host: 'localhost:9250'
+  host: 'localhost:9200'
 ```
 
 The result config merges both hashes. Client options are passed as is to Elasticsearch::Transport::Client except the `:prefix` - it is used internally by chewy to create prefixed index names:
@@ -265,7 +267,13 @@ This strategy is highly usable for rails actions:
 
 ```ruby
 class ApplicationController < ActionController::Base
-  around_action { |&block| Chewy.atomic(&block) }
+  around_action :chewy_atomic
+
+  def chewy_atomic
+    Chewy.atomic do
+      yield
+    end
+  end
 end
 ```
 
@@ -317,6 +325,17 @@ UsersIndex::User.filter{ name == 'Fred' }.filter{ age < 42 }.filter_mode('75%')
 
 See [query.rb](lib/chewy/query.rb) for more details.
 
+### Additional query action.
+
+You may also perform additional actions on query scope, such as deleting of all the scope documents:
+
+```ruby
+UsersIndex.delete_all
+UsersIndex::User.delete_all
+UsersIndex.filter{ age < 42 }.delete_all
+UsersIndex::User.filter{ age < 42 }.delete_all
+```
+
 ### Filters query DSL.
 
 There is a test version of filters creating DSL:
@@ -605,10 +624,10 @@ Facets are an optional sidechannel you can request from elasticsearch describing
 For instance, let's request the ```country``` field as a facet along with our users collection. We can do this with the #facets method like so:
 
 ```ruby
-UsersIndex.filter{ [...] }.facets({countries: {terms: {field: 'country'}}}) 
+UsersIndex.filter{ [...] }.facets({countries: {terms: {field: 'country'}}})
 ```
 
-Let's look at what we asked from elasticsearch. The facets setter method accepts a hash. You can choose custom/semantic key names for this hash for your own convinience (in this case I used the plural version of the actual field), in our case: ```countries```. The following nested hash tells ES to grab and aggregate values (terms) from the ```country``` field on our indexed records. 
+Let's look at what we asked from elasticsearch. The facets setter method accepts a hash. You can choose custom/semantic key names for this hash for your own convinience (in this case I used the plural version of the actual field), in our case: ```countries```. The following nested hash tells ES to grab and aggregate values (terms) from the ```country``` field on our indexed records.
 
 When the response comes back, it will have the ```:facets``` sidechannel included:
 

data/chewy.gemspec

@@ -19,7 +19,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 2.14.0'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
+  spec.add_development_dependency 'rspec-its', '~> 1.0.1'
+  spec.add_development_dependency 'rspec-collection_matchers'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'activerecord', '>= 3.2'
   spec.add_development_dependency 'database_cleaner'

data/lib/chewy.rb

@@ -1,4 +1,5 @@
 require 'active_support'
+require 'active_support/deprecation'
 require 'active_support/core_ext'
 require 'active_support/concern'
 require 'active_support/json'

data/lib/chewy/fields/base.rb

@@ -13,7 +13,7 @@ module Chewy
       end
 
       def object_field?
-        (nested.any? && options[:type].blank?) || options[:type].to_s == 'object'
+        (nested.any? && options[:type].blank?) || ['object', 'nested'].include?(options[:type].to_s)
       end
 
       def root_field?

data/lib/chewy/fields/root.rb

@@ -2,8 +2,12 @@ module Chewy
   module Fields
     class Root < Chewy::Fields::Base
       attr_reader :dynamic_templates
+      attr_reader :parent
+      attr_reader :parent_id
 
       def initialize(name, options = {})
+        @parent = options.delete(:parent) || options.delete(:_parent)
+        @parent_id = options.delete(:parent_id)
         options.reverse_merge!(value: ->(_){_})
         super(name, options)
         options.delete(:type)
@@ -24,10 +28,13 @@ module Chewy
 
       def mappings_hash
         mappings = super
+
         if dynamic_templates.any?
           mappings[name][:dynamic_templates] ||= []
           mappings[name][:dynamic_templates].concat dynamic_templates
         end
+
+        mappings[name][:_parent] = parent.is_a?(Hash) ? parent : { type: parent } if parent
         mappings
       end
 
@@ -51,6 +58,12 @@ module Chewy
           @dynamic_templates.push(options)
         end
       end
+
+      def compose_parent(object)
+        if parent_id
+          parent_id.arity == 0 ? object.instance_exec(&parent_id) : parent_id.call(object)
+        end
+      end
     end
   end
 end

data/lib/chewy/index/search.rb

@@ -6,7 +6,7 @@ module Chewy
       included do
         singleton_class.delegate :explain, :limit, :offset, :highlight, :rescore,
           :facets, :aggregations, :none, :strategy, :query, :filter, :post_filter,
-          :order, :reorder, :only, :types, :suggest, to: :all
+          :order, :reorder, :only, :types, :suggest, :delete_all, :total_count, to: :all
       end
 
       module ClassMethods

data/lib/chewy/query.rb

@@ -286,6 +286,149 @@ module Chewy
       end
     end
 
+    # Adds a script function to score the search request. All scores are
+    # added to the search request and combinded according to
+    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    #
+    #   UsersIndex.script_score("doc['boost'].value", filter: { foo: :bar})
+    #       # => {body:
+    #              query: {
+    #                function_score: {
+    #                  query: { ...},
+    #                  functions: [{
+    #                    script_score: {
+    #                       script: "doc['boost'].value"
+    #                     },
+    #                     filter: { foo: :bar }
+    #                    }
+    #                  }]
+    #                } } }
+    def script_score(script, options = {})
+      scoring = options.merge(script_score: { script: script })
+      chain { criteria.update_scores scoring }
+    end
+
+    # Adds a boost factor to the search request. All scores are
+    # added to the search request and combinded according to
+    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    #
+    # This probably only makes sense if you specifiy a filter
+    # for the boost factor as well
+    #
+    #   UsersIndex.boost_factor(23, filter: { foo: :bar})
+    #       # => {body:
+    #              query: {
+    #                function_score: {
+    #                  query: { ...},
+    #                  functions: [{
+    #                    boost_factor: 23,
+    #                    filter: { foo: :bar }
+    #                  }]
+    #                } } }
+    def boost_factor(factor, options = {})
+      scoring = options.merge(boost_factor: factor.to_i)
+      chain { criteria.update_scores scoring }
+    end
+
+    # Adds a random score to the search request. All scores are
+    # added to the search request and combinded according to
+    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    #
+    # This probably only makes sense if you specifiy a filter
+    # for the random score as well.
+    #
+    # If you do not pass in a seed value, Time.now will be used
+    #
+    #   UsersIndex.random_score(23, filter: { foo: :bar})
+    #       # => {body:
+    #              query: {
+    #                function_score: {
+    #                  query: { ...},
+    #                  functions: [{
+    #                    random_score: { seed: 23 },
+    #                    filter: { foo: :bar }
+    #                  }]
+    #                } } }
+    def random_score(seed = Time.now, options = {})
+      scoring = options.merge(random_score: { seed: seed.to_i })
+      chain { criteria.update_scores scoring }
+    end
+
+    # Add a field value scoring to the search. All scores are
+    # added to the search request and combinded according to
+    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    #
+    # This function is only available in Elasticsearch 1.2 and
+    # greater
+    #
+    #   UsersIndex.field_value_factor(
+    #                {
+    #                  field: :boost,
+    #                  factor: 1.2,
+    #                  modifier: :sqrt
+    #                }, filter: { foo: :bar})
+    #       # => {body:
+    #              query: {
+    #                function_score: {
+    #                  query: { ...},
+    #                  functions: [{
+    #                    field_value_factor: {
+    #                      field: :boost,
+    #                      factor: 1.2,
+    #                      modifier: :sqrt
+    #                    },
+    #                    filter: { foo: :bar }
+    #                  }]
+    #                } } }
+    def field_value_factor(settings, options = {})
+      scoring = options.merge(field_value_factor: settings)
+      chain { criteria.update_scores scoring }
+    end
+
+    # Add a decay scoring to the search. All scores are
+    # added to the search request and combinded according to
+    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    #
+    # The parameters have default values, but those may not
+    # be very useful for most applications.
+    #
+    #   UsersIndex.decay(
+    #                :gauss,
+    #                :field,
+    #                origin: '11, 12',
+    #                scale: '2km',
+    #                offset: '5km'
+    #                decay: 0.4
+    #                filter: { foo: :bar})
+    #       # => {body:
+    #              query: {
+    #                gauss: {
+    #                  query: { ...},
+    #                  functions: [{
+    #                    gauss: {
+    #                      field: {
+    #                        origin: '11, 12',
+    #                        scale: '2km',
+    #                        offset: '5km',
+    #                        decay: 0.4
+    #                      }
+    #                    },
+    #                    filter: { foo: :bar }
+    #                  }]
+    #                } } }
+    def decay(function, field, options = {})
+      field_options = {
+        origin: options.delete(:origin) || 0,
+        scale: options.delete(:scale) || 1,
+        offset: options.delete(:offset) || 0,
+        decay: options.delete(:decay) || 0.1
+      }
+      scoring = options.merge(function => {
+        field => field_options
+      })
+      chain { criteria.update_scores scoring }
+    end
+
     # Sets elasticsearch <tt>aggregations</tt> search request param
     #
     #  UsersIndex.filter{ name == 'Johny' }.aggregations(category_id: {terms: {field: 'category_ids'}})
@@ -446,6 +589,83 @@ module Chewy
       chain { criteria.update_post_filters params }
     end
 
+    # Sets the boost mode for custom scoring/boosting.
+    # Not used if no score functions are specified
+    # Possible values:
+    #
+    # * <tt>:multiply</tt>
+    #   Default value. Query score and function result are multiplied.
+    #
+    #   Ex:
+    #
+    #     UsersIndex.boost_mode('multiply').script_score('doc['boost'].value')
+    #       # => {body: {query: function_score: {
+    #         query: {...},
+    #         boost_mode: 'multiply',
+    #         functions: [ ... ]
+    #       }}}
+    #
+    # * <tt>:replace</tt>
+    #   Only function result is used, query score is ignored.
+    #
+    # * <tt>:sum</tt>
+    #   Query score and function score are added.
+    #
+    # * <tt>:avg</tt>
+    #   Average of query and function score.
+    #
+    # * <tt>:max</tt>
+    #   Max of query and function score.
+    #
+    # * <tt>:min</tt>
+    #   Min of query and function score.
+    #
+    # Default value for <tt>:boost_mode</tt> might be changed
+    # with <tt>Chewy.score_mode</tt> config option.
+    def boost_mode value
+      chain { criteria.update_options boost_mode: value }
+    end
+
+    # Sets the scoring mode for combining function scores/boosts
+    # Not used if no score functions are specified.
+    # Possible values:
+    #
+    # * <tt>:multiply</tt>
+    #   Default value. Scores are multiplied.
+    #
+    #   Ex:
+    #
+    #     UsersIndex.score_mode('multiply').script_score('doc['boost'].value')
+    #       # => {body: {query: function_score: {
+    #         query: {...},
+    #         score_mode: 'multiply',
+    #         functions: [ ... ]
+    #       }}}
+    #
+    # * <tt>:sum</tt>
+    #   Scores are summed.
+    #
+    # * <tt>:avg</tt>
+    #   Scores are averaged.
+    #
+    # * <tt>:first</tt>
+    #   The first function that has a matching filter is applied.
+    #
+    # * <tt>:max</tt>
+    #   Maximum score is used.
+    #
+    # * <tt>:min</tt>
+    #   Minimum score is used
+    #
+    # Default value for <tt>:score_mode</tt> might be changed
+    # with <tt>Chewy.score_mode</tt> config option.
+    #
+    #   Chewy.score_mode = :first
+    #
+    def score_mode value
+      chain { criteria.update_options score_mode: value }
+    end
+
     # Sets search request sorting
     #
     #   UsersIndex.order(:first_name, :last_name).order(age: :desc).order(price: {order: :asc, mode: :avg})
@@ -559,6 +779,17 @@ module Chewy
       chain { criteria.merge!(other.criteria) }
     end
 
+    # Deletes all records matching a query.
+    #
+    #   UsersIndex.delete_all
+    #   UsersIndex.filter{ age <= 42 }.delete_all
+    #   UsersIndex::User.delete_all
+    #   UsersIndex::User.filter{ age <= 42 }.delete_all
+    #
+    def delete_all
+      _delete_all_response
+    end
+
   protected
 
     def initialize_clone other
@@ -580,19 +811,27 @@ module Chewy
       @_request ||= criteria.request_body.merge(index: index.index_name, type: types)
     end
 
+    def _delete_all_request
+      @_delete_all_request ||= criteria.delete_all_request_body.merge(index: index.index_name, type: types)
+    end
+
     def _response
-      @_response ||= begin
-        ActiveSupport::Notifications.instrument 'search_query.chewy', request: _request, index: index do
-          begin
-            index.client.search(_request)
-          rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
-            raise e if e.message !~ /IndexMissingException/
-            {}
-          end
+      @_response ||= ActiveSupport::Notifications.instrument 'search_query.chewy', request: _request, index: index do
+        begin
+          index.client.search(_request)
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
+          raise e if e.message !~ /IndexMissingException/
+          {}
         end
       end
     end
 
+    def _delete_all_response
+      @_delete_all_response ||= ActiveSupport::Notifications.instrument 'delete_query.chewy', request: _delete_all_request, index: index do
+        index.client.delete_by_query(_delete_all_request)
+      end
+    end
+
     def _results
       @_results ||= (criteria.none? || _response == {} ? [] : _response['hits']['hits']).map do |hit|
         attributes = (hit['_source'] || {}).merge(hit['highlight'] || {}, &RESULT_MERGER)