chewy 0.8.2 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 465b8f0c2bff702e61235bbd9b6782f3f57296e6
-  data.tar.gz: 60827a551d9b4338ee87a91c346b84cfbcca6aa2
+  metadata.gz: 366a83f019d42b9edab700ebfa189d949f5937fb
+  data.tar.gz: 65c60e5fa14b6f96b9cd13e49ba752ad64b7a271
 SHA512:
-  metadata.gz: e0efb611f827fa291ea9f3765d14e50450e6787f0541e9c04f034d79e20189cdb8dd718e2c8c8074e7736ac3575018e13fe9317f880d7b6d0429ac1ab060e6b2
-  data.tar.gz: 0270d359d7831c3f1c0217369f32d5017c7b90e7871780a5e79f7945414c7a3aaadf39f1505ab85c7a3c61a1f2fbb28ae49c183034f43c12d1ed065cf66e9acf
+  metadata.gz: dbee3534a08ddc5c0a3080d159602c1d1d334657abc321f5ef87fdfdc2729e13a97febd9686193f578b1845b083556893865df05dbd058cfa9874819af46d3b8
+  data.tar.gz: 0257820ba35319dc0b8a1bd9b21f15acec62ca57701abbf35a49f0fc37a5999ee0875fc8dc043d1bc844a44ca0b7f36b636c3408ff2db01d35e78124e229b4e1

data/.travis.yml

@@ -29,7 +29,7 @@ gemfile:
   - gemfiles/rails.4.2.mongoid.gemfile
   - gemfiles/rails.4.2.mongoid.kaminari.gemfile
   - gemfiles/rails.4.2.mongoid.will_paginate.gemfile
-  - gemfiles/sequel.4.23.gemfile
+  - gemfiles/sequel.4.28.gemfile
 matrix:
   exclude:
     - rvm: 2.2

data/Appraisals

@@ -43,7 +43,7 @@ end
   end
 end
 
-appraise "sequel.4.23" do
-  gem 'sequel', "~> 4.23.0"
+appraise "sequel.4.28" do
+  gem 'sequel', "~> 4.28.0"
   gem 'activesupport', '~> 4.2.0'
 end

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # master
 
+## Changes
+
+  * Sequel support completely reworked to use common ORM implementations + better sequel specs covarage.
+
+## Bugfixes
+
+  * Sequel objects transactional destruction fix
+
+  * Correct Rspec mocking framework checking (@mainameiz)
+
+  * Atomic strategy is now compatible with custom ids proc.
+
+  * Safe unsubscribe on import (@marshall-lee)
+
+  * Correct custom assets path silencer (@davekaro)
+
+## Incompatible changes:
+
+  * `Chewy.atomic` and `Chewy.urgent_update=` methods was removed from the codebase, use `Chewy.strategy` block instead.
+
+  * `delete_from_index?` hook is removed from the codebase.
+
 # Version 0.8.2
 
 ## Changes

data/gemfiles/{sequel.4.23.gemfile → sequel.4.28.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "sequel", "~> 4.23.0"
+gem "sequel", "~> 4.28.0"
 gem "activesupport", "~> 4.2.0"
 
 group :test do

data/lib/chewy.rb

@@ -179,20 +179,6 @@ module Chewy
       end
     end
 
-    def urgent_update= value
-      ActiveSupport::Deprecation.warn('`Chewy.urgent_update = value` is deprecated and will be removed soon, use `Chewy.strategy(:urgent)` block instead')
-      if value
-        strategy(:urgent)
-      else
-        strategy.pop
-      end
-    end
-
-    def atomic &block
-      ActiveSupport::Deprecation.warn('`Chewy.atomic` block is deprecated and will be removed soon, use `Chewy.strategy(:atomic)` block instead')
-      strategy(:atomic, &block)
-    end
-
     def config
       Chewy::Config.instance
     end

data/lib/chewy/railtie.rb

@@ -10,7 +10,7 @@ module Chewy
       end
 
       def call(env)
-        if env['PATH_INFO'].start_with?('/assets/')
+        if env['PATH_INFO'].start_with?(Rails.application.config.assets.prefix)
           @app.call(env)
         else
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }

data/lib/chewy/rspec/update_index.rb

@@ -194,7 +194,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
   end
 
   def agnostic_stub
-    if defined? Mocha
+    if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
       "type.stubs(:bulk).with"
     else
       "allow(type).to receive(:bulk)"

data/lib/chewy/strategy/atomic.rb

@@ -20,7 +20,7 @@ module Chewy
         ActiveSupport::Deprecation.warn("`urgent: true` option is deprecated and is not effective inside `:atomic` strategy, use `Chewy.strategy(:urgent)` strategy instead") if options.key?(:urgent)
 
         @stash[type] ||= []
-        @stash[type] |= type.adapter.identify(objects)
+        @stash[type] |= type.send(:build_root).id ? Array.wrap(objects) : type.adapter.identify(objects)
       end
 
       def leave

data/lib/chewy/type/adapter/active_record.rb

@@ -37,6 +37,10 @@ module Chewy
           result
         end
 
+        def target_id
+          target.arel_table[target.primary_key]
+        end
+
         def pluck_ids(scope)
           scope.except(:includes).uniq.pluck(target.primary_key.to_sym)
         end
@@ -45,14 +49,6 @@ module Chewy
           scope.where(target_id.in(Array.wrap(ids)))
         end
 
-        def all_scope
-          target.where(nil)
-        end
-
-        def target_id
-          target.arel_table[target.primary_key]
-        end
-
         def relation_class
           ::ActiveRecord::Relation
         end

data/lib/chewy/type/adapter/base.rb

@@ -60,17 +60,12 @@ module Chewy
       private
 
         def grouped_objects(objects)
-          objects.group_by do |object|
+          objects.to_a.group_by do |object|
             delete_from_index?(object) ? :delete : :index
           end
         end
 
         def delete_from_index?(object)
-          if object.respond_to?(:delete_from_index?)
-            ActiveSupport::Deprecation.warn('`delete_from_index?` method in models is deprecated and will be removed soon. Use per-type `delete_if` option for `define_type`')
-            delete = object.delete_from_index?
-          end
-
           delete_if = options[:delete_if]
           delete ||= case delete_if
           when Symbol, String

data/lib/chewy/type/adapter/mongoid.rb

@@ -22,9 +22,9 @@ module Chewy
             Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified')
           end
 
-          @default_scope = @default_scope.reorder(nil)
           @default_scope.options.delete(:limit)
           @default_scope.options.delete(:skip)
+          @default_scope = @default_scope.reorder(nil)
         end
 
         def import_scope(scope, batch_size)

data/lib/chewy/type/adapter/orm.rb

@@ -10,7 +10,7 @@ module Chewy
           @options = args.extract_options!
           class_or_relation = args.first
           if class_or_relation.is_a?(relation_class)
-            @target = class_or_relation.klass
+            @target = model_of_relation(class_or_relation)
             @default_scope = class_or_relation
           else
             @target = class_or_relation
@@ -20,7 +20,7 @@ module Chewy
         end
 
         def name
-          @name ||= (options[:name].present? ? options[:name].to_s.camelize : target.model_name.to_s).demodulize
+          @name ||= (options[:name].presence || target.name).to_s.camelize.demodulize
         end
 
         def identify collection
@@ -28,7 +28,7 @@ module Chewy
             pluck_ids(collection)
           else
             Array.wrap(collection).map do |entity|
-              entity.is_a?(object_class) ? entity.id : entity
+              entity.is_a?(object_class) ? entity.public_send(primary_key) : entity
             end
           end
         end
@@ -93,23 +93,23 @@ module Chewy
 
           additional_scope = load_options[load_options[:_type].type_name.to_sym].try(:[], :scope) || load_options[:scope]
 
-          scope = all_scope_where_ids_in(objects.map(&:id))
+          scope = all_scope_where_ids_in(objects.map(&primary_key))
           loaded_objects = if additional_scope.is_a?(Proc)
             scope.instance_exec(&additional_scope)
-          elsif additional_scope.is_a?(relation_class)
+          elsif additional_scope.is_a?(relation_class) && scope.respond_to?(:merge)
             scope.merge(additional_scope)
           else
             scope
-          end.index_by { |object| object.id.to_s }
+          end.index_by { |object| object.public_send(primary_key).to_s }
 
-          objects.map { |object| loaded_objects[object.id.to_s] }
+          objects.map { |object| loaded_objects[object.public_send(primary_key).to_s] }
         end
 
       private
 
         def import_objects(collection, batch_size)
           hash = collection.index_by do |entity|
-            entity.is_a?(object_class) ? entity.id : entity
+            entity.is_a?(object_class) ? entity.public_send(primary_key) : entity
           end
 
           indexed = hash.keys.each_slice(batch_size).map do |ids|
@@ -117,7 +117,7 @@ module Chewy
             if batch.empty?
               true
             else
-              batch.each { |object| hash.delete(object.id) }
+              batch.each { |object| hash.delete(object.public_send(primary_key)) }
               yield grouped_objects(batch)
             end
           end.all?
@@ -129,6 +129,10 @@ module Chewy
           indexed && deleted
         end
 
+        def primary_key
+          :id
+        end
+
         def default_scope_where_ids_in(ids)
           scope_where_ids_in(default_scope, ids)
         end
@@ -136,6 +140,14 @@ module Chewy
         def all_scope_where_ids_in(ids)
           scope_where_ids_in(all_scope, ids)
         end
+
+        def all_scope
+          target.where(nil)
+        end
+
+        def model_of_relation relation
+          relation.klass
+        end
       end
     end
   end

data/lib/chewy/type/adapter/sequel.rb

@@ -3,121 +3,73 @@ require 'chewy/type/adapter/base'
 module Chewy
   class Type
     module Adapter
-      class Sequel < Base
-
-        attr_reader :default_dataset
+      class Sequel < Orm
+        attr_reader :default_scope
+        alias_method :default_dataset, :default_scope
 
         def self.accepts?(target)
           defined?(::Sequel::Model) && (
-            target.is_a?(Class) && target < ::Sequel::Model || target.is_a?(::Sequel::Dataset))
+            target.is_a?(Class) && target < ::Sequel::Model ||
+            target.is_a?(::Sequel::Dataset))
         end
 
-        def initialize(*args)
-          @options = args.extract_options!
-
-          if dataset? args.first
-            dataset = args.first
-            @target = dataset.model
-            @default_dataset = dataset.unordered.unlimited
+        def identify collection
+          if collection.is_a?(relation_class)
+            pluck_ids(collection)
           else
-            model = args.first
-            @target = model
-            @default_dataset = model.where(nil)
-          end
-        end
-
-        def name
-          @name ||= (options[:name].presence || target.name).camelize.demodulize
-        end
-
-        def identify(obj)
-          if dataset? obj
-            obj.select_map(target_pk)
-          else
-            Array.wrap(obj).map do |item|
-              model?(item) ? item.pk : item
+            Array.wrap(collection).map do |entity|
+              entity.is_a?(object_class) ? entity.public_send(primary_key) : entity
             end
           end
         end
 
-        def import(*args, &block)
-          import_options = args.extract_options!
-          batch_size = import_options[:batch_size] || BATCH_SIZE
+      private
 
-          if args.empty?
-            import_dataset(default_dataset, batch_size, &block)
-          elsif args.one? && dataset?(args.first)
-            import_dataset(args.first, batch_size, &block)
-          else
-            import_models(args.flatten.compact, batch_size, &block)
+        def cleanup_default_scope!
+          if Chewy.logger && @default_scope != @default_scope.unordered.unlimited
+            Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified')
           end
-        end
-
-        def load(*args)
-          load_options = args.extract_options!
-          index_ids = args.flatten.map(&:id)  # args contains index instances
-
-          type_name = load_options[:_type].type_name.to_sym
-          additional_scope = load_options[type_name].try(:[], :scope) || load_options[:scope]
-
-          dataset = select_by_ids(target, index_ids)
 
-          if additional_scope.is_a?(Proc)
-            index_ids.map!(&:to_s)
-            dataset.instance_exec(&additional_scope).to_a.select do |model|
-              index_ids.include? model.pk.to_s
-            end
-          else
-            dataset.to_a
-          end
+          @default_scope = @default_scope.unordered.unlimited
         end
 
-        private
+        def import_scope(scope, batch_size)
+          scope = scope.unordered.order(::Sequel.asc(primary_key)).limit(batch_size)
 
-        def import_dataset(dataset, batch_size)
-          dataset = dataset.limit(batch_size)
-
-          dataset.db.transaction(isolation: :committed) do
-            0.step(Float::INFINITY, batch_size).lazy
-              .map { |offset| dataset.offset(offset).to_a }
-              .take_while(&:any?)
-              .map { |items| yield grouped_objects(items) }
-              .reduce(:&)
-          end
-        end
+          ids = pluck_ids(scope)
+          result = true
 
-        def import_models(objects, batch_size)
-          objects_by_id = objects.index_by do |item|
-            model?(item) ? item.pk : item
+          while ids.any?
+            result &= yield grouped_objects(default_scope_where_ids_in(ids))
+            break if ids.size < batch_size
+            ids = pluck_ids(scope.where { |o| o.__send__(primary_key) > ids.last })
           end
 
-          indexed = objects_by_id.keys.each_slice(batch_size).map do |ids|
-            models = select_by_ids(default_dataset, ids).to_a
-            models.each { |model| objects_by_id.delete(model.pk) }
-            models.empty? || yield(grouped_objects(models))
-          end
+          result
+        end
 
-          deleted = objects_by_id.keys.each_slice(batch_size).map do |ids|
-            yield delete: objects_by_id.values_at(*ids)
-          end
+        def primary_key
+          target.primary_key
+        end
 
-          indexed.all? && deleted.all?
+        def pluck_ids(scope)
+          scope.distinct.select_map(primary_key)
         end
 
-        def select_by_ids(dataset, ids)
-          dataset.where(target_pk => Array.wrap(ids))
+        def scope_where_ids_in(scope, ids)
+          scope.where(primary_key => Array.wrap(ids))
         end
 
-        def target_pk
-          target.primary_key
+        def model_of_relation relation
+          relation.model
         end
 
-        def dataset?(obj)
-          obj.is_a? ::Sequel::Dataset
+        def relation_class
+          ::Sequel::Dataset
         end
 
-        def model?(obj)
-          obj.is_a? ::Sequel::Model
+        def object_class
+          ::Sequel::Model
         end
       end
     end

data/lib/chewy/type/import.rb

@@ -22,11 +22,10 @@ module Chewy
           bulk_options = import_options.reject { |k, v| ![:refresh, :suffix].include?(k) }.reverse_merge!(refresh: true)
 
           index.create!(bulk_options.slice(:suffix)) unless index.exists?
-          build_root unless self.root_object
 
           ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
             adapter.import(*args, import_options) do |action_objects|
-              indexed_objects = self.root_object.parent_id && fetch_indexed_objects(action_objects.values.flatten)
+              indexed_objects = build_root.parent_id && fetch_indexed_objects(action_objects.values.flatten)
               body = bulk_body(action_objects, indexed_objects)
 
               errors = bulk(bulk_options.merge(body: body)) if body.any?
@@ -57,9 +56,10 @@ module Chewy
             errors = args.last[:errors]
           end
           import *args
-          ActiveSupport::Notifications.unsubscribe(subscriber)
           raise Chewy::ImportFailed.new(self, errors) if errors.present?
           true
+        ensure
+          ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
         end
 
         # Wraps elasticsearch-ruby client indices bulk method.
@@ -86,8 +86,8 @@ module Chewy
         def delete_bulk_entry(object, indexed_objects = nil, crutches = nil)
           entry = {}
 
-          if self.root_object.id
-            entry[:_id] = self.root_object.compose_id(object)
+          if root_object.id
+            entry[:_id] = root_object.compose_id(object)
           else
             entry[:_id] = object.id if object.respond_to?(:id)
             entry[:_id] ||= object[:id] || object['id'] if object.is_a?(Hash)
@@ -95,7 +95,7 @@ module Chewy
             entry[:_id] = entry[:_id].to_s if defined?(BSON) && entry[:_id].is_a?(BSON::ObjectId)
           end
 
-          if self.root_object.parent_id
+          if root_object.parent_id
             existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
             entry.merge!(parent: existing_object[:parent]) if existing_object
           end
@@ -106,8 +106,8 @@ module Chewy
         def index_bulk_entry(object, indexed_objects = nil, crutches = nil)
           entry = {}
 
-          if self.root_object.id
-            entry[:_id] = self.root_object.compose_id(object)
+          if root_object.id
+            entry[:_id] = root_object.compose_id(object)
           else
             entry[:_id] = object.id if object.respond_to?(:id)
             entry[:_id] ||= object[:id] || object['id'] if object.is_a?(Hash)
@@ -115,8 +115,8 @@ module Chewy
           end
           entry.delete(:_id) if entry[:_id].blank?
 
-          if self.root_object.parent_id
-            entry[:parent] = self.root_object.compose_parent(object)
+          if root_object.parent_id
+            entry[:parent] = root_object.compose_parent(object)
             existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
           end
 
@@ -150,7 +150,7 @@ module Chewy
         end
 
         def object_data object, crutches = nil
-          (self.root_object ||= build_root).compose(object, crutches)[type_name.to_sym]
+          build_root.compose(object, crutches)[type_name.to_sym]
         end
 
         def extract_errors result