chewy_kiqqer 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b46e354039335e662d5a2703dfefede25e6eb3ae
-  data.tar.gz: c274a92f28b5123db90522739df092eb0bdf0488
+  metadata.gz: 56d8782dbf31ea522b3949701611734c73d7c719
+  data.tar.gz: ab2aca5b6fd3414b9bd28ecbd44c34d80364ae7e
 SHA512:
-  metadata.gz: 093e22e868d55e03a0a508b48aee199ee5887664a5ae09ca9decb533ad7c8ba2f7ebf0c90a03d5383cd29b7969950e8f2e22ae16aaea924d3e31a7006f8aef1a
-  data.tar.gz: 60a94f08eca01d4b087cdcb48da86949ade028aeaf4aa6479d79763b5a21156aef966ebc8ed3f12bba8a4784095f5c36e283fd12cd2f17c4ee13a6356135cb0c
+  metadata.gz: d7495bbdf62b2a67264c7a6dd0af12bec1381264b0a41b6210f817da6e2ea72d995c4425d15229bf6baa5b0aca7332eefac6955ab16d2118b663d893c059da80
+  data.tar.gz: 20573650635ad47f0c1ed8b6031f8e82462673ad3a47e9abc97ca221711718743c0b569bdb11ae71da56ad3df15273d7226d9d446fc5949f447e2f5a567c8102

data/README.md

@@ -2,7 +2,9 @@
 
 This is an alternative udpate/callback mechanism for [Chewy](https://github.com/toptal/chewy). It queues the updates as [Sidekiq](https://github.com/mperham/sidekiq) jobs.
 
-Unlike the standard update_index mechnism it will **always** use the record's index for updates (at this time at least). If you need to do bulk updates, just use chewy's built-in mechanisms.
+You can pass backrefs like with the standard chewy mechanism, but the job itself will always receive an array of ids.
+
+It is possible to install more multiple update hooks.
 
 ## Installation
 
@@ -25,7 +27,7 @@ Just add the module and set it up:
     class User < ActiveRecord::Base
       include ChewyKiqqer::Mixin
       
-      async_update_index index: 'users#user', queue: :other_than_default
+      async_update_index index: 'users#user', queue: :other_than_default, backref: :something
     end
 
 You can also include the mixin into ActiveRecord::Base in an initializer if it should be generally available.
@@ -33,6 +35,16 @@ The queue name is optional. You can also set a default queue name for your appli
     
     ChewyKiqqer.default_queue = :my_queue
 
+Giving a backref is also optional (also check the chewy docs for the concept). The backref is the element
+which will be indexed. The default is to use the current record.
+
+    # use the current record for the backref
+    ... backref: :self
+    # call a method on the current record to get the backref
+    ... backref: :some_method
+    # Pass a proc. It will be called with the current record to get the backref
+    ... backref: -> (rec) { |rec| rec.do_something }
+
 ## Contributing
 
 1. Fork it

data/lib/chewy_kiqqer.rb

@@ -1,3 +1,4 @@
 require "chewy_kiqqer/version"
 require "chewy_kiqqer/mixin"
 require "chewy_kiqqer/worker"
+require "chewy_kiqqer/index"

data/lib/chewy_kiqqer/index.rb

@@ -0,0 +1,27 @@
+module ChewyKiqqer
+
+  class Index
+
+    def initialize(backref: :self, index: nil, queue: ChewyKiqqer.default_queue)
+      @index_name = index
+      @backref_method = backref
+      @queue = queue
+    end
+
+    def enqueue(object)
+      Sidekiq::Client.push(queue: @queue, class: ChewyKiqqer::Worker, args: [@index_name, backref_ids(object)])
+    end
+
+    def backref(object)
+      return @backref_method.call(object) if @backref_method.respond_to?(:call)
+      return object if @backref_method.to_s == 'self'
+      object.send(@backref_method)
+    end
+
+    def backref_ids(object)
+      Array.wrap(backref(object)).map { |object| object.respond_to?(:id) ? object.id : object.to_i }
+    end
+
+  end
+
+end

data/lib/chewy_kiqqer/mixin.rb

@@ -1,4 +1,5 @@
 require 'active_support/concern'
+require 'active_support/core_ext/array/wrap'
 
 module ChewyKiqqer
 
@@ -16,19 +17,27 @@ module ChewyKiqqer
 
     module ClassMethods
 
-      attr_reader :index_name
+      attr_reader :indexers
 
-      def async_update_index(index: nil, queue: ChewyKiqqer::default_queue)
-        @index_name = index
+      def async_update_index(index: nil, queue: ChewyKiqqer::default_queue, backref: :self)
+        @indexers ||= []
+        install_chewy_hooks if @indexers.empty?
+        @indexers << ChewyKiqqer::Index.new(index: index, queue: queue, backref: backref)
+      end
+
+      def reset_async_chewy
+        @indexers and @indexers.clear
+      end
+
+      def install_chewy_hooks
         after_save    :queue_chewy_job
         after_destroy :queue_chewy_job
-        ChewyKiqqer::Worker.sidekiq_options queue: queue
       end
-
     end
 
-    def queue_chewy_job
-      ChewyKiqqer::Worker.perform_async(self.class.index_name, id)
+    def queue_chewy_jobs
+      self.class.indexers or return
+      self.class.indexers.each { |idx| idx.enqueue(self) }
     end
   end
 end

data/lib/chewy_kiqqer/version.rb

@@ -1,3 +1,3 @@
 module ChewyKiqqer
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/index_spec.rb

@@ -0,0 +1,66 @@
+require 'chewy_kiqqer'
+
+describe ChewyKiqqer::Index do
+
+  context 'compute the backref' do
+
+    it 'defaults to the corresponding object' do
+      object = Object.new
+      idx = ChewyKiqqer::Index.new
+      idx.backref(object).should eq object
+    end
+
+    it 'can run a random method' do
+      object = double(foobar: :backref)
+      idx = ChewyKiqqer::Index.new(backref: :foobar)
+      idx.backref(object).should eq :backref
+    end
+
+    it 'can use a proc' do
+      object = double(foobar: :my_backref)
+      idx = ChewyKiqqer::Index.new(backref: -> (r) { r.foobar })
+      idx.backref(object).should eq :my_backref
+    end
+
+    context 'turning backrefs into ids' do
+      let(:idx) { ChewyKiqqer::Index.new }
+
+      it 'uses the ids of the objects' do
+        idx.backref_ids([double(id: 3), double(id: 6)]).should eq [3, 6]
+      end
+
+      it 'turns everything else into ints' do
+        idx.backref_ids([3, '6']).should eq [3, 6]
+      end
+
+    end
+
+    context 'queue the job' do
+      it 'queues the job with the settings from the index' do
+        object = double(id: 24)
+        idx = ChewyKiqqer::Index.new index: 'foo#bar',
+                                     queue: 'hello'
+
+        Sidekiq::Client.should_receive(:push)
+                       .with(queue: 'hello',
+                             class: ChewyKiqqer::Worker,
+                             args: ['foo#bar', [24]])
+        idx.enqueue object
+      end
+
+      it 'queues the job on the chewy default queue if not told otherwise' do
+        object = double(id: 24)
+        ChewyKiqqer.default_queue = :my_default
+        idx = ChewyKiqqer::Index.new index: 'foo#bar'
+
+        Sidekiq::Client.should_receive(:push)
+                       .with(queue: :my_default,
+                             class: ChewyKiqqer::Worker,
+                             args: ['foo#bar', [24]])
+        idx.enqueue object
+      end
+    end
+
+  end
+
+end

data/spec/mixin_spec.rb

@@ -5,44 +5,55 @@ class Gummi
 
   def self.after_save(*args) ; end
   def self.after_destroy(*args) ; end
-  def id ; 17 ; end
 
 end
 
 describe ChewyKiqqer::Mixin do
 
-  context 'class methods' do
-    it 'installs the hooks' do
-      Gummi.should_receive(:after_save).with(:queue_chewy_job)
-      Gummi.should_receive(:after_destroy).with(:queue_chewy_job)
+  before(:each) { Gummi.reset_async_chewy }
+
+  context '#update_index' do
+
+    it 'installs the hooks if nothing was installed yet' do
+      Gummi.should_receive(:install_chewy_hooks)
       Gummi.async_update_index(index: 'xxx')
     end
 
-    it 'knows the index_name' do
-      Gummi.async_update_index(index: 'bar#foo')
-      Gummi.index_name.should eq 'bar#foo'
+    it 'does not install the hooks twice' do
+      Gummi.should_receive(:install_chewy_hooks).once
+      Gummi.async_update_index(index: 'xxx')
+      Gummi.async_update_index(index: 'xxx')
     end
 
-    it 'sets the queue name' do
-      ChewyKiqqer::Worker.should_receive(:sidekiq_options).with(queue: :some_queue)
-      Gummi.async_update_index(index: 'xxx', queue: :some_queue)
+    it 'installs the indexer' do
+      ChewyKiqqer::Index.should_receive(:new)
+                        .with(index: 'some#thing', queue: :medium, backref: :foobar)
+                        .and_return(:idx)
+      Gummi.async_update_index(index: 'some#thing', queue: :medium, backref: :foobar)
+      Gummi.indexers.should eq [:idx]
     end
 
-    it 'uses the default queue if none was specified' do
-      ChewyKiqqer::Worker.should_receive(:sidekiq_options).with(queue: :default3)
-      ChewyKiqqer.default_queue = :default3
-      Gummi.async_update_index(index: 'xxx')
+  end
+
+  context '#install hooks' do
+
+    it 'installs the hooks' do
+      Gummi.should_receive(:after_save).with(:queue_chewy_job)
+      Gummi.should_receive(:after_destroy).with(:queue_chewy_job)
+      Gummi.install_chewy_hooks
     end
+
   end
 
-  context '#queue_job' do
+  context '#queue_chewy_jobs' do
 
     let(:record) { Gummi.new }
 
     it 'queues the job' do
-      Gummi.async_update_index index: 'foo#bar'
-      ChewyKiqqer::Worker.should_receive(:perform_async).with('foo#bar', 17)
-      record.queue_chewy_job
+      idx = double
+      idx.should_receive(:enqueue).with(record)
+      Gummi.stub(indexers: [idx])
+      record.queue_chewy_jobs
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chewy_kiqqer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Hahn
@@ -108,9 +108,11 @@ files:
 - Rakefile
 - chewy_kiqqer.gemspec
 - lib/chewy_kiqqer.rb
+- lib/chewy_kiqqer/index.rb
 - lib/chewy_kiqqer/mixin.rb
 - lib/chewy_kiqqer/version.rb
 - lib/chewy_kiqqer/worker.rb
+- spec/index_spec.rb
 - spec/mixin_spec.rb
 - spec/worker.spec.rb
 homepage: ''
@@ -139,5 +141,6 @@ specification_version: 4
 summary: Small helper gem that allows you to automatically run all chewy index updates
   in sidekiq
 test_files:
+- spec/index_spec.rb
 - spec/mixin_spec.rb
 - spec/worker.spec.rb