tantot 0.1.0

data/lib/tantot/formatter.rb

@@ -0,0 +1,10 @@
+require 'tantot/formatter/compact'
+require 'tantot/formatter/detailed'
+
+module Tantot
+  module Formatter
+    def self.resolve(name)
+      "Tantot::Formatter::#{name.to_s.camelize}".safe_constantize or raise "Can't find formatter class `#{name}`"
+    end
+  end
+end

data/lib/tantot/observe.rb

@@ -0,0 +1,84 @@
+require 'cityhash'
+
+module Tantot
+  module Observe
+    module Helpers
+      def condition_proc(context)
+        attributes = context[:attributes]
+        options = context[:options]
+        proc do
+          has_changes = attributes.any? ? (self.destroyed? || (self._watch_changes.keys & attributes).any?) : true
+          has_changes && (!options.key?(:if) || self.instance_exec(&options[:if]))
+        end
+      end
+
+      def update_proc(context)
+        proc do
+          attributes = context[:attributes]
+          watched_changes =
+            if attributes.any?
+              if self.destroyed?
+                attributes.each.with_object({}) {|attr, hash| hash[attr] = [self[attr]]}
+              else
+                self._watch_changes.slice(*attributes)
+              end
+            else
+              self._watch_changes
+            end
+
+          Tantot.collector.push(context, self, watched_changes)
+        end
+      end
+    end
+
+    extend Helpers
+
+    module ActiveRecordMethods
+      extend ActiveSupport::Concern
+
+      def _watch_changes
+        Tantot.config.use_after_commit_callbacks ? self.previous_changes : self.changes
+      end
+
+      class_methods do
+        # watch watcher, :attr, :attr, :attr, option: :value
+        # watch :attr, :attr, option: :value, &block
+        # watch watcher, option: :value
+        # watch option: :value, &block
+        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
+
+          attributes = args.collect(&:to_s)
+
+          context = {
+            model: self,
+            attributes: attributes,
+            options: options
+          }
+
+          context[:watcher] = watcher if watcher
+          context[:block_id] = CityHash.hash64(block.source_location.collect(&:to_s).join) if block_given?
+
+          Tantot.collector.register_watch(context, block)
+
+          callback_options = {
+            if: Observe.condition_proc(context)
+          }
+          update_proc = Observe.update_proc(context)
+
+          if Tantot.config.use_after_commit_callbacks
+            after_commit(callback_options, &update_proc)
+          else
+            after_save(callback_options, &update_proc)
+            after_destroy(callback_options, &update_proc)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tantot/performer/bypass.rb

@@ -0,0 +1,9 @@
+module Tantot
+  module Performer
+    class Bypass
+      def run(context, changes)
+        # nop
+      end
+    end
+  end
+end

data/lib/tantot/performer/inline.rb

@@ -0,0 +1,9 @@
+module Tantot
+  module Performer
+    class Inline
+      def run(context, changes)
+        Tantot.collector.perform(context, changes)
+      end
+    end
+  end
+end

data/lib/tantot/performer/sidekiq.rb

@@ -0,0 +1,19 @@
+module Tantot
+  module Performer
+    class Sidekiq
+      class Worker
+        include ::Sidekiq::Worker
+
+        def perform(context, changes)
+          context, changes = Tantot.collector.unmarshal(context, changes)
+          Tantot.collector.perform(context, changes)
+        end
+      end
+
+      def run(context, changes)
+        context, changes = Tantot.collector.marshal(context, changes)
+        Tantot::Performer::Sidekiq::Worker.perform_async(context, changes)
+      end
+    end
+  end
+end

data/lib/tantot/performer.rb

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

data/lib/tantot/railtie.rb

@@ -0,0 +1,23 @@
+module Tantot
+  class Railtie < Rails::Railtie
+    class RequestStrategy
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Tantot.collector.run { @app.call(env) }
+      end
+    end
+
+    console do |app|
+      # Will sweep after every push (unfortunately)
+      Tantot.config.console_mode = true
+    end
+
+    initializer 'tantot.request_strategy' do |app|
+      Tantot.logger.debug { "[Tantot] Installing Rails middleware" }
+      app.config.middleware.insert_after(Rails::Rack::Logger, RequestStrategy)
+    end
+  end
+end

data/lib/tantot/registry.rb

@@ -0,0 +1,11 @@
+module Tantot
+  class Registry
+    include Singleton
+
+    attr_reader :watch_config
+
+    def initialize
+      @watch_config = {}
+    end
+  end
+end

data/lib/tantot/version.rb

@@ -0,0 +1,3 @@
+module Tantot
+  VERSION = "0.1.0"
+end

data/lib/tantot/watcher.rb

@@ -0,0 +1,16 @@
+module Tantot
+  module Watcher
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :watcher_options_hash
+    end
+
+    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.merge(opts)
+      end
+    end
+  end
+end

data/lib/tantot.rb

@@ -0,0 +1,62 @@
+require 'tantot/version'
+
+require 'active_support'
+require 'active_support/core_ext'
+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/observe'
+
+require 'tantot/extensions/chewy'
+require 'tantot/extensions/grape/middleware'
+
+require 'tantot/railtie' if defined?(::Rails::Railtie)
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:include, Tantot::Observe::ActiveRecordMethods)
+  ActiveRecord::Base.send(:include, Tantot::Extensions::Chewy)
+end
+
+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
+    end
+
+    def config
+      Tantot::Config.instance
+    end
+
+    def registry
+      Tantot::Registry.instance
+    end
+
+    def logger
+      @logger || Rails.logger
+    end
+
+  end
+end

data/spec/changes_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe Tantot::Changes do
+
+  describe Tantot::Changes::ById do
+    let(:raw_changes) { {1 => {"id" => [nil, 1], "name" => [nil, "foo"]}, 2 => {"name" => ["foo", nil]}, 3 => {"id" => [3, nil], "name" => ["bar", "baz", nil]}} }
+    subject { described_class.new(raw_changes) }
+
+    it "should find ids" do
+      expect(subject.ids).to eq([1, 2, 3])
+    end
+
+    it "should find all values for an attribute, removing nil by default" do
+      expect(subject.for_attribute(:name)).to eq(["foo", "bar", "baz"])
+    end
+
+    it "should find all values for an attribute, including nil" do
+      expect(subject.for_attribute(:name, false)).to eq([nil, "foo", "bar", "baz"])
+    end
+
+    it "should find all changed attributes" do
+      expect(subject.attributes).to eq([:id, :name])
+    end
+
+    it "should correctly implement ==" do
+      expect(subject).to eq(described_class.new(raw_changes))
+    end
+
+    it "should implement Enumerable" do
+      expect(subject.collect {|id, changes| [id, changes]}).to eq(raw_changes.to_a)
+    end
+  end
+
+  describe Tantot::Changes::ByModel do
+    before do
+      stub_const('City', Class.new)
+      stub_const('Country', Class.new)
+    end
+    let(:city_changes) { {1 => {"id" => [nil, 1], "name" => [nil, "foo"]}, 2 => {"name" => ["foo", nil]}, 3 => {"id" => [3, nil], "name" => ["bar", "baz", nil]}} }
+    let(:country_changes) { {1 => {'id' => [nil, 1]}} }
+    let(:raw_changes) { {City => city_changes, Country => country_changes} }
+    subject { described_class.new(raw_changes) }
+
+    it "should find models" do
+      expect(subject.models).to eq([City, Country])
+    end
+
+    it "should implement []" do
+      expect(subject[City]).to eq(Tantot::Changes::ById.new(city_changes))
+    end
+
+    it "should implement Enumerable" do
+      expect(subject.collect {|model, changes| [model, changes]}).to eq([
+        [City, Tantot::Changes::ById.new(city_changes)],
+        [Country, Tantot::Changes::ById.new(country_changes)]
+      ])
+    end
+  end
+
+end

data/spec/extensions/chewy_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+describe Tantot::Extensions::Chewy do
+
+  # Stub the Chewy namespace
+  before do
+    stub_const("Chewy", {})
+  end
+
+  [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
+
+      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
+
+      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
+
+        def self.class_get_ids(changes)
+          self.yielded_changes = changes
+          [1, 2, 3]
+        end
+      end
+
+      city1 = city2 = nil
+
+      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)
+
+        # 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
+
+    stub_model(:city) do
+      watch_index 'foo'
+    end
+
+    city = City.create!
+    Tantot.collector.sweep(performer: :bypass)
+
+    Tantot.collector.run do
+      city.destroy
+
+      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
+
+  it "should allow registering an index watch on self (all attributes, destroy, block)" do
+    chewy_type = double
+
+    stub_model(:city) do
+      watch_index 'foo' do |changes|
+        changes.ids
+      end
+    end
+
+    city = City.create!
+    Tantot.collector.sweep(performer: :bypass)
+
+    Tantot.collector.run do
+      city.destroy
+
+      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
+
+  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.create!
+
+      expect(Chewy).not_to receive(:derive_type)
+    end
+  end
+end

data/spec/sidekiq_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+
+if defined?(::Sidekiq)
+  require 'sidekiq/testing'
+
+  describe Tantot::Performer::Sidekiq do
+    around do |example|
+      Tantot.config.performer = :sidekiq
+      example.run
+      Tantot.config.performer = :inline
+    end
+
+    describe Tantot::Collector::Watcher do
+
+      class SidekiqWatcher
+        include Tantot::Watcher
+
+        def perform(changes)
+        end
+      end
+
+      before do
+        Sidekiq::Worker.clear_all
+        stub_model(:city) do
+          watch SidekiqWatcher, :name
+        end
+      end
+
+      it "should call a sidekiq worker" do
+        Tantot.collector.run do
+          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']}}}])
+      end
+
+      it "should call the watcher" do
+        ::Sidekiq::Testing.inline! do
+          Tantot.collector.run do
+            city = City.create name: 'foo'
+            expect_any_instance_of(SidekiqWatcher).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
+          end
+        end
+      end
+
+      it "should skip sidekiq and process atomically when `sweep`ing, then resume using sidekiq" do
+        Sidekiq::Testing.fake! do
+          Tantot.collector.run do
+            # 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)
+            expect(Tantot::Performer::Sidekiq::Worker.jobs.size).to eq(0)
+
+            # Further modifications should trigger through sidekiq when exiting the strategy block
+            city.name = 'bar'
+            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']}}}])
+        end
+      end
+    end
+
+    describe Tantot::Collector::Block do
+      let(:value) { {changed: false} }
+      let(:changes) { {obj: nil} }
+
+      before do
+        Sidekiq::Worker.clear_all
+        v = value
+        c = changes
+        stub_model(:city) do
+          watch(:name) {|changes| v[:changed] = true; c[:obj] = changes}
+        end
+      end
+
+      it "should call a sidekiq worker" do
+        Tantot.collector.run do
+          City.create name: 'foo'
+        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']}}])
+      end
+
+      it "should call the watcher" do
+        ::Sidekiq::Testing.inline! do
+          city = nil
+          Tantot.collector.run do
+            city = City.create name: 'foo'
+          end
+          expect(value[:changed]).to be_truthy
+          expect(changes[:obj]).to eq(Tantot::Changes::ById.new({city.id => {"name" => [nil, 'foo']}}))
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'bundler'
+
+Bundler.require
+
+require 'active_record'
+require 'database_cleaner'
+
+Tantot.logger = Logger.new(STDOUT)
+
+def stub_class(name, superclass = nil, &block)
+  stub_const(name.to_s.camelize, Class.new(superclass || Object, &block))
+end
+
+def stub_model(name, superclass = nil, &block)
+  stub_class(name, superclass || ActiveRecord::Base, &block)
+end
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define do
+  create_table :countries do |t|
+    t.column :name, :string
+    t.column :country_code, :string
+    t.column :rating, :integer
+  end
+
+  create_table :cities do |t|
+    t.column :country_id, :integer
+    t.column :name, :string
+    t.column :rating, :integer
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.clean_with :transaction
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before do
+    DatabaseCleaner.start
+  end
+
+  config.after do
+    DatabaseCleaner.clean
+  end
+end