tantot 0.1.0

data/spec/tantot_spec.rb

@@ -0,0 +1,299 @@
+require "spec_helper"
+
+describe Tantot do
+  it "has a version number" do
+    expect(Tantot::VERSION).not_to be nil
+  end
+
+  describe '.derive_watcher' do
+    class TestWatcher
+      include Tantot::Watcher
+    end
+
+    class WrongWatcher
+    end
+
+    module Foo
+      class BarWatcher
+        include Tantot::Watcher
+      end
+    end
+
+    specify { expect { described_class.derive_watcher('foo') }.to raise_error(Tantot::UnderivableWatcher) }
+    specify { expect { described_class.derive_watcher(WrongWatcher) }.to raise_error(Tantot::UnderivableWatcher) }
+    specify { expect(described_class.derive_watcher(TestWatcher)).to eq(TestWatcher) }
+    specify { expect(described_class.derive_watcher(Foo::BarWatcher)).to eq(Foo::BarWatcher) }
+    specify { expect(described_class.derive_watcher('test')).to eq(TestWatcher) }
+    specify { expect(described_class.derive_watcher('foo/bar')).to eq(Foo::BarWatcher) }
+  end
+
+  describe '.watch' do
+
+    let(:watcher_instance) { double }
+
+    before do
+      stub_class("TestWatcher") { include Tantot::Watcher }
+      allow(TestWatcher).to receive(:new).and_return(watcher_instance)
+    end
+
+    [true, false].each do |use_after_commit_callbacks|
+      context "using after_commit hooks: #{use_after_commit_callbacks}" do
+        before { allow(Tantot.config).to receive(:use_after_commit_callbacks).and_return(use_after_commit_callbacks) }
+
+        context "watching an attribute" do
+          before do
+            stub_model(:city) do
+              watch TestWatcher, :name
+            end
+          end
+
+          it "doesn't call back when the attribute doesn't change" do
+            Tantot.collector.run do
+              City.create
+              expect(watcher_instance).not_to receive(:perform)
+            end
+          end
+
+          it "calls back when the attribute changes (on creation)" 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']}}}))
+            end
+          end
+
+          it "calls back on model update" do
+            city = City.create!
+            city.reload
+            Tantot.collector.sweep(performer: :bypass)
+
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo']}}}))
+            Tantot.collector.run do
+              city.name = "foo"
+              city.save
+            end
+          end
+
+          it "calls back on model destroy" do
+            city = City.create!(name: 'foo')
+            city.reload
+            Tantot.collector.sweep(performer: :bypass)
+
+            expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo']}}}))
+            Tantot.collector.run do
+              city.destroy
+            end
+          end
+
+          it "calls back once per model even when updated more than once" do
+            Tantot.collector.run do
+              city = City.create! name: 'foo'
+              city.name = 'bar'
+              city.save
+              city.name = 'baz'
+              city.save
+              expect(watcher_instance).to receive(:perform).once.with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [nil, 'foo', 'bar', 'baz']}}}))
+            end
+          end
+
+          it "allows to call a watcher mid-stream" 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)
+              city.name = 'bar'
+              city.save
+              expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => ['foo', 'bar']}}}))
+            end
+          end
+        end
+      end
+    end
+
+    context "detailed format" do
+      let(:watcher_instance) { double }
+      before do
+        stub_class("DetailedTestWatcher") do
+          include Tantot::Watcher
+
+          watcher_options format: :detailed
+        end
+        allow(DetailedTestWatcher).to receive(:new).and_return(watcher_instance)
+        stub_model(:city) do
+          watch 'detailed_test', :name
+        end
+      end
+
+      it "should output a detailed array of changes" do
+        Tantot.collector.run do
+          city = City.create! name: 'foo'
+          city.name = 'bar'
+          city.save
+          expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {"name" => [[nil, 'foo'], ['foo', 'bar']]}}}))
+        end
+      end
+    end
+
+    context "on multiple models" do
+      before do
+        stub_model(:city) do
+          watch TestWatcher, :name, :country_id
+        end
+        stub_model(:country) do
+          watch TestWatcher, :country_code
+        end
+      end
+
+      it "calls back once per watch when multiple watched models change" do
+        country = Country.create!(country_code: "CDN")
+        city = City.create!(name: "Quebec", country_id: country.id)
+        country.reload
+        city.reload
+        Tantot.collector.sweep(performer: :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
+          city.name = "foo"
+          city.save
+          city.name = "bar"
+          city.save
+          city.country_id = nil
+          city.save
+          country.country_code = 'US'
+          country.save
+          city.destroy
+        end
+      end
+    end
+
+    context "with multiple watchers" do
+      let(:watchA_instance) { double }
+      let(:watchB_instance) { double }
+      before do
+        stub_class("TestWatcherA") { include Tantot::Watcher }
+        stub_class("TestWatcherB") { include Tantot::Watcher }
+        allow(TestWatcherA).to receive(:new).and_return(watchA_instance)
+        allow(TestWatcherB).to receive(:new).and_return(watchB_instance)
+        stub_model(:city) do
+          watch TestWatcherA, :name, :country_id
+          watch TestWatcherB, :rating
+        end
+        stub_model(:country) do
+          watch TestWatcherA, :country_code
+          watch TestWatcherB, :name, :rating
+        end
+      end
+
+      it "calls each watcher once for multiple models" do
+        country = Country.create!(country_code: "CDN")
+        city = City.create!(name: "Quebec", country_id: country.id, rating: 12)
+        country.reload
+        city.reload
+        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.run do
+          city.name = "foo"
+          city.save
+          city.name = "bar"
+          city.save
+          city.country_id = nil
+          city.save
+          country.country_code = 'US'
+          country.save
+          city.destroy
+        end
+      end
+    end
+
+    context 'watching all attributes' do
+      before do
+        stub_model(:city) do
+          watch TestWatcher
+        end
+      end
+
+      it "should watch all changes" do
+        Tantot.collector.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"]}}}))
+        end
+      end
+
+      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)
+
+        expect(watcher_instance).to receive(:perform).with(Tantot::Changes::ByModel.new({City => {city.id => {}}}))
+        Tantot.collector.run do
+          city.destroy
+        end
+      end
+    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]
+            watch_params << :id if attribute_opt == :some
+            watch_params << {if: -> { c.passed? }}
+            stub_model(:city) do
+              watch(*watch_params)
+            end
+          end
+
+          it "should fail if the condition is false" do
+            Tantot.collector.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.collector.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 '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.collector.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.collector.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 # describe '.watch'
+end

data/tantot.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tantot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tantot"
+  spec.version       = Tantot::VERSION
+  spec.authors       = ["François-Pierre Bouchard"]
+  spec.email         = ["fpbouchard@gmail.com"]
+
+  spec.summary       = %q{Delayed, grouped and compact ActiveRecord callbacks}
+  spec.description   = %q{Centralize and delay changes to multiple ActiveRecord models to offload processing of complex calculations caused by model mutations.}
+  spec.homepage      = "https://github.com/petalmd/tantot"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($RS)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'database_cleaner'
+
+  spec.add_dependency 'activesupport', '>= 3.2'
+  spec.add_dependency 'activerecord', '>= 3.2'
+  spec.add_dependency 'cityhash', '>= 0.8'
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: tantot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- François-Pierre Bouchard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: cityhash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Centralize and delay changes to multiple ActiveRecord models to offload
+  processing of complex calculations caused by model mutations.
+email:
+- fpbouchard@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- 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
+- lib/tantot/errors.rb
+- lib/tantot/extensions/chewy.rb
+- lib/tantot/extensions/grape/middleware.rb
+- lib/tantot/formatter.rb
+- lib/tantot/formatter/compact.rb
+- lib/tantot/formatter/detailed.rb
+- lib/tantot/observe.rb
+- lib/tantot/performer.rb
+- lib/tantot/performer/bypass.rb
+- lib/tantot/performer/inline.rb
+- lib/tantot/performer/sidekiq.rb
+- lib/tantot/railtie.rb
+- lib/tantot/registry.rb
+- lib/tantot/version.rb
+- lib/tantot/watcher.rb
+- spec/changes_spec.rb
+- spec/extensions/chewy_spec.rb
+- spec/sidekiq_spec.rb
+- spec/spec_helper.rb
+- spec/tantot_spec.rb
+- tantot.gemspec
+homepage: https://github.com/petalmd/tantot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Delayed, grouped and compact ActiveRecord callbacks
+test_files:
+- spec/changes_spec.rb
+- spec/extensions/chewy_spec.rb
+- spec/sidekiq_spec.rb
+- spec/spec_helper.rb
+- spec/tantot_spec.rb