reactor 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7693ae6991c1cb79fa7257e131e844363db098fc
-  data.tar.gz: df0eac5e0c734cace8b3d37fa2be485f896ffc31
+  metadata.gz: 6bbad3c2e6c18e53fd80a1c434aa616b24fca5bf
+  data.tar.gz: 990dc1373ec901fecedebd5f8f9878901a85bc7f
 SHA512:
-  metadata.gz: 95f7c623e0569143793bc7ee1bd2870e5d71902ea794dd7f6aee6b0c95d67984f70b306ece0e1609f01f19ab0cb58b66f585dd557268a98e1c40d380b1113b36
-  data.tar.gz: 4bf1fe49637b5a72cdd5e774c42c2ba2e24b5567b6be195b0c11f5f9a0b36708ddd54f303a1e554250107f1bcd1ff700686888c66a0ac279da7cea6057530e3b
+  metadata.gz: 9047b728853f35fe0fce8020942d5359a8d52ab69232d39e2011628b73607f9b96c0b902f7c94bcc99e91fff8a77f1c734352a9ac9de35aa441885c5a2f6ee8b
+  data.tar.gz: b46fc1ffc3de6e48e82998ba0134d6532b3a0c91ee448b554eb75a04fc15f91a8950ac9911c91cbc14a689a5e9e497b369189fda01daa3c908efabe4183e3096

data/README.md

@@ -45,7 +45,29 @@ Reactor::Event.publish(:event_name, any: 'data', you: 'want')
 
 ```ruby
 publishes :my_model_created
-publishes :state_has_changed, if: -> { state_has_changed? }
+```
+
+  Schedule an event to get published at a specific time. Note: if timestamp is a property on an ActiveRecord::Model
+  then updating that property will re-schedule the firing of the event
+
+```ruby
+publishes :something_happened, at: :timestamp
+```
+
+  Schedule an event to get published at a specific time using a method to generate the timestamp and following some other property. In this case the :something_happened event will be fired 72 hours after your model is created. The event will be re-scheduled if created_at is changed.
+
+```ruby
+def reminder_email_time
+  created_at + 72.hours
+end
+
+publishes :reminder_sent, at: :reminder_email_time, watch: :created_at
+```
+
+  Scheduled events can check conditionally fire -- eg: in 2 days fire reminder_email if the user hasn't already responded.
+
+```ruby
+publishes :reminder_sent, at: :reminder_email_time, if: -> { user.responded == false }
 ```
 
 #### Subscribable

data/lib/reactor/event.rb

@@ -12,9 +12,28 @@ class Reactor::Event
   end
 
   def perform(name, data)
-    data.merge!(fired_at: Time.current, name: name)
-    fire_database_driven_subscribers(data, name)
-    fire_block_subscribers(data, name)
+    data = data.with_indifferent_access
+
+    if data['actor_type']
+      actor = data["actor_type"].constantize.find(data["actor_id"])
+      publishable_event = actor.class.events[name.to_sym]
+      ifarg = publishable_event[:if] if publishable_event
+    end
+
+    need_to_fire =  case ifarg
+                    when Proc
+                      actor.instance_exec(&ifarg)
+                    when Symbol
+                      actor.send(ifarg)
+                    when NilClass
+                      true
+                    end
+
+    if need_to_fire
+      data.merge!(fired_at: Time.current, name: name)
+      fire_database_driven_subscribers(data, name)
+      fire_block_subscribers(data, name)
+    end
   end
 
   def method_missing(method, *args)
@@ -37,10 +56,10 @@ class Reactor::Event
     def publish(name, data = {})
       message = new(data.merge(event: name))
 
-      if message.at.nil?
-        perform_async name, message.data
-      elsif message.at.future?
+      if message.at
         perform_at message.at, name, message.data
+      else
+        perform_async name, message.data
       end
     end
 
@@ -51,9 +70,10 @@ class Reactor::Event
         job['args'].first == name.to_s &&
         job.score.to_i == data[:was].to_i
       end
-      return if job.nil?
-      job.delete
-      publish(name, data.except(:was)) if data[:at].future?
+
+      job.delete if job
+
+      publish(name, data.except([:was, :if])) if data[:at].future?
     end
   end
 

data/lib/reactor/models/concerns/publishable.rb

@@ -3,15 +3,19 @@ module Reactor::Publishable
 
   included do
     after_commit :schedule_events, if: :persisted?, on: :create
-    after_commit :schedule_conditional_events_on_create, if: :persisted?, on: :create
-    after_commit :schedule_conditional_events_on_update, if: :persisted?, on: :update
-    after_commit :reschedule_events, if: :persisted?, on: :update
+    after_commit :reschedule_events_on_update, if: :persisted?, on: :update
   end
 
   def publish(name, data = {})
     Reactor::Event.publish(name, data.merge(actor: self) )
   end
 
+  def reschedule_events
+    self.class.events.each do |name, data|
+      reschedule(name, data)
+    end
+  end
+
   module ClassMethods
     def publishes(name, data = {})
       events[name] = data
@@ -24,41 +28,32 @@ module Reactor::Publishable
 
   private
 
-  def schedule_events
+  def reschedule_events_on_update
     self.class.events.each do |name, data|
-      event = event_data_for_signature(data)
-      Reactor::Event.publish name, event
+      attr_changed_method = data[:watch] || data[:at]
+      if previous_changes[attr_changed_method]
+        reschedule(name, data)
+      end
     end
   end
 
-  def reschedule_events
-    self.class.events.each do |name, data|
-      attr_changed_method = data[:watch] || data[:at]
-      if data[:at] && previous_changes[attr_changed_method]
-        Reactor::Event.reschedule name,
-          data.merge(
+  def reschedule(name, data)
+    if data[:at]
+      Reactor::Event.reschedule name,
+        data.merge(
             at: send(data[:at]),
             actor: ( data[:actor] ? send(data[:actor]) : self ),
             target: ( data[:target] ? self : nil),
             was: previous_changes[data[:at]].try(:first) || send("#{data[:at]}_was"))
-      end
     end
   end
 
-  def schedule_conditional_events
-    self.class.events.select { |k,v| v.has_key?(:if) }.each do |name, data|
+  def schedule_events
+    self.class.events.each do |name, data|
       event = event_data_for_signature(data)
-      need_to_fire = case (ifarg = data[:if])
-                       when Proc
-                         instance_exec(&ifarg)
-                       when Symbol
-                         send(ifarg)
-                     end
-      Reactor::Event.publish name, event if need_to_fire
+      Reactor::Event.publish name, event
     end
   end
-  alias :schedule_conditional_events_on_create :schedule_conditional_events
-  alias :schedule_conditional_events_on_update :schedule_conditional_events
 
   def event_data_for_signature(signature)
     signature.merge(
@@ -67,5 +62,4 @@ module Reactor::Publishable
         at: (signature[:at] ? send(signature[:at]) : nil)
     ).except(:watch, :if)
   end
-
 end

data/lib/reactor/testing/matchers.rb

@@ -4,11 +4,11 @@ RSpec::Matchers.define :publish_event do |name, data = {}|
   match do |block|
     defaults = {:actor => anything}
 
-    allow(Reactor::Event).to receive(:publish).with(name, a_hash_including(defaults.merge(data)))
+    allow(Reactor::Event).to receive(:publish)
 
     block.call
 
-    expect(Reactor::Event).to have_received(:publish).with(name, a_hash_including(defaults.merge(data)))
+    expect(Reactor::Event).to have_received(:publish).with(name, a_hash_including(defaults.merge(data))).at_least(:once)
   end
 end
 
@@ -18,14 +18,12 @@ RSpec::Matchers.define :publish_events do |*names|
   match do |block|
     defaults = {:actor => anything}
 
-    names.each do |name|
-      allow(Reactor::Event).to receive(:publish).with(name, a_hash_including(defaults))
-    end
+    allow(Reactor::Event).to receive(:publish)
 
     block.call
 
     names.each do |name|
-      expect(Reactor::Event).to have_received(:publish).with(name, a_hash_including(defaults))
+      expect(Reactor::Event).to have_received(:publish).with(name, a_hash_including(defaults)).at_least(:once)
     end
   end
 end

data/lib/reactor/version.rb

@@ -1,3 +1,3 @@
 module Reactor
-  VERSION = "0.8.3"
+  VERSION = "0.9.0"
 end

data/reactor.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "rspec-its"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "sqlite3"

data/spec/event_spec.rb

@@ -14,6 +14,7 @@ end
 
 describe Reactor::Event do
 
+  let(:model) { ArbitraryModel.create! }
   let(:event_name) { :user_did_this }
 
   describe 'publish' do
@@ -27,23 +28,23 @@ describe Reactor::Event do
     before { Reactor::Subscriber.create(event_name: :user_did_this) }
     after { Reactor::Subscriber.destroy_all }
     it 'fires all subscribers' do
-      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(actor_id: '1'))
-      Reactor::Event.perform(event_name, actor_id: '1')
+      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(actor_id: model.id.to_s))
+      Reactor::Event.perform(event_name, actor_id: model.id.to_s, actor_type: model.class.to_s)
     end
 
     it 'sets a fired_at key in event data' do
       expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(fired_at: anything))
-      Reactor::Event.perform(event_name, actor_id: '1')
+      Reactor::Event.perform(event_name, actor_id: model.id.to_s, actor_type: model.class.to_s)
     end
 
     it 'works with the legacy .process method, too' do
-      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(actor_id: '1'))
-      Reactor::Event.perform(event_name, actor_id: '1')
+      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(actor_id: model.id.to_s))
+      Reactor::Event.perform(event_name, actor_id: model.id.to_s, actor_type: model.class.to_s)
     end
 
     describe 'when subscriber throws exception', :sidekiq do
       let(:mock) { double(:thing, some_method: 3) }
-      let(:barfing_event) { Reactor::Event.perform('barfed', somethin: 'up') }
+      let(:barfing_event) { Reactor::Event.perform('barfed', somethin: 'up', actor_id: model.id.to_s, actor_type: model.class.to_s) }
 
       before do
         Reactor::SUBSCRIBERS['barfed'] ||= []
@@ -65,6 +66,10 @@ describe Reactor::Event do
     let(:scheduled) { Sidekiq::ScheduledSet.new }
     let(:time) { 1.hour.from_now }
 
+    before do
+      Sidekiq::Worker.clear_all
+    end
+
     it 'can schedule and reschedule an event in the future' do
       expect {
         jid = Reactor::Event.publish :turtle_time, at: time
@@ -76,6 +81,13 @@ describe Reactor::Event do
         expect(scheduled.find_job(jid).score).to eq((time + 2.hours).to_f)
       }.to_not change { scheduled.size }
     end
+
+    it 'will schedule an event in the future even if that event was not previously scheduled in the past' do
+      expect {
+        jid = Reactor::Event.reschedule :no_old_turtule_time, at: (time + 2.hours), was: time
+        expect(scheduled.find_job(jid).score).to eq((time + 2.hours).to_f)
+      }.to change{ scheduled.size }.by(1)
+    end
   end
 
   describe 'event content' do
@@ -89,25 +101,12 @@ describe Reactor::Event do
 
       describe 'getters' do
         context 'basic key value' do
-          describe '#random' do
-            subject { super().random }
-            it { is_expected.to eq('data') }
-          end
+          its(:random) { is_expected.to eq('data') }
         end
 
         context 'foreign key and foreign type' do
-          describe '#pet' do
-            subject { super().pet }
-            it { is_expected.to be_a MyModule::Cat }
-          end
-
-          describe '#pet' do
-            subject { super().pet }
-            describe '#id' do
-              subject { super().id }
-              it { is_expected.to eq(MyModule::Cat.last.id) }
-            end
-          end
+          its(:pet) { is_expected.to be_a MyModule::Cat }
+          its('pet.id') { is_expected.to eq(MyModule::Cat.last.id) }
         end
       end
 

data/spec/models/concerns/publishable_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
+require 'sidekiq/testing'
 
 class Auction < ActiveRecord::Base
-  attr_accessor :we_want_it
   belongs_to :pet
 
   def ring_timeout
@@ -15,7 +15,7 @@ class Auction < ActiveRecord::Base
   publishes :bell
   publishes :ring, at: :ring_timeout, watch: :start_at
   publishes :begin, at: :start_at, additional_info: 'curtis was here'
-  publishes :conditional_event_on_save, if: -> { we_want_it }
+  publishes :conditional_event_on_save, at: :start_at, if: -> { we_want_it }
   publishes :woof, actor: :pet, target: :self
 end
 
@@ -35,7 +35,7 @@ describe Reactor::Publishable do
 
   describe 'publish' do
     let(:pet) { Pet.create! }
-    let(:auction) { Auction.create!(pet: pet, start_at: DateTime.new(2012,12,21)) }
+    let(:auction) { Auction.create!(pet: pet, start_at: Time.current + 1.day, we_want_it: false) }
 
     it 'publishes an event with actor_id and actor_type set as self' do
       auction
@@ -52,8 +52,13 @@ describe Reactor::Publishable do
     it 'reschedules an event when the :at time changes' do
       start_at = auction.start_at
       new_start_at = start_at + 1.week
-      expect(Reactor::Event).to receive(:reschedule).with :ring, anything
-      expect(Reactor::Event).to receive(:reschedule).with(:begin,
+
+      allow(Reactor::Event).to receive(:reschedule)
+
+      auction.start_at = new_start_at
+      auction.save!
+
+      expect(Reactor::Event).to have_received(:reschedule).with(:begin,
         a_hash_including(
           at: new_start_at,
           actor: auction,
@@ -61,24 +66,58 @@ describe Reactor::Publishable do
           additional_info: 'curtis was here'
         )
       )
-      auction.start_at = new_start_at
-      auction.save!
     end
 
     it 'reschedules an event when the :watch field changes' do
       ring_time = auction.ring_timeout
       new_start_at = auction.start_at + 1.week
       new_ring_time = new_start_at + 30.seconds
-      expect(Reactor::Event).to receive(:reschedule).with :begin, anything
-      expect(Reactor::Event).to receive(:reschedule).with(:ring,
+
+      allow(Reactor::Event).to receive(:reschedule)
+
+      auction.start_at = new_start_at
+      auction.save!
+
+      expect(Reactor::Event).to have_received(:reschedule).with(:ring,
         a_hash_including(
           at: new_ring_time,
           actor: auction,
           was: ring_time
         )
       )
-      auction.start_at = new_start_at
-      auction.save!
+    end
+
+    context 'conditional firing' do
+      before do
+        Sidekiq::Testing.fake!
+        Sidekiq::Worker.clear_all
+        TestSubscriber.create! event_name: :conditional_event_on_save
+        auction
+        job = Reactor::Event.jobs.detect do |job|
+          job['class'] == 'Reactor::Event' && job['args'].first == 'conditional_event_on_save'
+        end
+        @job_args = job['args']
+      end
+
+      after do
+        Sidekiq::Testing.inline!
+      end
+
+      it 'calls the subscriber when if is set to true' do
+        auction.we_want_it = true
+        auction.start_at = 3.day.from_now
+        auction.save!
+
+        expect{ Reactor::Event.perform(@job_args[0], @job_args[1]) }.to change{ Sidekiq::Extensions::DelayedClass.jobs.size }
+      end
+
+      it 'does not call the subscriber when if is set to false' do
+        auction.we_want_it = false
+        auction.start_at = 3.days.from_now
+        auction.save!
+
+        expect{ Reactor::Event.perform(@job_args[0], @job_args[1]) }.to_not change{ Sidekiq::Extensions::DelayedClass.jobs.size }
+      end
     end
 
     it 'supports immediate events (on create) that get fired once' do
@@ -91,30 +130,11 @@ describe Reactor::Publishable do
       expect(TestSubscriber.class_variable_get(:@@called)).to be_falsey
     end
 
-    it 'does not publish an event scheduled for the past' do
-      TestSubscriber.create! event_name: :begin
-      auction
-      expect(TestSubscriber.class_variable_get(:@@called)).to be_falsey
-    end
-
     it 'does publish an event scheduled for the future' do
       TestSubscriber.create! event_name: :begin
       Auction.create!(pet: pet, start_at: Time.current + 1.week)
 
       expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
     end
-
-    it 'can fire events onsave for any condition' do
-      TestSubscriber.create! event_name: :conditional_event_on_save
-      auction
-      TestSubscriber.class_variable_set(:@@called, false)
-      auction.start_at = 1.day.from_now
-      auction.save
-      expect(TestSubscriber.class_variable_get(:@@called)).to be_falsey
-      auction.start_at = 2.days.from_now
-      auction.we_want_it = true
-      auction.save
-      expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
-    end
   end
 end

data/spec/models/subscriber_spec.rb

@@ -13,18 +13,8 @@ describe Reactor::Subscriber do
   describe 'fire' do
     subject { MySubscriber.create(event_name: :you_name_it).fire some: 'random', event: 'data' }
 
-    describe '#event' do
-      subject { super().event }
-      it { is_expected.to be_a Reactor::Event }
-    end
-
-    describe '#event' do
-      subject { super().event }
-      describe '#some' do
-        subject { super().some }
-        it { is_expected.to eq('random') }
-      end
-    end
+    its(:event) { is_expected.to be_a Reactor::Event }
+    its('event.some') { is_expected.to eq('random') }
 
     it 'executes block given' do
       expect(subject.was_called).to be_truthy

data/spec/spec_helper.rb

@@ -9,6 +9,8 @@ require 'sidekiq/api'
 require 'reactor'
 require 'reactor/testing/matchers'
 
+require 'rspec/its'
+
 Sidekiq.configure_server do |config|
   config.redis = { url: ENV["REDISTOGO_URL"] }
 

data/spec/support/active_record.rb

@@ -8,6 +8,7 @@ ActiveRecord::Migration.create_table :auctions do |t|
   t.string :name
   t.datetime :start_at
   t.datetime :close_at
+  t.boolean :we_want_it
   t.integer :pet_id
 
   t.timestamps

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reactor
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.9.0
 platform: ruby
 authors:
 - winfred
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-13 00:00:00.000000000 Z
+date: 2014-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -83,6 +83,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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: pry
   requirement: !ruby/object:Gem::Requirement