chewy 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f677d05031da075087c0fb9942f31741766ce341
-  data.tar.gz: 5759eead057c0e533a988ce96e5dd1c77ab9ccd2
+  metadata.gz: b9ce5f8bf5d9ad285ee36e1196ebd0516e7ded43
+  data.tar.gz: 9f4bc4e97c744d020cd33529a6aeb9d8ee8a4e7a
 SHA512:
-  metadata.gz: 76d493cea3e5fd380fc455e53fe886a16e48a1d1050f619668617f719d7721dd3cd93ae1b815bec5785142a5bf7f3d327e3dbc2e4db3a8a8cee521ed61ee93fc
-  data.tar.gz: 3091372369882b60d33b5b2ca8928a81ff1b9e7f5c7d8ff38fb0518bbb4a8d4e431746594e78d34a193c58c4aebff0bc245bc6be2ee27f046ca863e2988027a8
+  metadata.gz: 647b9df1cc80287dc95525ac8f55a94130eb1f94e91c5d1d72c370d47047a2055d9c751be3277fe93791fdbd36f083aa4af873a31a88a758c702c603806b4dbc
+  data.tar.gz: eddd0288baab2431ee08cb61d47e2a2bdbfc7453d4b3891f4b12d8af7c897f63415e01c56fedbc9fbb7f5eeceb48a7f79799b73cca797c6f8d876be6cee5ee2d

data/.travis.yml

@@ -2,13 +2,13 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1.1
   # - rbx
 gemfile:
   - Gemfile
   - gemfiles/Gemfile.rails-3.2
   - gemfiles/Gemfile.rails-4.0
 before_install:
-  - curl -# https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.0.1.tar.gz | tar xz -C /tmp
+  - curl -# https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.2.1.tar.gz | tar xz -C /tmp
 before_script:
-  - TEST_CLUSTER_COMMAND="/tmp/elasticsearch-1.0.1/bin/elasticsearch" rake elasticsearch:start
+  - TEST_CLUSTER_COMMAND="/tmp/elasticsearch-1.2.1/bin/elasticsearch" rake elasticsearch:start

data/CHANGELOG.md

@@ -1,9 +1,51 @@
 # master
 
-# Version 0.4.1
+# Version 0.5.0
+
+## Incompatible changes:
+
+  * 404 exception (IndexMissingException) while query is swallowed and treated like an empty result set.
+
+  * `load` and `preload` for queries became lazy. Might be partially incompatible.
+
+  * Changed mapping behavior: multi-fields are defined in conformity with ElasticSearch documentation (http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/_multi_fields.html#_multi_fields)
+
+## Changes:
+
+  * `suggest` query options support (@rschellhorn).
+
+  * Added hash data support. How it is possible to pass hashes to import.
+
+  * `rake chewy:reset` and `rake chewy:update` paramless acts as `rake chewy:reset:all` and `rake chewy:update:all` respectively
+
+  * Added `delete_from_index?` API method for custom deleted objects marking.
+
+  * Added `post_filter` API, working the same way as filters.
+
+  * Added chainable `strategy` query method.
+
+  * Aliasing is performed in index create request for ElasticSearch >= 1.1.
+
+  * `preload` scope method loads ORM/ODM objects in background.
+
+  * `load` method `:only` and `:except` options to specify load types.
+
+  * `highlight` and `rescore` query options support.
 
   * config/chewy.yml ERB support.
 
+## Bugfixes:
+
+  * Fixed `missing` and `exists` filters DSL constructors.
+
+  * Reworked index data composing.
+
+  * Support for Kaminari new PaginatableArray behavior (@leemhenson)
+
+  * Correct waiting for status. After index creation, bulk import, and deletion.
+
+  * Fix #23 "wrong constant name" with namespace models
+
 # Version 0.4.0
 
   * Changed `update_index` matcher behavior. Now it compare array attributes position-independantly.

data/Gemfile

@@ -3,7 +3,10 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in chewy.gemspec
 gemspec
 
+gem 'kaminari', require: false
+
 group :test do
+
   gem 'guard'
   gem 'guard-rspec'
   gem 'rb-inotify', require: false

data/README.md

@@ -9,11 +9,11 @@ Chewy is ODM and wrapper for official elasticsearch client (https://github.com/e
 
 * Multi-model indexes.
 
-  Index classes are independant from ORM/ODM models. Now implementing, e.g. cross-model autocomplete is much easier. You can just define index and work with it in object-oriented style. You can define several types for index - one per indexed model.
+  Index classes are independent from ORM/ODM models. Now implementing, e.g. cross-model autocomplete is much easier. You can just define index and work with it in object-oriented style. You can define several types for index - one per indexed model.
 
 * Every index is observable by all the related models.
 
-  Most of the indexed models a related to other and somtimes it is nessesary to denormalize this related data and put at the same object. Like you need to index array of tags with article together. Chewy allows you to specify updatable index for every model separately. So, corresponding articles will be reindexed on the any tag update.
+  Most of the indexed models are related to other and sometimes it is nessesary to denormalize this related data and put at the same object. For example, you need to index array of tags with article together. Chewy allows you to specify updatable index for every model separately. So, corresponding articles will be reindexed on any tag update.
 
 * Bulk import everywhere.
 
@@ -61,7 +61,7 @@ development:
 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:
 
 ```ruby
-  Chewy.configuration = {prefix: 'testing'}
+  Chewy.configuration = {prefix: 'test'}
   UsersIndex.index_name # => 'test_users'
 ```
 
@@ -102,7 +102,7 @@ See [config.rb](lib/chewy/config.rb) for more details.
       field :email, analyzer: 'email' # elasticsearch-related options
       field :country, value: ->(user) { user.country.name } # custom value proc
       field :badges, value: ->(user) { user.badges.map(&:name) } # passing array values to index
-      field :projects, type: 'object' do # the same syntax for `multi_field`
+      field :projects do # the same block syntax for multi_field, if `:type` is specified
         field :title
         field :description # default data type is `string`
       end
@@ -130,17 +130,17 @@ See [config.rb](lib/chewy/config.rb) for more details.
 
     define_type User.active.includes(:country, :badges, :projects) do
       root date_detection: false do
-        template 'about_translations.*', type: 'string', analyzer: 'stantard'
+        template 'about_translations.*', type: 'string', analyzer: 'standard'
 
         field :first_name, :last_name
         field :email, analyzer: 'email'
         field :country, value: ->(user) { user.country.name }
         field :badges, value: ->(user) { user.badges.map(&:name) }
-        field :projects, type: 'object' do
+        field :projects do
           field :title
           field :description
         end
-        field :about_translations, type: 'object'
+        field :about_translations, type: 'object' # pass object type explicitely if necessary
         field :rating, type: 'integer'
         field :created, type: 'date', include_in_all: false,
           value: ->{ created_at }
@@ -172,7 +172,7 @@ See [config.rb](lib/chewy/config.rb) for more details.
     update_index('users#user') { user if user.active? } # you can return even `nil` from the backreference
   end
 
-  class Bage < ActiveRecord::Base
+  class Badge < ActiveRecord::Base
     has_and_belongs_to_many :users
 
     update_index('users') { users } # if index has only one type
@@ -223,7 +223,7 @@ UsersIndex.import user: User.where('rating > 100') # import only active users to
 UsersIndex.reset! # purges index and imports default data for all types
 ```
 
-Also if passed user is #destroyed? or specified id is not existing in the database, import will perform `delete` index for this it
+Also if passed user is `#destroyed?` or `#delete_from_index?` or specified id does not exists in the database, import will perform delete from index action for this object.
 
 See [actions.rb](lib/chewy/index/actions.rb) for more details.
 
@@ -296,7 +296,7 @@ Also, queries can be performed on a type individually
 UsersIndex::User.filter(term: {name: 'foo'}) # will return UserIndex::User collection only
 ```
 
-If you are performing more then one `filter` or `query` in the chain,
+If you are performing more than one `filter` or `query` in the chain,
 all the filters and queries will be concatenated in the way specified by
 `filter_mode` and `query_mode` respectively.
 
@@ -598,6 +598,24 @@ Compliance cheatsheet for filters and DSL expressions:
 
 See [filters.rb](lib/chewy/query/filters.rb) for more details.
 
+### Faceting
+
+Facets are an optional sidechannel you can request from elasticsearch describing certain fields of the resulting collection. The most common use for facets is to allow the user continue filtering specifically within the subset, as opposed to the global index.
+
+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'}}}) 
+```
+
+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:
+
+```
+< { ... ,"facets":{"countries":{"_type":"terms","missing":?,"total":?,"other":?,"terms":[{"term":"USA","count":?},{"term":"Brazil","count":?}, ...}}
+```
+
 ### Objects loading
 
 It is possible to load source objects from database for every search result:
@@ -605,7 +623,8 @@ It is possible to load source objects from database for every search result:
 ```ruby
 scope = UsersIndex.filter(range: {rating: {gte: 100}})
 
-scope.load # => will return User instances array (not a scope because )
+scope.load # => scope is marked to return User instances array
+scope.load.query(...) # => since objects are loaded lazily you can complete scope
 scope.load(user: { scope: ->{ includes(:country) }}) # you can also pass loading scopes for each
                                                      # possibly returned type
 scope.load(user: { scope: User.includes(:country) }) # the second scope passing way.
@@ -614,6 +633,14 @@ scope.load(scope: ->{ includes(:country) }) # and more common scope applied to e
 scope.only(:id).load # it is optimal to request ids only if you are not planning to use type objects
 ```
 
+The `preload` method takes the same options as `load` and ORM/ODM objects will be loaded, but scope will still return array of Chewy wrappers. To access real objects use `_object` wrapper method:
+
+```ruby
+UsersIndex.filter(range: {rating: {gte: 100}}).preload(...).query(...).map(&:_object)
+```
+
+See [loading.rb](lib/chewy/query/loading.rb) for more details.
+
 ### `ActiveSupport::Notifications` support
 
 Chewy has notifing the following events:
@@ -679,7 +706,11 @@ Inside Rails application some index mantaining rake tasks are defined.
 
 ```bash
 rake chewy:reset:all # resets all the existing indexes, declared in app/chewy
+rake chewy:reset # alias for chewy:reset:all
 rake chewy:reset[users] # resets UsersIndex
+
+rake chewy:update:all # updates all the existing indexes, declared in app/chewy
+rake chewy:update # alias for chewy:update:all
 rake chewy:update[users] # updates UsersIndex
 ```
 
@@ -704,3 +735,10 @@ See [update_index.rb](lib/chewy/rspec/update_index.rb) for more details.
 4. Commit your changes (`git commit -am 'Add some feature'`)
 5. Push to the branch (`git push origin my-new-feature`)
 6. Create new Pull Request
+
+Use the following Rake tasks to control ElasticSearch cluster while developing.
+
+```bash
+rake elasticsearch:start # start Elasticsearch cluster on 9250 port for tests
+rake elasticsearch:stop # stop Elasticsearch
+```

data/chewy.gemspec

@@ -19,9 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'rspec', '~> 2.14.0'
   spec.add_development_dependency 'sqlite3'
-  spec.add_development_dependency 'kaminari'
   spec.add_development_dependency 'activerecord', '>= 3.2'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'elasticsearch-extensions'

data/gemfiles/Gemfile.rails-3.2

@@ -4,6 +4,7 @@ gemspec path: '../'
 
 gem 'activerecord', '~> 3.2.0'
 gem 'activesupport', '~> 3.2.0'
+gem 'kaminari', require: false
 
 group :test do
   gem 'guard'

data/gemfiles/Gemfile.rails-4.0

@@ -4,6 +4,7 @@ gemspec path: '../'
 
 gem 'activerecord', '~> 4.0.0'
 gem 'activesupport', '~> 4.0.0'
+gem 'kaminari', require: false
 
 group :test do
   gem 'guard'

data/lib/chewy.rb

@@ -1,19 +1,25 @@
-require 'active_support/concern'
+require 'active_support'
 require 'active_support/core_ext'
+require 'active_support/concern'
 require 'active_support/json'
 require 'i18n/core_ext/hash'
+require 'chewy/backports/deep_dup' unless Object.respond_to?(:deep_dup)
 require 'singleton'
 
+begin
+  require 'kaminari'
+rescue LoadError
+end
 require 'elasticsearch'
 
 require 'chewy/version'
 require 'chewy/errors'
 require 'chewy/config'
+require 'chewy/runtime'
 require 'chewy/index'
 require 'chewy/type'
 require 'chewy/query'
 require 'chewy/fields/base'
-require 'chewy/fields/default'
 require 'chewy/fields/root'
 
 require 'chewy/railtie' if defined?(::Rails)

data/lib/chewy/backports/deep_dup.rb

@@ -0,0 +1,46 @@
+require 'chewy/backports/duplicable'
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def deep_dup
+    map { |it| it.deep_dup }
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def deep_dup
+    each_with_object(dup) do |(key, value), hash|
+      hash[key.deep_dup] = value.deep_dup
+    end
+  end
+end

data/lib/chewy/backports/duplicable.rb

@@ -0,0 +1,90 @@
+#--
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for +nil+, +false+, +true+, symbol, and number objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  def duplicable?
+    false
+  end
+end
+
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  def duplicable?
+    false
+  end
+end
+
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  def duplicable?
+    false
+  end
+end
+
+require 'bigdecimal'
+class BigDecimal
+  begin
+    BigDecimal.new('4.56').dup
+
+    def duplicable?
+      true
+    end
+  rescue TypeError
+    # can't dup, so use superclass implementation
+  end
+end

data/lib/chewy/config.rb

@@ -3,7 +3,34 @@ module Chewy
     include Singleton
 
     attr_reader :analyzers, :tokenizers, :filters, :char_filters
-    attr_accessor :configuration, :urgent_update, :query_mode, :filter_mode, :logger
+    attr_accessor :configuration,
+      # Just sets up logger to current configuration
+      #
+      #   Chewy.logger = Rails.logger
+      #
+      :logger,
+
+      # Urgent update default value. False by default. Urgent
+      # updates are useful for testing, so don't use it in the
+      # application code. Prefer `Chewy.atomic` block for cumulative
+      # index updates.
+      #
+      :urgent_update,
+
+      # Default query compilation mode. `:must` by default.
+      # See Chewy::Query#query_mode for details
+      #
+      :query_mode,
+
+      # Default filters compilation mode. `:and` by default.
+      # See Chewy::Query#filter_mode for details
+      #
+      :filter_mode,
+
+      # Default post_filters compilation mode. `nil` by default.
+      # See Chewy::Query#post_filter_mode for details
+      #
+      :post_filter_mode
 
     def self.delegated
       public_instance_methods - self.superclass.public_instance_methods - Singleton.public_instance_methods
@@ -20,8 +47,8 @@ module Chewy
     end
 
     def initialize
-      @urgent_update = false
       @configuration = {}
+      @urgent_update = false
       @query_mode = :must
       @filter_mode = :and
       @analyzers = {}
@@ -101,10 +128,10 @@ module Chewy
     #      creation.
     #
     #        test: &test
-    #        host: 'localhost:9250'
-    #        index:
-    #          number_of_shards: 1
-    #          number_of_replicas: 0
+    #          host: 'localhost:9250'
+    #          index:
+    #            number_of_shards: 1
+    #            number_of_replicas: 0
     #
     def configuration
       options = @configuration.deep_symbolize_keys.merge(yaml_options)