eventable 0.1.0.beta1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in eventable.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mike Bethany
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,157 @@
+#Eventable#
+
+An incredibly simple way to add events to your classes.
+
+##Description##
+
+Provides an easy to use and understand event model. Other systems did way too much for my needs. I didn't need to monitor network IO ports, I didn't want a central loop that polled IO, I just wanted a simple way to add real, non-polled events to a class and to register other classes to listen for those events.
+
+If you want a simple way to add events to your classes without a bunch of other unrelated IO stuff this is the solution for you. (If you want to monitor IO events check out EventMachine)
+
+You don't have to worry about memory leaks either because Eventable only make a reference to the listening object when it needs to talk to it then it disposes of that reference. Best of all it will automatically remove registered listeners when they get garbage collected.
+
+Eventable couldn't be easier to use. 
+
+This example shows the basics of using Eventable to add an event to a class and listen for that event. (Without threading it's a bit pointless):
+
+    require 'eventable'
+
+    class EventClass
+      include Eventable
+  
+      # This is all you have to do to add an event (after you include Eventable)
+      event :stuff_happens
+
+      # don't name your method fire_event, that's taken
+      def do_event
+        puts "firing :stuff_happens"
+        # And this is all you have to do to make the event happen
+        fire_event(:stuff_happens, rand(1000))
+      end
+  
+    end
+
+    class ListenClass
+
+      def stuff_happened(stuff)
+        puts "stuff happened callback: #{stuff}"
+      end
+
+    end
+
+    # Create an instance of a class that has an event
+    evented   = EventClass.new
+
+    # Create a class that listens for that event
+    listener  = ListenClass.new
+
+    # Register the listener with the instance that will have the event
+    evented.register_for_event(event: :stuff_happens, listener: listener, callback: :stuff_happened)
+
+    # We'll just arbitrarilly fire the event to see how it works
+    evented.do_event
+
+    # Wait just to be sure you see it happen
+    sleep(1)
+
+    => firing :stuff_happens
+    => stuff happened callback: 575
+    
+This example shows you how you might actually use it in a multi-threaded environment but is a lot harder to read because of all the debug code:
+
+    require 'eventable'
+
+    class EventedClass
+      include Eventable
+      event :stuff_happens
+      event :other_stuff_happens
+  
+      def make_stuff_happen(parent_id)
+        # You handle concurrency however you want, threads or fibers, up to you.
+        Thread.new{
+          puts "firing :stuff_happens"
+          fire_event(:stuff_happens, {:parent_id=>parent_id, :some_value => rand(1000)})
+        }
+      end
+
+      def start_other_stuff_happening
+        Thread.new {
+          5.times do 
+            sleep(rand(1)+2)
+            puts "firing :other_stuff_happens"
+            fire_event(:other_stuff_happens)
+          end
+        }
+      end
+  
+    end
+
+    class ListenerClass
+  
+      def initialize(some_object)
+        @some_thing = some_object
+        @some_thing.register_for_event(event: :stuff_happens, listener: self, callback: :stuff_happened)
+      end
+
+      def do_somestuff(parent_id, times=6)
+        # I wrapped this in a thread to show it works cross threaded
+        Thread.new{
+          id = rand(1000)
+          times.times do
+            sleep(rand(2)+1)
+            puts "[#{parent_id}, #{id}]: do_somestuff"
+            @some_thing.make_stuff_happen(parent_id)
+          end
+        }
+      end
+  
+      def stuff_happened(stuff)
+        splat = stuff
+        puts "[#{splat[:parent_id]}] stuff_happened callback: #{splat[:some_value]}"
+      end
+  
+      def other_stuff_happened
+        puts "[n/a] same_stuff_happened callback: n/a"
+      end
+  
+    end
+
+    # Now show it running
+    evented = EventedClass.new
+
+    # You can inject the evented class
+    listener = ListenerClass.new(evented)
+
+    # or attach to events outside of a listener class
+    evented.register_for_event(event: :other_stuff_happens, listener: listener, callback: :other_stuff_happened)
+
+    evented.start_other_stuff_happening
+    (1..3).each do |index|
+      listener.do_somestuff(index)
+      puts "[#{index}] did some stuff, sleeping"
+      sleep(rand(3)+4)
+      puts "[#{index}] slept"
+    end
+
+    puts "all done"
+
+
+
+##Version History##
+
+**2011.06.06**  
+Ver: 0.1.0.beta1
+Completely redesigned from naive first attempt.
+
+**Added features**  
+
+Now includes RSpecs.
+
+Garbage collection safe:  
+* Won't keep references to listeners open. 
+* Automatically removes garbage collected listeners from event notifications.  
+
+
+**2011.06.04**  
+Ver: 0.0.1.alpha  
+Just wrote it as a proof of concept.  

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/_brainstorm/finalizer.rb

@@ -0,0 +1,48 @@
+# how does the finalizer work?
+# I need to unregister the object when the finalizer
+# is called but will it be called if I'm holding a reference to it?
+
+class Foo
+  def self.finalize(object_id)
+    proc {puts "finalize me: #{object_id}"}
+  end
+
+  def initialize
+    ObjectSpace.define_finalizer( self, self.class.finalize(self.object_id))
+  end
+
+  def hello
+    puts "hello: #{self.object_id}"
+  end
+
+end
+
+@y = []
+def external_finalizer(object_id)
+  proc do 
+    puts "external finalizer: #{object_id}"
+    @y.delete(object_id)
+  end
+end
+
+(0..4).each do |i|
+  f = Foo.new
+  ObjectSpace.define_finalizer(f, external_finalizer(f.object_id))
+  GC.start
+  @y << f.object_id
+  puts "i: #{i}"
+end
+
+@y.each do |object_id|
+  begin
+    obj = ObjectSpace._id2ref(object_id)
+    obj.hello
+  rescue RangeError => e
+    puts "das error: #{!!e.message.match(/is recycled object/)}"
+  end
+end
+
+puts "all done : note the finalizers firing AFTER this..."
+
+
+

data/_brainstorm/splat.rb

@@ -0,0 +1,27 @@
+def foo(a,b,c)
+  puts
+  puts "foo"
+  puts "a:#{a}; b: #{b}; c: #{c};"
+end
+
+def foo_explicit_block(a, b, c, &block)
+  puts
+  puts "foo_with_block"
+  puts "a:#{a}; b: #{b}; c: #{c};"
+  puts block.inspect
+end
+
+def foo_implied_block(a,b,c)
+  puts
+  puts "foo_implied_block"
+  puts "a:#{a}; b: #{b}; c: #{c};"
+  yield [a,b,c]
+end
+
+def bar(*args, &block)
+  foo(*args, &block)
+  foo_explicit_block(*args, &block)
+  foo_implied_block(*args, &block)
+end
+
+bar(1,2,3) {|x| puts x}

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery {"rspec2"}

data/eventable.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "eventable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "eventable"
+  s.version     = Eventable::VERSION
+  s.authors     = ["Mike Bethany"]
+  s.email       = ["mikbe.tk@gmail.com"]
+  s.homepage    = "http://mikbe.tk"
+  s.summary     = %q{An incredibly simple and easy to use event mixin module.}
+  s.description = %q{Provides an easy to use and understand event model. If you want a simple way to add events to your classes without a bunch of other unrelated IO stuff this is the solution for you. (If you want to monitor IO events check out EventMachine)}
+
+  s.add_development_dependency('rspec', "~>2.6")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/example/example.rb

@@ -0,0 +1,76 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'eventable'
+
+class EventedClass
+  include Eventable
+  event :stuff_happens
+  event :other_stuff_happens
+
+  def make_stuff_happen(parent_id)
+    # You handle concurrency however you want, threads or fibers, up to you.
+    Thread.new{
+      puts "firing :stuff_happens"
+      fire_event(:stuff_happens, {:parent_id=>parent_id, :some_value => rand(1000)})
+    }
+  end
+
+  def start_other_stuff_happening
+    Thread.new {
+      5.times do 
+        sleep(rand(1)+2)
+        puts "firing :other_stuff_happens"
+        fire_event(:other_stuff_happens)
+      end
+    }
+  end
+
+end
+
+class ListenerClass
+
+  def initialize(some_object)
+    @some_thing = some_object
+    @some_thing.register_for_event(event: :stuff_happens, listener: self, callback: :stuff_happened)
+  end
+
+  def do_somestuff(parent_id, times=6)
+    # I wrapped this in a thread to show it works cross threaded
+    Thread.new{
+      id = rand(1000)
+      times.times do
+        sleep(rand(2)+1)
+        puts "[#{parent_id}, #{id}]: do_somestuff"
+        @some_thing.make_stuff_happen(parent_id)
+      end
+    }
+  end
+
+  def stuff_happened(stuff)
+    splat = stuff
+    puts "[#{splat[:parent_id]}] stuff_happened callback: #{splat[:some_value]}"
+  end
+
+  def other_stuff_happened
+    puts "[n/a] same_stuff_happened callback: n/a"
+  end
+
+end
+
+# Now show it running
+evented = EventedClass.new
+
+# You can inject the evented class
+listener = ListenerClass.new(evented)
+
+# or attach to events outside of a listener class
+evented.register_for_event(event: :other_stuff_happens, listener: listener, callback: :other_stuff_happened)
+
+evented.start_other_stuff_happening
+(1..3).each do |index|
+  listener.do_somestuff(index)
+  puts "[#{index}] did some stuff, sleeping"
+  sleep(rand(3)+4)
+  puts "[#{index}] slept"
+end
+
+puts "all done"

data/example/simple_example.rb

@@ -0,0 +1,42 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'eventable'
+
+class EventClass
+  include Eventable
+  
+  # This is all you have to do to add an event (after you include Eventable)
+  event :stuff_happens
+
+  # don't name your method fire_event, that's taken
+  def do_event
+    puts "firing :stuff_happens"
+    # And this is all you have to do to make the event happen
+    fire_event(:stuff_happens, rand(1000))
+  end
+  
+end
+
+class ListenClass
+
+  def stuff_happened(stuff)
+    puts "stuff happened callback: #{stuff}"
+  end
+
+end
+
+# Create an instance of a class that has an event
+evented   = EventClass.new
+
+# Create a class that listens for that event
+listener  = ListenClass.new
+
+# Register the listener with the instance that will have the event
+evented.register_for_event(event: :stuff_happens, listener: listener, callback: :stuff_happened)
+
+# We'll just arbitrarilly fire the event to see how it works
+evented.do_event
+
+# Wait just to be sure you see it happen
+sleep(1)
+
+

data/lib/eventable.rb

@@ -0,0 +1,3 @@
+require "eventable/version"
+require "eventable/errors"
+require "eventable/eventable"

data/lib/eventable/errors.rb

@@ -0,0 +1,5 @@
+module Eventable
+  module Errors
+    UnknownEvent = Class.new(StandardError)
+  end
+end

data/lib/eventable/eventable.rb

@@ -0,0 +1,87 @@
+# Incredibly simple framework for adding events
+module Eventable
+
+  # Allows for dynamic discovery of hooked callbacks
+  attr_reader :callbacks
+
+  # Add the #event method to the extending class not instances of that class
+  def self.included(base)
+    base.extend(EventableClassMethods)
+  end
+  
+  module EventableClassMethods
+    
+    # register an event
+    def event(event_name)
+      @events ||= []
+      @events << event_name unless @events.include? event_name
+    end
+    
+    # returns a list of registered events
+    def events
+      @events.clone
+    end
+    
+  end
+
+  def events
+    self.class.events
+  end
+  
+  # When the event happens the class where it happens runs this
+  def fire_event(event, *return_value, &block)
+    return false unless @callbacks[event] && !@callbacks[event].empty?
+    @callbacks[event].each do |listener_id, callbacks|
+      listener = ObjectSpace._id2ref(listener_id)
+      callbacks.each {|callback| listener.send callback, *return_value, &block}
+    end
+  end
+
+  # Allows an object to listen for an event and have a callback run when the event happens
+  def register_for_event(args)
+    [:event, :listener, :callback].each do |parameter|
+      raise ArgumentError, "Missing parameter :#{parameter}" unless args[parameter]
+    end
+
+    event = args[:event]
+    raise Errors::UnknownEvent unless events.include? event
+    @callbacks ||= {}
+    @callbacks[event] ||= {}
+    
+    listener    = args[:listener]
+    listener_id = listener.object_id
+    callback    = args[:callback]
+    
+    # save the callback info without creating a reference to the object
+    @callbacks[event][listener_id] ||= []
+    @callbacks[event][listener_id] << callback
+
+    # will remove the object from the callback list if it is destroyed
+    ObjectSpace.define_finalizer(
+      listener, 
+      unregister_finalizer(event, listener_id, callback)
+    )
+
+  end
+
+  # Allows objects to stop listening to events
+  def unregister_for_event(args)
+    event = args[:event]
+    return unless @callbacks && @callbacks[event]
+    
+    listener_id = args[:listener_id] || args[:listener].object_id
+    callback    = args[:callback]
+    
+    @callbacks[event].delete_if do |listener, callbacks|
+      callbacks.delete(callback) if listener == listener_id
+      callbacks.empty?
+    end
+  end
+
+  # Wrapper for the finalize proc. You have to call a method
+  # from define_finalizer; you can't just put this proc in there.
+  def unregister_finalizer(event, listener_id, callback)
+    proc {unregister_for_event(event: event, listener_id: listener_id, callback: callback)}
+  end
+  
+end

data/lib/eventable/version.rb

@@ -0,0 +1,3 @@
+module Eventable
+  VERSION = "0.1.0.beta1"
+end

data/spec/eventable/eventable_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+
+describe Eventable do
+
+  before(:each) do
+    @evented = EventClass.new
+    @listener = ListenClass.new
+  end
+
+  context "when specifiying an event" do
+
+    it 'should list the event from the class' do
+      EventClass.events.should include(:stuff_happens)
+    end
+    
+    it 'should list more than one event' do
+      EventClass.events.should include(:other_stuff_happens)
+    end
+
+    it 'should list the event from an instance of the class' do
+      @evented.events.should include(:stuff_happens)
+    end
+    
+    it 'should list more than one event from an instance' do
+      @evented.events.should include(:other_stuff_happens)
+    end
+
+    it "should not add an event that's already been added" do
+      eval %{
+        class EventClass
+          include Eventable
+          event :stuff_happens
+        end
+      }
+      EventClass.events.count.should == 2
+    end
+
+    it "should not add events to other classes" do
+      eval %{
+        class EventClass2
+          include Eventable
+          event :some_other_event
+        end
+      }
+      EventClass.events.should_not include(:some_other_event)
+    end
+    
+    it "should not allow its event list to be altered external" do
+      events = EventClass.events
+      events.pop
+      events.should_not == EventClass.events
+    end
+  
+    it "should allow multiple classes to use the mixin" do
+    end
+  
+  end
+  
+  context "when registering for an event" do
+
+    context "and there is a missing parameter" do
+
+      # these tests could be refactored into one...
+      it "should raise an error if the event is not specified" do
+        lambda{ 
+          @evented.register_for_event(listener: @listener, callback: :callback)
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error if the listener is not specified" do
+        lambda{ 
+          @evented.register_for_event(event: :do_something, callback: :callback)
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an error if the callback is not specified" do
+        lambda{ 
+          @evented.register_for_event(event: :do_something, listener: @listener)
+        }.should raise_error(ArgumentError)
+      end
+
+    end
+
+    it "should raise an error if the event doesn't exist" do
+      foo = Class.new
+      lambda{ 
+        @evented.register_for_event(event: :nonexistent, listener: foo, callback: :bar)
+      }.should raise_error(Eventable::Errors::UnknownEvent)
+    end
+
+    it "should not raise an error when registering for events that do exist" do
+      lambda{ 
+        @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      }.should_not raise_error
+    end
+
+    it "should allow multiple callbacks to the same method from different events" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.register_for_event(event: :other_stuff_happens, listener: @listener, callback: :callback)
+      @evented.callbacks.count.should == 2 
+    end
+    
+    it "should not add a callback that's already been added" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.callbacks[:stuff_happens].count.should == 1 
+    end
+
+    it "should allow multiple instances of the same class to register the same callback for the same event" do
+      listener2 = ListenClass.new
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.register_for_event(event: :stuff_happens, listener: listener2, callback: :callback)
+      @evented.callbacks[:stuff_happens].keys.should == [@listener.object_id, listener2.object_id]
+    end
+
+    it "should allow callbacks from the same event to different methods in the same instance" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback2)
+      @evented.do_event
+      @listener.callback?.should be_true
+      @listener.callback2?.should be_true
+    end
+
+    it "should allow callbacks to class methods" do
+      # should be a no brainer because a class is an object too, but just to be sure
+      @evented.register_for_event(event: :stuff_happens, listener: ListenClass, callback: :class_callback)
+      @evented.do_event
+      ListenClass.class_callback?.should be_true
+    end
+
+    context "when multiple classes mixin eventable" do
+
+      # this is kind of redundant but just to be sure there's no bleed over through the mixin module
+
+      it "should not call the wrong class" do
+        another_evented = AnotherEventClass.new
+        another_listener = AnotherListenClass.new
+        @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+        another_evented.register_for_event(event: :stuff_happens, listener: another_listener, callback: :callback)
+        @evented.do_event
+        @listener.callback?.should be_true
+        another_listener.callback?.should_not be_true
+      end
+
+      it "should not call the wrong class when both evented classes fire events" do
+        another_evented = AnotherEventClass.new
+        another_listener = AnotherListenClass.new
+        @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+        another_evented.register_for_event(event: :stuff_happens, listener: another_listener, callback: :callback2)
+        @evented.do_event
+        another_evented.do_event
+        @listener.callback?.should be_true
+        another_listener.callback2?.should be_true
+      end
+
+    end
+
+  end
+  
+  context "when unregistering for an event" do
+  
+    it "should remove a callback" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.callbacks[:stuff_happens].keys.should include(@listener.object_id) # <= just to be sure...
+      @evented.unregister_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.callbacks[:stuff_happens].keys.should_not include(@listener.object_id)
+    end
+  
+    it "should not call a callback that has been removed" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.unregister_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.do_event
+      @listener.callback?.should_not be_true
+    end
+  
+    it "should automatically remove callbacks to objects that are garbage collected" do
+      listener_object_id = nil
+      (0..1).each do
+        listener = ListenClass.new
+        listener_object_id ||= listener.object_id
+        @evented.register_for_event(event: :stuff_happens, listener: listener, callback: :callback)
+      end
+      GC.start
+      @evented.callbacks[:stuff_happens].keys.should_not include(listener_object_id) 
+    end
+  
+  end
+
+  context "when an event is fired" do
+  
+    it "should call back the specified method when the event is fired" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.do_event
+      @listener.callback?.should be_true
+    end
+      
+    it "should not call back the wrong method when the event is fired" do
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.do_event
+      @listener.callback2?.should_not be_true
+    end
+    
+    it "should call back more than one class" do
+      listener2 = ListenClass.new
+    
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.register_for_event(event: :stuff_happens, listener: listener2, callback: :callback2)
+    
+      @evented.do_event
+    
+      @listener.callback?.should be_true
+      listener2.callback2?.should be_true
+    end
+
+    it "should not call back the wrong method when using multiple classes" do
+      listener2 = ListenClass.new
+    
+      @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
+      @evented.register_for_event(event: :stuff_happens, listener: listener2, callback: :callback2)
+    
+      @evented.do_event
+    
+      @listener.callback2?.should_not be_true
+      listener2.callback?.should_not be_true
+    end
+
+    context "and it has return data" do
+
+      it "should return the return values" do
+        @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback_with_args)
+        a, b, c = rand(100), rand(100), rand(100)
+        @evented.do_event_with_args(a,b,c)
+        @listener.callback_with_args?.should == [a,b,c]
+      end
+
+      it "should return a block" do
+        @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback_with_block)
+        block = proc {"a block"}
+        @evented.do_event_with_block(&block)
+        @listener.callback_with_block?.should == block
+      end
+
+      it "should return the return values and a block" do
+        @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback_with_args_and_block)
+        a, b, c, block = rand(100), rand(100), rand(100), proc {"a block"}
+        @evented.do_event_with_args_and_block(a,b,c,&block)
+        @listener.callback_with_args_and_block?.should == [a,b,c,block]
+      end
+
+    end
+    
+  end
+
+end
+
+# Test classes
+
+class EventClass
+  include Eventable
+  event :stuff_happens
+  event :other_stuff_happens
+  def do_event(event=:stuff_happens)
+    fire_event(event)
+  end
+  def do_event_with_args(*args)
+    fire_event(:stuff_happens, *args)
+  end
+  def do_event_with_block(&block)
+    fire_event(:stuff_happens, &block)
+  end
+  def do_event_with_args_and_block(*args, &block)
+    fire_event(:stuff_happens, *args, &block)
+  end
+end
+
+class AnotherEventClass
+  include Eventable
+  event :stuff_happens
+  event :different_happens
+  
+  def do_event(event=:stuff_happens)
+    fire_event(event)
+  end
+end
+
+class ListenClass
+  def self.class_callback?
+    @@callback
+  end
+  def self.class_callback
+    @@callback = true
+  end
+  def callback?
+    @callback
+  end
+  def callback
+    @callback = true
+  end
+  def callback2?
+    @callback2
+  end
+  def callback2
+    @callback2 = true
+  end
+  def callback_with_args(a,b,c)
+    @a, @b, @c = a, b, c
+  end
+  def callback_with_args?
+    [@a, @b, @c]
+  end
+  def callback_with_block(&block)
+    @block = block
+  end
+  def callback_with_block?
+    @block
+  end
+  def callback_with_args_and_block(a,b,c,&block)
+    @a, @b, @c, @block = a, b, c, block
+  end
+  def callback_with_args_and_block?
+    [@a, @b, @c, @block]
+  end
+end
+
+class AnotherListenClass
+  def callback?
+    @callback
+  end
+  def callback
+    @callback = true
+  end
+    def callback2?
+    @callback2
+  end
+  def callback2
+    @callback2 = true
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$: << '.'
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'rspec'
+require 'eventable'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: eventable
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta1
+  prerelease: 6
+platform: ruby
+authors:
+- Mike Bethany
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-06-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156146420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *2156146420
+description: Provides an easy to use and understand event model. If you want a simple
+  way to add events to your classes without a bunch of other unrelated IO stuff this
+  is the solution for you. (If you want to monitor IO events check out EventMachine)
+email:
+- mikbe.tk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- _brainstorm/finalizer.rb
+- _brainstorm/splat.rb
+- autotest/discover.rb
+- eventable.gemspec
+- example/example.rb
+- example/simple_example.rb
+- lib/eventable.rb
+- lib/eventable/errors.rb
+- lib/eventable/eventable.rb
+- lib/eventable/version.rb
+- spec/eventable/eventable_spec.rb
+- spec/spec_helper.rb
+homepage: http://mikbe.tk
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: An incredibly simple and easy to use event mixin module.
+test_files:
+- spec/eventable/eventable_spec.rb
+- spec/spec_helper.rb