celluloid 0.11.0 → 0.11.1

data/README.md

@@ -50,7 +50,7 @@ features which make concurrent programming simple, easy, and fun:
   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).
+  and [supervision groups](https://github.com/celluloid/celluloid/wiki/Supervision-Groups).
 
 * __[Futures](https://github.com/celluloid/celluloid/wiki/futures):__
   Ever wanted to call a method "in the background" and retrieve the

data/lib/celluloid.rb

@@ -1,6 +1,7 @@
 require 'logger'
 require 'thread'
 require 'timeout'
+require 'set'
 
 module Celluloid
   SHUTDOWN_TIMEOUT = 120 # How long actors have to terminate
@@ -169,6 +170,13 @@ module Celluloid
       end
     end
 
+    # Mark methods as running exclusively
+    def exclusive(*methods)
+      @exclusive_methods ||= Set.new
+      @exclusive_methods.merge methods.map(&:to_sym)
+    end
+    attr_reader :exclusive_methods
+
     # Create a mailbox for this actor
     def mailbox_factory
       if defined?(@mailbox_factory)
@@ -297,6 +305,11 @@ module Celluloid
     Thread.current[:actor].exclusive(&block)
   end
 
+  # Are we currently exclusive
+  def exclusive?
+    Celluloid.exclusive?
+  end
+
   # Call a block after a given interval, returning a Celluloid::Timer object
   def after(interval, &block)
     Thread.current[:actor].after(interval, &block)
@@ -333,7 +346,7 @@ module Celluloid
       unbanged_meth = meth.to_s.sub(/!$/, '')
       args.unshift unbanged_meth
 
-      call = AsyncCall.new(nil, :__send__, args, block)
+      call = AsyncCall.new(:__send__, args, block)
       begin
         Thread.current[:actor].mailbox << call
       rescue MailboxError
@@ -368,7 +381,6 @@ require 'celluloid/responses'
 require 'celluloid/signals'
 require 'celluloid/task'
 require 'celluloid/thread_handle'
-require 'celluloid/timers'
 require 'celluloid/uuid'
 
 require 'celluloid/actor'
@@ -376,3 +388,4 @@ require 'celluloid/future'
 require 'celluloid/pool_manager'
 require 'celluloid/supervision_group'
 require 'celluloid/supervisor'
+require 'celluloid/notifications'

data/lib/celluloid/actor.rb

@@ -1,3 +1,5 @@
+require 'timers'
+
 module Celluloid
   # Don't do Actor-like things outside Actor scope
   class NotActorError < StandardError; end
@@ -19,10 +21,21 @@ module Celluloid
   # normal Ruby objects wrapped in threads which communicate with asynchronous
   # messages.
   class Actor
-    extend Registry
     attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
 
     class << self
+      extend Forwardable
+
+      def_delegators "Celluloid::Registry.root", :[], :[]=
+
+      def registered
+        Registry.root.names
+      end
+
+      def clear_registry
+        Registry.root.clear
+      end
+
       # Obtain the current actor
       def current
         actor = Thread.current[:actor]
@@ -63,7 +76,7 @@ module Celluloid
       # Invoke a method asynchronously on an actor via its mailbox
       def async(mailbox, meth, *args, &block)
         begin
-          mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
+          mailbox << AsyncCall.new(meth, args, block)
         rescue MailboxError
           # Silently swallow asynchronous calls to dead actors. There's no way
           # to reliably generate DeadActorErrors for async calls, so users of
@@ -92,8 +105,11 @@ module Celluloid
 
     # Wrap the given subject with an Actor
     def initialize(subject)
-      @subject   = subject
-      @mailbox   = subject.class.mailbox_factory
+      @subject      = subject
+      @mailbox      = subject.class.mailbox_factory
+      @exit_handler = subject.class.exit_handler
+      @exclusives   = subject.class.exclusive_methods
+
       @tasks     = Set.new
       @links     = Links.new
       @signals   = Signals.new
@@ -142,26 +158,19 @@ module Celluloid
 
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
-      @receivers.receive(timeout, &block)
+      begin
+        @receivers.receive(timeout, &block)
+      rescue SystemEvent => event
+        handle_system_event(event)
+        retry
+      end
     end
 
     # Run the actor loop
     def run
       begin
         while @running
-          begin
-            message = @mailbox.receive(timeout)
-          rescue ExitEvent => exit_event
-            Task.new(:exit_handler) { handle_exit_event exit_event }.resume
-            retry
-          rescue NamingRequest => ex
-            @name = ex.name
-            retry
-          rescue TerminationRequest
-            break
-          end
-
-          if message
+          if message = @mailbox.receive(timeout)
             handle_message message
           else
             # No message indicates a timeout
@@ -169,6 +178,9 @@ module Celluloid
             @receivers.fire_timers
           end
         end
+      rescue SystemEvent => event
+        handle_system_event event
+        retry
       rescue MailboxShutdown
         # If the mailbox detects shutdown, exit the actor
       end
@@ -195,14 +207,14 @@ module Celluloid
 
     # Schedule a block to run at the given time
     def after(interval)
-      @timers.add(interval) do
+      @timers.after(interval) do
         Task.new(:timer) { yield }.resume
       end
     end
 
     # Schedule a block to run at the given time
     def every(interval)
-      @timers.add(interval, true) do
+      @timers.every(interval) do
         Task.new(:timer) { yield }.resume
       end
     end
@@ -213,34 +225,48 @@ module Celluloid
         Kernel.sleep(interval)
       else
         task = Task.current
-        @timers.add(interval) { task.resume }
+        @timers.after(interval) { task.resume }
         Task.suspend :sleeping
       end
     end
 
-    # Handle an incoming message
+    # Handle standard low-priority messages
     def handle_message(message)
       case message
       when Call
-        Task.new(:message_handler) { message.dispatch(@subject) }.resume
+        if @exclusives && @exclusives.include?(message.method)
+          exclusive { message.dispatch(@subject) }
+        else
+          Task.new(:message_handler) { message.dispatch(@subject) }.resume
+        end
       when Response
-        message.call.task.resume message
+        message.dispatch
       else
         @receivers.handle_message(message)
       end
       message
     end
 
-    # Handle exit events received by this actor
-    def handle_exit_event(exit_event)
-      exit_handler = @subject.class.exit_handler
-      if exit_handler
-        return @subject.send(exit_handler, exit_event.actor, exit_event.reason)
+    # Handle high-priority system event messages
+    def handle_system_event(event)
+      case event
+      when ExitEvent
+        Task.new(:exit_handler) { handle_exit_event event }.resume
+      when NamingRequest
+        @name = event.name
+      when TerminationRequest
+        @running = false
       end
+    end
+
+    # Handle exit events received by this actor
+    def handle_exit_event(event)
+      # Run the exit handler if available
+      return @subject.send(@exit_handler, event.actor, event.reason) if @exit_handler
 
       # Reraise exceptions from linked actors
       # If no reason is given, actor terminated cleanly
-      raise exit_event.reason if exit_event.reason
+      raise event.reason if event.reason
     end
 
     # Handle any exceptions that occur within a running actor

data/lib/celluloid/actor_proxy.rb

@@ -65,7 +65,8 @@ module Celluloid
     # Terminate the associated actor
     def terminate
       terminate!
-      Thread.pass while alive?
+      join
+      nil
     end
 
     # Terminate the associated actor asynchronously

data/lib/celluloid/calls.rb

@@ -1,10 +1,10 @@
 module Celluloid
   # Calls represent requests to an actor
   class Call
-    attr_reader :caller, :method, :arguments, :block
+    attr_reader :method, :arguments, :block
 
-    def initialize(caller, method, arguments = [], block = nil)
-      @caller, @method, @arguments, @block = caller, method, arguments, block
+    def initialize(method, arguments = [], block = nil)
+      @method, @arguments, @block = method, arguments, block
     end
 
     def check_signature(obj)
@@ -37,10 +37,11 @@ module Celluloid
 
   # Synchronous calls wait for a response
   class SyncCall < Call
-    attr_reader :task
+    attr_reader :caller, :task
 
     def initialize(caller, method, arguments = [], block = nil, task = Fiber.current.task)
-      super(caller, method, arguments, block)
+      super(method, arguments, block)
+      @caller = caller
       @task = task
     end
 

data/lib/celluloid/notifications.rb

@@ -0,0 +1,84 @@
+module Celluloid
+  module Notifications
+    class Fanout
+      include Celluloid
+      trap_exit :prune
+
+      def initialize
+        @subscribers = []
+        @listeners_for = {}
+      end
+
+      def subscribe(actor, pattern, method)
+        subscriber = Subscriber.new(actor, pattern, method).tap do |s|
+          @subscribers << s
+        end
+        link actor
+        @listeners_for.clear
+        subscriber
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.reject! { |s| s.matches?(subscriber) }
+        @listeners_for.clear
+      end
+
+      def publish(pattern, *args)
+        listeners_for(pattern).each { |s| s.publish(pattern, *args) }
+      end
+
+      def listeners_for(pattern)
+        @listeners_for[pattern] ||= @subscribers.select { |s| s.subscribed_to?(pattern) }
+      end
+
+      def listening?(pattern)
+        listeners_for(pattern).any?
+      end
+
+      def prune(actor, reason=nil)
+        @subscribers.reject! { |s| s.actor == actor }
+        @listeners_for.clear
+      end
+    end
+
+    class Subscriber
+      attr_accessor :actor, :pattern, :method
+
+      def initialize(actor, pattern, method)
+        @actor = actor
+        @pattern = pattern
+        @method = method
+      end
+
+      def publish(pattern, *args)
+        Actor.async(actor.mailbox, method, pattern, *args)
+      end
+
+      def subscribed_to?(pattern)
+        !pattern || @pattern === pattern.to_s
+      end
+
+      def matches?(subscriber_or_pattern)
+        self === subscriber_or_pattern ||
+          @pattern && @pattern === subscriber_or_pattern
+      end
+    end
+
+    class << self
+      attr_accessor :notifier
+    end
+    self.notifier = Fanout.new
+    
+    def publish(pattern, *args)
+      Celluloid::Notifications.notifier.publish(pattern, *args)
+    end
+
+    def subscribe(pattern, method)
+      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
+    end
+
+    def unsubscribe(*args)
+      Celluloid::Notifications.notifier.unsubscribe(*args)
+    end
+  end
+end

data/lib/celluloid/pool_manager.rb

@@ -1,6 +1,7 @@
 module Celluloid
   # Manages a fixed-size pool of workers
   # Delegates work (i.e. methods) and supervises workers
+  # Don't use this class directly. Instead use MyKlass.pool
   class PoolManager
     include Celluloid
     trap_exit :crash_handler
@@ -16,21 +17,44 @@ module Celluloid
       @idle = @size.times.map { worker_class.new_link(*@args) }
     end
 
-    # Execute the given method within a worker
-    def execute(method, *args, &block)
-      worker = provision_worker
+    def _send_(method, *args, &block)
+      worker = __provision_worker
 
       begin
         worker._send_ method, *args, &block
-      rescue => ex
+      rescue Exception => ex
         abort ex
       ensure
         @idle << worker if worker.alive?
       end
     end
 
+    def name
+      _send_ @mailbox, :name
+    end
+
+    def is_a?(klass)
+      _send_ :is_a?, klass
+    end
+
+    def kind_of?(klass)
+      _send_ :kind_of?, klass
+    end
+
+    def methods(include_ancestors = true)
+      _send_ :methods, include_ancestors
+    end
+
+    def to_s
+      _send_ :to_s
+    end
+
+    def inspect
+      _send_ :inspect
+    end
+
     # Provision a new worker
-    def provision_worker
+    def __provision_worker
       while @idle.empty?
         # Using exclusive mode blocks incoming messages, so they don't pile
         # up as waiting Celluloid::Tasks
@@ -53,7 +77,7 @@ module Celluloid
 
     def method_missing(method, *args, &block)
       if respond_to?(method)
-        execute method, *args, &block
+        _send_ method, *args, &block
       else
         super
       end

data/lib/celluloid/receivers.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'timers'
 
 module Celluloid
   # Allow methods to directly interact with the actor protocol
@@ -16,7 +17,7 @@ module Celluloid
         receiver = Receiver.new block
 
         if timeout
-          receiver.timer = @timers.add(timeout) do
+          receiver.timer = @timers.after(timeout) do
             @receivers.delete receiver
             receiver.resume
           end

data/lib/celluloid/registry.rb

@@ -2,9 +2,15 @@ require 'thread'
 
 module Celluloid
   # The Registry allows us to refer to specific actors by human-meaningful names
-  module Registry
-    @@registry = {}
-    @@registry_lock = Mutex.new
+  class Registry
+    def self.root
+      @root ||= new
+    end
+
+    def initialize
+      @registry = {}
+      @registry_lock = Mutex.new
+    end
 
     # Register an Actor
     def []=(name, actor)
@@ -13,8 +19,8 @@ module Celluloid
         raise TypeError, "not an actor"
       end
 
-      @@registry_lock.synchronize do
-        @@registry[name.to_sym] = actor
+      @registry_lock.synchronize do
+        @registry[name.to_sym] = actor
       end
 
       actor.mailbox.system_event NamingRequest.new(name.to_sym)
@@ -22,14 +28,34 @@ module Celluloid
 
     # Retrieve an actor by name
     def [](name)
-      @@registry_lock.synchronize do
-        @@registry[name.to_sym]
+      @registry_lock.synchronize do
+        @registry[name.to_sym]
+      end
+    end
+
+    alias_method :get, :[]
+    alias_method :set, :[]=
+
+    def delete(name)
+      @registry_lock.synchronize do
+        @registry[name.to_sym]
       end
     end
 
     # List all registered actors by name
-    def registered
-      @@registry_lock.synchronize { @@registry.keys }
+    def names
+      @registry_lock.synchronize { @registry.keys }
+    end
+
+    # removes and returns all registered actors as a hash of `name => actor`
+    # can be used in testing to clear the registry 
+    def clear
+      hash = nil
+      @registry_lock.synchronize do
+        hash = @registry.dup
+        @registry.clear
+      end
+      hash
     end
   end
 end

data/lib/celluloid/responses.rb

@@ -6,6 +6,10 @@ module Celluloid
     def initialize(call, value)
       @call, @value = call, value
     end
+
+    def dispatch
+      @call.task.resume self
+    end
   end
 
   # Call completed successfully

data/lib/celluloid/supervision_group.rb

@@ -6,12 +6,19 @@ module Celluloid
 
     class << self
       # Actors or sub-applications to be supervised
-      def members
-        @members ||= []
+      def blocks
+        @blocks ||= []
       end
 
       # Start this application (and watch it with a supervisor)
-      alias_method :run!, :supervise
+      def run!
+        group = new do |group|
+          blocks.each do |block|
+            block.call(group)
+          end
+        end
+        group
+      end
 
       # Run the application in the foreground with a simple watchdog
       def run
@@ -31,52 +38,68 @@ module Celluloid
       # * as: register this application in the Celluloid::Actor[] directory
       # * args: start the actor with the given arguments
       def supervise(klass, options = {})
-        members << Member.new(klass, options)
+        blocks << lambda do |group|
+          group.add klass, options
+        end
       end
 
       # Register a pool of actors to be launched on group startup
       def pool(klass)
-        members << Member.new(klass, method: 'pool_link')
+        blocks << lambda do |group|
+          group.pool klass
+        end
       end
     end
 
     # Start the group
-    def initialize
-      @actors = {}
-
-      # This is some serious lolcode, but like... start the supervisors for
-      # this group
-      self.class.members.each do |member|
-        actor = member.start
-        @actors[actor] = member
-      end
+    def initialize(registry = nil)
+      @members = []
+      @registry = registry || Registry.root
+
+      yield self if block_given?
+    end
+
+    def supervise(klass, *args, &block)
+      add(klass, :args => args, :block => block)
+    end
+
+    def supervise_as(name, klass, *args, &block)
+      add(klass, :args => args, :block => block, :as => name)
+    end
+
+    def pool(klass)
+      add(klass, :method => 'pool_link')
+    end
+
+    def add(klass, options)
+      member = Member.new(@registry, klass, options)
+      @members << member
+      member
+    end
+
+    def actors
+      @members.map(&:actor)
     end
 
     # Terminate the group
     def finalize
-      @actors.each do |actor, _|
-        begin
-          actor.terminate
-        rescue DeadActorError
-        end
-      end
+      @members.each(&:terminate)
     end
 
     # Restart a crashed actor
     def restart_actor(actor, reason)
-      member = @actors.delete actor
+      member = @members.find do |member|
+        member.actor == actor
+      end
       raise "a group member went missing. This shouldn't be!" unless member
 
-      # Ignore supervisors that shut down cleanly
-      return unless reason
-
-      actor = member.start
-      @actors[actor] = member
+      member.restart(reason)
     end
 
     # A member of the group
     class Member
-      def initialize(klass, options = {})
+      def initialize(registry, klass, options = {})
+        @registry = registry
         @klass = klass
 
         # Stringify keys :/
@@ -84,12 +107,31 @@ module Celluloid
 
         @name = options['as']
         @args = options['args'] ? Array(options['args']) : []
+        @block = options['block']
         @method = options['method'] || 'new_link'
+
+        start
       end
+      attr_reader :name, :actor
 
       def start
-        actor = @klass.send(@method, *@args)
-        Actor[@name] = actor if @name
+        @actor = @klass.send(@method, *@args, &@block)
+        @registry[@name] = @actor if @name
+      end
+
+      def restart(reason)
+        @actor = nil
+        @registry.delete(@name) if @name
+
+        # Ignore supervisors that shut down cleanly
+        return unless reason
+
+        start
+      end
+
+      def terminate
+        @actor.terminate if @actor
+      rescue DeadActorError
       end
     end
   end

data/lib/celluloid/supervisor.rb

@@ -2,68 +2,21 @@ module Celluloid
   # Supervisors are actors that watch over other actors and restart them if
   # they crash
   class Supervisor
-    include Celluloid
-    trap_exit :restart_actor
-
-    # Retrieve the actor this supervisor is supervising
-    attr_reader :actor
-
     class << self
       # Define the root of the supervision tree
       attr_accessor :root
 
       def supervise(klass, *args, &block)
-        new(nil, klass, *args, &block)
+        SupervisionGroup.new do |group|
+          group.supervise klass, *args, &block
+        end
       end
 
       def supervise_as(name, klass, *args, &block)
-        new(name, klass, *args, &block)
-      end
-    end
-
-    def initialize(name, klass, *args, &block)
-      @name, @klass, @args, @block = name, klass, args, block
-      @started = false
-
-      start_actor
-    end
-
-    def finalize
-      @actor.terminate if @actor and @actor.alive?
-    end
-
-    def start_actor(start_attempts = 3, sleep_interval = 30)
-      failures = 0
-
-      begin
-        @actor = @klass.new_link(*@args, &@block)
-      rescue
-        failures += 1
-        if failures >= start_attempts
-          failures = 0
-
-          Logger.warn("#{@klass} is crashing on initialize too quickly, sleeping for #{sleep_interval} seconds")
-          sleep sleep_interval
+        SupervisionGroup.new do |group|
+          group.supervise_as name, klass, *args, &block
         end
-        retry
       end
-
-      @started = true
-      Actor[@name] = @actor if @name
-    end
-
-    # When actors die, regardless of the reason, restart them
-    def restart_actor(actor, reason)
-      # If the actor we're supervising exited cleanly, exit the supervisor cleanly too
-      terminate unless reason
-
-      start_actor if @started
-    end
-
-    def inspect
-      str = "#<#{self.class}(#{@klass}):0x#{object_id.to_s(16)}"
-      str << " " << @args.map { |arg| arg.inspect }.join(' ') unless @args.empty?
-      str << ">"
     end
   end
 end

data/lib/celluloid/version.rb

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

data/spec/support/actor_examples.rb

@@ -3,83 +3,7 @@ shared_context "a Celluloid Actor" do |included_module|
     attr_accessor :foo
   end
 
-  let :actor_class do
-    Class.new do
-      include included_module
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-        @delegate = [:bar]
-      end
-
-      def change_name(new_name)
-        @name = new_name
-      end
-
-      def change_name_async(new_name)
-        change_name! new_name
-      end
-
-      def greet
-        "Hi, I'm #{@name}"
-      end
-
-      def run(*args)
-        yield(*args)
-      end
-
-      def crash
-        raise ExampleCrash, "the spec purposely crashed me :("
-      end
-
-      def crash_with_abort(reason, foo = nil)
-        example_crash = ExampleCrash.new(reason)
-        example_crash.foo = foo
-        abort example_crash
-      end
-
-      def crash_with_abort_raw(reason)
-        abort reason
-      end
-
-      def internal_hello
-        external_hello
-      end
-
-      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
-
-      def call_private
-        zomg_private!
-      end
-
-      def zomg_private
-        @private_called = true
-      end
-      private :zomg_private
-      attr_reader :private_called
-
-      private
-
-      def delegates?(method_name)
-        @delegate.respond_to?(method_name)
-      end
-    end
-  end
+  let(:actor_class) { ExampleActorClass.create(included_module) }
 
   it "returns the actor's class, not the proxy's" do
     actor = actor_class.new "Troy McClure"
@@ -417,6 +341,22 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context :exclusive do
+    subject do
+      Class.new do
+        include included_module
+        def exclusive_example
+          exclusive?
+        end
+        exclusive :exclusive_example
+      end.new
+    end
+
+    it "supports exclusive methods" do
+      subject.exclusive_example.should be_true
+    end
+  end
+
   context :receiving do
     before do
       @receiver = Class.new do
@@ -446,11 +386,14 @@ shared_context "a Celluloid Actor" do |included_module|
       started_at = Time.now
 
       receiver.receive(interval) { false }.should be_nil
-      (Time.now - started_at).should be_within(Celluloid::Timer::QUANTUM).of interval
+      (Time.now - started_at).should be_within(Q).of interval
     end
   end
 
   context :timers do
+    # Level of accuracy enforced by the tests (50ms)
+    Q = 0.05
+
     before do
       @klass = Class.new do
         include included_module
@@ -487,7 +430,7 @@ shared_context "a Celluloid Actor" do |included_module|
 
       # Sleep long enough to ensure we're actually seeing behavior when asleep
       # but not so long as to delay the test suite unnecessarily
-      interval = Celluloid::Timer::QUANTUM * 10
+      interval = Q * 10
       started_at = Time.now
 
       future = actor.future(:do_sleep, interval)
@@ -495,49 +438,49 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.should be_sleeping
 
       future.value
-      (Time.now - started_at).should be_within(Celluloid::Timer::QUANTUM).of interval
+      (Time.now - started_at).should be_within(Q).of interval
     end
 
     it "schedules timers which fire in the future" do
       actor = @klass.new
 
-      interval = Celluloid::Timer::QUANTUM * 10
+      interval = Q * 10
       started_at = Time.now
 
       timer = actor.fire_after(interval)
       actor.should_not be_fired
 
-      sleep(interval + Celluloid::Timer::QUANTUM) # wonky! #/
+      sleep(interval + Q) # wonky! #/
       actor.should be_fired
     end
 
     it "schedules recurring timers which fire in the future" do
       actor = @klass.new
 
-      interval = Celluloid::Timer::QUANTUM * 10
+      interval = Q * 10
       started_at = Time.now
 
       timer = actor.fire_every(interval)
       actor.fired.should be == 0
 
-      sleep(interval + Celluloid::Timer::QUANTUM) # wonky! #/
+      sleep(interval + Q) # wonky! #/
       actor.fired.should be == 1
 
-      2.times { sleep(interval + Celluloid::Timer::QUANTUM) } # wonky! #/
+      2.times { sleep(interval + Q) } # wonky! #/
       actor.fired.should be == 3
     end
 
     it "cancels timers before they fire" do
       actor = @klass.new
 
-      interval = Celluloid::Timer::QUANTUM * 10
+      interval = Q * 10
       started_at = Time.now
 
       timer = actor.fire_after(interval)
       actor.should_not be_fired
       timer.cancel
 
-      sleep(interval + Celluloid::Timer::QUANTUM) # wonky! #/
+      sleep(interval + Q) # wonky! #/
       actor.should_not be_fired
     end
   end

data/spec/support/example_actor_class.rb

@@ -0,0 +1,79 @@
+module ExampleActorClass
+  def self.create(included_module)
+    Class.new do
+      include included_module
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+        @delegate = [:bar]
+      end
+
+      def change_name(new_name)
+        @name = new_name
+      end
+
+      def change_name_async(new_name)
+        change_name! new_name
+      end
+
+      def greet
+        "Hi, I'm #{@name}"
+      end
+
+      def run(*args)
+        yield(*args)
+      end
+
+      def crash
+        raise ExampleCrash, "the spec purposely crashed me :("
+      end
+
+      def crash_with_abort(reason, foo = nil)
+        example_crash = ExampleCrash.new(reason)
+        example_crash.foo = foo
+        abort example_crash
+      end
+
+      def crash_with_abort_raw(reason)
+        abort reason
+      end
+
+      def internal_hello
+        external_hello
+      end
+
+      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
+
+      def call_private
+        zomg_private!
+      end
+
+      def zomg_private
+        @private_called = true
+      end
+      private :zomg_private
+      attr_reader :private_called
+
+      private
+
+      def delegates?(method_name)
+        @delegate.respond_to?(method_name)
+      end
+    end
+  end
+end

data/spec/support/mailbox_examples.rb

@@ -1,4 +1,7 @@
 shared_context "a Celluloid Mailbox" do
+  # Level of timer accuracy enforced by the tests (50ms)
+  Q = 0.05
+
   class TestEvent < Celluloid::SystemEvent; end
 
   it "receives messages" do
@@ -47,6 +50,6 @@ shared_context "a Celluloid Mailbox" do
     started_at = Time.now
 
     subject.receive(interval) { false }
-    (Time.now - started_at).should be_within(Celluloid::Timer::QUANTUM).of interval
+    (Time.now - started_at).should be_within(Q).of interval
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-01 00:00:00.000000000 Z
+date: 2012-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &70191377653480 !ruby/object:Gem::Requirement
+  name: timers
+  requirement: &70167227984140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 1.0.0
+  type: :runtime
   prerelease: false
-  version_requirements: *70191377653480
+  version_requirements: *70167227984140
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &70191377602840 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &70167227983760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70191377602840
+  version_requirements: *70167227983760
 - !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: &70191350440520 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: &70167227983300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70191350440520
+  version_requirements: *70167227983300
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
-  requirement: &70191350401720 !ruby/object:Gem::Requirement
+  requirement: &70167227982880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70191350401720
+  version_requirements: *70167227982880
 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:
@@ -77,6 +77,7 @@ files:
 - lib/celluloid/links.rb
 - lib/celluloid/logger.rb
 - lib/celluloid/mailbox.rb
+- lib/celluloid/notifications.rb
 - lib/celluloid/pool_manager.rb
 - lib/celluloid/receivers.rb
 - lib/celluloid/registry.rb
@@ -87,11 +88,11 @@ files:
 - lib/celluloid/supervisor.rb
 - lib/celluloid/task.rb
 - lib/celluloid/thread_handle.rb
-- lib/celluloid/timers.rb
 - lib/celluloid/uuid.rb
 - lib/celluloid/version.rb
 - lib/celluloid.rb
 - spec/support/actor_examples.rb
+- spec/support/example_actor_class.rb
 - spec/support/mailbox_examples.rb
 homepage: https://github.com/celluloid/celluloid
 licenses:

data/lib/celluloid/timers.rb

@@ -1,110 +0,0 @@
-module Celluloid
-  # Low precision timers implemented in pure Ruby
-  class Timers
-    def initialize
-      @timers = []
-    end
-
-    # Call the given block after the given interval
-    def add(interval, recurring = false, &block)
-      Timer.new(self, interval, recurring, block)
-    end
-
-    # Wait for the next timer and fire it
-    def wait
-      return if @timers.empty?
-
-      interval = wait_interval
-      sleep interval if interval >= Timer::QUANTUM
-      fire
-    end
-
-    # Interval to wait until when the next timer will fire
-    def wait_interval
-      @timers.first.time - Time.now unless empty?
-    end
-
-    # Fire all timers that are ready
-    def fire
-      return if @timers.empty?
-
-      time = Time.now + Timer::QUANTUM
-      while not empty? and time > @timers.first.time
-        timer = @timers.shift
-        timer.call
-      end
-    end
-
-    # Insert a timer into the active timers
-    def insert(timer)
-      @timers.insert(index(timer), timer)
-    end
-
-    # Remove a given timer from the set we're monitoring
-    def cancel(timer)
-      @timers.delete timer
-    end
-
-    # Are there any timers pending?
-    def empty?
-      @timers.empty?
-    end
-
-    # Index where a timer would be located in the sorted timers array
-    def index(timer)
-      l, r = 0, @timers.size - 1
-
-      while l <= r
-        m = (r + l) / 2
-        if timer < @timers.at(m)
-          r = m - 1
-        else
-          l = m + 1
-        end
-      end
-      l
-    end
-  end
-
-  # An individual timer set to fire a given proc at a given time
-  class Timer
-    include Comparable
-
-    # The timer system is guaranteed (at least by the specs) to be this precise
-    # during normal operation. Long blocking calls within actors will delay the
-    # firing of timers
-    QUANTUM = 0.02
-
-    attr_reader :interval, :time, :recurring
-
-    def initialize(timers, interval, recurring, block)
-      @timers, @interval, @recurring = timers, interval, recurring
-      @block = block
-
-      reset
-    end
-
-    def <=>(other)
-      @time <=> other.time
-    end
-
-    # Cancel this timer
-    def cancel
-      @timers.cancel self
-    end
-
-    # Reset this timer
-    def reset
-      @timers.cancel self if defined?(@time)
-      @time = Time.now + @interval
-      @timers.insert self
-    end
-
-    # Fire the block
-    def fire
-      reset if recurring
-      @block.call
-    end
-    alias_method :call, :fire
-  end
-end