reactor 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48d54ad63bce2589fbe3d6e39d8d9fe7e2d1fca6
-  data.tar.gz: 484fbf659d971b11479a0bd24392657ba4e9a031
+  metadata.gz: c458036301b887cea2e6e656cd94ed497750ebed
+  data.tar.gz: 706f502c1bbbac9172374b7b065ddb627f3de656
 SHA512:
-  metadata.gz: 32f14db9aba4a493b5a8765cf8b7d1a50723cc585215a40e0cb5bd8b8369d504871ec0288232e3dd647eb50ae5521b89577123af8708cf03bb8df61b413da995
-  data.tar.gz: 3c854cf77e8188db2598dba97e80cb40856fc3f70f497861508c99447147e1743840d7cc06c9c1997c87f6baa6a360d56257ae8a57b8074d96a65591f3e1b2a1
+  metadata.gz: 1b5ebaf7f01782274bbd324789f138e6fc82af0de759d624d63e6c50f553783ff4be37b774d365086984e64ef11367777d4f98f108533a6b1ebc3a6532d64c65
+  data.tar.gz: e0f664ec820fcaa59c7a181bceffdb3b049799f841ccced731392e21b1e6453bacfafc2460b3010fca64ae083d17fcd0ae674484c0c955ecb5f208399c4d6487

data/lib/reactor/event.rb

@@ -64,9 +64,9 @@ class Reactor::Event
 
     def enforce_serializable_model_keys!(event_signature)
       event_signature = event_signature.stringify_keys
-      serializable_models = event_signature.keys.map(&:to_s).select { |k| k.include?('_id') || k.include?('_type') }
-      .map { |k| k.gsub('_id', '') }
-      .map { |k| k.gsub('_type', '') }
+      serializable_models = event_signature.keys.map(&:to_s).select { |k| k.end_with?('_id') || k.end_with?('_type') }
+      .map { |k| k.gsub(/_id\Z/, '') }
+      .map { |k| k.gsub(/_type\Z/, '') }
       .uniq
 
       serializable_models.each do |model_relation_name|

data/lib/reactor/testing/matchers.rb

@@ -1,7 +1,9 @@
 RSpec::Matchers.define :publish_event do |name, data = {}|
+  supports_block_expectations
+
   match do |block|
     defaults = {:actor => anything}
-    Reactor::Event.should_receive(:publish).with(name, hash_including(defaults.merge(data)))
+    expect(Reactor::Event).to receive(:publish).with(name, hash_including(defaults.merge(data)))
 
     begin
       block.call
@@ -14,14 +16,16 @@ RSpec::Matchers.define :publish_event do |name, data = {}|
 end
 
 RSpec::Matchers.define :publish_events do |*events|
+  supports_block_expectations
+
   match do |block|
-    Reactor::Event.should_receive(:publish).exactly(events.count).times.with do |event, data|
+    expect(Reactor::Event).to receive(:publish).exactly(events.count).times do |event, data|
       match = events.select { |e| (e.is_a?(Hash) ? e.keys.first : e) == event }.first
-      match.should be_present
+      expect(match).to be_present
 
       expected = match.is_a?(Hash) ? match.values.first : {match => {}}
       expected.each do |key, value|
-        value.should == expected[key]
+        expect(value).to eq(expected[key])
       end
     end
 
@@ -36,8 +40,10 @@ RSpec::Matchers.define :publish_events do |*events|
 end
 
 RSpec::Matchers.define :subscribe_to do |name, data = {}, &expectations|
+  supports_block_expectations
+
   match do
     expectations.call if expectations.present?
     Reactor::Event.publish(name, data)
   end
-end
+end

data/lib/reactor/version.rb

@@ -1,3 +1,3 @@
 module Reactor
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

data/reactor.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "rspec", "~> 2.99.0"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "test_after_commit"

data/spec/controllers/concerns/resource_actionable_spec.rb

@@ -30,7 +30,7 @@ describe Reactor::ResourceActionable do
 
   describe "when action strategy class exists" do
     it 'runs the strategy of the matching name' do
-      Reactor::ResourceActionable::CreateEvent.should_receive(:perform_on).with(controller_stub)
+      expect(Reactor::ResourceActionable::CreateEvent).to receive(:perform_on).with(controller_stub)
       controller_stub.create
     end
   end
@@ -38,7 +38,7 @@ describe Reactor::ResourceActionable do
   describe "when action is non-standard rails CRUD action" do
     it 'fires a basic action_event' do
       controller_stub.action_name = 'do_thing'
-      controller_stub.should_receive(:action_event).with("cat_do_thing")
+      expect(controller_stub).to receive(:action_event).with("cat_do_thing")
       controller_stub.create
     end
   end
@@ -47,41 +47,41 @@ end
 describe "ActionEvents" do
   let(:actionable_resource) { ArbitraryModel.create! }
   let(:nested_resource) { Pet.create! }
-  let(:ctrl_stub) { stub(resource_name: "cat", actionable_resource: actionable_resource, nested_resource: nested_resource, params: {'cat' => {name: "Sasha"}} ) }
+  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 { ctrl_stub.should_receive(:action_event).with("cat_viewed", target: actionable_resource) }
+    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 { ctrl_stub.should_receive(:action_event).with("edit_cat_form_viewed", target: actionable_resource) }
+    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 { ctrl_stub.should_receive(:action_event).with("new_cat_form_viewed", target: nested_resource) }
+    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 { ctrl_stub.should_receive(:action_event).with("cats_indexed", target: nested_resource) }
+    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 { ctrl_stub.should_receive(:action_event).with("cat_destroyed", last_snapshot: actionable_resource.as_json) }
+    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 { actionable_resource.should_receive(:valid?).and_return(true) }
+      before { expect(actionable_resource).to receive(:valid?).and_return(true) }
 
       specify do
-        ctrl_stub.should_receive(:action_event)
+        expect(ctrl_stub).to receive(:action_event)
           .with("cat_created",
                 target: actionable_resource,
                 attributes: {name: "Sasha"})
@@ -90,12 +90,12 @@ describe "ActionEvents" do
 
     describe "when resource is not valid" do
       before do
-        actionable_resource.should_receive(:valid?).and_return(false)
-        actionable_resource.should_receive(:errors).and_return('awesomeness' => 'too awesome')
+        expect(actionable_resource).to receive(:valid?).and_return(false)
+        expect(actionable_resource).to receive(:errors).and_return('awesomeness' => 'too awesome')
       end
 
       specify do
-        ctrl_stub.should_receive(:action_event)
+        expect(ctrl_stub).to receive(:action_event)
           .with("cat_create_failed",
                 errors: {'awesomeness' => 'too awesome'},
                 target: nested_resource,
@@ -109,12 +109,12 @@ describe "ActionEvents" do
 
     describe "when resource is valid" do
       before do
-        actionable_resource.should_receive(:valid?).and_return(true)
-        actionable_resource.should_receive(:previous_changes).and_return({'name' => [nil, "Sasha"]})
+        expect(actionable_resource).to receive(:valid?).and_return(true)
+        expect(actionable_resource).to receive(:previous_changes).and_return({'name' => [nil, "Sasha"]})
       end
 
       specify do
-        ctrl_stub.should_receive(:action_event)
+        expect(ctrl_stub).to receive(:action_event)
           .with("cat_updated",
                 target: actionable_resource,
                 changes: {'name' => [nil, "Sasha"]})
@@ -123,12 +123,12 @@ describe "ActionEvents" do
 
     describe "when resource is not valid" do
       before do
-        actionable_resource.should_receive(:valid?).and_return(false)
-        actionable_resource.should_receive(:errors).and_return('awesomeness' => 'too awesome')
+        expect(actionable_resource).to receive(:valid?).and_return(false)
+        expect(actionable_resource).to receive(:errors).and_return('awesomeness' => 'too awesome')
       end
 
       specify do
-        ctrl_stub.should_receive(:action_event)
+        expect(ctrl_stub).to receive(:action_event)
           .with("cat_update_failed",
               target: actionable_resource,
               errors: {'awesomeness' => 'too awesome'},

data/spec/event_spec.rb

@@ -18,7 +18,7 @@ describe Reactor::Event do
 
   describe 'publish' do
     it 'fires the first perform and sets message event_id' do
-      Reactor::Event.should_receive(:perform_async).with(event_name, 'actor_id' => '1', 'actor_type' => 'Pet', 'event' => :user_did_this)
+      expect(Reactor::Event).to receive(:perform_async).with(event_name, 'actor_id' => '1', 'actor_type' => 'Pet', 'event' => :user_did_this)
       Reactor::Event.publish(:user_did_this, actor_id: '1', actor_type: 'Pet')
     end
 
@@ -39,22 +39,22 @@ describe Reactor::Event do
     before { Reactor::Subscriber.create(event_name: :user_did_this) }
     after { Reactor::Subscriber.destroy_all }
     it 'fires all subscribers' do
-      Reactor::Subscriber.any_instance.should_receive(:fire).with(hash_including(actor_id: '1'))
+      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(actor_id: '1'))
       Reactor::Event.perform(event_name, actor_id: '1')
     end
 
     it 'sets a fired_at key in event data' do
-      Reactor::Subscriber.any_instance.should_receive(:fire).with(hash_including(fired_at: anything))
+      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(fired_at: anything))
       Reactor::Event.perform(event_name, actor_id: '1')
     end
 
     it 'works with the legacy .process method, too' do
-      Reactor::Subscriber.any_instance.should_receive(:fire).with(hash_including(actor_id: '1'))
+      expect_any_instance_of(Reactor::Subscriber).to receive(:fire).with(hash_including(actor_id: '1'))
       Reactor::Event.perform(event_name, actor_id: '1')
     end
 
     describe 'when subscriber throws exception', :sidekiq do
-      let(:mock) { mock(:thing, some_method: 3) }
+      let(:mock) { double(:thing, some_method: 3) }
       let(:barfing_event) { Reactor::Event.perform('barfed', somethin: 'up') }
 
       before do
@@ -63,7 +63,7 @@ describe Reactor::Event do
           raise 'UNEXPECTED!'
         end
         Reactor::SUBSCRIBERS['barfed'] << Reactor::Subscribable::StaticSubscriberFactory.create('barfed') do |event|
-          mock.some_method
+          double.some_method
         end
       end
 
@@ -80,12 +80,12 @@ describe Reactor::Event do
     it 'can schedule and reschedule an event in the future' do
       expect {
         jid = Reactor::Event.publish :turtle_time, at: time
-        scheduled.find_job(jid).score.should == time.to_f
+        expect(scheduled.find_job(jid).score).to eq(time.to_f)
       }.to change { scheduled.size }.by(1)
 
       expect {
         jid = Reactor::Event.reschedule :turtle_time, at: (time + 2.hours), was: time
-        scheduled.find_job(jid).score.should == (time + 2.hours).to_f
+        expect(scheduled.find_job(jid).score).to eq((time + 2.hours).to_f)
       }.to_not change { scheduled.size }
     end
   end
@@ -101,19 +101,32 @@ describe Reactor::Event do
 
       describe 'getters' do
         context 'basic key value' do
-          its(:random) { should == 'data' }
+          describe '#random' do
+            subject { super().random }
+            it { is_expected.to eq('data') }
+          end
         end
 
         context 'foreign key and foreign type' do
-          its(:pet) { should be_a MyModule::Cat }
-          its('pet.id') { should == MyModule::Cat.last.id }
+          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
         end
       end
 
       describe 'setters' do
         it 'sets simple keys' do
           event.simple = 'key'
-          event.data[:simple].should == 'key'
+          expect(event.data[:simple]).to eq('key')
         end
 
         it 'sets active_record polymorphic keys' do
@@ -126,14 +139,14 @@ describe Reactor::Event do
 
     describe 'data' do
       let(:serialized_event) { event.data }
-      specify { serialized_event.should be_a Hash }
-      specify { serialized_event[:random].should == 'data' }
+      specify { expect(serialized_event).to be_a Hash }
+      specify { expect(serialized_event[:random]).to eq('data') }
     end
 
     describe 'new' do
-      specify { event.should be_a Reactor::Event }
-      specify { event.pet_id.should == cat.id }
-      specify { event.arbitrary_model_id.should == arbitrary_model.id }
+      specify { expect(event).to be_a Reactor::Event }
+      specify { expect(event.pet_id).to eq(cat.id) }
+      specify { expect(event.arbitrary_model_id).to eq(arbitrary_model.id) }
     end
   end
 end

data/spec/models/concerns/publishable_spec.rb

@@ -35,18 +35,18 @@ describe Reactor::Publishable do
 
     it 'publishes an event with actor_id and actor_type set as self' do
       auction
-      Reactor::Event.should_receive(:publish) do |name, data|
-        name.should == :an_event
-        data[:what].should == 'the'
-        data[:actor].should == auction
+      expect(Reactor::Event).to receive(:publish) do |name, data|
+        expect(name).to eq(:an_event)
+        expect(data[:what]).to eq('the')
+        expect(data[:actor]).to eq(auction)
       end
       auction.publish(:an_event, {what: 'the'})
     end
 
     it 'publishes an event with provided actor and target methods' do
-      Reactor::Event.should_receive(:publish) do |name, data|
-        name.should == :woof
-        data[:actor].should == pet
+      expect(Reactor::Event).to receive(:publish) do |name, data|
+        expect(name).to eq(:woof)
+        expect(data[:actor]).to eq(pet)
       end
       auction
     end
@@ -54,8 +54,8 @@ 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
-      Reactor::Event.should_receive(:reschedule).with :ring, anything
-      Reactor::Event.should_receive(:reschedule).with :begin,
+      expect(Reactor::Event).to receive(:reschedule).with :ring, anything
+      expect(Reactor::Event).to receive(:reschedule).with :begin,
         hash_including(
           at: new_start_at,
           actor: auction,
@@ -70,8 +70,8 @@ describe Reactor::Publishable do
       ring_time = auction.ring_timeout
       new_start_at = auction.start_at + 1.week
       new_ring_time = new_start_at + 30.seconds
-      Reactor::Event.should_receive(:reschedule).with :begin, anything
-      Reactor::Event.should_receive(:reschedule).with :ring,
+      expect(Reactor::Event).to receive(:reschedule).with :begin, anything
+      expect(Reactor::Event).to receive(:reschedule).with :ring,
         hash_including(
           at: new_ring_time,
           actor: auction,
@@ -84,24 +84,24 @@ describe Reactor::Publishable do
     it 'supports immediate events (on create) that get fired once' do
       TestSubscriber.create! event_name: :bell
       auction
-      TestSubscriber.class_variable_get(:@@called).should be_true
+      expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
       TestSubscriber.class_variable_set(:@@called, false)
       auction.start_at = 1.day.from_now
       auction.save
-      TestSubscriber.class_variable_get(:@@called).should be_false
+      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
-      TestSubscriber.class_variable_get(:@@called).should be_false
+      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)
 
-      TestSubscriber.class_variable_get(:@@called).should be_true
+      expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
     end
 
     it 'can fire events onsave for any condition' do
@@ -110,11 +110,11 @@ describe Reactor::Publishable do
       TestSubscriber.class_variable_set(:@@called, false)
       auction.start_at = 1.day.from_now
       auction.save
-      TestSubscriber.class_variable_get(:@@called).should be_false
+      expect(TestSubscriber.class_variable_get(:@@called)).to be_falsey
       auction.start_at = 2.days.from_now
       auction.we_want_it = true
       auction.save
-      TestSubscriber.class_variable_get(:@@called).should be_true
+      expect(TestSubscriber.class_variable_get(:@@called)).to be_truthy
     end
   end
 end

data/spec/models/concerns/subscribable_spec.rb

@@ -33,7 +33,7 @@ describe Reactor::Subscribable do
 
   describe 'on_event' do
     it 'binds block of code statically to event being fired' do
-      Auction.any_instance.should_receive(:update_column).with(:status, 'first_bid_made')
+      expect_any_instance_of(Auction).to receive(:update_column).with(:status, 'first_bid_made')
       Reactor::Event.publish(:bid_made, target: Auction.create)
     end
 
@@ -46,49 +46,49 @@ describe Reactor::Subscribable do
 
     describe 'binding symbol of class method' do
       it 'fires on event' do
-        Auction.should_receive(:ring_bell)
+        expect(Auction).to receive(:ring_bell)
         Reactor::Event.publish(:puppy_delivered)
       end
 
       it 'can be delayed' do
-        Auction.should_receive(:pick_up_poop)
-        Auction.should_receive(:delay_for).with(5.minutes).and_return(Auction)
+        expect(Auction).to receive(:pick_up_poop)
+        expect(Auction).to receive(:delay_for).with(5.minutes).and_return(Auction)
         Reactor::Event.perform('pooped', {})
       end
     end
 
     it 'binds proc' do
-      Auction.should_receive(:puppies!)
+      expect(Auction).to receive(:puppies!)
       Reactor::Event.publish(:any_event)
     end
 
     it 'accepts wildcard event name' do
-      Auction.any_instance.should_receive(:more_puppies!)
+      expect_any_instance_of(Auction).to receive(:more_puppies!)
       Reactor::Event.publish(:another_event, actor: Auction.create)
     end
 
     describe 'in_memory flag' do
       it 'doesnt fire perform_async when true' do
-        Auction.should_receive(:puppies!)
-        Reactor::StaticSubscribers::CatDeliveredHandler0.should_not_receive(:perform_async)
+        expect(Auction).to receive(:puppies!)
+        expect(Reactor::StaticSubscribers::CatDeliveredHandler0).not_to receive(:perform_async)
         Reactor::Event.publish(:cat_delivered)
       end
 
       it 'fires perform_async when falsey' do
-        Reactor::StaticSubscribers::WildcardHandler0.should_receive(:perform_async)
+        expect(Reactor::StaticSubscribers::WildcardHandler0).to receive(:perform_async)
         Reactor::Event.publish(:puppy_delivered)
       end
     end
 
     describe '#perform' do
       it 'returns :__perform_aborted__ when Reactor is in test mode' do
-        Reactor::StaticSubscribers::TestPuppyDeliveredHandler0.new.perform({}).should == :__perform_aborted__
+        expect(Reactor::StaticSubscribers::TestPuppyDeliveredHandler0.new.perform({})).to eq(:__perform_aborted__)
         Reactor::Event.publish(:test_puppy_delivered)
       end
 
       it 'performs normally when specifically enabled' do
         Reactor.enable_test_mode_subscriber(TestModeAuction)
-        Reactor::StaticSubscribers::TestPuppyDeliveredHandler0.new.perform({}).should_not == :__perform_aborted__
+        expect(Reactor::StaticSubscribers::TestPuppyDeliveredHandler0.new.perform({})).not_to eq(:__perform_aborted__)
         Reactor::Event.publish(:test_puppy_delivered)
       end
     end

data/spec/models/subscriber_spec.rb

@@ -13,11 +13,21 @@ describe Reactor::Subscriber do
   describe 'fire' do
     subject { MySubscriber.create(event_name: :you_name_it).fire some: 'random', event: 'data' }
 
-    its(:event) { should be_a Reactor::Event }
-    its('event.some') { should == 'random' }
+    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
 
     it 'executes block given' do
-      subject.was_called.should be_true
+      expect(subject.was_called).to be_truthy
     end
   end
 
@@ -25,7 +35,7 @@ describe Reactor::Subscriber do
   describe 'matcher' do
     it 'can be set to star to bind to all events' do
       MySubscriber.create!(event_name: '*')
-      MySubscriber.any_instance.should_receive(:fire).with(hash_including('random' => 'data', 'event' => 'this_event'))
+      expect_any_instance_of(MySubscriber).to receive(:fire).with(hash_including('random' => 'data', 'event' => 'this_event'))
       Reactor::Event.publish(:this_event, {random: 'data'})
     end
   end

data/spec/reactor_spec.rb

@@ -12,9 +12,9 @@ describe Reactor do
 
   describe '.test_mode!' do
     it 'sets Reactor into test mode' do
-      Reactor.test_mode?.should be_false
+      expect(Reactor.test_mode?).to be_falsey
       Reactor.test_mode!
-      Reactor.test_mode?.should be_true
+      expect(Reactor.test_mode?).to be_truthy
     end
   end
 
@@ -23,13 +23,13 @@ describe Reactor do
     after  { Reactor.disable_test_mode! }
 
     it 'subscribers created in test mode are disabled' do
-      subscriber.should_not_receive :spy_on_me
+      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
-        subscriber.should_receive :spy_on_me
+        expect(subscriber).to receive :spy_on_me
         Reactor.with_subscriber_enabled(subscriber) do
           Reactor::Event.publish :test_event
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reactor
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - winfred
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-08 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -75,14 +75,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 2.99.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 2.99.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement