ventable 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d49bbdbaf27b03c942ba8887eb4eca4c89f63cbc
-  data.tar.gz: c75ae281c96bfa5998c6f338ba5fd6d5bb164ace
+SHA256:
+  metadata.gz: 57b42bb96d2c3c0bac1f4fc8e97ed42b3ee5eb9494a9f36f04cea0c0888765e3
+  data.tar.gz: 13b3f1b9860d9b26b812bf0ff6b2daa4d318af0906d71d4e02a17577067e7eca
 SHA512:
-  metadata.gz: 7d130ab305df24c7f31e1fc11dcf7cc64c560edd2311ff6330ebeb33394ed819e444795b8f6c5fb3aff8ba9371c96c746dbec17db3ac3b368a149891bde5fc0c
-  data.tar.gz: 2f12228bb3d42a58d7534f077844b26c5f1212c104b5da2bbf8aa4facb2f1783f86cfa1abc10e8b08982cbcfd6a07efbd6dd8f8afb9e76e42ecd271e06f07887
+  metadata.gz: 2a032511c88f1f9f2f62f2a0b3b39a2f81337585550596634eabb875c34731bfe458477a4246e47e2624363041fccb92fc6e98b7628d5e4bb32a6a62ab058511
+  data.tar.gz: 396af327f6e393cc9db4efd5f12c2787eeec7fa2cb1f83f9c600e389bd8296bb3092713a5e9056b252acd9e1129e5703853e0099cc82f9a58646c0bc5b1532a0

data/.gitignore

@@ -1,3 +1,4 @@
+**/.DS_Store
 *.gem
 *.rbc
 .bundle
@@ -5,6 +6,7 @@
 .yardoc
 InstalledFiles
 _yardoc
+Gemfile.lock
 coverage
 doc/
 lib/bundler/man
@@ -15,3 +17,4 @@ test/tmp
 test/version_tmp
 tmp
 .idea/
+vendor/

data/.travis.yml

@@ -1,10 +1,18 @@
 language: ruby
 rvm:
-  - 1.9.3
-script: "bundle exec rspec"
-notifications:
-  email:
-    recipients:
-      - kigster@gmail.com
-    on_success: never
-    on_failure: always
+- 2.3.8
+- 2.4.5
+- 2.5.3
+- 2.6.1
+script:
+- bundle exec rspec
+env:
+  global:
+  - secure: mjjlvfSCJpmD06E5DIkqhaYwjGP85cyBeM8NrxLsUXuEYLVNvL8pKoL5GJVPE8oqnQ93j2egLXZw50ZER7rBWDJhdHZ1LosQEKJgljRNc/wjqyQBTXRr3ZBRpWxKO4SJMhM65lUp1UYzIQj8AJDNehuZIIngFBTy01sHsI+hs8g=
+before_script:
+- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64
+  > ./cc-test-reporter
+- chmod +x ./cc-test-reporter
+- "./cc-test-reporter before-build"
+after_script:
+- "./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"

data/Gemfile

@@ -1,4 +1,2 @@
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in ventable.gemspec
 gemspec

data/README.md

@@ -1,14 +1,47 @@
-[![Gem Version](https://badge.fury.io/rb/ventable.png)](http://badge.fury.io/rb/ventable)
-[![Build status](https://secure.travis-ci.org/kigster/ventable.png)](http://travis-ci.org/kigster/ventable)
-[![Code Climate](https://codeclimate.com/github/kigster/ventable.png)](https://codeclimate.com/github/kigster/ventable)
+
+[![Gem Version](https://badge.fury.io/rb/ventable.svg)](https://badge.fury.io/rb/ventable)
+[![Build Status](https://travis-ci.org/kigster/ventable.svg?branch=master)](https://travis-ci.org/kigster/ventable)
+[![Code Climate](https://codeclimate.com/github/kigster/ventable/badges/gpa.svg)](https://codeclimate.com/github/kigster/ventable)
+[![Downloads](http://ruby-gem-downloads-badge.herokuapp.com/ventable?type=total)](https://rubygems.org/gems/ventable)
+[![Gitter](https://img.shields.io/gitter/room/gitterHQ/gitter.svg)](https://gitter.im/kigster/ventable)
+
+[![Test Coverage](https://api.codeclimate.com/v1/badges/c28d141c978293886d21/test_coverage)](https://codeclimate.com/github/kigster/ventable/test_coverage)
 
 
 # Ventable
 
-Simple eventing gem that implements Observable pattern, but with more options, ability to group observers and wrap
-them in arbitrary blocks of code.  For example, when a certain event fires, some observers may be called within
-a transaction context, while others maybe called outside of the transaction context.
+This gem is a variation of the [Observer Design Pattern](https://en.wikipedia.org/wiki/Observer_pattern). 
+
+In particular: 
+
+ * Ventable requires creation of simple event classes that may carry data and be serialized.
+ * Observers can be grouped together, and notified within a pre-defined `Proc`. For example, using grouping some observers may be called within the boundaries of a database transaction, while others maybe called outside of it.
+ * Ventable allows both compile time and run time observer binding.
+ * Ventable calls specific method on each observer, using automatically derived method name from the event class. A generic `#handle_event` method is also supported.
+
+Limitations:
+
+ * At the moment, Ventable can only notify observers within the current ruby process.
+ 
+## Plugins
+
+Ventable has several plugins that add various functionality on top of the basic event dispatch mechanism.
 
+ * [ventable-statsd](https://github.com/kigster/ventable-statsd) is an extension that allows notifying Statsd whenever an event occurs.
+ * [simple-feed](https://github.com/kigster/simple-feed) is a generic implementation of the activity feed concept commonly seen on social networks,  and it integrates nicely with Ventable.
+
+## Ruby Versions
+
+This gem has been verified to work in the following ruby versions:
+
+ * MRI Ruby
+   * 1.9.3-p551
+   * 2.2
+   * 2.3
+   * 2.4
+
+The gem also likely works with non-MRI rubies, but it has not been tested.
+    
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -25,13 +58,16 @@ Or install it yourself as:
 
 ## Usage
 
-1. Create your own plain ruby Event class that optionally carries some data important to the event. Include module ```Ventable::Event```.
+1. Create your own plain ruby Event class that optionally carries some data important to the event. Include module `Ventable::Event`.
+
 2. Create one or more observers.  Observer can be any class that implements event handler method as a class method, such as a
-   generic method ```self.handle(event)``` or a more specific method mapped to the event name: say for event UserRegistered the
-   callback event would be ```self.handle_user_registered(event)```
-3. Register your observers with the event using ```notifies``` event method, or register groups using ```group``` method, and then
-   use ```notify``` with options ```inside: :group_name```
-4. Instantiate your event class (optionally with some data), and call ```fire!``` method.
+   generic method `self.handle(event)` or a more specific method mapped to the event name: say for event UserRegistered the
+   callback event would be `self.handle_user_registered(event)`
+
+3. Register your observers with the event using `notifies` event method, or register groups using `group` method, and then
+   use `notify` with options `inside: :group_name`
+
+4. Instantiate your event class (optionally with some data), and call `publish` or, a deprecated `fire!` method.
 
 ## Example
 
@@ -62,7 +98,7 @@ end
 AlarmSoundEvent.notifies SleepingPerson
 
 # Create and fire the event
-AlarmSoundEvent.new(Date.new).fire!
+AlarmSoundEvent.new(Date.new).publish
 ```
 
 ## Using #configure and groups
@@ -101,7 +137,7 @@ SomeEvent.configure do
   notifies ObserverClass1, ObserverClass2, inside: :transaction
 end
 
-SomeEvent.new.fire!
+SomeEvent.new.publish
 ```
 
 ## Callback Method Name
@@ -119,23 +155,23 @@ using the following logic:
 
 You should start by defining your event library for your application (list of events
 that are important to you),  you can place these files anywhere you like, such as
-```lib/events``` or ```app/events```, etc.
+`lib/events` or `app/events`, etc.
 
-It is recommended to ```configure``` all events and their observers in the ```event_initializer.rb``` file,
-inside the ```config/ininitalizers``` folder.  You may need to require your events in that file also.
+It is recommended to `configure` all events and their observers in the `event_initializer.rb` file,
+inside the `config/ininitalizers` folder.  You may need to require your events in that file also.
 
 When your event is tied to a creation of a "first class objects", such as user registration,
 it is recommended to create the User record first, commit it to the database, and then throw
-a ```UserRegisteredEvent.new(user).fire!```, and have all subsequent logic broeken into
-their respective classes.  For example, if you need to send an email to the user, have a ```Mailer```
-class observe the ```UserRegisteredEvent```, and so all the mailing logic can live inside the ```Mailer```
-class, instead of, say, registration controller directly calling ```Mailer.deliver_user_registration!(user)```.
+a `UserRegisteredEvent.new(user).publish`, and have all subsequent logic broeken into
+their respective classes.  For example, if you need to send an email to the user, have a `Mailer`
+class observe the `UserRegisteredEvent`, and so all the mailing logic can live inside the `Mailer`
+class, instead of, say, registration controller directly calling `Mailer.deliver_user_registration!(user)`.
 The callback method will receive the event, that wraps the User instance, or any other useful data necessary.
 
 ## Integration with tests
 
 There are times when it may be desirable to disable all eventing. For instance, when writing unit tests,
-testing that events are fired may be useful, but integrating with all observers adds complexity and confusion.
+testing that events are published may be useful, but integrating with all observers adds complexity and confusion.
 In these cases, Ventable may be globally disabled.
 
 ```ruby
@@ -153,14 +189,14 @@ Now in a spec file:
 ```ruby
 describe "Stuff", eventing: false do
   it 'does stuff' do
-    ... my code that fires events, in isolation from event observers
+    ... my code that publishes events, in isolation from event observers
   end
 
-  it 'tests that events are fired, using stubs' do
-    event = double(fire!: true)
+  it 'tests that events are published, using stubs' do
+    event = double(publish: true)
     allow(MyEvent).to receive(:new).and_return(event)
     ... my code that should fire event
-    expect(event).to have_received(:fire!)
+    expect(event).to have_received(:publish)
   end
 end
 

data/Rakefile

@@ -1,3 +1,22 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+
+def shell(*args)
+  puts "running: #{args.join(' ')}"
+  system(args.join(' '))
+end
+
+task :clean do
+  shell('rm -rf pkg/ tmp/ coverage/ doc/ ' )
+end
+
+task :gem => [:build] do
+  shell('gem install pkg/*')
+end
+
+task :permissions => [ :clean ] do
+  shell("chmod -v o+r,g+r * */* */*/* */*/*/* */*/*/*/* */*/*/*/*/*")
+  shell("find . -type d -exec chmod o+x,g+x {} \\;")
+end
+
+task :build => :permissions
 

data/lib/ventable.rb

@@ -1,5 +1,5 @@
-require "ventable/version"
-require "ventable/event"
+require 'ventable/version'
+require 'ventable/event'
 
 module Ventable
 
@@ -12,7 +12,7 @@ module Ventable
   end
 
   def self.enabled?
-    @disabled != true
+    !@disabled
   end
 end
 
@@ -21,7 +21,7 @@ class String
     self.gsub(/::/, '/').
         gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
         gsub(/([a-z\d])([A-Z])/, '\1_\2').
-        tr("-", "_").
+        tr('-', '_').
         downcase
   end
 end

data/lib/ventable/event.rb

@@ -20,6 +20,8 @@ module ::Ventable
       notify_observer_set(self.class.observers) if Ventable.enabled?
     end
 
+    alias publish fire!
+
     private
 
     def notify_observer_set(observer_set)
@@ -28,25 +30,23 @@ module ::Ventable
           around_block = observer_entry[:around_block]
           inside_block = -> { notify_observer_set(observer_entry[:observers]) }
           around_block.call(inside_block)
-        elsif observer_entry
-          notify_observer(observer_entry)
         else
-          raise Ventable::Error.new("nil in observer_entry set #{observer_set.inspect}!")
+          notify_observer(observer_entry)
         end
       end
     end
 
     def notify_observer(observer)
       case observer
-        when Proc
-          observer.call(self)
-        else # class
-          notify_class_observer(observer)
+      when Proc
+        observer.call(self)
+      else # class
+        notify_class_observer(observer)
       end
     end
 
     def notify_class_observer(observer)
-      default_handler = self.class.default_callback_method
+      default_handler = self.class.send(:default_callback_method)
       return observer.send(default_handler, self) if observer.respond_to?(default_handler)
       return observer.send(:handle_event, self) if observer.respond_to?(:handle_event)
       raise Ventable::Error.new("no suitable event handler method found for #{self.class} in observer #{observer} (try adding #{default_handler} to this observer)")
@@ -57,43 +57,40 @@ module ::Ventable
         class_eval(&block)
       end
 
-      def notifies(*observer_list, &block)
-        options = {}
-        options.merge! observer_list.pop if observer_list.last.is_a?(Hash)
+      def notifies(*observer_list, **options, &block)
         observer_set = self.observers
         if options[:inside]
           observer_entry = self.find_observer_group(options[:inside])
-          if observer_entry.nil?
-            raise Ventable::Error.new("No group with name #{options[:inside]} found.")
-          end
+          raise Ventable::Error.new("No group with name #{options[:inside]} found.") if observer_entry.nil?
           observer_set = observer_entry[:observers]
         end
-        raise Ventable::Error.new("found nil observer in params #{observer_list.inspect}") if observer_list.any?{|l| l.nil?}
+        raise Ventable::Error.new("found nil observer in params #{observer_list.inspect}") if observer_list.any?(&:nil?)
         observer_list.compact.each { |o| observer_set << o } unless observer_list.empty?
         observer_set << block if block
       end
 
       def group(name, &block)
-        g = find_observer_group(name)
-        raise "Group #{name} already defined by #{g}" if g
-        self.observers <<
-            { name: name,
-              around_block: block,
-              observers: Set.new
-            }
+        self.observers << { name:         name,
+                            around_block: block,
+                            observers:    Set.new }
+
       end
 
+      protected
+
       def find_observer_group(name)
         self.observers.find { |o| o.is_a?(Hash) && o[:name] == name }
       end
 
+      private
+
       # Determine method name to call when notifying observers from this event.
       def default_callback_method
         if respond_to?(:ventable_callback_method_name)
           self.ventable_callback_method_name
         else
           target = self
-          method = "handle_" + target.name.gsub(/::/,'__').underscore.gsub(/_event/, '')
+          method = 'handle_' + target.name.gsub(/::/, '__').underscore.gsub(/_event/, '')
           method.to_sym
         end
       end

data/lib/ventable/version.rb

@@ -1,3 +1,3 @@
 module Ventable
-  VERSION = "1.0.0"
+  VERSION = '1.2.0'
 end

data/spec/spec_helper.rb

@@ -1,17 +1,11 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'simplecov'
+require 'rspec'
+
+SimpleCov.start
 
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-require 'rubygems'
-require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
 require 'ventable'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/ventable/ventable_spec.rb

@@ -1,4 +1,4 @@
-require 'ventable'
+require 'spec_helper'
 
 describe Ventable do
   before do
@@ -26,13 +26,13 @@ describe Ventable do
     end
   end
 
-  describe "including Ventable::Event" do
-    it "should create a class instance variable to keep observers" do
+  describe 'including Ventable::Event' do
+    it 'should create a class instance variable to keep observers' do
       expect(TestEvent.observers).not_to be_nil
-      expect(TestEvent.observers.class.name).to eq("Set")
+      expect(TestEvent.observers.class.name).to eq('Set')
     end
 
-    it "should see observers variable from instance methods" do
+    it 'should see observers variable from instance methods' do
       observers = nil
       TestEvent.new.instance_eval do
         observers = self.class.observers
@@ -40,7 +40,7 @@ describe Ventable do
       expect(observers).to_not be_nil
     end
 
-    it "should maintain separate sets of observers for each event" do
+    it 'should maintain separate sets of observers for each event' do
       class AnotherEvent
         include Ventable::Event
       end
@@ -48,19 +48,19 @@ describe Ventable do
     end
   end
 
-  describe "#fire" do
+  describe '#fire' do
     before do
       class TestEvent
         include Ventable::Event
       end
     end
 
-    it "should properly call a Proc observer" do
+    it 'should properly call a Proc observer' do
       run_block = false
-      event = nil
+      event     = nil
       TestEvent.notifies do |e|
         run_block = true
-        event = e
+        event     = e
       end
       expect(run_block).to eq(false)
       expect(event).to be_nil
@@ -72,33 +72,69 @@ describe Ventable do
       expect(event).not_to be_nil
     end
 
-    it "should properly call a class observer" do
-      class TestEvent
-        class << self
-          attr_accessor :flag
+    describe 'class observer' do
+      before do
+        class TestEvent
+          class << self
+            attr_accessor :flag
+          end
+
+          self.flag = 'unset'
+
+          def flag=(value)
+            self.class.flag = value
+          end
         end
-        self.flag = "unset"
-        def flag= value
-          self.class.flag = value
+
+        class TestEventObserver
+          def self.handle_test(event)
+            event.flag = 'boo'
+          end
         end
-      end
 
-      class TestEventObserver
-        def self.handle_test event
-          event.flag = "boo"
+        class GlobalObserver
+          class << self
+            def handle_event(event)
+              puts event.inspect
+            end
+          end
         end
+
+        TestEvent.notifies TestEventObserver, GlobalObserver
       end
-      TestEvent.notifies TestEventObserver
-      expect(TestEvent.flag).to eq("unset")
 
-      TestEvent.new.fire!
-      expect(TestEvent.flag).to eq("boo")
+      let(:event) { TestEvent.new }
+
+      before do
+        expect(TestEvent.flag).to eq('unset')
+        expect(GlobalObserver).to receive(:handle_event).with(event)
+      end
+
+      it 'should set the flag and call observers' do
+        event.fire!
+        expect(TestEvent.flag).to eq('boo')
+      end
+
+      it 'should also fire via the publish alias' do
+        event.publish
+      end
+
+      context 'observer without a handler' do
+        before {
+          class ObserverWithoutAHandler
+          end
+          TestEvent.notifies ObserverWithoutAHandler
+        }
+        it 'should raise an exception' do
+          expect { event.publish }.to raise_error(Ventable::Error)
+        end
+      end
     end
 
-    it "should properly call a group of observers" do
-      transaction_called = false
+    it 'should properly call a group of observers' do
+      transaction_called    = false
       transaction_completed = false
-      transaction = ->(observer_block) {
+      transaction           = ->(observer_block) {
         transaction_called = true
         observer_block.call
         transaction_completed = true
@@ -110,11 +146,11 @@ describe Ventable do
       # this flag ensures that this block really runs inside
       # the transaction group block
       transaction_already_completed = false
-      event_inside = nil
+      event_inside                  = nil
       TestEvent.notifies inside: :transaction do |event|
-        observer_block_called = true
+        observer_block_called         = true
         transaction_already_completed = transaction_completed
-        event_inside = event
+        event_inside                  = event
       end
 
       expect(transaction_called).to be false
@@ -123,9 +159,9 @@ describe Ventable do
 
       TestEvent.new.fire!
 
-      expect(transaction_called).to be  true
-      expect(observer_block_called).to be  true
-      expect(transaction_called).to be  true
+      expect(transaction_called).to be true
+      expect(observer_block_called).to be true
+      expect(transaction_called).to be true
       expect(transaction_already_completed).to be false
       expect(event_inside).to_not be_nil
       expect(event_inside).to be_a(TestEvent)
@@ -148,7 +184,7 @@ describe Ventable do
     end
   end
 
-  describe "#default_callback_method" do
+  describe '#default_callback_method' do
     before do
       class SomeAwesomeEvent
         include Ventable::Event
@@ -163,6 +199,7 @@ describe Ventable do
       class SomeOtherStuffHappened
         include Ventable::Event
       end
+
       class ClassWithCustomCallbackMethodEvent
         include Ventable::Event
 
@@ -172,16 +209,16 @@ describe Ventable do
       end
     end
 
-    it "should properly set the callback method name" do
-      expect(SomeAwesomeEvent.default_callback_method).to eq(:handle_some_awesome)
-      expect(Blah::AnotherSweetEvent.default_callback_method).to eq(:handle_blah__another_sweet)
-      expect(SomeOtherStuffHappened.default_callback_method).to eq(:handle_some_other_stuff_happened)
-      expect(ClassWithCustomCallbackMethodEvent.default_callback_method).to eq(:handle_my_special_event)
+    it 'should properly set the callback method name' do
+      expect(SomeAwesomeEvent.send(:default_callback_method)).to eq(:handle_some_awesome)
+      expect(Blah::AnotherSweetEvent.send(:default_callback_method)).to eq(:handle_blah__another_sweet)
+      expect(SomeOtherStuffHappened.send(:default_callback_method)).to eq(:handle_some_other_stuff_happened)
+      expect(ClassWithCustomCallbackMethodEvent.send(:default_callback_method)).to eq(:handle_my_special_event)
     end
   end
 
-  describe "#configure" do
-    it "properly configures the event with observers" do
+  describe '#configure' do
+    it 'properly configures the event with observers' do
       notified_observer = false
       TestEvent.configure do
         notifies do
@@ -192,11 +229,11 @@ describe Ventable do
       expect(notified_observer).to be true
     end
 
-    it "configures observers with groups" do
-      notified_observer = false
+    it 'configures observers with groups' do
+      notified_observer  = false
       called_transaction = false
       TestEvent.configure do
-        group :transaction, &->(b){
+        group :transaction, &->(b) {
           b.call
           called_transaction = true
         }
@@ -209,24 +246,24 @@ describe Ventable do
       expect(called_transaction).to be true
     end
 
-    it "throws exception if :inside references unknown group" do
+    it 'throws exception if :inside references unknown group' do
       begin
         TestEvent.configure do
           notifies inside: :transaction do
             # some stuff
           end
         end
-        fail "Shouldn't reach here, must throw a valid exception"
+        fail 'Shouldn\'t reach here, must throw a valid exception'
       rescue Exception => e
         expect(e.class).to eq(Ventable::Error)
       end
     end
-    it "throws exception if nil observer added to the list" do
+    it 'throws exception if nil observer added to the list' do
       begin
         TestEvent.configure do
           notifies nil
         end
-        fail "Shouldn't reach here, must throw a valid exception"
+        fail 'Shouldn\'t reach here, must throw a valid exception'
       rescue Exception => e
         expect(e.class).to eq(Ventable::Error)
       end

data/ventable.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |gem|
   gem.version       = Ventable::VERSION
 
   gem.add_development_dependency "rake"
+  gem.add_development_dependency "simplecov"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "rspec-mocks"
   gem.add_development_dependency 'guard-rspec'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ventable
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Konstantin Gredeskoul
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-28 00:00:00.000000000 Z
+date: 2019-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -78,7 +92,6 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - Guardfile
 - LICENSE
 - README.md
@@ -108,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Event/Observable design pattern in ruby

data/Gemfile.lock

@@ -1,72 +0,0 @@
-PATH
-  remote: .
-  specs:
-    ventable (1.0.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    coderay (1.1.0)
-    diff-lcs (1.2.5)
-    ffi (1.9.10)
-    formatador (0.2.5)
-    guard (2.13.0)
-      formatador (>= 0.2.4)
-      listen (>= 2.7, <= 4.0)
-      lumberjack (~> 1.0)
-      nenv (~> 0.1)
-      notiffany (~> 0.0)
-      pry (>= 0.9.12)
-      shellany (~> 0.0)
-      thor (>= 0.18.1)
-    guard-compat (1.2.1)
-    guard-rspec (4.6.4)
-      guard (~> 2.1)
-      guard-compat (~> 1.1)
-      rspec (>= 2.99.0, < 4.0)
-    listen (3.0.5)
-      rb-fsevent (>= 0.9.3)
-      rb-inotify (>= 0.9)
-    lumberjack (1.0.10)
-    method_source (0.8.2)
-    nenv (0.2.0)
-    notiffany (0.0.8)
-      nenv (~> 0.1)
-      shellany (~> 0.0)
-    pry (0.10.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rake (10.5.0)
-    rb-fsevent (0.9.7)
-    rb-inotify (0.9.5)
-      ffi (>= 0.5.0)
-    rspec (3.4.0)
-      rspec-core (~> 3.4.0)
-      rspec-expectations (~> 3.4.0)
-      rspec-mocks (~> 3.4.0)
-    rspec-core (3.4.1)
-      rspec-support (~> 3.4.0)
-    rspec-expectations (3.4.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-mocks (3.4.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-support (3.4.1)
-    shellany (0.0.1)
-    slop (3.6.0)
-    thor (0.19.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  guard-rspec
-  rake
-  rspec
-  rspec-mocks
-  ventable!
-
-BUNDLED WITH
-   1.11.2