reactor 0.13.0 → 0.14.0

data/lib/reactor/subscription.rb

@@ -0,0 +1,100 @@
+module Reactor
+  class Subscription
+
+    attr_reader :source, :event_name, :action, :handler_name, :delay, :async, :worker_class
+
+    def self.build_handler_name(event_name, handler_name_option = nil)
+      if handler_name_option
+        handler_name_option.to_s.camelize
+      elsif event_name == '*'
+        'WildcardHandler'
+      else
+        "#{event_name.to_s.camelize}Handler"
+      end
+    end
+
+    def initialize(options = {}, &block)
+      @source = options[:source]
+      @handler_name = self.class.build_handler_name(
+        options[:event_name], options[:handler_name]
+      )
+
+      @event_name = options[:event_name]
+      @action = options[:action] || block
+
+      @delay = options[:delay].to_i
+      @async = determine_async(options)
+      build_worker_class
+    end
+
+    def handler_defined?
+      namespace.const_defined?(handler_name) &&
+        namespace.const_get(handler_name).ancestors.include?(Reactor.subscriber_namespace)
+    end
+
+    def event_handler_names
+      @event_handler_names ||= []
+    end
+
+    def namespace
+      return @namespace if @namespace
+
+      ns = source.name.demodulize
+      unless Reactor.subscriber_namespace.const_defined?(ns, false)
+        Reactor.subscriber_namespace.const_set(ns, Module.new)
+      end
+
+      @namespace = Reactor.subscriber_namespace.const_get(ns, false)
+    end
+
+    def mailer_subscriber?
+      !!(source < ActionMailer::Base)
+    end
+
+    private
+
+    # options[:in_memory] is a legacy way of setting async to false -
+    # see Reactor::Workers::EventWorker#perform_where_needed
+    def determine_async(options = {})
+      if options[:async].nil?
+        if options[:in_memory].nil?
+          true
+        else
+          !options[:in_memory]
+        end
+      else
+        !!options[:async]
+      end
+    end
+
+    def build_worker_class
+      return @worker_class = namespace.const_get(handler_name) if handler_defined?
+
+
+      worker_class = mailer_subscriber? ? build_mailer_worker : build_event_worker
+      namespace.const_set(handler_name, worker_class)
+      @worker_class = namespace.const_get(handler_name)
+    end
+
+    def build_event_worker
+      subscription = self
+      Class.new(Reactor::Workers::EventWorker) do
+        self.source = subscription.source
+        self.action = subscription.action
+        self.async  = subscription.async
+        self.delay  = subscription.delay
+      end
+    end
+
+    def build_mailer_worker
+      subscription = self
+      Class.new(Reactor::Workers::MailerWorker) do
+        self.source = subscription.source
+        self.action = subscription.action
+        self.delay  = subscription.delay
+        self.async  = subscription.async
+      end
+    end
+
+  end
+end

data/lib/reactor/testing.rb

@@ -0,0 +1,50 @@
+module Reactor
+  TEST_MODE_SUBSCRIBERS = Set.new
+  @@test_mode = false
+
+  module_function
+
+  def test_mode?
+    @@test_mode
+  end
+
+  def test_mode!
+    @@test_mode = true
+  end
+
+  def disable_test_mode!
+    @@test_mode = false
+  end
+
+  def in_test_mode
+    test_mode!
+    (yield if block_given?).tap { disable_test_mode! }
+  end
+
+  def test_mode_subscribers
+    TEST_MODE_SUBSCRIBERS
+  end
+
+  def enable_test_mode_subscriber(klass)
+    test_mode_subscribers << klass
+  end
+
+  def disable_test_mode_subscriber(klass)
+    test_mode_subscribers.delete klass
+  end
+
+  def with_subscriber_enabled(klass)
+    enable_test_mode_subscriber klass
+    yield if block_given?
+  ensure
+    disable_test_mode_subscriber klass
+  end
+
+  def clear_test_subscribers!
+    test_mode_subscribers.each {|klass| test_mode_subscribers.delete klass }
+  end
+
+  def test_mode_subscriber_enabled?(subscriber)
+    test_mode_subscribers.include?(subscriber)
+  end
+end

data/lib/reactor/version.rb

@@ -1,3 +1,3 @@
 module Reactor
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/lib/reactor/workers/database_subscriber_worker.rb

@@ -0,0 +1,22 @@
+module Reactor
+  module Workers
+    class DatabaseSubscriberWorker
+
+      include Sidekiq::Worker
+
+      def perform(model_id, data)
+        return :__perform_aborted__ unless should_perform?
+        Reactor::Subscriber.fire(model_id, data)
+      end
+
+      def should_perform?
+        if Reactor.test_mode?
+          Reactor.test_mode_subscriber_enabled? Reactor::Subscriber
+        else
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/reactor/workers/event_worker.rb

@@ -0,0 +1,65 @@
+=begin
+EventWorker is an abstract worker for handling events defined by on_event.
+You can create handlers by subclassing and redefining the configuration class
+methods, or by using Reactor::Workers::EventWorker.dup and overriding the
+methods on the new class.
+=end
+module Reactor
+  module Workers
+    class EventWorker
+
+      include Sidekiq::Worker
+
+      CONFIG = [:source, :action, :async, :delay]
+
+      class_attribute *CONFIG
+
+      def self.configured?
+        CONFIG.all? {|field| !self.send(field).nil? }
+      end
+
+      def self.perform_where_needed(data)
+        if delay > 0
+          perform_in(delay, data)
+        elsif async
+          perform_async(data)
+        else
+          new.perform(data)
+        end
+        source
+      end
+
+      def configured?
+        self.class.configured?
+      end
+
+      def perform(data)
+        raise_unconfigured! unless configured?
+        return :__perform_aborted__ unless should_perform?
+        event = Reactor::Event.new(data)
+        if action.is_a?(Symbol)
+          source.send(action, event)
+        else
+          action.call(event)
+        end
+      end
+
+      def should_perform?
+        if Reactor.test_mode?
+          Reactor.test_mode_subscriber_enabled? source
+        else
+          true
+        end
+      end
+
+      private
+
+      def raise_unconfigured!
+        settings = Hash[CONFIG.map {|s| [s, self.class.send(s)] }]
+        raise UnconfiguredWorkerError.new(
+          "#{self.class.name} is not properly configured! Here are the settings: #{settings}"
+        )
+      end
+    end
+  end
+end

data/lib/reactor/workers/mailer_worker.rb

@@ -0,0 +1,80 @@
+=begin
+MailerWorker has a bit more to do than EventWorker. It has to run the event, then if the
+output is a Mail::Message or the like it needs to deliver it like ActionMailer would
+=end
+module Reactor
+  module Workers
+    class MailerWorker
+
+      include Sidekiq::Worker
+
+      CONFIG = [:source, :action, :async, :delay]
+
+      class_attribute *CONFIG
+
+      def self.configured?
+        CONFIG.all? {|field| field.present? }
+      end
+
+      def self.perform_where_needed(data)
+        if delay > 0
+          perform_in(delay, data)
+        elsif async
+          perform_async(data)
+        else
+          new.perform(data)
+        end
+        source
+      end
+
+      def configured?
+        self.class.configured?
+      end
+
+      def perform(data)
+        raise_unconfigured! unless configured?
+        return :__perform_aborted__ unless should_perform?
+        event = Reactor::Event.new(data)
+
+        msg = if action.is_a?(Symbol)
+          source.send(action, event)
+        else
+          source.class_exec event, &action
+        end
+
+        deliverable?(msg) ? deliver(msg) : msg
+      end
+
+      def deliver(msg)
+        if msg.respond_to?(:deliver_now)
+          # Rails 4.2/5.0
+          msg.deliver_now
+        else
+          # Rails 3.2/4.0/4.1 + Generic Mail::Message
+          msg.deliver
+        end
+      end
+
+      def deliverable?(msg)
+        msg.respond_to?(:deliver_now) || msg.respond_to?(:deliver)
+      end
+
+      def should_perform?
+        if Reactor.test_mode?
+          Reactor.test_mode_subscriber_enabled? source
+        else
+          true
+        end
+      end
+
+      private
+
+      def raise_unconfigured!
+        settings = Hash[CONFIG.map {|s| [s, self.class.send(s)] }]
+        raise UnconfiguredWorkerError.new(
+          "#{self.class.name} is not properly configured! Here are the settings: #{settings}"
+        )
+      end
+    end
+  end
+end

data/lib/reactor/workers.rb

@@ -0,0 +1,8 @@
+module Reactor
+  module Workers
+  end
+end
+
+require "reactor/workers/event_worker"
+require "reactor/workers/mailer_worker"
+require "reactor/workers/database_subscriber_worker"

data/lib/reactor.rb

@@ -1,49 +1,39 @@
+require "active_record"
+require "active_support/hash_with_indifferent_access"
+require "action_mailer"
+
 require "reactor/version"
-require "reactor/models/concerns/publishable"
-require "reactor/models/concerns/subscribable"
-require "reactor/models/concerns/optionally_subclassable"
-require "reactor/models/subscriber"
-require "reactor/controllers/concerns/resource_actionable"
+require "reactor/errors"
+require "reactor/static_subscribers"
+require "reactor/workers"
+require "reactor/subscription"
+require "reactor/models"
+require "reactor/controllers"
 require "reactor/event"
 
-module Reactor
-  SUBSCRIBERS = {}
-  TEST_MODE_SUBSCRIBERS = Set.new
-  @@test_mode = false
+# FIXME: should only be included in test environments
+require "reactor/testing"
 
-  module StaticSubscribers
-  end
-
-  def self.test_mode?
-    @@test_mode
-  end
-
-  def self.test_mode!
-    @@test_mode = true
-  end
+module Reactor
+  SUBSCRIBERS = {}.with_indifferent_access
 
-  def self.disable_test_mode!
-    @@test_mode = false
-  end
+  module_function
 
-  def self.in_test_mode
-    test_mode!
-    (yield if block_given?).tap { disable_test_mode! }
+  def subscribers
+    SUBSCRIBERS
   end
 
-  def self.enable_test_mode_subscriber(klass)
-    TEST_MODE_SUBSCRIBERS << klass
+  def add_subscriber(event_name, worker_class)
+    subscribers[event_name] ||= []
+    subscribers[event_name] << worker_class
   end
 
-  def self.disable_test_mode_subscriber(klass)
-    TEST_MODE_SUBSCRIBERS.delete klass
+  def subscribers_for(event_name)
+    Array(subscribers[event_name]) + Array(subscribers['*'])
   end
 
-  def self.with_subscriber_enabled(klass)
-    enable_test_mode_subscriber klass
-    yield if block_given?
-  ensure
-    disable_test_mode_subscriber klass
+  def subscriber_namespace
+    Reactor::StaticSubscribers
   end
 end
 

data/reactor.gemspec

@@ -19,7 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "sidekiq"
-  spec.add_dependency 'activerecord', '~> 5.0.1'
+
+  rails_version = '~> 5.0.2'
+
+  spec.add_dependency 'rails',  rails_version
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
@@ -29,4 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "test_after_commit"
+  spec.add_development_dependency "simplecov"
 end

data/spec/event_spec.rb

@@ -63,8 +63,16 @@ describe Reactor::Event do
   end
 
   describe 'perform' do
-    before { Reactor::Subscriber.create(event_name: :user_did_this) }
-    after { Reactor::Subscriber.destroy_all }
+    before do
+      Reactor::Subscriber.create(event_name: :user_did_this)
+      Reactor.enable_test_mode_subscriber(Reactor::Subscriber)
+    end
+
+    after do
+      Reactor::Subscriber.destroy_all
+      Reactor.enable_test_mode_subscriber(Reactor::Subscriber)
+    end
+
     it 'fires all subscribers' do
       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)

data/spec/models/concerns/publishable_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'sidekiq/testing'
 
-class Auction < ActiveRecord::Base
+class Publisher < ActiveRecord::Base
   belongs_to :pet
 
   def ring_timeout
@@ -35,33 +35,33 @@ describe Reactor::Publishable do
 
   describe 'publish' do
     let(:pet) { Pet.create! }
-    let(:auction) { Auction.create!(pet: pet, start_at: Time.current + 1.day, we_want_it: false) }
+    let(:publisher) { Publisher.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
-      expect(Reactor::Event).to receive(:publish).with(:an_event, what: 'the', actor: auction)
-      auction.publish(:an_event, {what: 'the'})
+      publisher
+      expect(Reactor::Event).to receive(:publish).with(:an_event, what: 'the', actor: publisher)
+      publisher.publish(:an_event, {what: 'the'})
     end
 
     it 'publishes an event with provided actor and target methods' do
       allow(Reactor::Event).to receive(:publish).exactly(5).times
-      auction
-      expect(Reactor::Event).to have_received(:publish).with(:woof, a_hash_including(actor: pet, target: auction))
+      publisher
+      expect(Reactor::Event).to have_received(:publish).with(:woof, a_hash_including(actor: pet, target: publisher))
     end
 
     it 'reschedules an event when the :at time changes' do
-      start_at = auction.start_at
+      start_at = publisher.start_at
       new_start_at = start_at + 1.week
 
       allow(Reactor::Event).to receive(:reschedule)
 
-      auction.start_at = new_start_at
-      auction.save!
+      publisher.start_at = new_start_at
+      publisher.save!
 
       expect(Reactor::Event).to have_received(:reschedule).with(:begin,
         a_hash_including(
           at: new_start_at,
-          actor: auction,
+          actor: publisher,
           was: start_at,
           additional_info: 'curtis was here'
         )
@@ -69,19 +69,19 @@ describe Reactor::Publishable do
     end
 
     it 'reschedules an event when the :watch field changes' do
-      ring_time = auction.ring_timeout
-      new_start_at = auction.start_at + 1.week
+      ring_time = publisher.ring_timeout
+      new_start_at = publisher.start_at + 1.week
       new_ring_time = new_start_at + 30.seconds
 
       allow(Reactor::Event).to receive(:reschedule)
 
-      auction.start_at = new_start_at
-      auction.save!
+      publisher.start_at = new_start_at
+      publisher.save!
 
       expect(Reactor::Event).to have_received(:reschedule).with(:ring,
         a_hash_including(
           at: new_ring_time,
-          actor: auction,
+          actor: publisher,
           was: ring_time
         )
       )
@@ -92,7 +92,7 @@ describe Reactor::Publishable do
         Sidekiq::Testing.fake!
         Sidekiq::Worker.clear_all
         TestSubscriber.create! event_name: :conditional_event_on_save
-        auction
+        publisher
         job = Reactor::Event.jobs.detect do |job|
           job['class'] == 'Reactor::Event' && job['args'].first == 'conditional_event_on_save'
         end
@@ -104,33 +104,35 @@ describe Reactor::Publishable do
       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!
+        publisher.we_want_it = true
+        publisher.start_at = 3.day.from_now
+        allow(Reactor::Event).to receive(:perform_at)
+        publisher.save!
+        expect(Reactor::Event).to have_received(:perform_at).with(publisher.start_at, :conditional_event_on_save, anything())
 
-        expect{ Reactor::Event.perform(@job_args[0], @job_args[1]) }.to change{ Sidekiq::Extensions::DelayedClass.jobs.size }
+        Reactor::Event.perform(@job_args[0], @job_args[1])
       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!
+        publisher.we_want_it = false
+        publisher.start_at = 3.days.from_now
+        publisher.save!
 
         expect{ Reactor::Event.perform(@job_args[0], @job_args[1]) }.to_not change{ Sidekiq::Extensions::DelayedClass.jobs.size }
       end
 
       it 'keeps the if intact when rescheduling' do
-        old_start_at = auction.start_at
-        auction.start_at = 3.day.from_now
+        old_start_at = publisher.start_at
+        publisher.start_at = 3.day.from_now
         allow(Reactor::Event).to receive(:publish)
         expect(Reactor::Event).to receive(:publish).with(:conditional_event_on_save, {
-          at: auction.start_at,
-          actor: auction,
+          at: publisher.start_at,
+          actor: publisher,
           target: nil,
           was: old_start_at,
           if: anything
         })
-        auction.save!
+        publisher.save!
       end
 
       it 'keeps the if intact when scheduling' do
@@ -142,25 +144,32 @@ describe Reactor::Publishable do
           target: nil,
           if: anything
         })
-        Auction.create!(start_at: start_at)
+        Publisher.create!(start_at: start_at)
       end
     end
 
     it 'supports immediate events (on create) that get fired once' do
-      TestSubscriber.create! event_name: :bell
-      auction
-      expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
-      TestSubscriber.class_variable_set(:@@called, false)
-      auction.start_at = 1.day.from_now
-      auction.save
-      expect(TestSubscriber.class_variable_get(:@@called)).to be_falsey
+      Reactor.with_subscriber_enabled(Reactor::Subscriber) do
+        TestSubscriber.create! event_name: :bell
+        publisher
+        expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
+        TestSubscriber.class_variable_set(:@@called, false)
+        publisher.start_at = 1.day.from_now
+        publisher.save
+        expect(TestSubscriber.class_variable_get(:@@called)).to be_falsey
+      end
     end
 
     it 'does publish an event scheduled for the future' do
+      Reactor.enable_test_mode_subscriber Reactor::Subscriber
+      Reactor.enable_test_mode_subscriber Publisher
       TestSubscriber.create! event_name: :begin
-      Auction.create!(pet: pet, start_at: Time.current + 1.week)
+      Publisher.create!(pet: pet, start_at: Time.current + 1.week)
 
       expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
+
+      Reactor.disable_test_mode_subscriber Reactor::Subscriber
+      Reactor.disable_test_mode_subscriber Publisher
     end
   end
 end