tantot 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1aca7d8b60134dc22beb994d5d51caabd6b98f9
-  data.tar.gz: c561b19426b24a5650ff23b092274f0212b0e1ff
+  metadata.gz: 56725354395a9033cc635de74a735b73edac40b3
+  data.tar.gz: f5a41a93122899cb7ee27946a18a50a6b7fec825
 SHA512:
-  metadata.gz: 382ba5b261e10b733db81f5d24c1900292666d70de3aa17cacbc6238dff566a68d7fd9caf4238f2d4609e0cfed015ac1c20f11c8e5f34af0cc73eb4ff991981e
-  data.tar.gz: 1c2799e8e61ae8acecf7c53c38cefbf2b1104bb12e62f7dc6e7884537f732ca3bb5a83255902419ca31103a5a1193db695f5034f2111b04adf861c9c752f2d20
+  metadata.gz: 97e9aad665296f329b93269feb68ba1e6e3aecd099e3b91bc9fe60f3f91fc4f88dbaa4e32b9958e4ad7d4ac55950896b308d81cd6823144975b85033eeded7ce
+  data.tar.gz: 195da978eb98c9accd59e17b2679012a8e74bbb6bf33092e21cff06f909c3fbac9fa6fd57345ae1b613ab4c6046a664d578437ed52f835fe0080107def78f3fa

data/Gemfile

@@ -4,3 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'sidekiq', require: false
+gem 'chewy', require: false

data/lib/tantot/collector/base.rb

@@ -0,0 +1,46 @@
+module Tantot
+  module Collector
+    class Base
+      class_attribute :context_key
+
+      def self.manages?(context)
+        context.key?(self.context_key)
+      end
+
+      def register_watch(context, block)
+        raise NotImplementedError
+      end
+
+      def push(context, instance, mutations)
+        formatter = Tantot::Formatter.resolve(context[:options][:format] || Tantot.config.format).new
+        attribute_hash = get_stash(context, instance)
+        mutations.each do |attr, changes|
+          attribute_hash[attr] = formatter.push(attribute_hash[attr], context, changes)
+        end
+      end
+
+      def sweep(performer_name)
+        if @stash.any?
+          Tantot.logger.debug { "[Tantot] [Sweeping] [#{self.class.name.demodulize}] #{debug_state}" }
+          @stash.each do |id, changes|
+            context = Tantot.registry.watch_config[id][:context]
+            performer = Tantot::Performer.resolve(performer_name || context[:options][:performer] || Tantot.config.performer).new
+            Tantot.logger.debug { "[Tantot] [Performer] [#{self.class.name.demodulize}] [#{performer.class.name.demodulize}] #{debug_state(Hash[id, changes])}" }
+            performer.run(context, changes)
+          end
+          @stash.clear
+        end
+      end
+
+      def debug_changes_for_model(model, changes_by_id)
+        "#{model.name}#{changes_by_id.keys.inspect}"
+      end
+
+    protected
+
+      def get_stash(context, instance)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/tantot/collector/block.rb

@@ -1,9 +1,7 @@
 module Tantot
   module Collector
-    class Block
-      def self.manages?(context)
-        context.key?(:block_id)
-      end
+    class Block < Base
+      self.context_key = :block_id
 
       def initialize
         @stash = Hash.new do |block_id_hash, block_id|
@@ -17,22 +15,6 @@ module Tantot
         Tantot.registry.watch_config[context[:block_id]] = {context: context, block: block}
       end
 
-      def push(context, instance, mutations)
-        options = context.fetch(:options, {})
-        formatter = Tantot::Formatter.resolve(options[:format] || Tantot.config.default_watcher_options[:format]).new
-        attribute_hash = @stash[context[:block_id]][instance.id]
-        mutations.each do |attr, changes|
-          attribute_hash[attr] = formatter.push(attribute_hash[attr], context, changes)
-        end
-      end
-
-      def sweep(performer, context = {})
-        @stash.each do |block_id, changes|
-          performer.run({block_id: block_id}, changes)
-        end
-        @stash.clear
-      end
-
       def perform(context, changes_by_id)
         watch_config = Tantot.registry.watch_config[context[:block_id]]
         watch_config[:context][:model].instance_exec(Tantot::Changes::ById.new(changes_by_id), &watch_config[:block])
@@ -60,17 +42,26 @@ module Tantot
         debug_block(block)
       end
 
-      def debug_state(context)
-        return false if @stash.empty?
-        @stash.collect do |block_id, changes_by_id|
+      def debug_changes(watch_config, changes_by_id)
+        "#{debug_changes_for_model(watch_config[:context][:model], changes_by_id)} for #{debug_block(watch_config[:block])}"
+      end
+
+      def debug_state(stash = @stash)
+        stash.collect do |block_id, changes_by_id|
           watch_config = Tantot.registry.watch_config[block_id]
-          "#{watch_config[:context][:model].name}*#{changes_by_id.size} for #{debug_block(watch_config[:block])}"
+          debug_changes(watch_config, changes_by_id)
         end.join(" / ")
       end
 
       def debug_perform(context, changes_by_id)
         watch_config = Tantot.registry.watch_config[context[:block_id]]
-        "#{watch_config[:context][:model].name}*#{changes_by_id.size} for #{debug_block(watch_config[:block])}"
+        debug_changes(watch_config, changes_by_id)
+      end
+
+    protected
+
+      def get_stash(context, instance)
+        @stash[context[:block_id]][instance.id]
       end
 
     end

data/lib/tantot/collector/watcher.rb

@@ -1,9 +1,7 @@
 module Tantot
   module Collector
-    class Watcher
-      def self.manages?(context)
-        context.key?(:watcher)
-      end
+    class Watcher < Base
+      self.context_key = :watcher
 
       def initialize
         @stash = Hash.new do |watcher_hash, watcher|
@@ -16,30 +14,7 @@ module Tantot
       end
 
       def register_watch(context, block)
-        # nop
-      end
-
-      def push(context, instance, mutations)
-        watcher = context[:watcher]
-        model = context[:model]
-        formatter = Tantot::Formatter.resolve(watcher.watcher_options[:format]).new
-        attribute_hash = @stash[watcher][model][instance.id]
-        mutations.each do |attr, changes|
-          attribute_hash[attr] = formatter.push(attribute_hash[attr], context, changes)
-        end
-      end
-
-      def sweep(performer, context = {})
-        watcher = context[:watcher]
-        filtered_stash = watcher ? @stash.select {|w, _c| w == watcher} : @stash
-        filtered_stash.each do |w, changes_by_model|
-          performer.run({watcher: w}, changes_by_model)
-        end
-        if watcher
-          @stash.delete(watcher)
-        else
-          @stash.clear
-        end
+        Tantot.registry.watch_config[context[:watcher]] = {context: context}
       end
 
       def perform(context, changes_by_model)
@@ -64,22 +39,27 @@ module Tantot
       end
 
       def debug_context(context)
-        context[:watcher].name.demodulize
+        context[:watcher].name
       end
 
-      def debug_state(context)
-        return false if @stash.empty?
-        @stash.collect do |watcher, changes_by_model|
-          "#{watcher.name}[#{changes_by_model.collect do |model, changes_by_id|
-            "#{model.name}*#{changes_by_id.size}"
-          end.join("&")}]"
-        end.flatten.join(" / ")
+      def debug_changes(watcher, changes_by_model)
+        "#{watcher.name}(#{changes_by_model.collect {|model, changes_by_id| debug_changes_for_model(model, changes_by_id)}.join(" & ")})"
+      end
+
+      def debug_state(stash = @stash)
+        stash.collect {|watcher, changes_by_model| debug_changes(watcher, changes_by_model)}.flatten.join(" / ")
       end
 
       def debug_perform(context, changes_by_model)
-        "#{context[:watcher].name}[#{changes_by_model.collect do |model, changes_by_id|
-          "#{model.name}*#{changes_by_id.size}"
-        end.join("&")}]"
+        debug_changes(context[:watcher], changes_by_model)
+      end
+
+    protected
+
+      def get_stash(context, instance)
+        watcher = context[:watcher]
+        model = context[:model]
+        @stash[watcher][model][instance.id]
       end
 
     end

data/lib/tantot/collector.rb

@@ -1,3 +1,4 @@
+require 'tantot/collector/base'
 require 'tantot/collector/watcher'
 require 'tantot/collector/block'
 
@@ -27,24 +28,16 @@ module Tantot
           "[Tantot] [Collecting] [#{collector.class.name.demodulize}] #{mutate} on <#{instance.class.name}:#{instance.id}> for <#{collector.debug_context(context)}>"
         end
         collector.push(context, instance, mutations)
-        sweep(context.merge(performer: :inline)) if Tantot.config.console_mode
+        sweep if Tantot.config.sweep_on_push
       end
 
-      def sweep(context = {})
-        performer = Tantot::Performer.resolve(context[:performer] || Tantot.config.performer).new
-        specific_collector = resolve(context)
-        collectors = specific_collector ? [specific_collector] : @collectors.values
-        collectors.each do |collector|
-          if Tantot.logger.debug? && (debug_state = collector.debug_state(context))
-            Tantot.logger.debug { "[Tantot] [Sweeping] [#{collector.class.name.demodulize}] [#{performer.class.name.demodulize}] #{debug_state}" }
-          end
-          collector.sweep(performer, context)
-        end
+      def sweep(performer_name = nil)
+        @collectors.values.each {|collector| collector.sweep(performer_name)}
       end
 
       def perform(context, changes)
         collector = resolve!(context)
-        Tantot.logger.debug { "[Tantot] [Performing] [#{collector.class.name.demodulize}] #{collector.debug_perform(context, changes)}" }
+        Tantot.logger.debug { "[Tantot] [Run] [#{collector.class.name.demodulize}] #{collector.debug_perform(context, changes)}" }
         collector.perform(context, changes)
       end
 

data/lib/tantot/config.rb

@@ -2,16 +2,13 @@ module Tantot
   class Config
     include Singleton
 
-    attr_accessor :performer, :use_after_commit_callbacks, :default_watcher_options, :console_mode, :chewy_strategy
+    attr_accessor :performer, :format, :use_after_commit_callbacks, :sweep_on_push
 
     def initialize
       @performer = :inline
+      @format = :compact
       @use_after_commit_callbacks = true
-      @default_watcher_options = {
-        format: :compact
-      }
-      @console_mode = false
-      @chewy_strategy = :atomic
+      @sweep_on_push = false
     end
   end
 end

data/lib/tantot/extensions/chewy.rb

@@ -26,6 +26,8 @@ module Tantot
       class ChewyWatcher
         include Tantot::Watcher
 
+        watcher_options performer: :chewy
+
         def perform(changes_by_model)
           changes_by_model.each do |model, changes_by_id|
             model_watches = model._tantot_chewy_callbacks
@@ -70,11 +72,8 @@ module Tantot
 
                   # Make sure there are any backreferences
                   if backreference.any?
-                    # Call update_index, will follow normal chewy strategy
-                    ::Chewy.strategy Tantot.config.chewy_strategy do
-                      Tantot.logger.debug { "[Tantot] [Chewy] [update_index] #{reference} (#{backreference.count} objects): #{backreference.inspect}" }
-                      ::Chewy.derive_type(reference).update_index(backreference, options)
-                    end
+                    Tantot.logger.debug { "[Tantot] [Chewy] [update_index] #{reference} (#{backreference.count} objects): #{backreference.inspect}" }
+                    ::Chewy.derive_type(reference).update_index(backreference, options)
                   end
                 end
 

data/lib/tantot/observe.rb

@@ -61,7 +61,10 @@ module Tantot
             options: options
           }
 
-          context[:watcher] = watcher if watcher
+          if watcher
+            context[:watcher] = watcher
+            options.reverse_merge!(watcher.watcher_options)
+          end
           context[:block_id] = CityHash.hash64(block.source_location.collect(&:to_s).join) if block_given?
 
           Tantot.collector.register_watch(context, block)

data/lib/tantot/performer/chewy.rb

@@ -0,0 +1,31 @@
+module Tantot
+  module Performer
+    class Chewy
+      class Worker
+        include ::Sidekiq::Worker
+
+        def perform(context, changes)
+          context, changes = Tantot.collector.unmarshal(context, changes)
+          ::Chewy.strategy(Tantot.config.chewy_strategy) do
+            Tantot.collector.perform(context, changes)
+          end
+        end
+      end
+
+      def run(context, changes)
+        case ::Chewy.strategy.current.name
+        when :atomic, :urgent
+          Tantot::Performer::Inline.new.run(context, changes)
+        when /sidekiq/
+          context, changes = Tantot.collector.marshal(context, changes)
+          Tantot::Performer::Chewy::Worker.perform_async(context, changes)
+        when :bypass
+          return
+        else
+          # No strategy defined, do an Inline run and let Chewy fail
+          Tantot::Performer::Inline.new.run(context, changes)
+        end
+      end
+    end
+  end
+end

data/lib/tantot/performer.rb

@@ -1,6 +1,13 @@
 require 'tantot/performer/bypass'
 require 'tantot/performer/inline'
 
+begin
+  require 'chewy'
+  require 'tantot/performer/chewy'
+rescue LoadError
+  nil
+end
+
 begin
   require 'sidekiq'
   require 'tantot/performer/sidekiq'

data/lib/tantot/railtie.rb

@@ -12,7 +12,7 @@ module Tantot
 
     console do |app|
       # Will sweep after every push (unfortunately)
-      Tantot.config.console_mode = true
+      Tantot.config.sweep_on_push = true
     end
 
     initializer 'tantot.request_strategy' do |app|

data/lib/tantot/version.rb

@@ -1,3 +1,3 @@
 module Tantot
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/tantot/watcher.rb

@@ -8,7 +8,7 @@ module Tantot
 
     class_methods do
       def watcher_options(opts = {})
-        self.watcher_options_hash ||= Tantot::Config.instance.default_watcher_options
+        self.watcher_options_hash ||= {}
         self.watcher_options_hash = self.watcher_options_hash.merge(opts)
       end
     end

data/spec/extensions/chewy_spec.rb

@@ -1,127 +1,140 @@
 require "spec_helper"
 
-describe Tantot::Extensions::Chewy do
+if defined?(::Chewy)
 
-  # Stub the Chewy namespace
-  before do
-    stub_const("Chewy", {})
-  end
+  describe Tantot::Extensions::Chewy do
 
-  [nil, :self, :class_method, :block].product([:some, :all]).each do |backreference_opt, attribute_opt|
-    it "should update indexes using backreference: #{backreference_opt.inspect}, attributes: #{attribute_opt}" do
-      chewy_type = double
+    [nil, :self, :class_method, :block].product([:some, :all]).each do |backreference_opt, attribute_opt|
+      it "should update indexes using backreference: #{backreference_opt.inspect}, attributes: #{attribute_opt}" do
+        chewy_type = double
 
-      watch_index_params = ['foo']
-      watch_index_params << :id if attribute_opt == :some
+        watch_index_params = ['foo']
+        watch_index_params << :id if attribute_opt == :some
 
-      block_callback = proc do |changes|
-        self.yielded_changes = changes
-        [1, 2, 3]
-      end
+        block_callback = proc do |changes|
+          self.yielded_changes = changes
+          [1, 2, 3]
+        end
 
-      case backreference_opt
-      when nil, :block
-      when :self
-        watch_index_params << {method: :self}
-      when :class_method
-        watch_index_params << {method: :class_get_ids}
-      end
+        case backreference_opt
+        when nil, :block
+        when :self
+          watch_index_params << {method: :self}
+        when :class_method
+          watch_index_params << {method: :class_get_ids}
+        end
 
-      stub_model(:city) do
-        class_attribute :yielded_changes
+        stub_model(:city) do
+          class_attribute :yielded_changes
 
-        if backreference_opt == :block
-          watch_index(*watch_index_params, &block_callback)
-        else
-          watch_index(*watch_index_params)
-        end
+          if backreference_opt == :block
+            watch_index(*watch_index_params, &block_callback)
+          else
+            watch_index(*watch_index_params)
+          end
 
-        def self.class_get_ids(changes)
-          self.yielded_changes = changes
-          [1, 2, 3]
+          def self.class_get_ids(changes)
+            self.yielded_changes = changes
+            [1, 2, 3]
+          end
         end
-      end
 
-      city1 = city2 = nil
+        city1 = city2 = nil
 
-      Tantot.collector.run do
-        city1 = City.create!
-        city2 = City.create!
+        Tantot.collector.run do
+          city1 = City.create!
+          city2 = City.create!
 
-        # Stub the integration point between us and Chewy
-        expect(Chewy).to receive(:strategy).with(:atomic).and_yield
-        expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+          # Stub the integration point between us and Chewy
+          expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
 
-        # Depending on backreference
-        case backreference_opt
-        when nil, :self
-          # Implicit and self reference will update with the created model id
-          expect(chewy_type).to receive(:update_index).with([city1.id, city2.id], {})
-        when :class_method, :block
-          # Validate that the returned ids are updated
-          expect(chewy_type).to receive(:update_index).with([1, 2, 3], {})
+          # Depending on backreference
+          case backreference_opt
+          when nil, :self
+            # Implicit and self reference will update with the created model id
+            expect(chewy_type).to receive(:update_index).with([city1.id, city2.id], {})
+          when :class_method, :block
+            # Validate that the returned ids are updated
+            expect(chewy_type).to receive(:update_index).with([1, 2, 3], {})
+          end
         end
+
+        # Make sure the callbacks received the changes
+        if [:class_method, :block].include?(backreference_opt)
+          expect(City.yielded_changes).to eq(Tantot::Changes::ById.new({city1.id => {"id" => [nil, city1.id]}, city2.id => {"id" => [nil, city2.id]}}))
+        end
+
       end
+    end
+
+    it "should allow registering an index watch on self (all attributes, destroy)" do
+      chewy_type = double
 
-      # Make sure the callbacks received the changes
-      if [:class_method, :block].include?(backreference_opt)
-        expect(City.yielded_changes).to eq(Tantot::Changes::ById.new({city1.id => {"id" => [nil, city1.id]}, city2.id => {"id" => [nil, city2.id]}}))
+      stub_model(:city) do
+        watch_index 'foo'
       end
 
-    end
-  end
+      city = City.create!
+      Tantot.collector.sweep(:bypass)
 
-  it "should allow registering an index watch on self (all attributes, destroy)" do
-    chewy_type = double
+      Tantot.collector.run do
+        city.destroy
 
-    stub_model(:city) do
-      watch_index 'foo'
+        expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+        expect(chewy_type).to receive(:update_index).with([city.id], {})
+      end
     end
 
-    city = City.create!
-    Tantot.collector.sweep(performer: :bypass)
+    it "should allow registering an index watch on self (all attributes, destroy, block)" do
+      chewy_type = double
 
-    Tantot.collector.run do
-      city.destroy
+      stub_model(:city) do
+        watch_index 'foo' do |changes|
+          changes.ids
+        end
+      end
 
-      expect(Chewy).to receive(:strategy).with(:atomic).and_yield
-      expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
-      expect(chewy_type).to receive(:update_index).with([city.id], {})
-    end
-  end
+      city = City.create!
+      Tantot.collector.sweep(:bypass)
 
-  it "should allow registering an index watch on self (all attributes, destroy, block)" do
-    chewy_type = double
+      Tantot.collector.run do
+        city.destroy
 
-    stub_model(:city) do
-      watch_index 'foo' do |changes|
-        changes.ids
+        expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
+        expect(chewy_type).to receive(:update_index).with([city.id], {})
       end
     end
 
-    city = City.create!
-    Tantot.collector.sweep(performer: :bypass)
+    it "should allow returning nothing in a callback" do
+      stub_model(:city) do
+        watch_index('foo') { 1 if false }
+        watch_index('bar') { [] }
+        watch_index('baz') { nil }
+      end
 
-    Tantot.collector.run do
-      city.destroy
+      Tantot.collector.run do
+        City.create!
 
-      expect(Chewy).to receive(:strategy).with(:atomic).and_yield
-      expect(Chewy).to receive(:derive_type).with('foo').and_return(chewy_type)
-      expect(chewy_type).to receive(:update_index).with([city.id], {})
+        expect(Chewy).not_to receive(:derive_type)
+      end
     end
   end
 
-  it "should allow returning nothing in a callback" do
-    stub_model(:city) do
-      watch_index('foo') { 1 if false }
-      watch_index('bar') { [] }
-      watch_index('baz') { nil }
+  describe "Chewy.strategy" do
+    before do
+      allow(Tantot.config).to receive(:sweep_on_push).and_return(true)
     end
 
-    Tantot.collector.run do
-      City.create!
+    it "should bypass if Chewy.strategy is :bypass" do
+      stub_model(:city) do
+        watch_index('foo')
+      end
 
       expect(Chewy).not_to receive(:derive_type)
+      Chewy.strategy :bypass do
+        City.create!
+      end
     end
   end
+
 end

data/spec/sidekiq_spec.rb

@@ -31,7 +31,13 @@ if defined?(::Sidekiq)
           City.create name: 'foo'
         end
         expect(Tantot::Performer::Sidekiq::Worker.jobs.size).to eq(1)
-        expect(Tantot::Performer::Sidekiq::Worker.jobs.first["args"]).to eq([{"watcher" => "SidekiqWatcher", "collector_class" => "Tantot::Collector::Watcher"}, {"City" => {"1" => {"name" => [nil, 'foo']}}}])
+        expect(Tantot::Performer::Sidekiq::Worker.jobs.first["args"]).to eq([{
+          "model" => "City",
+          "attributes" => ["name"],
+          "options" => {},
+          "watcher" => "SidekiqWatcher",
+          "collector_class" => "Tantot::Collector::Watcher"},
+          {"City" => {"1" => {"name" => [nil, 'foo']}}}])
       end
 
       it "should call the watcher" do
@@ -49,7 +55,7 @@ if defined?(::Sidekiq)
             # Create a model, then sweep. It should have called perform wihtout triggering a sidekiq worker
             city = City.create name: 'foo'
             expect_any_instance_of(SidekiqWatcher).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
-            Tantot.collector.sweep(performer: :inline, watcher: SidekiqWatcher)
+            Tantot.collector.sweep(:inline)
             expect(Tantot::Performer::Sidekiq::Worker.jobs.size).to eq(0)
 
             # Further modifications should trigger through sidekiq when exiting the strategy block
@@ -57,7 +63,13 @@ if defined?(::Sidekiq)
             city.save
           end
           expect(Tantot::Performer::Sidekiq::Worker.jobs.size).to eq(1)
-          expect(Tantot::Performer::Sidekiq::Worker.jobs.first["args"]).to eq([{"watcher" => "SidekiqWatcher", "collector_class" => "Tantot::Collector::Watcher"}, {"City" => {"1" => {"name" => ['foo', 'bar']}}}])
+          expect(Tantot::Performer::Sidekiq::Worker.jobs.first["args"]).to eq([{
+            "model" => "City",
+            "attributes" => ["name"],
+            "options" => {},
+            "watcher" => "SidekiqWatcher",
+            "collector_class" => "Tantot::Collector::Watcher"},
+            {"City" => {"1" => {"name" => ['foo', 'bar']}}}])
         end
       end
     end
@@ -81,7 +93,13 @@ if defined?(::Sidekiq)
         end
         expect(Tantot::Performer::Sidekiq::Worker.jobs.size).to eq(1)
         block_id = Tantot.registry.watch_config.keys.last
-        expect(Tantot::Performer::Sidekiq::Worker.jobs.first["args"]).to eq([{"block_id" => block_id, "collector_class" => "Tantot::Collector::Block"}, {"1" => {"name" => [nil, 'foo']}}])
+        expect(Tantot::Performer::Sidekiq::Worker.jobs.first["args"]).to eq([{
+          "model" => "City",
+          "attributes" => ["name"],
+          "options" => {},
+          "block_id" => block_id,
+          "collector_class" => "Tantot::Collector::Block"},
+          {"1" => {"name" => [nil, 'foo']}}])
       end
 
       it "should call the watcher" do

data/spec/tantot_spec.rb

@@ -64,7 +64,7 @@ describe Tantot do
           it "calls back on model update" do
             city = City.create!
             city.reload
-            Tantot.collector.sweep(performer: :bypass)
+            Tantot.collector.sweep(:bypass)
 
             expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
             Tantot.collector.run do
@@ -76,7 +76,7 @@ describe Tantot do
           it "calls back on model destroy" do
             city = City.create!(name: 'foo')
             city.reload
-            Tantot.collector.sweep(performer: :bypass)
+            Tantot.collector.sweep(:bypass)
 
             expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo']}}}))
             Tantot.collector.run do
@@ -99,7 +99,7 @@ describe Tantot do
             Tantot.collector.run do
               city = City.create name: 'foo'
               expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
-              Tantot.collector.sweep(performer: :inline, watcher: TestWatcher)
+              Tantot.collector.sweep(:inline)
               city.name = 'bar'
               city.save
               expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo', 'bar']}}}))
@@ -148,7 +148,7 @@ describe Tantot do
         city = City.create!(name: "Quebec", country_id: country.id)
         country.reload
         city.reload
-        Tantot.collector.sweep(performer: :bypass)
+        Tantot.collector.sweep(:bypass)
 
         expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['Quebec', 'foo', 'bar'], "country_id" => [country.id, nil]}}, Country => {country.id => {"country_code" => ['CDN', 'US']}}}))
         Tantot.collector.run do
@@ -191,7 +191,7 @@ describe Tantot do
         expect(watchA_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['Quebec', 'foo', 'bar'], "country_id" => [country.id, nil]}}, Country => {country.id => {"country_code" => ['CDN', 'US']}}}))
         # WatchB receives the last value of rating since it has been destroyed
         expect(watchB_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"rating" => [12]}}}))
-        Tantot.collector.sweep(performer: :bypass)
+        Tantot.collector.sweep(:bypass)
 
         Tantot.collector.run do
           city.name = "foo"
@@ -224,7 +224,7 @@ describe Tantot do
       it "should also watch on destroy, but when watching all attributes, change hash is empty" do
         city = City.create!(name: 'foo')
         city.reload
-        Tantot.collector.sweep(performer: :bypass)
+        Tantot.collector.sweep(:bypass)
 
         expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {}}}))
         Tantot.collector.run do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tantot
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - François-Pierre Bouchard
@@ -159,6 +159,7 @@ files:
 - lib/tantot.rb
 - lib/tantot/changes.rb
 - lib/tantot/collector.rb
+- lib/tantot/collector/base.rb
 - lib/tantot/collector/block.rb
 - lib/tantot/collector/watcher.rb
 - lib/tantot/config.rb
@@ -171,6 +172,7 @@ files:
 - lib/tantot/observe.rb
 - lib/tantot/performer.rb
 - lib/tantot/performer/bypass.rb
+- lib/tantot/performer/chewy.rb
 - lib/tantot/performer/inline.rb
 - lib/tantot/performer/sidekiq.rb
 - lib/tantot/railtie.rb