eventually 0.0.1

data/.gitignore

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@eventually --create

data/Gemfile

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

data/README.md

@@ -0,0 +1,86 @@
+# Eventually
+
+`Eventually` is a module that facilitates evented callback management *similar* to the [EventEmitter API](http://nodejs.org/docs/v0.4.7/api/events.html) in NodeJS. Support for Ruby's various lambda-ish callback styles is heavily baked in, so using blocks, lambdas, procs, or event detached methods works out of the box, batteries included. Simply include `Eventually` in the class you will be emitting events from, register some listeners and fire away.
+
+```ruby
+class Car
+  include Eventually
+  def stop
+    #...
+    emit(:stopped, 0)
+  end
+end
+
+car = Car.new
+car.on(:stopped) do |mph|
+  puts 'the car stopped, sitting at %d mph' % mph
+end
+car.stop # this will indirectly invoke the above callback
+```
+
+## Pre-define Events
+
+For documentation purposes, it can often be nice to define up front what events you'll be expecting to emit from the instances of a certain class. Anyone who's ever spent a couple of minutes trying to dig up their database columns from an ActiveRecord model knows what I'm talking about. Annoying. So `Eventually` let's you put that all up front in a nice DSL.
+
+```ruby
+class Car
+  include Eventually
+  emits :stopped, :started, :turning
+  emits :reversing
+end
+```
+
+The previous snippet acts mostly as documentation.
+
+*See the **examples/basic.rb** file for a slightly more complicated setup than this one.*
+
+## Callback arity validation
+
+However, sometimes you want to be sure that a given registered callback will conform to your event interface, so specify an **arity validation**. Let's add another event to our definition and ensure that callbacks registering for that event must have an arity of 1.
+
+```ruby
+class Car
+  include Eventually
+  emits :driving, :arity => 1
+end
+car = Car.new
+car.on(:driving) do
+  puts 'The car is driving'
+end
+# Error will be raise explaining the arity mismatch (expected 1, received -1)
+```
+
+*See the **examples/arity.rb** file for more on this.*
+
+## Strict Mode
+
+Strict mode is useful if you want to enforce the `#emits` documentation as being the **ONLY** events that your instances can emit or be registered against.
+
+```ruby
+class Car
+  include Eventually
+  
+  enable_strict!
+  emits :started, :stopped
+  
+  def turn
+    # Emitting :turning event here will throw an error in strict mode
+    emit(:turning)
+  end
+end
+
+car = Car.new
+# Registering for the :turning event here will throw an error in strict mode
+car.on(:turning) do
+  puts 'the car is turning'
+end
+
+*See the **examples/scrict.rb** file for more on this.*
+
+## More?
+
+Further examples can be found in the examples directory. I know, novel idea that one.
+
+## Contact
+
+[@localshred](http://twitter.com/localshred) wrote this. He [sometimes blogs](http://www.rand9.com) too.

data/Rakefile

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

data/eventually.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "eventually/version"
+
+Gem::Specification.new do |s|
+  s.name        = "eventually"
+  s.version     = Eventually::VERSION
+  s.authors     = ["BJ Neilsen"]
+  s.email       = ["bj.neilsen@gmail.com"]
+  s.homepage    = "http://www.rand9.com"
+  s.summary     = %q{Eventually is an event library built to loosely mirror the NodeJS EventEmitter API.}
+  s.description = s.summary
+
+  s.rubyforge_project = "eventually"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+end

data/examples/arity.rb

@@ -0,0 +1,39 @@
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+require 'eventually'
+
+class Car
+  include Eventually
+  emits(:driving, :arity => 1)
+  emits(:stopped, :arity => 0)
+  emits(:reversing, :arity => -1)
+  emits(:turning, :arity => 3)
+end
+
+car = Car.new
+car.on(:driving) do |mph|
+  puts 'The car is traveling %d mph' % mph
+end
+
+# Notice the odd empty "pipes" below...
+# Checking arity on a block will give -1 for no args.
+# If you're expecting arity == 0 you have to pass empty pipes (e.g. do ||)
+# In other words, it doesn't make a ton of sense to
+# expect an arity of zero, better a -1 validation such
+# as on the :reversing event
+car.on(:stopped) do ||
+  puts 'The car stopped'
+end
+
+# Validated on -1 (no arguments)
+car.on(:reversing) do
+  puts 'The car is reversing'
+end
+
+begin
+  car.on(:turning) do |direction|
+    puts 'Car is turning %s' % direction
+  end
+rescue => e
+  # "Invalid callback arity for event :turning (expected 3, received 1)"
+  puts e.message
+end

data/examples/basic.rb

@@ -0,0 +1,53 @@
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+require 'eventually'
+
+SPEED_LIMIT = 65
+
+class SpeedingCar
+  include Eventually
+  
+  # Document the events we'll likely emit
+  emits :stopped, :driving
+  
+  def stop
+    puts 'Car is stopped'
+    emit(:stopped)
+  end
+  
+  def go(mph)
+    puts 'Car is driving %d mph' % mph
+    emit(:driving, mph)
+  end
+end
+
+class PoliceCar
+  def initialize(speeding_car)
+    speeding_car.on(:stopped, method(:eat_donut))
+    speeding_car.on(:driving, method(:arrest_if_speeding))
+  end
+  
+  def eat_donut
+    puts 'CHOMP'
+  end
+  
+  def arrest_if_speeding(speed)
+    if speed > SPEED_LIMIT
+      puts 'ARREST THEM!'
+    else
+      eat_donut
+    end
+  end
+end
+
+car = SpeedingCar.new
+police = PoliceCar.new(car)
+car.stop
+car.go(100)
+
+# The above will write to stdout:
+#
+#  Car is stopped
+#  CHOMP
+#  Car is driving 100 mph
+#  ARREST THEM!
+#

data/examples/strict.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+require 'eventually'
+
+class Door
+  include Eventually
+  enable_strict!
+  emits :opened, :closed
+end
+
+door = Door.new
+door.on(:opened) do
+  puts 'door was opened'
+end
+
+door.on(:closed) do
+  puts 'door was closed'
+end
+
+begin
+  # This will raise an error!
+  door.on(:slammed) do
+    puts 'oh noes'
+  end
+rescue => e
+  # "Event type :slammed will not be emitted. Use Door.emits(:slammed)"
+  puts e.message
+end

data/lib/eventually.rb

@@ -0,0 +1,169 @@
+require "eventually/version"
+
+# Eventually is a module that facilitates evented callback
+# management similar to the EventEmitter API in NodeJS.
+# Simply include in the class you will be emitting events
+# from and fire away.
+#
+# Support exists for strict mode, pre-defining the events
+# you plan on emitting, and arity validation on callbacks.
+# See the docs below or the examples folder for further documentation.
+module Eventually
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    NO_CHECK_ARITY = -1
+    attr_accessor :emittable_events
+    
+    # Define an event or list of events
+    # that instances of this class will potentially emit.
+    #
+    # Usage (list of events):
+    #    emits :started, :stopped
+    #
+    # Usage (single event):
+    #    emits :started
+    #
+    # Usage (single event with arity validation):
+    #    emits :started, :arity => 2
+    #
+    def emits(*evts)
+      if evts && !evts.empty?
+        if evts.all?{|e| e.is_a?(Symbol) }
+          evts.each{|e| emittable[e.to_sym] = NO_CHECK_ARITY }
+        elsif evts.count == 2
+          emittable[evts[0].to_sym] = (evts[1].fetch(:arity) { NO_CHECK_ARITY }).to_i
+        end
+      else
+        emittable.keys
+      end
+    end
+    
+    # Check if instances of this class have pre-defined
+    # the given event as potentially emittable
+    def emits?(evt)
+      emittable.key?(evt.to_sym)
+    end
+    
+    # Puts instances into strict mode. This does two things:
+    #   - Raise an error if registering a callback for an event
+    #     that has not already been pre-defined (e.g. with #emits)
+    #   - Raise an error if instance attempts to emit an event
+    #     that has not already been pre-defined (e.g. with #emits)    
+    def enable_strict!
+      @strict = true
+    end
+    
+    # The default state of an Eventually instance. Does not require
+    # pre-definition of an event to register against it or emit it
+    def disable_strict!
+      @strict = false
+    end
+    
+    # Are we strict or not
+    def strict?
+      @strict || false
+    end
+    
+    # Determines if the given event has an arity validation assigned
+    def validates_arity?(evt)
+      emits?(evt) && emittable[evt.to_sym] > NO_CHECK_ARITY
+    end
+    
+    # Returns the arity validation, nil if event isn't defined
+    def arity_for_event(evt)
+      emits?(evt) ? emittable[evt.to_sym] : nil
+    end
+    
+    # Reset the known emittable events (events defined with #emits)
+    # More useful for tests probably, but leaving it in API just 'cause
+    def emits_none
+      @emittable = {}
+      nil
+    end
+    
+    # Shorthand predicate to determine if a given event is 
+    # "emittable" or "registerable"
+    def can_emit_or_register?(event)
+      !strict? || emits?(event)
+    end
+    
+    private
+    
+    def emittable
+      @emittable ||= {}
+    end
+  end # ClassMethods
+  
+  # Event registration method. Takes an event to register against and either
+  # a callable object (e.g. proc/lambda/detached method) or a block
+  # 
+  # Usage: see Eventually#emit or examples directory
+  #
+  def on(event, callable=nil, &blk)
+    raise "Event type :#{event} will not be emitted. Use #{self.class.name}.emits(:#{event})" unless self.class.can_emit_or_register?(event)
+    
+    cbk = nil
+    if callable.respond_to?(:call)
+      cbk = callable
+    elsif block_given? && !blk.nil?
+      cbk = blk
+    else
+      raise 'Cannot register callback. Neither callable nor block was given'
+    end
+    
+    # if self.class.validates_arity?(event) && cbk.arity != (expected_arity = self.class.arity_for_event(event))
+    unless valid_event_arity?(event, cbk.arity)
+      raise "Invalid callback arity for event :#{event} (expected #{self.class.arity_for_event(event)}, received #{cbk.arity})"
+    end
+    
+    (__registered__[event.to_sym] ||= []) << cbk
+  end
+  
+  # Emit the payload arguments back to the registered listeners
+  # on the given event. FIFO calling, and we won't deal with 
+  # concurrency, so it should be handled at the callback level.
+  # 
+  # Usage:
+  #   class Car
+  #     include Eventually
+  #     def stop
+  #       #...
+  #       emit(:stopped, 0)
+  #     end
+  #   end
+  #
+  #   car = Car.new
+  #   car.on(:stopped) do |mph|
+  #     puts 'the car stopped, sitting at %d mph' % mph
+  #   end
+  #   car.stop # this will indirectly invoke the above callback
+  #
+  def emit(event, *payload)
+    raise "Event type :#{event} cannot be emitted. Use #{self.class.name}.emits(:#{event})" unless self.class.can_emit_or_register?(event)
+    
+    unless valid_event_arity?(event, payload.length)
+      raise "Invalid emit arity for event :#{event} (expected #{self.class.arity_for_event(event)}, received #{payload.length})"
+    end
+    
+    (__registered__[event.to_sym] || []).each do |cbk|
+      cbk.call(*payload)
+    end
+  end
+  
+  # Shorthand predicate to determine if the given cbk for this event
+  # has a valid arity amount
+  def valid_event_arity?(event, arity_count)
+    expected_arity = self.class.arity_for_event(event)
+    !self.class.validates_arity?(event) || arity_count == expected_arity
+  end
+  
+  private
+  
+  def __registered__
+    @__registered__ ||= {}
+  end
+  
+end

data/lib/eventually/version.rb

@@ -0,0 +1,3 @@
+module Eventually
+  VERSION = "0.0.1"
+end

data/spec/lib/eventually_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper'
+
+class Emitter
+  include Eventually
+end
+
+describe Eventually do
+  before(:each) do
+    Emitter.disable_strict!
+    Emitter.emits_none
+  end
+  
+  let(:emitter) { Emitter.new }
+  let(:defined_events) { [:one, :two, :three] }
+  
+  context 'external api' do
+    describe '.emits_none' do
+      it 'clears out emitter definitions' do
+        Emitter.emits(:jigger)
+        Emitter.emits?(:jigger).should be_true
+        Emitter.emits_none
+        Emitter.emits?(:jigger).should be_false
+      end
+    end
+    
+    describe '.emits' do
+      it 'allows event definition at class level' do
+        Emitter.emits(:jigger)
+        Emitter.emits?(:jigger).should be_true
+      end
+      
+      it 'can register multiple event symbols at once' do
+        Emitter.emits(*defined_events)
+        defined_events.each {|e| Emitter.emits?(e).should be_true }
+      end
+      
+      it 'provides a list of pre-defined emittable events' do
+        Emitter.emits(*defined_events)
+        Emitter.emits.should eq defined_events
+      end
+      
+      describe '.enable_strict!' do
+        it 'requires the event to have been pre-defined for watchers to register callbacks to it' do
+          Emitter.enable_strict!
+          Emitter.emits(:start)
+          Emitter.emits?(:start).should be_true
+          expect {
+            emitter.on(:start, lambda{ puts 'hi' })
+          }.should_not raise_error
+          expect {
+            emitter.on(:stop, lambda{ puts 'hi' })
+          }.should raise_error(/Event type :stop will not be emitted/)
+        end  
+      end
+      
+      describe '.disable_strict!' do
+        it 'disables strict mode' do
+          Emitter.disable_strict!
+          Emitter.emits?(:start).should be_false
+          expect {
+            emitter.on(:start, lambda{ puts 'hi' })
+          }.should_not raise_error
+        end
+      end
+      
+      describe '.strict?' do
+        context 'when strict mode is enabled' do
+          it 'returns true' do
+            Emitter.enable_strict!
+            Emitter.strict?.should be_true
+          end
+        end
+        
+        context 'when strict mode is disabled' do
+          it 'returns false' do
+            Emitter.disable_strict!
+            Emitter.strict?.should be_false
+          end
+        end
+      end
+      
+      context 'when providing an arity validation' do
+        it 'sets an arity expectation for future event callbacks' do
+          Emitter.emits(:jigger, arity: 5)
+          Emitter.emits?(:jigger)
+          Emitter.validates_arity?(:jigger).should be_true
+        end
+        
+        it 'allows 0 as a specified arity' do
+          Emitter.emits(:jigger, arity: 0)
+          Emitter.emits?(:jigger)
+          Emitter.validates_arity?(:jigger).should be_true
+        end
+        
+        describe '.arity_for_event' do
+          it 'reports the arity requirement for the event, if any' do
+            Emitter.emits(:jigger, arity: 5)
+            Emitter.arity_for_event(:jigger).should eq 5
+            Emitter.emits(:pingpong)
+            Emitter.arity_for_event(:pingpong).should eq -1        
+            Emitter.arity_for_event(:nonevent).should eq nil
+          end
+        end
+      end
+    end
+    
+    it 'allows event registration with lambda' do
+      emitter.on(:start, lambda{ puts 'hi' })
+    end
+    
+    it 'allows event registration with proc' do
+      emitter.on(:start, proc{ puts 'hi' })
+    end
+    
+    it 'allows event registration with block' do
+      emitter.on(:start) do
+        puts 'hi'
+      end
+    end
+    
+    it 'allows event registration with detached method' do
+      def event_handler; end
+      emitter.on(:start, method(:event_handler))
+    end
+    
+    it 'allows multiple registrations for a given event' do
+      emitter.on(:start) { puts 'hello' }
+      emitter.on(:start) { puts 'world' }
+    end
+    
+    describe '.can_emit_or_register?' do
+      context 'when strict mode enabled' do
+        before { Emitter.enable_strict! }
+        context 'when given event is registered' do
+          it 'returns true' do
+            Emitter.emits(:known)
+            Emitter.emits?(:known).should be_true
+            Emitter.can_emit_or_register?(:known).should be_true
+          end
+        end
+        context 'when given event is not registered' do
+          it 'returns false' do
+            Emitter.emits?(:unknown).should be_false
+            Emitter.can_emit_or_register?(:unknown).should be_false
+          end
+        end
+      end
+      
+      context 'when strict mode disabled' do
+        before { Emitter.disable_strict! }
+        context 'when given event is registered' do
+          it 'returns true' do
+            Emitter.emits(:known)
+            Emitter.emits?(:known).should be_true
+            Emitter.can_emit_or_register?(:known).should be_true
+          end
+        end
+        context 'when given event is not registered' do
+          it 'returns true' do
+            Emitter.emits?(:unknown).should be_false
+            Emitter.can_emit_or_register?(:unknown).should be_true
+          end
+        end
+      end
+    end
+  end
+  
+  context 'when emitting events' do    
+    let(:emitter) { Emitter.new }
+    let(:watcher) { Watcher.new }
+    
+    class Watcher
+      attr_accessor :value
+      def initialize
+        @value = 1
+      end
+      def block_callback
+        Proc.new{|payload| @value += payload }
+      end
+      def lambda_callback
+        lambda{|payload| @value += payload }
+      end
+      def method_callback
+        method(:update_method)
+      end
+      def proc_callback
+        proc{|payload| @value += payload }
+      end
+      
+      def update_method(payload)
+        @value += payload
+      end
+    end
+    
+    shared_examples_for 'emitting an event' do |cbk_type|
+      it "by invoking a #{cbk_type} callback" do
+        expect {          
+          case cbk_type
+          when :block then
+            emitter.on(:start, &watcher.block_callback)
+          when :lambda then
+            emitter.on(:start, watcher.lambda_callback)
+          when :method then
+            emitter.on(:start, watcher.method_callback)
+          when :proc then
+            emitter.on(:start, watcher.proc_callback)
+          end
+        }.should_not raise_error(/Cannot register callback/)
+        emitter.__send__(:emit, :start, 1)
+        watcher.value.should eq 2
+      end
+    end
+    
+    it_behaves_like 'emitting an event', :block
+    it_behaves_like 'emitting an event', :lambda
+    it_behaves_like 'emitting an event', :method
+    it_behaves_like 'emitting an event', :proc
+    
+    it 'emits nothing when no event callbacks are given' do
+      expect { emitter.__send__(:emit, :hullabaloo) }.should_not raise_error
+    end
+    
+    it 'raises an error when a given callback is invalid' do
+      expect { emitter.on(:start, nil, &nil)  }.should raise_error(/Cannot register callback/)
+      expect { emitter.on(:start, 10_000)     }.should raise_error(/Cannot register callback/)
+      expect { emitter.on(:start, "callback") }.should raise_error(/Cannot register callback/)
+    end
+    
+    it 'invokes registered callbacks in a FIFO manner' do
+      watcher1 = Watcher.new
+      watcher1.value = []
+      
+      watcher2 = Watcher.new
+      watcher2.value = []
+      
+      emitter.on(:push) {|v| watcher1.value << "A"+v }
+      emitter.on(:push) {|v| watcher2.value << "B"+v }
+      emitter.on(:push) {|v| watcher2.value << "C"+v }
+      emitter.on(:push) {|v| watcher1.value << "D"+v }
+      emitter.__send__(:emit, :push, "-VALUE")
+      
+      watcher1.value.should eq ["A-VALUE", "D-VALUE"]
+      watcher2.value.should eq ["B-VALUE", "C-VALUE"]
+    end
+    
+    context 'when arity validation is enabled' do
+      before { Emitter.emits(:hello_world, arity: 2) }
+      it 'accepts a callback with matching arity' do
+        expect {
+          emitter.on(:hello_world) do |param1, param2|
+            #not invoked
+          end
+        }.should_not raise_error
+      end
+      
+      it 'rejects a callback if the given arity is not exact' do
+        expect {
+          emitter.on(:hello_world) do |param1, param2, param3|
+            #not invoked
+          end
+        }.should raise_error(/Invalid callback arity for event :hello_world \(expected 2, received 3\)/)
+      end
+      
+      it 'accepts emitting an event when arity is valid' do
+        expect {
+          emitter.__send__(:emit, :hello_world, "hello", "world")
+        }.should_not raise_error
+      end
+      
+      it 'rejects emitting an event when the arity is not exact' do
+        expect {
+          emitter.__send__(:emit, :hello_world, "hello")
+        }.should raise_error(/Invalid emit arity for event :hello_world \(expected 2, received 1\)/)
+      end
+    end
+    
+    context 'when strict mode is enabled' do
+      context 'when emitting an event not previously defined' do
+        it 'raises an error concerning the unknown event type' do
+          emitter.class.enable_strict!
+          emitter.class.strict?.should be_true
+          emitter.class.emits?(:stop).should be_false
+          expect {
+            emitter.__send__(:emit, :stop)
+          }.should raise_error(/Event type :stop cannot be emitted/)
+        end
+      end
+    end
+    
+    describe '#valid_event_arity?' do
+      context 'when arity is validated for event' do
+        context 'and the arity matches' do
+          it 'doesn\'t raise an error' do
+            Emitter.emits(:jump, arity: 2)
+            expect {
+              emitter.on(:jump) do |param1, param2|
+                puts 'hi'
+              end
+            }.should_not raise_error
+          end
+        end
+        context 'and the arity does not match' do
+          it 'raises an error' do
+            Emitter.emits(:jump, arity: 2)
+            expect {
+              emitter.on(:jump) do |param1|
+                puts 'hi'
+              end
+            }.should raise_error(/expected 2, received 1/)
+          end
+        end
+      end
+      context 'when arity is not for event' do
+        it 'doesn\'t raise an error' do
+          Emitter.emits?(:jump).should be_false
+          expect {
+            emitter.on(:jump) do |param1, param2|
+              puts 'hi'
+            end
+          }.should_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+require 'eventually'
+require 'rspec'

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: eventually
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- BJ Neilsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2153560520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153560520
+description: Eventually is an event library built to loosely mirror the NodeJS EventEmitter
+  API.
+email:
+- bj.neilsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- eventually.gemspec
+- examples/arity.rb
+- examples/basic.rb
+- examples/strict.rb
+- lib/eventually.rb
+- lib/eventually/version.rb
+- spec/lib/eventually_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.rand9.com
+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: '0'
+requirements: []
+rubyforge_project: eventually
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Eventually is an event library built to loosely mirror the NodeJS EventEmitter
+  API.
+test_files:
+- spec/lib/eventually_spec.rb
+- spec/spec_helper.rb