tantot 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f6ad6fe3fb7afb2054c68fe8625cc99ea85c327
-  data.tar.gz: 2196c42e206c184669e3429323b4d77774db068e
+  metadata.gz: 9977ff915ab335570ae85a05425204dc31625a21
+  data.tar.gz: f0c7baed8f6eb5a773ac7cd79b79c9b377cb90ab
 SHA512:
-  metadata.gz: 757def8ab9f5e5fa8846b95a6aec91d7f12c2181c51c01680e4fb683cfe61debfe5f71f45e0560da93f43a88c87e2d01d24b1e0c5c338bda469628287bdbe97a
-  data.tar.gz: 9c0c6e845e61607d91e0513d6ce8cf6226b577b416e3aee6fdba89e3be4cde58c7bb1c52a4186313d85623f6db07a96df4716a8c81f619bcf72908a4a44b6fe9
+  metadata.gz: f5391976b3520c289a2d30f10a348c8a7ab280ed7a59b0af2b4834a768aeae0cfe15b3e9e015e983ca110106e05f8e492b27571c11e68046635e17c88a489ad6
+  data.tar.gz: 1fcc978f3c7ccdac880879e0f05fe6c158c8f4f9a87058bea6b71071477bc2d776fc3bc9bbf922851e5055cb0ae6030f1d02a29ab000d667c372bc7f2f0f842b

data/lib/tantot.rb

@@ -6,12 +6,10 @@ require 'singleton'
 
 require 'tantot/errors'
 require 'tantot/config'
-require 'tantot/registry'
 require 'tantot/changes'
-require 'tantot/watcher'
-require 'tantot/performer'
-require 'tantot/formatter'
-require 'tantot/collector'
+require 'tantot/agent'
+require 'tantot/strategy'
+require 'tantot/manager'
 require 'tantot/observe'
 
 require 'tantot/extensions/chewy'
@@ -28,30 +26,16 @@ module Tantot
   class << self
     attr_writer :logger
 
-    def derive_watcher(name)
-      watcher =
-        if name.is_a?(Class)
-          name
-        else
-          class_name = "#{name.camelize}Watcher"
-          watcher = class_name.safe_constantize
-          raise Tantot::UnderivableWatcher, "Can not find watcher named `#{class_name}`" unless watcher
-          watcher
-        end
-      raise Tantot::UnderivableWatcher, "Watcher class does not include Tantot::Watcher: #{watcher}" unless watcher.included_modules.include?(Tantot::Watcher)
-      watcher
-    end
-
-    def collector
-      Thread.current[:tantot_collector] ||= Tantot::Collector::Manager.new
+    def manager
+      Thread.current[:tantot_manager] ||= Tantot::Manager.new
     end
 
     def config
       Tantot::Config.instance
     end
 
-    def registry
-      Tantot::Registry.instance
+    def agent_registry
+      Tantot::Agent::Registry.instance
     end
 
     def logger

data/lib/tantot/agent.rb

@@ -0,0 +1,19 @@
+require 'tantot/agent/base'
+require 'tantot/agent/block'
+require 'tantot/agent/watcher'
+require 'tantot/agent/registry'
+
+module Tantot
+  module Agent
+
+    AGENT_CLASSES = [Tantot::Agent::Block, Tantot::Agent::Watcher]
+
+    def self.resolve!(watch)
+      agent_classes = AGENT_CLASSES.collect {|klass| [klass, klass.identify(watch)]}.reject {|_klass, id| id.nil?}
+      raise UnresolvableAgent("Can't resolve agent for watch: #{watch.inspect}") unless agent_classes.any?
+      raise UnresolvableAgent("More than one agent manages watch: #{watch.inspect}") if agent_classes.many?
+      agent_classes.first
+    end
+
+  end
+end

data/lib/tantot/agent/base.rb

@@ -0,0 +1,71 @@
+module Tantot
+  module Agent
+    class Base
+      attr_reader :id, :watches, :stash
+
+      def self.identify(watch)
+        raise NotImplementedError
+      end
+
+      def initialize(id)
+        @id = id
+        @watches = []
+        @stash = Hash.new do |model_hash, model|
+          model_hash[model] = Hash.new do |instance_id_hash, instance_id|
+            instance_id_hash[instance_id] = Hash.new do |attribute_hash, attribute|
+              attribute_hash[attribute] = []
+            end
+          end
+        end
+      end
+
+      def options
+        @watches.first.options
+      end
+
+      def add_watch(watch)
+        watch.agent = self
+        setup_watch(watch)
+        @watches.push(watch)
+      end
+
+      def setup_watch(watch)
+        # nop
+      end
+
+      def push(watch, instance, changes_by_attribute)
+        Tantot.logger.debug do
+          mutate = changes_by_attribute.size.zero? ? 'destroy' : "#{changes_by_attribute.size} mutations(s)"
+          "[Tantot] [Collecting] [#{self.class.name.demodulize}] #{mutate} on <#{instance.class.name}:#{instance.id}> for <#{debug_id}>"
+        end
+        attribute_hash = @stash[watch.model][instance.id]
+        changes_by_attribute.each do |attr, changes|
+          attribute_hash[attr] |= changes
+        end
+        sweep if Tantot.config.sweep_on_push
+      end
+
+      def sweep(strategy_name = nil)
+        if @stash.any?
+          strategy = Tantot::Strategy.resolve(strategy_name || options[:strategy] || Tantot.config.strategy).new
+          Tantot.logger.debug { "[Tantot] [Strategy] [#{self.class.name.demodulize}] [#{strategy.class.name.demodulize}] [#{debug_id}] #{debug_stash}" }
+          strategy.run(self, @stash)
+          @stash.clear
+        end
+      end
+
+      def debug_id
+        raise NotImplementedError
+      end
+
+      def debug_stash
+        "#{@stash.collect {|model, changes_by_id| debug_changes_for_model(model, changes_by_id)}.join(" & ")})"
+      end
+
+      def debug_changes_for_model(model, changes_by_id)
+        "#{model.name}#{changes_by_id.keys.inspect}"
+      end
+
+    end
+  end
+end

data/lib/tantot/agent/block.rb

@@ -0,0 +1,32 @@
+module Tantot
+  module Agent
+    class Block < Base
+      def self.identify(watch)
+        if watch.block.present?
+          "#{watch.model.to_s}|#{watch.options.inspect}"
+        else
+          nil
+        end
+      end
+
+      def perform(changes_by_model)
+        # Block agent always has only one watch
+        block = watches.first.block
+        model = watches.first.model
+        # Skip the model part of the changes since it will always be on a
+        # single model, and wrap it in the ById helper.
+        model.instance_exec(Tantot::Changes::ById.new(changes_by_model.values.first), &block)
+      end
+
+      def debug_block(block)
+        location, line = block.source_location
+        short_path = defined?(Rails) ? Pathname.new(location).relative_path_from(Rails.root).to_s : location
+        "block @ #{short_path}##{line}"
+      end
+
+      def debug_id
+        debug_block(watches.first.block)
+      end
+    end
+  end
+end

data/lib/tantot/agent/registry.rb

@@ -0,0 +1,34 @@
+module Tantot
+  module Agent
+    class Registry
+      include Singleton
+
+      def initialize
+        @agents = {}
+      end
+
+      def register(watch)
+        agent_class, watch_id = Tantot::Agent.resolve!(watch)
+        agent = @agents.fetch(watch_id.to_s) do
+          agent_class.new(watch_id).tap {|new_agent| @agents[watch_id.to_s] = new_agent}
+        end
+        agent.add_watch(watch)
+        agent
+      end
+
+      def agent(agent_id)
+        @agents[agent_id.to_s]
+      end
+
+      def each_agent
+        @agents.values.each do |agent|
+          yield agent
+        end
+      end
+
+      def clear
+        @agents.clear
+      end
+    end
+  end
+end

data/lib/tantot/agent/watcher.rb

@@ -0,0 +1,46 @@
+require 'tantot/watcher'
+
+module Tantot
+  module Agent
+    class Watcher < Base
+      def self.identify(watch)
+        if watch.watcher.present?
+          derive_watcher(watch.watcher)
+        else
+          nil
+        end
+      end
+
+      def self.derive_watcher(name)
+        watcher =
+          if name.is_a?(Class)
+            name
+          else
+            class_name = "#{name.camelize}Watcher"
+            watcher = class_name.safe_constantize
+            raise Tantot::UnderivableWatcher, "Can not find watcher named `#{class_name}`" unless watcher
+            watcher
+          end
+        raise Tantot::UnderivableWatcher, "Watcher class does not include Tantot::Watcher: #{watcher}" unless watcher.included_modules.include?(Tantot::Watcher)
+        watcher
+      end
+
+      def watcher
+        # The id of the agent is the watcher class (see self#identify)
+        id
+      end
+
+      def setup_watch(watch)
+        watch.options.reverse_merge!(watcher.watcher_options)
+      end
+
+      def perform(changes_by_model)
+        watcher.new.perform(Tantot::Changes::ByModel.new(changes_by_model))
+      end
+
+      def debug_id
+        id.name
+      end
+    end
+  end
+end

data/lib/tantot/changes.rb

@@ -17,8 +17,7 @@ module Tantot
       end
 
       def for_attribute(attribute, compact = true)
-        changes = @changes_by_id.values.collect {|changes_by_attribute| changes_by_attribute[attribute.to_s]}.flatten.uniq
-        compact ? changes.compact : changes
+        @changes_by_id.values.collect {|changes_by_attribute| changes_by_attribute[attribute.to_s]}.flatten.uniq.tap {|changes| changes.compact! if compact}
       end
 
       def ids
@@ -39,7 +38,7 @@ module Tantot
         @changes_by_model = changes_by_model
       end
 
-      delegate :==, :keys, :count, :size, to: :changes_by_model
+      delegate :==, :keys, :values, :count, :size, to: :changes_by_model
       alias_method :models, :keys
 
       def ==(other)

data/lib/tantot/config.rb

@@ -2,10 +2,10 @@ module Tantot
   class Config
     include Singleton
 
-    attr_accessor :performer, :format, :use_after_commit_callbacks, :sweep_on_push, :sidekiq_queue
+    attr_accessor :strategy, :format, :use_after_commit_callbacks, :sweep_on_push, :sidekiq_queue
 
     def initialize
-      @performer = :inline
+      @strategy = :inline
       @format = :compact
       @use_after_commit_callbacks = true
       @sweep_on_push = false

data/lib/tantot/errors.rb

@@ -1,4 +1,10 @@
 module Tantot
   class UnderivableWatcher < StandardError
   end
+
+  class UnresolvableAgent < StandardError
+  end
+
+  class AgentNotFound < StandardError
+  end
 end

data/lib/tantot/extensions/chewy.rb

@@ -11,7 +11,27 @@ module Tantot
         # watch_index 'index#type', attribute, attribute, {method: [:self | :method | ignore and pass a block | ignore and don't pass a block, equivalent of :self]} [block]
         def watch_index(type_name, *args, &block)
           options = args.extract_options!
-          watch('tantot/extensions/chewy/chewy', *args)
+          watch_options = {}
+          watch_options[:only] = options[:only] if options[:only]
+
+          if options[:association]
+            reflection = self.reflect_on_association(options[:association])
+            raise ArgumentError.new("Association #{options[:association]} not found on #{self.class.name}") unless reflection
+            case reflection.macro
+            when :belongs_to
+              watch_options[:always] = reflection.foreign_key
+            when :has_one, :has_many
+              if reflection.options[:through]
+                if reflection.through_reflection.belongs_to?
+                  watch_options[:always] = reflection.through_reflection.foreign_key
+                end
+              end
+            else
+              raise NotImplementedError.new("Association of type #{reflection.macro} not yet supported")
+            end
+          end
+
+          watch('tantot/extensions/chewy/chewy', *args, watch_options)
           Tantot::Extensions::Chewy.register_watch(self, type_name, options, block)
         end
       end
@@ -26,7 +46,7 @@ module Tantot
       class ChewyWatcher
         include Tantot::Watcher
 
-        watcher_options performer: :chewy
+        watcher_options strategy: :chewy
 
         def perform(changes_by_model)
           changes_by_model.each do |model, changes_by_id|
@@ -46,25 +66,53 @@ module Tantot
 
               watch_args_array.each do |watch_args|
                 method = watch_args[:method]
-                options = watch_args[:options]
                 block = watch_args[:block]
+                options = watch_args[:options]
+                association = options[:association]
 
                 # Find ids to update
                 backreference =
-                  if (method && method.to_sym == :self) || (!method && !block)
-                    # Simply extract keys from changes
-                    changes_by_id.keys
-                  elsif method
-                    # We need to call `method`.
-                    # Try to find it on the class. If so, call it once with all changes.
-                    # There is no API to call per-instance since objects can be already destroyed
-                    # when using the sidekiq performer
-                    model.send(method, changes_by_id)
-                  elsif block
-                    # Since we can be post-destruction of the model, we can't load models here
-                    # Thus, the signature of the block callback is |changes| which are all
-                    # the changes to all the models
-                    model.instance_exec(changes_by_id, &block)
+                  if association
+                    reflection = model.reflect_on_association(association)
+                    reflection.check_validity!
+                    case reflection.macro
+                    when :belongs_to
+                      changes_by_id.for_attribute(reflection.foreign_key)
+                    when :has_one, :has_many
+                      if reflection.options[:through]
+                        through_query =
+                          case reflection.through_reflection.macro
+                          when :belongs_to
+                            reflection.through_reflection.klass.where(reflection.through_reflection.klass.primary_key => changes_by_id.for_attribute(reflection.through_reflection.foreign_key))
+                          when :has_many, :has_one
+                            reflection.through_reflection.klass.where(reflection.through_reflection.foreign_key => changes_by_id.ids)
+                          end
+                        case reflection.source_reflection.macro
+                        when :belongs_to
+                          through_query.pluck(reflection.source_reflection.foreign_key)
+                        when :has_many
+                          reflection.source_reflection.klass.where(reflection.source_reflection.foreign_key => (through_query.ids)).ids
+                        end
+                      else
+                        reflection.klass.where(reflection.foreign_key => changes_by_id.ids).ids
+                      end
+                    end
+                  else
+                    if (method && method.to_sym == :self) || (!method && !block)
+                      # Simply extract keys from changes
+                      changes_by_id.keys
+                    elsif method
+                      # We need to call `method`.
+                      # Try to find it on the class. If so, call it once with all changes.
+                      # There is no API to call per-instance since objects can be already destroyed
+                      # when using the sidekiq performer
+                      model.send(method, changes_by_id)
+                    elsif block
+                      # Since we can be post-destruction of the model, we can't load models here
+                      # Thus, the signature of the block callback is |changes| which are all
+                      # the changes to all the models
+                      model.instance_exec(changes_by_id, &block)
+                    end
                   end
 
                 if backreference
@@ -73,7 +121,7 @@ module Tantot
                   # Make sure there are any backreferences
                   if backreference.any?
                     Tantot.logger.debug { "[Tantot] [Chewy] [update_index] #{reference} (#{backreference.count} objects): #{backreference.inspect}" }
-                    ::Chewy.derive_type(reference).update_index(backreference, options)
+                    ::Chewy.derive_type(reference).update_index(backreference, {})
                   end
                 end
 

data/lib/tantot/extensions/grape/middleware.rb

@@ -5,7 +5,7 @@ if defined?(::Grape)
 
       class GrapeMiddleware < Grape::Middleware::Base
         def call!(env)
-          Tantot.collector.run do
+          Tantot.manager.run do
             @app_response = super(env)
           end
         end

data/lib/tantot/manager.rb

@@ -0,0 +1,31 @@
+module Tantot
+  class Manager
+    def run(&block)
+      yield
+    ensure
+      sweep
+    end
+
+    def sweep(strategy_name = nil)
+      Tantot.agent_registry.each_agent {|agent| agent.sweep(strategy_name)}
+    end
+
+    def perform(context, changes_by_model)
+      collector = resolve!(context)
+      Tantot.logger.debug { "[Tantot] [Run] [#{collector.class.name.demodulize}] #{collector.debug_perform(context, changes)}" }
+      collector.perform(context, changes_by_model)
+    end
+
+    def marshal(watch, changes)
+      collector.marshal(context, changes)
+    end
+
+    def unmarshal(context, changes)
+      context.deep_symbolize_keys!
+      collector_class = context[:collector_class].constantize
+      collector = @watches[collector_class] || @watches[collector_class] = collector_class.new
+      collector.unmarshal(context, changes)
+    end
+
+  end
+end