tantot 0.1.5 → 0.1.6

data/lib/tantot/observe.rb

@@ -1,32 +1,37 @@
-require 'cityhash'
+require 'ostruct'
 
 module Tantot
   module Observe
     module Helpers
-      def condition_proc(context)
-        attributes = context[:attributes]
-        options = context[:options]
+      def condition_proc(watch)
+        attributes = watch.attributes
+        options = watch.options
         proc do
-          has_changes = attributes.any? ? (self.destroyed? || (self._watch_changes.keys & attributes).any?) : true
+          has_changes = attributes[:only].any? ? (self.destroyed? || (self._watch_changes.keys & attributes[:watched]).any?) : true
           has_changes && (!options.key?(:if) || self.instance_exec(&options[:if]))
         end
       end
 
-      def update_proc(context)
+      def update_proc(watch)
         proc do
-          attributes = context[:attributes]
+          attributes = watch.attributes
           watched_changes =
-            if attributes.any?
+            if attributes[:only].any?
               if self.destroyed?
-                attributes.each.with_object({}) {|attr, hash| hash[attr] = [self[attr]]}
+                attributes[:watched].each.with_object({}) {|attr, hash| hash[attr] = [self.attributes[attr]]}
               else
-                self._watch_changes.slice(*attributes)
+                self._watch_changes.slice(*attributes[:watched])
               end
             else
               self._watch_changes
             end
 
-          Tantot.collector.push(context, self, watched_changes)
+          # If explicitly watching attributes, always include their values (if not already included through change tracking)
+          attributes[:always].each do |attribute|
+            watched_changes[attribute] = [self.attributes[attribute]] unless watched_changes.key?(attribute)
+          end
+
+          watch.agent.push(watch, self, watched_changes)
         end
       end
     end
@@ -48,33 +53,33 @@ module Tantot
         def watch(*args, &block)
           options = args.extract_options!
 
-          watcher = args.first.is_a?(String) || args.first.is_a?(Class) ? Tantot.derive_watcher(args.shift) : nil
-          unless !!watcher ^ block_given?
-            raise ArgumentError.new("At least one, and only one of `watcher` or `block` can be passed")
-          end
+          # Syntax allows for the first argument to be a watcher class, shift
+          # it if it is a string or class
+          watcher = args.first.is_a?(String) || args.first.is_a?(Class) ? args.shift : nil
 
-          attributes = args.collect(&:to_s)
+          only_attributes = Array.wrap(options.fetch(:only, [])).collect(&:to_s)
+          always_attributes = Array.wrap(options.fetch(:always, [])).collect(&:to_s)
 
-          context = {
-            model: self,
-            attributes: attributes,
-            options: options
+          # Setup watch
+          watch = OpenStruct.new
+          watch.model = self
+          watch.attributes ={
+            only: only_attributes,
+            always: always_attributes,
+            watched: only_attributes | always_attributes
           }
+          watch.options = options
+          watch.block = block
+          watch.watcher = 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)
+          Tantot.agent_registry.register(watch)
 
+          # Setup and register callbacks
           callback_options = {}.tap do |opts|
-            opts[:if] = Observe.condition_proc(context) if context[:attributes].any? || options.key?(:if)
-            opts[:on] = options[:on] if options.key?(:on)
+            opts[:if] = Observe.condition_proc(watch) if watch.attributes[:only].any? || watch.options.key?(:if)
+            opts[:on] = watch.options[:on] if watch.options.key?(:on)
           end
-          update_proc = Observe.update_proc(context)
-
+          update_proc = Observe.update_proc(watch)
           if Tantot.config.use_after_commit_callbacks
             after_commit(callback_options, &update_proc)
           else

data/lib/tantot/railtie.rb

@@ -19,5 +19,10 @@ module Tantot
       Tantot.logger.debug { "[Tantot] Installing Rails middleware" }
       app.config.middleware.insert_after(Rails::Rack::Logger, RequestStrategy)
     end
+
+    config.to_prepare do
+      Tantot.logger.debug { "[Tantot] Clearing registry" }
+      Tantot.registry.clear
+    end
   end
 end

data/lib/tantot/strategy.rb

@@ -0,0 +1,24 @@
+require 'tantot/strategy/bypass'
+require 'tantot/strategy/inline'
+
+begin
+  require 'chewy'
+  require 'tantot/strategy/chewy'
+rescue LoadError
+  nil
+end
+
+begin
+  require 'sidekiq'
+  require 'tantot/strategy/sidekiq'
+rescue LoadError
+  nil
+end
+
+module Tantot
+  module Strategy
+    def self.resolve(name)
+      "Tantot::Strategy::#{name.to_s.camelize}".safe_constantize or raise "Can't find strategy class `#{name}`"
+    end
+  end
+end

data/lib/tantot/{performer → strategy}/bypass.rb

@@ -1,7 +1,7 @@
 module Tantot
-  module Performer
+  module Strategy
     class Bypass
-      def run(context, changes)
+      def run(id, changes_by_model)
         # nop
       end
     end

data/lib/tantot/strategy/chewy.rb

@@ -0,0 +1,33 @@
+module Tantot
+  module Strategy
+    class Chewy
+      class Worker
+        include ::Sidekiq::Worker
+
+        def perform(agent_id, chew_strategy, changes_by_model)
+          agent = Tantot.agent_registry.agent(agent_id)
+          raise AgentNotFound.new("No registered agent with id #{id}") unless agent
+
+          ::Chewy.strategy(chewy_strategy) do
+            agent.peform(Tantot::Strategy::Sidekiq.unmarshal(changes_by_model))
+            Tantot.collector.perform(context, changes)
+          end
+        end
+      end
+
+      def run(agent, changes_by_model)
+        case ::Chewy.strategy.current.name
+        when /sidekiq/
+          queue = agent.options[:queue] || Tantot.config.sidekiq_queue
+          ::Sidekiq::Client.push('class' => Tantot::Strategy::Chewy::Worker,
+                                 'args' => [agent.id, ::Chewy.strategy.current.name, Tantot::Strategy::Sidekiq.marshal(changes_by_model)],
+                                 'queue' => queue)
+        when :bypass
+          return
+        else # :atomic, :urgent, any other (even nil, which we want to pass and fail in Chewy)
+          Tantot::Strategy::Inline.new.run(agent, changes_by_model)
+        end
+      end
+    end
+  end
+end

data/lib/tantot/strategy/inline.rb

@@ -0,0 +1,9 @@
+module Tantot
+  module Strategy
+    class Inline
+      def run(agent, changes_by_model)
+        agent.perform(changes_by_model)
+      end
+    end
+  end
+end

data/lib/tantot/strategy/sidekiq.rb

@@ -0,0 +1,36 @@
+module Tantot
+  module Strategy
+    class Sidekiq
+      class Worker
+        include ::Sidekiq::Worker
+
+        def perform(agent_id, changes_by_model)
+          agent = Tantot.agent_registry.agent(agent_id)
+          raise AgentNotFound.new("No registered agent with id #{agent_id}") unless agent
+          agent.perform(Tantot::Strategy::Sidekiq.unmarshal(changes_by_model))
+        end
+      end
+
+      def run(agent, changes_by_model)
+        queue = agent.options[:queue] || Tantot.config.sidekiq_queue
+        ::Sidekiq::Client.push('class' => Tantot::Strategy::Sidekiq::Worker,
+                               'args' => [agent.id, Tantot::Strategy::Sidekiq.marshal(changes_by_model)],
+                               'queue' => queue)
+      end
+
+      def self.marshal(changes_by_model)
+        changes_by_model.each.with_object({}) do |(model_class, changes), hash|
+          hash[model_class.name] = changes
+        end
+      end
+
+      def self.unmarshal(changes_by_model)
+        changes_by_model.each.with_object({}) do |(model_class_name, changes_by_id), model_hash|
+          model_hash[model_class_name.constantize] = changes_by_id.each.with_object({}) do |(id, changes), change_hash|
+            change_hash[id.to_i] = changes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tantot/version.rb

@@ -1,3 +1,3 @@
 module Tantot
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/performance/profile.rb

@@ -41,10 +41,12 @@ class BlockRun < ProfileRun
 
   def run
     RUNS.times do
-      city = BlockRunCity.create! name: 'foo'
-      city.name = 'bar'
-      city.save
-      city.destroy
+      Tantot.manager.run do
+        city = BlockRunCity.create! name: 'foo'
+        city.name = 'bar'
+        city.save
+        city.destroy
+      end
     end
   end
 end
@@ -71,10 +73,12 @@ class WatcherRun < ProfileRun
 
   def run
     RUNS.times do
-      city = WatcherRunCity.create! name: 'foo'
-      city.name = 'bar'
-      city.save
-      city.destroy
+      Tantot.manager.run do
+        city = WatcherRunCity.create! name: 'foo'
+        city.name = 'bar'
+        city.save
+        city.destroy
+      end
     end
   end
 

data/spec/collector/block_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Tantot::Agent::Block do
+
+  context 'using a block' do
+    let(:value) { {changes: 0} }
+    let(:changes) { {obj: nil} }
+    before do
+      v = value
+      c = changes
+      stub_model(:city) do
+        watch {|changes| v[:changes] += 1; c[:obj] = changes}
+      end
+    end
+
+    it "should call the block" do
+      city = nil
+      Tantot.manager.run do
+        city = City.create!
+      end
+      expect(value[:changes]).to eq(1)
+      expect(changes[:obj]).to eq(Tantot::Changes::ById.new({city.id => {"id" => [nil, 1]}}))
+    end
+
+    it "call a single time if multiple changes occur" do
+      Tantot.manager.run do
+        3.times { City.create! }
+      end
+      expect(value[:changes]).to eq(1)
+      expect(changes[:obj]).to eq(Tantot::Changes::ById.new({1=>{"id"=>[nil, 1]}, 2=>{"id"=>[nil, 2]}, 3=>{"id"=>[nil, 3]}}))
+    end
+  end
+end

data/spec/collector/options_spec.rb

@@ -0,0 +1,211 @@
+require "spec_helper"
+
+describe Tantot::Agent do
+  describe "options" do
+    let(:watcher_instance) { double }
+
+    before do
+      stub_class("TestWatcher") { include Tantot::Watcher }
+      allow(TestWatcher).to receive(:new).and_return(watcher_instance)
+    end
+
+    context 'with an additional `if` statement' do
+      [:no, :some].each do |attribute_opt|
+        context "with #{attribute_opt.to_s} attributes" do
+          let(:condition) { double }
+          before do
+            c = condition
+            watch_params = [TestWatcher]
+            hash = {}
+            hash[:only] = :id if attribute_opt == :some
+            hash[:if] = -> { c.passed? }
+            watch_params << hash
+            stub_model(:city) do
+              watch(*watch_params)
+            end
+          end
+
+          it "should fail if the condition is false" do
+            Tantot.manager.run do
+              expect(condition).to receive(:passed?).once.and_return(false)
+              City.create!
+              expect(watcher_instance).not_to receive(:perform)
+            end
+          end
+
+          it "should pass if the condition is true" do
+            Tantot.manager.run do
+              expect(condition).to receive(:passed?).once.and_return(true)
+              City.create!
+              expect(watcher_instance).to receive(:perform)
+            end
+          end
+        end
+      end
+    end
+
+    context 'always:' do
+      context 'when watching everything' do
+        before do
+          stub_model(:city) do
+            belongs_to :country
+
+            watch TestWatcher, always: :country_id
+          end
+
+          stub_model(:country) do
+            has_many :cities
+          end
+        end
+
+        it "should watch all changes including the always field even when not changed" do
+          Tantot.manager.run do
+            city = City.create name: 'foo'
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"id" => [nil, city.id], "name" => [nil, "foo"], "country_id" => [nil]}}}))
+          end
+        end
+
+        it "should watch all changes including the always field even when changed" do
+          Tantot.manager.run do
+            country = Country.create
+            city = City.create name: 'foo', country: country
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"id" => [nil, city.id], "name" => [nil, "foo"], "country_id" => [nil, country.id]}}}))
+          end
+        end
+
+        it "should send the field value when destroyed" do
+          Tantot.manager.run do
+            country = Country.create
+            city = City.create name: 'foo', country: country
+            Tantot.manager.sweep(:bypass)
+
+            city.reload
+
+            city.destroy
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"country_id" => [country.id]}}}))
+          end
+        end
+      end
+
+      context "when watching specific attributes" do
+        before do
+          stub_model(:city) do
+            belongs_to :country
+
+            watch TestWatcher, only: :name, always: :country_id
+          end
+
+          stub_model(:country) do
+            has_many :cities
+          end
+        end
+
+        it "should watch all changes including the always field even when not changed" do
+          Tantot.manager.run do
+            city = City.create name: 'foo'
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, "foo"], "country_id" => [nil]}}}))
+          end
+        end
+
+        it "should watch all changes including the always field even when changed" do
+          Tantot.manager.run do
+            country = Country.create
+            city = City.create name: 'foo', country: country
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, "foo"], "country_id" => [nil, country.id]}}}))
+          end
+        end
+
+        it "should send the field value when destroyed" do
+          Tantot.manager.run do
+            country = Country.create
+            city = City.create name: 'foo', country: country
+            Tantot.manager.sweep(:bypass)
+
+            city.reload
+
+            city.destroy
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo'], "country_id" => [country.id]}}}))
+          end
+        end
+
+      end
+    end
+
+    context 'on:' do
+      context ':create' do
+        before do
+          stub_model(:city) do
+            watch TestWatcher, on: :create
+          end
+        end
+
+        it "should only watch creation" do
+          city = nil
+          Tantot.manager.run do
+            city = City.create!
+            expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"id" => [nil, city.id]}}}))
+          end
+          Tantot.manager.run do
+            city = City.find(city)
+            city.name = 'foo'
+            city.save
+          end
+          Tantot.manager.run do
+            city = City.find(city)
+            city.destroy
+          end
+        end
+      end
+
+      context ':update' do
+        before do
+          stub_model(:city) do
+            watch TestWatcher, on: :update
+          end
+        end
+
+        it "should only watch update" do
+          city = nil
+          Tantot.manager.run do
+            city = City.create!
+            expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
+          end
+          Tantot.manager.run do
+            city = City.find(city)
+            city.name = 'foo'
+            city.save
+          end
+          Tantot.manager.run do
+            city = City.find(city)
+            city.destroy
+          end
+        end
+      end
+
+      context ':destroy' do
+        before do
+          stub_model(:city) do
+            watch TestWatcher, on: :destroy
+          end
+        end
+
+        it "should only watch destruction" do
+          city = nil
+          Tantot.manager.run do
+            city = City.create!
+            expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {}}}))
+          end
+          Tantot.manager.run do
+            city = City.find(city)
+            city.name = 'foo'
+            city.save
+          end
+          Tantot.manager.run do
+            city = City.find(city)
+            city.destroy
+          end
+        end
+      end
+    end
+  end
+end