ventable 0.0.3 → 0.0.4

data/README.md

@@ -24,8 +24,8 @@ Or install it yourself as:
 
 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(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(event)```
+   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.
@@ -48,7 +48,7 @@ end
 
 # This class is an observer, interested in WakeUpEvents.
 class SleepingPerson
-  def self.handle_wake_up_event(event)
+  def self.handle_alarm_sound event
     self.wake_up
     puts "snoozing at #{event.wakeup_time}"
     self.snooze(5)
@@ -64,10 +64,10 @@ AlarmSoundEvent.new(Date.new).fire!
 
 ## Using #configure and groups
 
-Events can be configured to call observers in groups, with an optional block around it.
+Events can be configured to call observers in groups, with an optional block around it.  Using groups
+allows you (as in this example) wrap some observers in a transaction, and control the order of notification.
 
 ```ruby
-
 transaction = ->(b){
   ActiveRecord::Base.transaction do
     b.call
@@ -90,7 +90,6 @@ SomeEvent.configure do
     # perform block
   end
 
-
   # this observer gets notified after all observers inside :transactions are notified
   notifies AnotherObserverClass
 
@@ -102,22 +101,33 @@ end
 SomeEvent.new.fire!
 ```
 
+## Callback Method Name
+
+When the observer is notified, Ventable library will call a class method on your observer, with the name determined
+using the following logic:
+
+1. If your event defines ```EventClass.ventable_callback_method_name``` method, it's return value is used as a method name.
+2. If not, your event's fully qualified class name is converted to a method name with underscrores. This method name
+   always begings with ```handle_```.  For example, a class ```User::RegistrationEvent``` will generate callback
+   method name ```ObserverClass.handle_user__registration(event)``` (note that '::' is converted to two underscores).
+3. If neither method is found in the observer, a generic ```ObserverClass.handle(event)``` method is called.
+
 ## Guidelines for Using Ventable with Rails
 
 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.
 
-It is recommended to configure all events and observers in the ```event_initializer.rb``` file,
-inside the ```config/ininitalizers``` folder.
+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 ```ruby UserRegisteredEvent.new(user).fire!```, and have all subsequent logic broeken into
-their respective classes.  For example, if you need to send email to the user, have a ```Mailer```
-class observe the ```UserRegisteredEvent```, and so all the mailing logic can live in the ```Mailer```
-class, instead of, say, registration controller.  The callback method will receive the event, that
-wraps the User instance, or any other useful data necessary.
+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)```.
+The callback method will receive the event, that wraps the User instance, or any other useful data necessary.
 
 ## Further Discussion
 

data/lib/ventable/event.rb

@@ -88,7 +88,7 @@ module ::Ventable
           self.ventable_callback_method_name
         else
           target = self
-          method = "handle_" + target.name.gsub(/::/,'__').underscore.gsub(/_event/, '') + "_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 = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/ventable/ventable_spec.rb

@@ -1,5 +1,5 @@
 require 'ventable'
-require 'pp'
+
 describe Ventable do
   before do
     class TestEvent
@@ -66,7 +66,7 @@ describe Ventable do
         end
       end
       class TestEventObserver
-        def self.handle_test_event event
+        def self.handle_test event
           event.set_flag!
         end
       end
@@ -138,9 +138,9 @@ describe Ventable do
     end
 
     it "should properly set the callback method name" do
-      SomeAwesomeEvent.default_callback_method.should == :handle_some_awesome_event
-      Blah::AnotherSweetEvent.default_callback_method.should == :handle_blah__another_sweet_event
-      SomeOtherStuffHappened.default_callback_method.should == :handle_some_other_stuff_happened_event
+      SomeAwesomeEvent.default_callback_method.should == :handle_some_awesome
+      Blah::AnotherSweetEvent.default_callback_method.should == :handle_blah__another_sweet
+      SomeOtherStuffHappened.default_callback_method.should == :handle_some_other_stuff_happened
       ClassWithCustomCallbackMethodEvent.default_callback_method.should == :handle_my_special_event
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ventable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors: