reactor 0.19.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fb837714e773b0e547099b05ed322b059310f23
-  data.tar.gz: 928b14c3d60d9cae2a318d2fb36fa84e2e6384da
+  metadata.gz: 8bbbeb29447a373e5c2d652170a9d9f57d2251b7
+  data.tar.gz: 8034ad54e39372f66f0f13255265e2ac77ccf954
 SHA512:
-  metadata.gz: 536da1fe846ac55173a110ffd7e25e1bb362e0ca765ab40dac2730f379521b6b62da64b77e8f1768733fa4ca275c872b7da9df2020389bbe729b02685fc7e52a
-  data.tar.gz: faf39d4f13d4a2d173284b0298947b92eb7959fc63d800a397df6db2963c22a4a421bf7c796880d22362f74db3175982412d82e08f8ccd5355873b04230cc266
+  metadata.gz: 2c1f561926d09bd84826533eab277b0cfb69bc2efe5c20a54b3f2e3ecfe217aeb52cff776d36e4c8174a5348d51e293323d2968f08cf23c7221cdfb57e5cb68e
+  data.tar.gz: 5d089b23eefc52622a1fc29db4dbf2c5f17392c46373836d7411517cadf39b15d8b17cc24dc3e5a5ec92e0508b998775f8a5dcaf667db85d8835e1119d4267b2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    reactor (0.19.0)
+    reactor (1.0.0)
       rails
       sidekiq (> 4.0)
 

data/README.md

@@ -87,15 +87,7 @@ on_event :any_event do |event|
 end
 ```
 
-  Static subscribers like these are automatically placed into Sidekiq and executed in the background
-
-  It's also possible to run a subscriber block in memory like so
-
-```ruby
-on_event :any_event, in_memory: true do |event|
-  event.target.do_something_about_it_and_make_the_user_wait!
-end
-```
+  Static subscribers like these are automatically placed into Sidekiq and executed in the background.
 
   You may also have Sidekiq process a subscriber block on a specific queue or supply any other Sidekiq::Worker options accordingly.
 
@@ -104,132 +96,13 @@ on_event :event_with_ui_bound, sidekiq_options: { queue: 'highest_priority' } do
   speedily_execute!
 end
 ```
+### Automatic Events
 
-#### ResourceActionable
+If you'd like to have events automatically fired for you around standard rails resource controller actions,
+you may want to write your own downstream abstraction for it. We attempted this once and it seems unwise to presume your application would want the same thing.
 
-    Enforce a strict 1:1 match between your event model and database model with this controller mixin.
-
-
-```ruby
-class PetsController < ApplicationController
-  include Reactor::ResourceActionable
-  actionable_resource :@pet
-
-  # GET /pets
-  # GET /pets.json
-  def index
-    @pets = current_user.pets
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.json { render json: @pets }
-    end
-  end
-
-  def show
-    @pet = current_user.pets.find(params[:id])
-    respond_to do |format|
-      format.html # index.html.erb
-      format.json { render json: @pet }
-    end
-  end
-end
-
-```
-
-Now your index action (and any of the other RESTful actions in that controller) will fire a useful event for you to bind to and log.
-
-*Important* Reactor::ResourceActionable has one major usage constraints:
-
-Your controller *must* have a method called "action_event" with this signature.
-```ruby
-def action_event(name, options = {})
-  # Here's what ours looks like, but yours may look different.
-  actor = options[:actor] || current_user
-  actor.publish(name, options.merge(default_action_parameters))
-  #where default_action_parameters includes things like ip_address, referrer, user_agent
-end
-```
-
-Once you write your own action_event to describe your event data model's base attributes, your ResourceActionable endpoints will now fire events that map like so (for the example above):
-
-<dl>
-<dt>index =></dt>
-<dd>"pets_indexed"</dd>
-</dl>
-
-<dl>
-<dt>show =></dt>
-<dd>"pet_viewed", target: @pet</dd>
-</dl>
-
-<dl>
-<dt>new =></dt>
-<dd>"new_pet_form_viewed"</dd>
-</dl>
-
-<dl>
-<dt>edit =></dt>
-<dd> "edit_pet_form_viewed", target: @pet</dd>
-</dl>
-
-<dl>
-<dt>create =></dt>
-<dd> when valid => "pet_created", target: @pet, attributes: params[:pet]
-<br />
-  when invalid => "pet_create_failed", errors: @pet.errors, attributes: params[:pet]</dd>
-</dl>
-
-<dl>
-<dt>update =></dt>
-<dd>
-when valid => "pet_updated", target: @pet, changes: @pet.previous_changes.as_json
-<br />
-  when invalid => "pet_update_failed", target: @pet,
-                  errors: @pet.errors.as_json, attributes: params[:pet]
-</dd>
-</dl>
-
-<dl>
-<dt>destroy =></dt>
-<dd>"pet_destroyed", last_snapshot: @pet.as_jsont</dd>
-</dl>
-
-
-##### What for?
-
-If you're obsessive about data like us, you'll have written a '*' subscriber that logs every event fired in the system. With information-dense resource information logged for each action a user performs, it will be trivial for a data analyst to determine patterns in user activity. For example, with the above data being logged for the pet resource, we can easily
-* determine which form field validations are constantly being hit by users
-* see if there are any fields that are consistently ignored on that form until later
-* recover data from the last_snapshot of a destroyed record
-* write a small conversion funnel analysis to see who never makes it back to a record to update it
-* bind arbitrary logic anywhere in the codebase (see next example) to that specific request without worrying about the logic being run during the request (all listeners are run in the background by Sidekiq)
-
-For example, in an action mailer.
-
-```ruby
-class MyMailer < ActionMailer::Base
-  include Reactor::EventMailer
-
-  on_event :pet_created do |event|
-    @user = event.actor
-    @pet = event.target
-    mail to: @user.email, subject: "Your pet is already hungry!", body: "feed it."
-  end
-end
-```
-
-Or in a model, concern, or other business logic file.
-
-```ruby
-class MyClass
-  include Reactor::Subscribable
-
-  on_event :pet_updated do |event|
-     event.actor.recalculate_expensive_something_for(event.target)
-  end
-end
-```
+It probably only makes sense if you have a real Magestic Monolith and an intentionally small team because coupling resource names to event streams makes refactoring harder.
+(Though it may still be worth it for you, depending on your needs!)
 
 ### Testing
 
@@ -266,12 +139,30 @@ expect { some_thing }.to publish_events(:some_event, :another_event)
 
 ### Production Deployments
 
-TLDR; Everything is a Sidekiq::Job, so all the same gotchas apply with regard to removing & renaming jobs that may have a live reference sitting in the queue. (AKA, you'll start seeing 'const undefined' exceptions when the job gets picked up if you've already deleted/renamed the job code.)
+TLDR; Everything is a Sidekiq::Worker, so all the same gotchas apply with regard to removing & renaming jobs that may have a live reference sitting in the queue. (AKA, you'll start seeing 'const undefined' exceptions when the job gets picked up if you've already deleted/renamed the job code.)
 
 #### Adding Events and Subscribers
 
 This is as easy as write + deploy. Of course your events getting fired won't have a subscriber pick them up until the new subscriber code is deployed in your sidekiq instances, but that's not too surprising.
 
+#### Validating Events On Publish
+
+As of 1.0 you may inject your own validator lambda to handle the logic and flow-control of valid/invalid events.
+
+This is entirely optional and the default behavior is to do nothing, to not validate any data being provided.
+
+```ruby
+# in config/initializers/reactor.rb
+Reactor.validator -> do |event|
+  Activity.build_from_event(event).validate! # you own the performance implications here
+end
+```
+
+We at Hired use this to validate the event's schema as we found having stricter schema definitions 
+gave us more leverage as our team grew.
+
+By injecting your own logic, you can be as permissive or strict as you want. (Throw exceptions if you want, even.)
+
 #### Removing Events and Subscribers
 
 Removing an event is as simple as deleting the line of code that `publish`es it.

data/lib/reactor.rb

@@ -9,14 +9,11 @@ require "reactor/workers/concerns/configuration"
 require "reactor/workers"
 require "reactor/subscription"
 require "reactor/models"
-require "reactor/controllers"
 require "reactor/event"
 
-# FIXME: should only be included in test environments
-require "reactor/testing"
-
 module Reactor
   SUBSCRIBERS = {}.with_indifferent_access
+  BASE_VALIDATOR = -> (_event) { } # default behavior is to not actually validate anything
 
   module_function
 
@@ -36,4 +33,17 @@ module Reactor
   def subscriber_namespace
     Reactor::StaticSubscribers
   end
+
+  #
+  # If you want, you can inject your own validator block in `config/initializers/reactor.rb`
+  #
+  # Reactor.validator -> (event) { Validator.new(event).validate! }
+  #
+  # If not, the default behavior is to do nothing. (see Reactor::BASE_VALIDATOR)
+  #
+  def validator(block = nil)
+    @validator = block if block.present?
+
+    @validator || BASE_VALIDATOR
+  end
 end

data/lib/reactor/event.rb

@@ -63,8 +63,11 @@ class Reactor::Event
       if defined?(Rails::Console) && ENV['RACK_ENV'] == 'production' && data[:srsly].blank?
         raise ArgumentError.new(CONSOLE_CONFIRMATION_MESSAGE)
       end
+
       message = new(data.merge(event: name, uuid: SecureRandom.uuid))
 
+      Reactor.validator.call(message)
+
       if message.at
         perform_at message.at, name, message.__data__
       else
@@ -124,6 +127,8 @@ class Reactor::Event
   end
 
   def fire_block_subscribers(data, name)
-    ((Reactor::SUBSCRIBERS[name.to_s] || []) | (Reactor::SUBSCRIBERS['*'] || [])).each { |s| s.perform_where_needed(data) }
+    ((Reactor::SUBSCRIBERS[name.to_s] || []) | (Reactor::SUBSCRIBERS['*'] || [])).each do |s|
+      s.perform_where_needed(data)
+    end
   end
 end

data/lib/reactor/subscription.rb

@@ -1,7 +1,7 @@
 module Reactor
   class Subscription
 
-    attr_reader :source, :event_name, :action, :handler_name, :delay, :async, :worker_class,
+    attr_reader :source, :event_name, :action, :handler_name, :delay, :worker_class,
                 :deprecated, :sidekiq_options
 
     def self.build_handler_name(event_name, handler_name_option = nil)
@@ -24,7 +24,6 @@ module Reactor
       @action = options[:action] || block
 
       @delay = options[:delay].to_i
-      @async = determine_async(options)
       @deprecated = !!options[:deprecated]
       @sidekiq_options = options[:sidekiq_options] || {}
       build_worker_class
@@ -41,13 +40,16 @@ module Reactor
 
     def namespace
       return @namespace if @namespace
+      @namespace = generate_namespace
+    end
 
-      ns = source.name.demodulize
-      unless Reactor.subscriber_namespace.const_defined?(ns, false)
-        Reactor.subscriber_namespace.const_set(ns, Module.new)
+    def generate_namespace
+      module_chain.reduce(Reactor.subscriber_namespace) do |mod, name|
+        unless mod.const_defined?(name, false)
+          mod.const_set(name, Module.new)
+        end
+        mod.const_get(name)
       end
-
-      @namespace = Reactor.subscriber_namespace.const_get(ns, false)
     end
 
     def mailer_subscriber?
@@ -56,24 +58,14 @@ module Reactor
 
     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
+    def module_chain
+      source.name.split('::')
     end
 
     def build_worker_class
-      namespace.send(:remove_const, handler_name) if handler_defined?
 
       worker_class = mailer_subscriber? ? build_mailer_worker : build_event_worker
+      namespace.send(:remove_const, handler_name) if handler_defined?
       namespace.const_set(handler_name, worker_class)
       @worker_class = namespace.const_get(handler_name)
     end
@@ -83,7 +75,6 @@ module Reactor
       Class.new(Reactor::Workers::EventWorker) do
         self.source = subscription.source
         self.action = subscription.action
-        self.async  = subscription.async
         self.delay  = subscription.delay
         self.deprecated  = subscription.deprecated
         self.sidekiq_options subscription.sidekiq_options
@@ -96,7 +87,6 @@ module Reactor
         self.source = subscription.source
         self.action = subscription.action
         self.delay  = subscription.delay
-        self.async  = subscription.async
         self.deprecated  = subscription.deprecated
         self.sidekiq_options subscription.sidekiq_options
       end

data/lib/reactor/testing/stubs.rb

@@ -0,0 +1,46 @@
+#
+# Run this before specs if you want to speed up tests by trading out code coverage into subscribers
+#
+def stub_reactor_subscribers
+  Reactor::SUBSCRIBERS.each do |_event, subscribers|
+    subscribers.each do |subscriber|
+      allow(subscriber).to receive(:perform_where_needed)
+    end
+  end
+end
+
+#
+# If stubbing out reactor in test, use this method to re-enable a specific subscriber
+# to test its logic.
+#
+def allow_reactor_subscriber(subscribable_class)
+  worker_module_name = "Reactor::StaticSubscribers::#{subscribable_class}"
+  worker_module_name.safe_constantize.constants.each do |worker_class_name|
+    worker_class = "#{worker_module_name}::#{worker_class_name}".safe_constantize
+    allow(worker_class).to receive(:perform_where_needed).and_call_original
+  end
+
+  yield if block_given? # yes you can use block syntax if you want
+end
+
+#
+# If you publish events in ActiveRecord lifecycle hooks, you're gonna have a bad time.
+#
+# But inevitably it may make sense for you (yay software), in which case you may want to
+#  disable a subscriber if you're testing logic around it.
+#
+def disable_reactor_subscriber(subscribable_class)
+  worker_module_name = "Reactor::StaticSubscribers::#{subscribable_class}"
+  worker_module_name.safe_constantize.constants.each do |worker_class_name|
+    worker_class = "#{worker_module_name}::#{worker_class_name}".safe_constantize
+    allow(worker_class).to receive(:perform_where_needed).and_return(nil)
+  end
+
+  if block_given? # yes you can use block syntax if you want
+    begin
+      yield
+    ensure
+      allow_reactor_subscriber(subscribable_class) # and if you do, expect it to be re-enabled after
+    end
+  end
+end

data/lib/reactor/version.rb

@@ -1,3 +1,3 @@
 module Reactor
-  VERSION = "0.19.0"
+  VERSION = "1.0.0"
 end

data/lib/reactor/workers/concerns/configuration.rb

@@ -3,7 +3,7 @@ module Reactor
     module Configuration
       extend ActiveSupport::Concern
 
-      CONFIG = [:source, :action, :async, :delay, :deprecated]
+      CONFIG = [:source, :action, :delay, :deprecated]
 
       included do
         include Sidekiq::Worker
@@ -21,10 +21,8 @@ module Reactor
             return
           elsif delay > 0
             event_queue.perform_in(delay, data)
-          elsif async
-            event_queue.perform_async(data)
           else
-            new.perform(data)
+            event_queue.perform_async(data)
           end
           source
         end
@@ -51,11 +49,7 @@ module Reactor
       end
 
       def should_perform?
-        if Reactor.test_mode?
-          Reactor.test_mode_subscriber_enabled? source
-        else
-          true
-        end
+        true
       end
 
       private

data/spec/event_spec.rb

@@ -25,6 +25,7 @@ class OtherWorker
 end
 
 describe Reactor::Event do
+  before { stub_reactor_subscribers }
 
   let(:model) { ArbitraryModel.create! }
   let(:event_name) { :user_did_this }
@@ -77,24 +78,32 @@ describe Reactor::Event do
         ENV['RACK_ENV'] = 'development'
       end
     end
+
+    describe 'using injected validator block' do
+      before { Reactor.validator -> (_event) {raise 'InvalidEvent'} }
+      after { Reactor.validator Reactor::BASE_VALIDATOR }
+
+      it 'gets called and yields flow control' do
+        expect {
+          Reactor::Event.publish(:something)
+        }.to raise_error(RuntimeError, 'InvalidEvent')
+      end
+    end
   end
 
   describe 'perform' do
-    # before do
-    #   allow(Reactor::Event).
-    # end
     let(:event_name) { :barfed }
 
     it 'fires all subscribers' do
       expect(Reactor::StaticSubscribers::ArbitraryModel::BarfedHandler).
-          to receive(:perform_async).with(hash_including(actor_id: model.id.to_s))
+          to receive(:perform_where_needed).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(Reactor::StaticSubscribers::ArbitraryModel::BarfedHandler).
-          to receive(:perform_async).with(hash_including(fired_at: anything))
+          to receive(:perform_where_needed).with(hash_including(fired_at: a_kind_of(Time)))
 
       Reactor::Event.perform(event_name, actor_id: model.id.to_s, actor_type: model.class.to_s)
     end
@@ -103,7 +112,7 @@ describe Reactor::Event do
       it 'doesnt matter because it runs in a separate worker process' do
         expect {
           Reactor::Event.perform(
-              'barfed',
+              event_name,
               somethin: 'up',
               actor_id: model.id.to_s,
               actor_type: model.class.to_s

data/spec/models/concerns/publishable_spec.rb

@@ -81,7 +81,6 @@ describe Reactor::Publishable do
       before do
         Sidekiq::Testing.fake!
         Sidekiq::Worker.clear_all
-        # TestSubscriber.create! event_name: :conditional_event_on_publish
         publisher
         job = Reactor::Event.jobs.detect do |job|
           job['class'] == 'Reactor::Event' && job['args'].first == 'conditional_event_on_publish'

data/spec/models/concerns/subscribable_spec.rb

@@ -15,10 +15,6 @@ class Auction < ApplicationRecord
     event.actor.more_puppies! if event.name == 'another_event'
   end
 
-  on_event :cat_delivered, async: false do |event|
-    puppies!
-  end
-
   on_event :a_high_frequency_event, deprecated: true do |event|
     raise 'hell'
   end
@@ -49,7 +45,7 @@ class KittenMailer < ActionMailer::Base
   include Reactor::Subscribable
 
   on_event :auction, handler_name: 'auction' do |event|
-    raise "Event auction"
+    @@fired = true
   end
 
   on_event :kitten_streaming do |event|
@@ -67,20 +63,14 @@ class KittenMailer < ActionMailer::Base
   end
 end
 
-Reactor.in_test_mode do
-  class TestModeAuction < ApplicationRecord
-    on_event :test_puppy_delivered, -> (event) { "success" }
-  end
+class TestModeAuction < ApplicationRecord
+  on_event :test_puppy_delivered, -> (event) { "success" }
 end
 
 describe Reactor::Subscribable do
   let(:scheduled) { Sidekiq::ScheduledSet.new }
 
   describe 'on_event' do
-    before do
-      Reactor.enable_test_mode_subscriber(Auction)
-    end
-
     it 'binds block of code statically to event being fired' do
       expect_any_instance_of(Auction).to receive(:update_column).with(:status, 'first_bid_made')
       Reactor::Event.publish(:bid_made, target: Auction.create!(start_at: 10.minutes.from_now))
@@ -92,8 +82,8 @@ describe Reactor::Subscribable do
         expect(Reactor::SUBSCRIBERS['puppy_delivered'][1]).to eq(Reactor::StaticSubscribers::Auction::DoNothingHandler)
       end
 
-      it 'adds a static subscriber for namespaced classes' do
-        expect(Reactor::SUBSCRIBERS['rain'][0]).to eq(Reactor::StaticSubscribers::MyClass::RainHandler)
+      it 'adds a static subscriber for namespaced classes at the same module depth' do
+        expect(Reactor::SUBSCRIBERS['rain'][0]).to eq(Reactor::StaticSubscribers::MyNamespace::MyClass::RainHandler)
       end
     end
 
@@ -101,10 +91,16 @@ describe Reactor::Subscribable do
       let(:pooped_handler) { Reactor::StaticSubscribers::Auction::PoopedHandler }
 
       it 'fires on event' do
+        expect(Reactor::StaticSubscribers::Auction::WildcardHandler).
+            to receive(:perform_async).and_call_original
         expect(Auction).to receive(:ring_bell)
         Reactor::Event.publish(:puppy_delivered)
       end
 
+      it 'fires perform_async when true / default' do
+        Reactor::Event.publish(:puppy_delivered)
+      end
+
       it 'can be delayed' do
         expect(Auction).to receive(:pick_up_poop)
         expect(pooped_handler).to receive(:perform_in).with(5.minutes, anything).and_call_original
@@ -132,19 +128,6 @@ describe Reactor::Subscribable do
       expect { Reactor::Event.publish :auction }.not_to raise_error
     end
 
-    describe 'async flag' do
-      it 'doesnt fire perform_async when false' do
-        expect(Auction).to receive(:puppies!)
-        expect(Reactor::StaticSubscribers::Auction::CatDeliveredHandler).not_to receive(:perform_async)
-        Reactor::Event.publish(:cat_delivered)
-      end
-
-      it 'fires perform_async when true / default' do
-        expect(Reactor::StaticSubscribers::Auction::WildcardHandler).to receive(:perform_async)
-        Reactor::Event.publish(:puppy_delivered)
-      end
-    end
-
     describe 'deprecate flag for high-frequency events in production deployments' do
       it 'doesnt enqueue subscriber worker when true' do
         # so subscriber can be safely deleted in next deploy
@@ -182,17 +165,8 @@ describe Reactor::Subscribable do
     end
 
     describe '#perform' do
-      around(:each) do |example|
-        Reactor.in_test_mode { example.run }
-      end
-
-      it 'returns :__perform_aborted__ when Reactor is in test mode' do
-        expect(Reactor::StaticSubscribers::TestModeAuction::TestPuppyDeliveredHandler.new.perform({})).to eq(:__perform_aborted__)
-        Reactor::Event.publish(:test_puppy_delivered)
-      end
-
       it 'performs normally when specifically enabled' do
-        Reactor.with_subscriber_enabled(TestModeAuction) do
+        allow_reactor_subscriber(TestModeAuction) do
           expect(Reactor::StaticSubscribers::TestModeAuction::TestPuppyDeliveredHandler.new.perform({})).not_to eq(:__perform_aborted__)
           Reactor::Event.publish(:test_puppy_delivered)
         end
@@ -201,8 +175,6 @@ describe Reactor::Subscribable do
   end
 
   describe 'mailers', type: :mailer do
-    before { Reactor.enable_test_mode_subscriber KittenMailer }
-    after  { Reactor.disable_test_mode_subscriber KittenMailer }
 
     def deliveries
       ActionMailer::Base.deliveries

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ end
 
 require 'reactor'
 require 'reactor/testing/matchers'
+require 'reactor/testing/stubs'
 
 require 'rspec/its'
 
@@ -53,8 +54,6 @@ RSpec.configure do |config|
   # some (optional) config here
 
   config.before(:each) do
-    Reactor.test_mode!
-    Reactor.clear_test_subscribers!
     ActionMailer::Base.deliveries.clear
   end
 

data/spec/subscription_spec.rb

@@ -2,6 +2,31 @@ require 'spec_helper'
 
 describe Reactor::Subscription do
 
+  describe '#initialize builds a worker class' do
+    subject! do
+      described_class.new(source: Pet, event_name: :pooped) do
+      end
+    end
+
+    specify do
+      expect(Reactor::StaticSubscribers::Pet::PoopedHandler < Reactor::Workers::EventWorker)
+          .to be true
+    end
+
+    describe 'when subscriber object has namespace of arbitrary length' do
+      subject! do
+        described_class.new(source: Reactor::Subscription, event_name: :pooped) do
+        end
+      end
+
+      specify do
+        expect(Reactor::StaticSubscribers::Reactor::Subscription::PoopedHandler <
+                   Reactor::Workers::EventWorker)
+            .to be true
+      end
+    end
+  end
+
   describe '.build_handler_name' do
     let(:event_name) { :kitten_sleeping }
 

data/spec/support/shared_examples.rb

@@ -24,7 +24,7 @@ shared_examples_for 'configurable subscriber worker' do
       end
     end
 
-    context 'for async workers' do
+    context 'for not delayed workers' do
       let(:klass) { MyEventWorker }
       subject { klass.perform_where_needed(event_data) }
 
@@ -33,15 +33,5 @@ shared_examples_for 'configurable subscriber worker' do
         subject
       end
     end
-
-    context 'for immediate workers' do
-      let(:klass) { MyImmediateWorker }
-      subject { klass.perform_where_needed(event_data) }
-
-      it 'creates and executes new instance' do
-        expect_any_instance_of(klass).to receive(:perform).with(event_data)
-        subject
-      end
-    end
   end
 end

data/spec/workers/event_worker_spec.rb

@@ -14,7 +14,6 @@ end
 class MyEventWorker < Reactor::Workers::EventWorker
   self.source = SourceSubscriber
   self.action = :fire_worker
-  self.async  = true
   self.delay  = 0
   self.deprecated = false
 end
@@ -22,7 +21,6 @@ end
 class MyBlockWorker < Reactor::Workers::EventWorker
   self.source = SourceSubscriber
   self.action = lambda { |event| :block_ran }
-  self.async  = true
   self.delay  = 0
   self.deprecated = false
 end
@@ -30,19 +28,10 @@ end
 class MyDelayedWorker < Reactor::Workers::EventWorker
   self.source = SourceSubscriber
   self.action = :fire_worker
-  self.async  = true
   self.delay  = 1 # seconds
   self.deprecated = false
 end
 
-class MyImmediateWorker < Reactor::Workers::EventWorker
-  self.source = SourceSubscriber
-  self.action = :fire_worker
-  self.async  = false
-  self.delay  = 0
-  self.deprecated = false
-end
-
 describe Reactor::Workers::EventWorker do
   let(:event_name) { :fire_worker }
   let(:event_data) { Hash[my_event_data: true] }
@@ -61,25 +50,15 @@ describe Reactor::Workers::EventWorker do
       end
     end
 
-    context 'when should_perform? is false' do
-      let(:klass) { MyEventWorker }
+    before { allow_any_instance_of(klass).to receive(:should_perform?).and_return(true) }
 
-      it 'returns :__perform_aborted__' do
-        expect(subject).to eq(:__perform_aborted__)
-      end
+    it 'calls class method by symbol' do
+      expect(subject).to eq(:method_called)
     end
 
-    context 'when should_perform? is true' do
-      before { allow_any_instance_of(klass).to receive(:should_perform?).and_return(true) }
-
-      it 'calls class method by symbol' do
-        expect(subject).to eq(:method_called)
-      end
-
-      context 'for block workers' do
-        let(:klass) { MyBlockWorker }
-        it { is_expected.to eq(:block_ran) }
-      end
+    context 'for block workers' do
+      let(:klass) { MyBlockWorker }
+      it { is_expected.to eq(:block_ran) }
     end
   end
 

data/spec/workers/mailer_worker_spec.rb

@@ -14,14 +14,12 @@ end
 class MyMailerWorker < Reactor::Workers::MailerWorker
   self.source = MailerSubscriber
   self.action = :fire_mailer
-  self.async  = false
   self.delay  = 0
   self.deprecated = false
 end
 
 class MyBlockMailerWorker < Reactor::Workers::MailerWorker
   self.source = MailerSubscriber
-  self.async  = false
   self.delay  = 0
   self.action = lambda { |event| fire_mailer(event) }
   self.deprecated = false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reactor
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 1.0.0
 platform: ruby
 authors:
 - winfred
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-25 00:00:00.000000000 Z
+date: 2018-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -205,16 +205,6 @@ files:
 - gemfiles/sidekiq_4.gemfile
 - gemfiles/sidekiq_5.gemfile
 - lib/reactor.rb
-- lib/reactor/controllers.rb
-- lib/reactor/controllers/concerns/actions/action_event.rb
-- lib/reactor/controllers/concerns/actions/create_event.rb
-- lib/reactor/controllers/concerns/actions/destroy_event.rb
-- lib/reactor/controllers/concerns/actions/edit_event.rb
-- lib/reactor/controllers/concerns/actions/index_event.rb
-- lib/reactor/controllers/concerns/actions/new_event.rb
-- lib/reactor/controllers/concerns/actions/show_event.rb
-- lib/reactor/controllers/concerns/actions/update_event.rb
-- lib/reactor/controllers/concerns/resource_actionable.rb
 - lib/reactor/errors.rb
 - lib/reactor/event.rb
 - lib/reactor/models.rb
@@ -222,19 +212,17 @@ files:
 - lib/reactor/models/concerns/subscribable.rb
 - lib/reactor/static_subscribers.rb
 - lib/reactor/subscription.rb
-- lib/reactor/testing.rb
 - lib/reactor/testing/matchers.rb
+- lib/reactor/testing/stubs.rb
 - lib/reactor/version.rb
 - lib/reactor/workers.rb
 - lib/reactor/workers/concerns/configuration.rb
 - lib/reactor/workers/event_worker.rb
 - lib/reactor/workers/mailer_worker.rb
 - reactor.gemspec
-- spec/controllers/concerns/resource_actionable_spec.rb
 - spec/event_spec.rb
 - spec/models/concerns/publishable_spec.rb
 - spec/models/concerns/subscribable_spec.rb
-- spec/reactor_spec.rb
 - spec/spec_helper.rb
 - spec/subscription_spec.rb
 - spec/support/active_record.rb
@@ -266,11 +254,9 @@ signing_key:
 specification_version: 4
 summary: Sidekiq/ActiveRecord pubsub lib
 test_files:
-- spec/controllers/concerns/resource_actionable_spec.rb
 - spec/event_spec.rb
 - spec/models/concerns/publishable_spec.rb
 - spec/models/concerns/subscribable_spec.rb
-- spec/reactor_spec.rb
 - spec/spec_helper.rb
 - spec/subscription_spec.rb
 - spec/support/active_record.rb

data/lib/reactor/controllers.rb

@@ -1,2 +0,0 @@
-# FIXME - these are not properly namespaced. The directories mean nothing
-require "reactor/controllers/concerns/resource_actionable"

data/lib/reactor/controllers/concerns/actions/action_event.rb

@@ -1,13 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class ActionEvent
-      def self.perform(&block)
-        @perform_block = block
-      end
-
-      def self.perform_on(ctx)
-        ctx.instance_exec(&@perform_block)
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/create_event.rb

@@ -1,18 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class CreateEvent < ActionEvent
-      perform do
-        if actionable_resource.valid?
-          action_event "#{resource_name}_created",
-                       target: actionable_resource,
-                       attributes: params[resource_name]
-        else
-          action_event "#{resource_name}_create_failed",
-                       errors: actionable_resource.errors.as_json,
-                       attributes: params[resource_name],
-                       target: nested_resource
-        end
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/destroy_event.rb

@@ -1,9 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class DestroyEvent < ActionEvent
-      perform do
-        action_event "#{resource_name}_destroyed", last_snapshot: actionable_resource.as_json
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/edit_event.rb

@@ -1,9 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class EditEvent < ActionEvent
-      perform do
-        action_event "edit_#{resource_name}_form_viewed", target: actionable_resource
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/index_event.rb

@@ -1,9 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class IndexEvent < ActionEvent
-      perform do
-        action_event "#{resource_name.pluralize}_indexed", target: nested_resource
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/new_event.rb

@@ -1,9 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class NewEvent < ActionEvent
-      perform do
-        action_event "new_#{resource_name}_form_viewed", target: nested_resource
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/show_event.rb

@@ -1,9 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class ShowEvent < ActionEvent
-      perform do
-        action_event "#{resource_name}_viewed", target: actionable_resource
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/actions/update_event.rb

@@ -1,18 +0,0 @@
-module Reactor
-  module ResourceActionable
-    class UpdateEvent < ActionEvent
-      perform do
-        if actionable_resource.valid?
-          action_event "#{resource_name}_updated",
-                       target: actionable_resource,
-                       changes: actionable_resource.previous_changes.as_json
-        else
-          action_event "#{resource_name}_update_failed",
-                       target: actionable_resource,
-                       errors: actionable_resource.errors.as_json,
-                       attributes: params[resource_name]
-        end
-      end
-    end
-  end
-end

data/lib/reactor/controllers/concerns/resource_actionable.rb

@@ -1,55 +0,0 @@
-module Reactor
-  module ResourceActionable
-    extend ActiveSupport::Concern
-
-    included do
-      around_filter :infer_basic_action_event
-    end
-
-    def infer_basic_action_event
-      yield if block_given?
-
-      if (event_descriptor = "Reactor::ResourceActionable::#{action_name.camelize}Event".safe_constantize).present?
-        event_descriptor.perform_on self
-      else
-        action_event "#{resource_name}_#{action_name}"
-      end
-    end
-
-    module ClassMethods
-      def actionable_resource(ivar_name = nil)
-        @resource_ivar_name ||= ivar_name
-      end
-
-      def nested_resource(ivar_name = nil)
-        @nested_resource_ivar_name ||= ivar_name
-      end
-
-      # this is so our API controller subclasses can re-use the resource declarations
-      def inherited(subclass)
-        [:resource_ivar_name, :nested_resource_ivar_name].each do |inheritable_attribute|
-          instance_var = "@#{inheritable_attribute}"
-          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
-        end
-      end
-    end
-
-    def actionable_resource; instance_variable_get(self.class.actionable_resource); end
-    def nested_resource; self.class.nested_resource && instance_variable_get(self.class.nested_resource); end
-
-    private
-
-    def resource_name
-      self.class.actionable_resource.to_s.gsub('@','').underscore
-    end
-  end
-end
-
-require "reactor/controllers/concerns/actions/action_event"
-require "reactor/controllers/concerns/actions/new_event"
-require "reactor/controllers/concerns/actions/index_event"
-require "reactor/controllers/concerns/actions/edit_event"
-require "reactor/controllers/concerns/actions/create_event"
-require "reactor/controllers/concerns/actions/update_event"
-require "reactor/controllers/concerns/actions/destroy_event"
-require "reactor/controllers/concerns/actions/show_event"

data/lib/reactor/testing.rb

@@ -1,50 +0,0 @@
-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/spec/controllers/concerns/resource_actionable_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-class RandomActionController
-
-  def self.around_filter(method)
-    @around_filter ||= method
-  end
-
-  include Reactor::ResourceActionable
-  actionable_resource :@cat
-  nested_resource :@owner
-
-  attr_accessor :action_name
-  def initialize
-    self.action_name = 'create'
-  end
-
-  def create
-    #because I dont feel like re-implementing around_filter for this stub
-    infer_basic_action_event do
-      @owner = ArbitraryModel.create!
-      @cat = Pet.create!
-    end
-  end
-
-end
-
-describe Reactor::ResourceActionable do
-  let(:controller_stub) { RandomActionController.new }
-
-  describe "when action strategy class exists" do
-    it 'runs the strategy of the matching name' do
-      expect(Reactor::ResourceActionable::CreateEvent).to receive(:perform_on).with(controller_stub)
-      controller_stub.create
-    end
-  end
-
-  describe "when action is non-standard rails CRUD action" do
-    it 'fires a basic action_event' do
-      controller_stub.action_name = 'do_thing'
-      expect(controller_stub).to receive(:action_event).with("cat_do_thing")
-      controller_stub.create
-    end
-  end
-end
-
-describe "ActionEvents" do
-  let(:actionable_resource) { ArbitraryModel.create! }
-  let(:nested_resource) { Pet.create! }
-  let(:ctrl_stub) { double(resource_name: "cat", actionable_resource: actionable_resource, nested_resource: nested_resource, params: {'cat' => {name: "Sasha"}} ) }
-
-  describe "ShowEvent" do
-    after { Reactor::ResourceActionable::ShowEvent.perform_on(ctrl_stub) }
-    specify { expect(ctrl_stub).to receive(:action_event).with("cat_viewed", target: actionable_resource) }
-  end
-
-  describe "EditEvent" do
-    after { Reactor::ResourceActionable::EditEvent.perform_on(ctrl_stub) }
-    specify { expect(ctrl_stub).to receive(:action_event).with("edit_cat_form_viewed", target: actionable_resource) }
-  end
-
-  describe "NewEvent" do
-    after { Reactor::ResourceActionable::NewEvent.perform_on(ctrl_stub) }
-    specify { expect(ctrl_stub).to receive(:action_event).with("new_cat_form_viewed", target: nested_resource) }
-  end
-
-  describe "IndexEvent" do
-    after { Reactor::ResourceActionable::IndexEvent.perform_on(ctrl_stub) }
-    specify { expect(ctrl_stub).to receive(:action_event).with("cats_indexed", target: nested_resource) }
-  end
-
-  describe "DestroyEvent" do
-    after { Reactor::ResourceActionable::DestroyEvent.perform_on(ctrl_stub) }
-    specify { expect(ctrl_stub).to receive(:action_event).with("cat_destroyed", last_snapshot: actionable_resource.as_json) }
-  end
-
-  describe "CreateEvent" do
-    after { Reactor::ResourceActionable::CreateEvent.perform_on(ctrl_stub) }
-
-    describe "when resource is valid" do
-      before { expect(actionable_resource).to receive(:valid?).and_return(true) }
-
-      specify do
-        expect(ctrl_stub).to receive(:action_event)
-          .with("cat_created",
-                target: actionable_resource,
-                attributes: {name: "Sasha"})
-      end
-    end
-
-    describe "when resource is not valid" do
-      before do
-        expect(actionable_resource).to receive(:valid?).and_return(false)
-        expect(actionable_resource).to receive(:errors).and_return('awesomeness' => 'too awesome')
-      end
-
-      specify do
-        expect(ctrl_stub).to receive(:action_event)
-          .with("cat_create_failed",
-                errors: {'awesomeness' => 'too awesome'},
-                target: nested_resource,
-                attributes: {name: "Sasha"})
-      end
-    end
-  end
-
-  describe "UpdateEvent" do
-    after { Reactor::ResourceActionable::UpdateEvent.perform_on(ctrl_stub) }
-
-    describe "when resource is valid" do
-      before do
-        expect(actionable_resource).to receive(:valid?).and_return(true)
-        expect(actionable_resource).to receive(:previous_changes).and_return({'name' => [nil, "Sasha"]})
-      end
-
-      specify do
-        expect(ctrl_stub).to receive(:action_event)
-          .with("cat_updated",
-                target: actionable_resource,
-                changes: {'name' => [nil, "Sasha"]})
-      end
-    end
-
-    describe "when resource is not valid" do
-      before do
-        expect(actionable_resource).to receive(:valid?).and_return(false)
-        expect(actionable_resource).to receive(:errors).and_return('awesomeness' => 'too awesome')
-      end
-
-      specify do
-        expect(ctrl_stub).to receive(:action_event)
-          .with("cat_update_failed",
-              target: actionable_resource,
-              errors: {'awesomeness' => 'too awesome'},
-              attributes: {name: "Sasha"})
-      end
-    end
-  end
-
-end

data/spec/reactor_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-Reactor.in_test_mode do
-  class SomeClass
-    include Reactor::Subscribable
-    on_event :test_event, -> (event) { self.spy_on_me }
-  end
-end
-
-describe Reactor do
-  let(:subscriber) { SomeClass }
-
-  describe '.test_mode!' do
-    before { Reactor.disable_test_mode! }
-
-    it 'sets Reactor into test mode' do
-      expect(Reactor.test_mode?).to be_falsey
-      Reactor.test_mode!
-      expect(Reactor.test_mode?).to be_truthy
-    end
-  end
-
-  context 'in test mode' do
-    before { Reactor.test_mode! }
-    after  { Reactor.disable_test_mode! }
-
-    it 'subscribers created in test mode are disabled' do
-      expect(subscriber).not_to receive :spy_on_me
-      Reactor::Event.publish :test_event
-    end
-
-    describe '.with_subscriber_enabled' do
-      it 'enables a subscriber during test mode' do
-        expect(subscriber).to receive :spy_on_me
-        Reactor.with_subscriber_enabled(subscriber) do
-          Reactor::Event.publish :test_event
-        end
-      end
-
-      it 'disables the subscriber outside the block' do
-        expect(Reactor::TEST_MODE_SUBSCRIBERS).to be_empty
-        Reactor.with_subscriber_enabled(subscriber) do
-          expect(Reactor::TEST_MODE_SUBSCRIBERS).to contain_exactly(subscriber)
-        end
-        expect(Reactor::TEST_MODE_SUBSCRIBERS).to be_empty
-      end
-
-      it 'correctly handles exceptions inside the block' do
-        expect(Reactor::TEST_MODE_SUBSCRIBERS).to be_empty
-        expect {
-          Reactor.with_subscriber_enabled(subscriber) do
-            raise RuntimeError
-          end
-        }.to raise_error(RuntimeError)
-        expect(Reactor::TEST_MODE_SUBSCRIBERS).to be_empty
-      end
-    end
-  end
-end