celluloid 0.9.0 → 0.9.1

data/README.md

@@ -1,7 +1,7 @@
-![Celluloid](https://github.com/tarcieri/celluloid/raw/master/logo.png)
+![Celluloid](https://github.com/celluloid/celluloid/raw/master/logo.png)
 =========
-[![Build Status](https://secure.travis-ci.org/tarcieri/celluloid.png?branch=master)](http://travis-ci.org/tarcieri/celluloid)
-[![Dependency Status](https://gemnasium.com/tarcieri/celluloid.png)](https://gemnasium.com/tarcieri/celluloid)
+[![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
+[![Dependency Status](https://gemnasium.com/celluloid/celluloid.png)](https://gemnasium.com/celluloid/celluloid)
 
 > "I thought of objects being like biological cells and/or individual
 > computers on a network, only able to communicate with messages"
@@ -11,41 +11,62 @@ Celluloid provides a simple and natural way to build fault-tolerant concurrent
 programs in Ruby. With Celluloid, you can build systems out of concurrent
 objects just as easily as you build sequential programs out of regular objects.
 Recommended for any developer, including novices, Celluloid should help ease
-your worries about building multithreaded Ruby programs:
-
-* __Automatic synchronization:__ Celluloid synchronizes access to instance
-  variables by using a special proxy object system and messaging model.
-* __[Futures](https://github.com/tarcieri/celluloid/wiki/futures):__
+your worries about building multithreaded Ruby programs.
+
+Much of the difficulty with building concurrent programs in Ruby arises because
+the object-oriented mechanisms for structuring code, such as classes and
+inheritance, are separate from the concurrency mechanisms, such as threads and
+locks. Celluloid combines these into a single structure, an active object
+running within a thread, called an "actor".
+
+By combining concurrency with object oriented programming, Celluloid frees you
+up from worry about where to use threads and locks. Celluloid combines them
+together into a single concurrent object oriented programming model,
+encapsulating state in concurrent objects and thus avoiding many of the
+problems associated with multithreaded programming. Celluloid provides many
+features which make concurrent programming simple, easy, and fun:
+
+* __Automatic "deadlock-free" synchronization:__ Celluloid uses a concurrent
+  object model which combines method dispatch and thread synchronization.
+  Each actor is a concurrent object running in its own thread, and every method
+  invocation is wrapped in a fiber that can be suspended whenever it calls
+  out to other actors, and resumed when the response is available. This means
+  methods which are waiting for responses from other actors, external messages,
+  or other system events (including I/O with Celluloid::IO) can be suspended
+  and will never block other methods that are ready to run. This won't prevent
+  bugs in Celluloid, bugs in other thread-safe libraries you use, and even
+  certain "dangerous" features of Celluloid from causing your program to
+  deadlock, but in general, programs built with Celluloid will be naturally
+  immune to deadlocks.
+
+* __Fault-tolerance:__ Celluloid has taken to heart many of Erlang's ideas
+  about fault-tolerance in order to enable self-healing applications.
+  The central idea: have you tried turning it off and on again? Celluloid
+  takes care of rebooting subcomponents of your application when they crash,
+  whether it's a single actor, or large (potentially multi-tiered) groups of
+  actors that are all interdependent. This means rather that worrying about
+  rescuing every last exception, you can just sit back, relax, and let parts
+  of your program crash, knowing Celluloid will automatically reboot them in
+  a clean state. Celluloid provides its own implementation of the core
+  fault-tolerance concepts in Erlang including [linking](https://github.com/celluloid/celluloid/wiki/Linking),
+  [supervisors](https://github.com/celluloid/celluloid/wiki/Supervisors),
+  and [supervision trees](https://github.com/celluloid/celluloid/wiki/Groups).
+
+* __[Futures](https://github.com/celluloid/celluloid/wiki/futures):__
   Ever wanted to call a method "in the background" and retrieve the
-  value it returns later? Celluloid futures allow you to do that. When you
-  ask for a method's return value it's returned if it's immediately available
-  or blocks if the method is still running.
-* __[Supervisors](https://github.com/tarcieri/celluloid/wiki/supervisors):__
-  Celluloid can monitor your concurrent objects and
-  automatically restart them when they crash. You can also link concurrent
-  objects together into groups that will crash and restart as a group,
-  ensuring that after a crash all interdependent objects are in a clean and
-  consistent state.
-
-Under the hood, Celluloid wraps regular objects in threads that talk to each
-other using messages. These concurrent objects are called "actors". When a
-caller wants another actor to execute a method, it literally sends it a
-message object telling it what method to execute. The receiver listens on its
-mailbox, gets the request, runs the method, and sends the caller the result.
-The receiver processes messages in its inbox one-at-a-time, which means that
-you don't need to worry about synchronizing access to an object's instance
-variables.
-
-In addition to that, Celluloid also gives you the ability to call methods
-_asynchronously_, so the receiver to do things in the background for you
-without the caller having to sit around waiting for the result.
+  value it returns later? Celluloid futures do just that. It's like
+  calling ahead to a restaurant to place an order, so they can work
+  on preparing your food while you're on your way to pick it up.
+  When you ask for a method's return value, it's returned immediately
+  if the method has already completed, or otherwise the current method is
+  suspended until the value becomes available.
 
 You can also build distributed systems with Celluloid using its
-[sister project DCell](https://github.com/tarcieri/dcell). Evented IO similar
-to EventMachine (albeit with a synchronous API) is available through the
-[Celluloid::IO](https://github.com/tarcieri/celluloid-io) library.
+[sister project DCell](https://github.com/celluloid/dcell). Evented IO similar
+to EventMachine (with a synchronous API) is available through the
+[Celluloid::IO](https://github.com/celluloid/celluloid-io) library.
 
-[Please see the Celluloid Wiki](https://github.com/tarcieri/celluloid/wiki)
+[Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
 for more detailed documentation and usage notes.
 
 Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
@@ -54,94 +75,21 @@ or visit us on IRC at #celluloid on freenode
 Supported Platforms
 -------------------
 
-Celluloid works on Ruby 1.9.2+, JRuby 1.6 (in 1.9 mode), and Rubinius 2.0. JRuby
+Celluloid works on Ruby 1.9.3, JRuby 1.6 (in 1.9 mode), and Rubinius 2.0. JRuby
 or Rubinius are the preferred platforms as they support true hardware-level
-parallelism when running Ruby code, whereas MRI/YARV is constrained by a global
-interpreter lock (GIL).
+parallelism for Ruby threads, whereas MRI/YARV is constrained by a global
+interpreter lock (GIL) and can only execute one thread at a time.
 
 To use JRuby in 1.9 mode, you'll need to pass the "--1.9" command line option
 to the JRuby executable, or set the "JRUBY_OPTS=--1.9" environment variable.
 
 Celluloid works on Rubinius in either 1.8 or 1.9 mode.
 
-Usage
------
-
-To use Celluloid, define a normal Ruby class that includes Celluloid:
-
-```ruby
-require 'celluloid'
-
-class Sheen
-  include Celluloid
-
-  def initialize(name)
-    @name = name
-  end
-
-  def set_status(status)
-    @status = status
-  end
-
-  def report
-    "#{@name} is #{@status}"
-  end
-end
-```
-
-Now when you create new instances of this class, they're actually concurrent
-objects, each running in their own thread:
-
-```ruby
->> charlie = Sheen.new "Charlie Sheen"
- => #<Celluloid::Actor(Sheen:0x00000100a312d0) @name="Charlie Sheen">
->> charlie.set_status "winning!"
- => "winning!"
->> charlie.report
- => "Charlie Sheen is winning!"
->> charlie.set_status! "asynchronously winning!"
- => nil
->> charlie.report
- => "Charlie Sheen is asynchronously winning!"
-```
-
-You can call methods on this concurrent object just like you would any other
-Ruby object. The Sheen#set_status method works exactly like you'd expect,
-returning the last expression evaluated.
-
-However, Celluloid's secret sauce kicks in when you call banged predicate
-methods (i.e. methods ending in !). Even though the Sheen class has no
-set_status! method, you can still call it. Why is this? Because bang methods
-have a special meaning in Celluloid. (Note: this also means you can't define
-bang methods on Celluloid classes and expect them to be callable from other
-objects)
-
-Adding a bang to the end of a method instructs Celluloid that you would like
-for the given method to be called _asynchronously_. This means that rather
-than the caller waiting for a response, the caller sends a message to the
-concurrent object that you'd like the given method invoked, and then the
-caller proceeds without waiting for a response. The concurrent object
-receiving the message will then process the method call in the background.
-
-Adding a bang to a method name is a convention in Ruby used to indicate that
-the method is in some way "dangerous", and in Celluloid this is no exception.
-You have no guarantees that just because you made an asynchronous call it was
-ever actually invoked. Asynchronous calls will never raise an exception, even
-if an exception occurs when the receiver is processing it. Worse, unhandled
-exceptions will crash the receiver, and making an asynchronous call to a
-crashed object will not raise an error.
-
-However, you can still handle errors created by asynchronous calls using
-two features of Celluloid called [supervisors](https://github.com/tarcieri/celluloid/wiki/supervisors)
-and [linking](https://github.com/tarcieri/celluloid/wiki/linking)
-
-[Please see the Celluloid Wiki](https://github.com/tarcieri/celluloid/wiki)
-for additional usage information.
-
-Suggested Reading
------------------
-
-* [Concurrent Object-Oriented Programming in Python with ATOM](http://python.org/workshops/1997-10/proceedings/atom/)
+Additional Reading
+------------------
+
+* [Concurrent Object-Oriented Programming in Python with ATOM](http://python.org/workshops/1997-10/proceedings/atom/):
+  a similar system to Celluloid written in Python
 
 Contributing to Celluloid
 -------------------------

data/lib/celluloid.rb

@@ -3,7 +3,7 @@ require 'thread'
 require 'timeout'
 
 module Celluloid
-  SHUTDOWN_TIMEOUT = 60 # How long actors have to terminate
+  SHUTDOWN_TIMEOUT = 120 # How long actors have to terminate
   @logger = Logger.new STDERR
 
   class << self
@@ -51,6 +51,18 @@ module Celluloid
       end
     end
 
+    # Generate a Universally Unique Identifier
+    def uuid
+      UUID.generate
+    end
+
+    # Obtain the number of CPUs in the system
+    def cores
+      CPUCounter.cores
+    end
+    alias_method :cpus, :cores
+    alias_method :ncpus, :cores
+
     # Define an exception handler for actor crashes
     def exception_handler(&block)
       Logger.exception_handler(&block)
@@ -61,19 +73,25 @@ module Celluloid
     # tree before iterating through all actors and telling them to terminate.
     def shutdown
       Timeout.timeout(SHUTDOWN_TIMEOUT) do
-        futures = Actor.all.each do |actor|
+        actors = Actor.all
+        Logger.info "Terminating #{actors.size} actors..." if actors.size > 0
+
+        # Actors cannot self-terminate, you must do it for them
+        terminators = actors.each do |actor|
           begin
             actor.future(:terminate)
           rescue DeadActorError, MailboxError
           end
         end
 
-        futures.each do |future|
+        terminators.each do |terminator|
           begin
-            future.value
+            terminator.value
           rescue DeadActorError, MailboxError
           end
         end
+
+        Logger.info "Shutdown completed cleanly"
       end
     end
   end
@@ -86,7 +104,7 @@ module Celluloid
     # Create a new actor
     def new(*args, &block)
       proxy = Actor.new(allocate).proxy
-      proxy.send(:__send__, :initialize, *args, &block)
+      proxy._send_(:initialize, *args, &block)
       proxy
     end
     alias_method :spawn, :new
@@ -98,7 +116,7 @@ module Celluloid
 
       proxy = Actor.new(allocate).proxy
       current_actor.link proxy
-      proxy.send(:__send__, :initialize, *args, &block)
+      proxy._send_(:initialize, *args, &block)
       proxy
     end
     alias_method :spawn_link, :new_link
@@ -255,6 +273,11 @@ module Celluloid
     Thread.current[:actor].after(interval, &block)
   end
 
+  # Call a block every given interval, returning a Celluloid::Timer object
+  def every(interval, &block)
+    Thread.current[:actor].every(interval, &block)
+  end
+
   # Perform a blocking or computationally intensive action inside an
   # asynchronous thread pool, allowing the caller to continue processing other
   # messages in its mailbox in the meantime
@@ -280,7 +303,7 @@ module Celluloid
         # during an async call (i.e. linking/supervisors)
       end
 
-      return # casts are async and return immediately
+      return
     end
 
     super
@@ -291,6 +314,7 @@ require 'celluloid/version'
 require 'celluloid/actor_proxy'
 require 'celluloid/calls'
 require 'celluloid/core_ext'
+require 'celluloid/cpu_counter'
 require 'celluloid/events'
 require 'celluloid/fiber'
 require 'celluloid/fsm'
@@ -305,6 +329,7 @@ require 'celluloid/signals'
 require 'celluloid/task'
 require 'celluloid/timers'
 require 'celluloid/thread_pool'
+require 'celluloid/uuid'
 
 require 'celluloid/actor'
 require 'celluloid/future'

data/lib/celluloid/actor.rb

@@ -184,6 +184,13 @@ module Celluloid
       end
     end
 
+    # Schedule a block to run at the given time
+    def every(interval)
+      @timers.add(interval, true) do
+        Task.new(:timer) { yield }.resume
+      end
+    end
+
     # Sleep for the given amount of time
     def sleep(interval)
       if Celluloid.exclusive?

data/lib/celluloid/actor_proxy.rb

@@ -9,12 +9,12 @@ module Celluloid
       @mailbox, @klass = mailbox, klass
     end
 
-    def send(meth, *args, &block)
-      Actor.call @mailbox, :send, meth, *args, &block
+    def _send_(meth, *args, &block)
+      Actor.call @mailbox, :__send__, meth, *args, &block
     end
 
     def class
-      Actor.call @mailbox, :send, :class
+      Actor.call @mailbox, :__send__, :class
     end
 
     def is_a?(klass)
@@ -57,7 +57,7 @@ module Celluloid
       raise DeadActorError, "actor already terminated" unless alive?
 
       begin
-        send :terminate
+        _send_ :terminate
       rescue DeadActorError
         # In certain cases this is thrown during termination. This is likely
         # a bug in Celluloid's internals, but it shouldn't affect the caller.

data/lib/celluloid/calls.rb

@@ -12,7 +12,16 @@ module Celluloid
         raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}"
       end
 
-      arity = obj.method(@method).arity
+      begin
+        arity = obj.method(@method).arity
+      rescue NameError
+        # If the object claims it responds to a method, but it doesn't exist,
+        # then we have to assume method_missing will do what it says
+        @arguments.unshift(@method)
+        @method = :method_missing
+        return
+      end
+
       if arity >= 0
         if arguments.size != arity
           raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{arity})"
@@ -38,7 +47,7 @@ module Celluloid
     def dispatch(obj)
       begin
         check_signature(obj)
-      rescue Exception => ex
+      rescue => ex
         respond ErrorResponse.new(self, AbortError.new(ex))
         return
       end
@@ -68,10 +77,6 @@ module Celluloid
       respond ErrorResponse.new(self, exception)
     end
 
-    #######
-    private
-    #######
-
     def respond(message)
       @caller << message
     rescue MailboxError

data/lib/celluloid/core_ext.rb

@@ -2,6 +2,8 @@ require 'celluloid/fiber'
 
 # Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
 class Thread
+  attr_accessor :uuid_counter, :uuid_limit
+
   # Retrieve the mailbox for the current thread or lazily initialize it
   def self.mailbox
     current[:mailbox] ||= Celluloid::Mailbox.new

data/lib/celluloid/cpu_counter.rb

@@ -0,0 +1,16 @@
+require 'rbconfig'
+
+module Celluloid
+  module CPUCounter
+    case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
+    when 'darwin'
+      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
+    when 'linux'
+      @cores = File.read("/proc/cpuinfo").scan(/core id\s+: \d+/).uniq.size
+    else
+      @cores = nil
+    end
+
+    def self.cores; @cores; end
+  end
+end

data/lib/celluloid/fsm.rb

@@ -1,6 +1,17 @@
 module Celluloid
-  # Turn concurrent objects into finite state machines
-  # Inspired by Erlang's gen_fsm. See http://www.erlang.org/doc/man/gen_fsm.html
+  # Simple finite state machines with integrated Celluloid timeout support
+  # Inspired by Erlang's gen_fsm (http://www.erlang.org/doc/man/gen_fsm.html)
+  #
+  # Basic usage:
+  #
+  #     class MyMachine
+  #       include Celluloid::FSM # NOTE: this does NOT pull in the Celluloid module
+  #     end
+  #
+  # Inside an actor:
+  #
+  #     #
+  #     machine = MyMachine.new(current_actor)
   module FSM
     class UnattachedError < StandardError; end # Not attached to an actor
 
@@ -52,6 +63,7 @@ module Celluloid
     def initialize(actor = nil)
       @state = self.class.default_state
       @actor = actor
+      @actor ||= Celluloid.current_actor if Celluloid.actor?
     end
 
     # Obtain the current state of the FSM

data/lib/celluloid/group.rb

@@ -71,6 +71,7 @@ module Celluloid
 
         @as = options['as']
         @args = options['args'] || []
+        raise ":args should be an Array" unless @args.kind_of? Array
       end
 
       def supervise

data/lib/celluloid/pool.rb

@@ -7,12 +7,12 @@ module Celluloid
     # Takes a class of actor to pool and a hash of options:
     #
     # * initial_size: how many actors to eagerly create
-    # * max_size: maximum number of actors (default nil, unlimited)
+    # * max_size: maximum number of actors (default one actor per CPU core)
     # * args: an array of arguments to pass to the actor's initialize
     def initialize(klass, options = {})
       opts = {
         :initial_size => 1,
-        :max_size     => nil,
+        :max_size     => Celluloid.cores,
         :args         => []
       }.merge(options)
 

data/lib/celluloid/responses.rb

@@ -2,22 +2,22 @@ module Celluloid
   # Responses to calls
   class Response
     attr_reader :call, :value
-    
+
     def initialize(call, value)
       @call, @value = call, value
     end
   end
-  
+
   # Call completed successfully
   class SuccessResponse < Response; end
-  
+
   # Call was aborted due to caller error
   class ErrorResponse < Response
     def value
       if super.is_a? AbortError
         # Aborts are caused by caller error, so ensure they capture the
         # caller's backtrace instead of the receiver's
-        raise super.cause.class.new(super.cause.message)
+        raise super.cause.exception
       else
         raise super
       end

data/lib/celluloid/timers.rb

@@ -6,8 +6,8 @@ module Celluloid
     end
 
     # Call the given block after the given interval
-    def add(interval, &block)
-      Timer.new(self, interval, block)
+    def add(interval, recurring = false, &block)
+      Timer.new(self, interval, recurring, block)
     end
 
     # Wait for the next timer and fire it
@@ -75,10 +75,10 @@ module Celluloid
     # firing of timers
     QUANTUM = 0.02
 
-    attr_reader :interval, :time
+    attr_reader :interval, :time, :recurring
 
-    def initialize(timers, interval, block)
-      @timers, @interval = timers, interval
+    def initialize(timers, interval, recurring, block)
+      @timers, @interval, @recurring = timers, interval, recurring
       @block = block
 
       reset
@@ -102,6 +102,7 @@ module Celluloid
 
     # Fire the block
     def fire
+      reset if recurring
       @block.call
     end
     alias_method :call, :fire

data/lib/celluloid/uuid.rb

@@ -0,0 +1,38 @@
+require 'securerandom'
+
+module Celluloid
+  # Clearly Ruby doesn't have enough UUID libraries
+  # This one aims to be fast and simple with good support for multiple threads
+  # If there's a better UUID library I can use with similar multithreaded
+  # performance, I certainly wouldn't mind using a gem for this!
+  module UUID
+    values = SecureRandom.hex(9).match(/(.{8})(.{4})(.{3})(.{3})/)
+    PREFIX = "#{values[1]}-#{values[2]}-4#{values[3]}-8#{values[4]}".freeze
+    BLOCK_SIZE = 0x10000
+
+    @counter = 0
+    @counter_mutex = Mutex.new
+
+    def self.generate
+      thread = Thread.current
+
+      unless thread.uuid_limit
+        @counter_mutex.synchronize do
+          block_base = @counter
+          @counter += BLOCK_SIZE
+          thread.uuid_counter = block_base
+          thread.uuid_limit   = @counter - 1
+        end
+      end
+
+      counter = thread.uuid_counter
+      if thread.uuid_counter >= thread.uuid_limit
+        thread.uuid_counter = thread.uuid_limit = nil
+      else
+        thread.uuid_counter += 1
+      end
+
+      "#{PREFIX}-#{sprintf("%012x", counter)}".freeze
+    end
+  end
+end

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -1,5 +1,7 @@
 shared_context "a Celluloid Actor" do |included_module|
-  class ExampleCrash < StandardError; end
+  class ExampleCrash < StandardError
+    attr_accessor :foo
+  end
 
   let :actor_class do
     Class.new do
@@ -8,6 +10,7 @@ shared_context "a Celluloid Actor" do |included_module|
 
       def initialize(name)
         @name = name
+        @delegate = [:bar]
       end
 
       def change_name(new_name)
@@ -30,8 +33,10 @@ shared_context "a Celluloid Actor" do |included_module|
         raise ExampleCrash, "the spec purposely crashed me :("
       end
 
-      def crash_with_abort(reason)
-        abort ExampleCrash.new(reason)
+      def crash_with_abort(reason, foo = nil)
+        example_crash = ExampleCrash.new(reason)
+        example_crash.foo = foo
+        abort example_crash
       end
 
       def internal_hello
@@ -41,6 +46,24 @@ shared_context "a Celluloid Actor" do |included_module|
       def external_hello
         "Hello"
       end
+
+      def method_missing(method_name, *args, &block)
+        if delegates?(method_name)
+          @delegate.send method_name, *args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name)
+        super || delegates?(method_name)
+      end
+
+      private
+
+      def delegates?(method_name)
+        @delegate.respond_to?(method_name)
+      end
     end
   end
 
@@ -87,6 +110,12 @@ shared_context "a Celluloid Actor" do |included_module|
     ponycopter.greet_by_proxy(actor).should == "Hi, I'm a ponycopter!"
   end
 
+  it "properly handles method_missing" do
+    actor = actor_class.new "Method Missing"
+    actor.should respond_to(:first)
+    actor.first.should be == :bar
+  end
+
   it "raises NoMethodError when a nonexistent method is called" do
     actor = actor_class.new "Billy Bob Thornton"
 
@@ -106,9 +135,20 @@ shared_context "a Celluloid Actor" do |included_module|
   it "raises exceptions in the caller when abort is called, but keeps running" do
     actor = actor_class.new "Al Pacino"
 
+    e = nil
+    line_no = nil
+
     expect do
-      actor.crash_with_abort ExampleCrash.new("You die motherfucker!")
-    end.to raise_exception(ExampleCrash)
+      begin
+        line_no = __LINE__; actor.crash_with_abort "You die motherfucker!", :bar
+      rescue => ex
+        e = ex
+        raise
+      end
+    end.to raise_exception(ExampleCrash, "You die motherfucker!")
+
+    e.backtrace.any? { |line| line.include?([__FILE__, line_no].join(':')) }.should be_true # Check the backtrace is appropriate to the caller
+    e.foo.should be == :bar # Check the exception maintains instance variables
 
     actor.should be_alive
   end
@@ -379,7 +419,13 @@ shared_context "a Celluloid Actor" do |included_module|
           after(n) { @fired = true }
         end
 
-        def fired?; @fired end
+        def fire_every(n)
+          @fired = 0
+          every(n) { @fired += 1 }
+        end
+
+        def fired?; !!@fired end
+        def fired; @fired end
       end
     end
 
@@ -412,6 +458,22 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.should be_fired
     end
 
+    it "schedules recurring timers which fire in the future" do
+      actor = @klass.new
+
+      interval = Celluloid::Timer::QUANTUM * 10
+      started_at = Time.now
+
+      timer = actor.fire_every(interval)
+      actor.fired.should be == 0
+
+      sleep(interval + Celluloid::Timer::QUANTUM) # wonky! #/
+      actor.fired.should be == 1
+
+      2.times { sleep(interval + Celluloid::Timer::QUANTUM) } # wonky! #/
+      actor.fired.should be == 3
+    end
+
     it "cancels timers before they fire" do
       actor = @klass.new
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-21 00:00:00.000000000 Z
+date: 2012-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70248586219120 !ruby/object:Gem::Requirement
+  requirement: &70275106519080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70248586219120
+  version_requirements: *70275106519080
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70248586218540 !ruby/object:Gem::Requirement
+  requirement: &70275106518620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70248586218540
+  version_requirements: *70275106518620
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70275106518200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70275106518200
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
-  requirement: &70248586217360 !ruby/object:Gem::Requirement
+  requirement: &70275106517780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,8 +54,9 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70248586217360
-description: Celluloid is a concurrent object framework inspired by the Actor Model
+  version_requirements: *70275106517780
+description: Celluloid enables people to build concurrent programs out of concurrent
+  objects just as easily as they build sequential programs out of sequential objects
 email:
 - tony.arcieri@gmail.com
 executables: []
@@ -56,6 +68,7 @@ files:
 - lib/celluloid/actor_proxy.rb
 - lib/celluloid/calls.rb
 - lib/celluloid/core_ext.rb
+- lib/celluloid/cpu_counter.rb
 - lib/celluloid/events.rb
 - lib/celluloid/fiber.rb
 - lib/celluloid/fsm.rb
@@ -74,11 +87,12 @@ files:
 - lib/celluloid/task.rb
 - lib/celluloid/thread_pool.rb
 - lib/celluloid/timers.rb
+- lib/celluloid/uuid.rb
 - lib/celluloid/version.rb
 - lib/celluloid.rb
 - spec/support/actor_examples.rb
 - spec/support/mailbox_examples.rb
-homepage: https://github.com/tarcieri/celluloid
+homepage: https://github.com/celluloid/celluloid
 licenses:
 - MIT
 post_install_message: 
@@ -102,6 +116,6 @@ rubyforge_project:
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Celluloid is a concurrent object framework inspired by the Actor Model
+summary: Actor-based concurrent object framework for Ruby
 test_files: []
 has_rdoc: