celluloid 0.12.3 → 0.12.4.pre

data/README.md

@@ -2,6 +2,7 @@
 =========
 [![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)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/celluloid/celluloid)
 
 > "I thought of objects being like biological cells and/or individual
 > computers on a network, only able to communicate with messages"
@@ -63,11 +64,9 @@ features which make concurrent programming simple, easy, and fun:
 
 You can also build distributed systems with Celluloid using its
 [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/celluloid/celluloid/wiki)
-for more detailed documentation and usage notes.
+to EventMachine (with a synchronous API instead of callback/deferrable soup)
+is available through the [Celluloid::IO](https://github.com/celluloid/celluloid-io)
+library.
 
 Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
 or visit us on IRC at #celluloid on freenode
@@ -75,7 +74,20 @@ or visit us on IRC at #celluloid on freenode
 ### Is It "Production Ready™"?
 
 Yes, many users are now running Celluloid in production by using
-[Sidekiq](https://github.com/mperham/sidekiq)
+[Sidekiq](http://sidekiq.org) and [Adhearsion](http://adhearsion.com/)
+
+Documentation
+-------------
+
+[Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
+for more detailed documentation and usage notes.
+
+The following API documentation is also available:
+
+* [YARD API documentation](http://rubydoc.info/gems/celluloid/frames)
+* [Celluloid module (primary API)](http://rubydoc.info/gems/celluloid/Celluloid)
+* [Celluloid class methods](http://rubydoc.info/gems/celluloid/Celluloid/ClassMethods)
+* [All Celluloid classes](http://rubydoc.info/gems/celluloid/index)
 
 Installation
 ------------

data/lib/celluloid.rb

@@ -24,7 +24,7 @@ module Celluloid
 
     # Are we currently inside of an actor?
     def actor?
-      !!Thread.current[:actor]
+      !!Thread.current[:celluloid_actor]
     end
 
     # Generate a Universally Unique Identifier
@@ -55,7 +55,7 @@ module Celluloid
     def shutdown
       Timeout.timeout(SHUTDOWN_TIMEOUT) do
         actors = Actor.all
-        Logger.info "Terminating #{actors.size} actors..." if actors.size > 0
+        Logger.debug "Terminating #{actors.size} actors..." if actors.size > 0
 
         # Attempt to shut down the supervision tree, if available
         Supervisor.root.terminate if Supervisor.root
@@ -75,7 +75,7 @@ module Celluloid
           end
         end
 
-        Logger.info "Shutdown completed cleanly"
+        Logger.debug "Shutdown completed cleanly"
       end
     end
   end
@@ -142,7 +142,7 @@ module Celluloid
 
     # Run an actor in the foreground
     def run(*args, &block)
-      new(*args, &block).join
+      Actor.join(new(*args, &block))
     end
 
     # Trap errors from actors we're linked to when they exit
@@ -170,6 +170,10 @@ module Celluloid
     def mailbox_class(klass)
       @mailbox_factory = proc { klass.new }
     end
+    
+    def proxy_class(klass)
+      @proxy_factory = proc { klass }
+    end
 
     # Define the default task type for this class
     def task_class(klass = nil)
@@ -204,11 +208,22 @@ module Celluloid
         Mailbox.new
       end
     end
+    
+    def proxy_factory
+      if defined?(@proxy_factory)
+        @proxy_factory.call
+      elsif superclass.respond_to?(:proxy_factory)
+        superclass.proxy_factory
+      else
+        nil
+      end
+    end
 
     # Configuration options for Actor#new
     def actor_options
       {
         :mailbox           => mailbox_factory,
+        :proxy_class       => proxy_factory,
         :exit_handler      => exit_handler,
         :exclusive_methods => @exclusive_methods,
         :task_class        => task_class
@@ -239,14 +254,29 @@ module Celluloid
     def bare_object; self; end
     alias_method :wrapped_object, :bare_object
 
+    # Are we being invoked in a different thread from our owner?
+    def leaked?
+      @celluloid_owner != Thread.current[:celluloid_actor]
+    end
+
     def inspect
-      str = "#<#{Celluloid::BARE_OBJECT_WARNING_MESSAGE}(#{self.class}:0x#{object_id.to_s(16)})"
-      ivars = instance_variables.map do |ivar|
-        "#{ivar}=#{instance_variable_get(ivar).inspect}"
+      str = "#<"
+
+      if leaked?
+        str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
+      else
+        str << "Celluloid::Actor"
+      end
+
+      str << "(#{self.class}:0x#{object_id.to_s(16)})"
+      str << " " unless instance_variables.empty?
+
+      instance_variables.each do |ivar|
+        next if ivar == Celluloid::OWNER_IVAR
+        str << "#{ivar}=#{instance_variable_get(ivar).inspect} "
       end
 
-      str << " " << ivars.join(' ') unless ivars.empty?
-      str << ">"
+      str.sub!(/\s$/, '>')
     end
 
     # Process async calls via method_missing
@@ -258,7 +288,7 @@ module Celluloid
 
         call = AsyncCall.new(:__send__, args, block)
         begin
-          Thread.current[:actor].mailbox << call
+          Thread.current[:celluloid_actor].mailbox << call
         rescue MailboxError
           # Silently swallow asynchronous calls to dead actors. There's no way
           # to reliably generate DeadActorErrors for async calls, so users of
@@ -290,17 +320,17 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:actor].terminate
+    Thread.current[:celluloid_actor].terminate
   end
 
   # Send a signal with the given name to all waiting methods
   def signal(name, value = nil)
-    Thread.current[:actor].signal name, value
+    Thread.current[:celluloid_actor].signal name, value
   end
 
   # Wait for the given signal
   def wait(name)
-    Thread.current[:actor].wait name
+    Thread.current[:celluloid_actor].wait name
   end
 
   # Obtain the current_actor
@@ -315,12 +345,12 @@ module Celluloid
 
   # Obtain the running tasks for this actor
   def tasks
-    Thread.current[:actor].tasks.to_a
+    Thread.current[:celluloid_actor].tasks.to_a
   end
 
   # Obtain the Celluloid::Links for this actor
   def links
-    Thread.current[:actor].links
+    Thread.current[:celluloid_actor].links
   end
 
   # Watch for exit events from another actor
@@ -355,7 +385,7 @@ module Celluloid
 
   # Receive an asynchronous message via the actor protocol
   def receive(timeout = nil, &block)
-    actor = Thread.current[:actor]
+    actor = Thread.current[:celluloid_actor]
     if actor
       actor.receive(timeout, &block)
     else
@@ -365,7 +395,7 @@ module Celluloid
 
   # Sleep letting the actor continue processing messages
   def sleep(interval)
-    actor = Thread.current[:actor]
+    actor = Thread.current[:celluloid_actor]
     if actor
       actor.sleep(interval)
     else
@@ -376,23 +406,23 @@ module Celluloid
   # Run given block in an exclusive mode: all synchronous calls block the whole
   # actor, not only current message processing.
   def exclusive(&block)
-    Thread.current[:actor].exclusive(&block)
+    Thread.current[:celluloid_actor].exclusive(&block)
   end
 
   # Are we currently exclusive
   def exclusive?
-    actor = Thread.current[:actor]
+    actor = Thread.current[:celluloid_actor]
     actor && actor.exclusive?
   end
 
   # Call a block after a given interval, returning a Celluloid::Timer object
   def after(interval, &block)
-    Thread.current[:actor].after(interval, &block)
+    Thread.current[:celluloid_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)
+    Thread.current[:celluloid_actor].every(interval, &block)
   end
 
   # Perform a blocking or computationally intensive action inside an
@@ -407,18 +437,18 @@ module Celluloid
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
     if meth
-      Actor.async Thread.current[:actor].mailbox, meth, *args, &block
+      Actor.async Thread.current[:celluloid_actor].mailbox, meth, *args, &block
     else
-      Thread.current[:actor].proxy.async
+      Thread.current[:celluloid_actor].proxy.async
     end
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
     if meth
-      Actor.future Thread.current[:actor].mailbox, meth, *args, &block
+      Actor.future Thread.current[:celluloid_actor].mailbox, meth, *args, &block
     else
-      Thread.current[:actor].proxy.future
+      Thread.current[:celluloid_actor].proxy.future
     end
   end
 end

data/lib/celluloid/actor.rb

@@ -21,6 +21,7 @@ module Celluloid
   end
 
   LINKING_TIMEOUT = 5 # linking times out after 5 seconds
+  OWNER_IVAR = :@celluloid_owner # reference to owning actor
 
   # Actors are Celluloid's concurrency primitive. They're implemented as
   # normal Ruby objects wrapped in threads which communicate with asynchronous
@@ -43,14 +44,14 @@ module Celluloid
 
       # Obtain the current actor
       def current
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.proxy
       end
 
       # Obtain the name of the current actor
       def name
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.name
       end
@@ -65,7 +66,7 @@ module Celluloid
           raise DeadActorError, "attempted to call a dead actor"
         end
 
-        if Thread.current[:task]
+        if Thread.current[:celluloid_task] && !Celluloid.exclusive?
           Task.suspend(:callwait).value
         else
           response = loop do
@@ -73,7 +74,7 @@ module Celluloid
               msg.respond_to?(:call) and msg.call == call
             end
             break message unless message.is_a?(SystemEvent)
-            Thread.current[:actor].handle_system_event(message)
+            Thread.current[:celluloid_actor].handle_system_event(message)
           end
 
           response.value
@@ -103,7 +104,7 @@ module Celluloid
       def all
         actors = []
         Thread.list.each do |t|
-          actor = t[:actor]
+          actor = t[:celluloid_actor]
           actors << actor.proxy if actor and actor.respond_to?(:proxy)
         end
         actors
@@ -112,25 +113,25 @@ module Celluloid
       # Watch for exit events from another actor
       def monitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:actor].linking_request(actor, :link)
+        Thread.current[:celluloid_actor].linking_request(actor, :link)
       end
 
       # Stop waiting for exit events from another actor
       def unmonitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:actor].linking_request(actor, :unlink)
+        Thread.current[:celluloid_actor].linking_request(actor, :unlink)
       end
 
       # Link to another actor
       def link(actor)
         monitor actor
-        Thread.current[:actor].links << actor
+        Thread.current[:celluloid_actor].links << actor
       end
 
       # Unlink from another actor
       def unlink(actor)
         unmonitor actor
-        Thread.current[:actor].links.delete actor
+        Thread.current[:celluloid_actor].links.delete actor
       end
 
       # Are we monitoring the given actor?
@@ -140,7 +141,7 @@ module Celluloid
 
       # Are we bidirectionally linked to the given actor?
       def linked_to?(actor)
-        monitoring?(actor) && Thread.current[:actor].links.include?(actor)
+        monitoring?(actor) && Thread.current[:celluloid_actor].links.include?(actor)
       end
 
       # Forcibly kill a given actor
@@ -163,6 +164,7 @@ module Celluloid
     def initialize(subject, options = {})
       @subject      = subject
       @mailbox      = options[:mailbox] || Mailbox.new
+      @proxy_class  = options[:proxy_class] || ActorProxy
       @exit_handler = options[:exit_handler]
       @exclusives   = options[:exclusive_methods]
       @task_class   = options[:task_class] || Celluloid.task_class
@@ -177,12 +179,13 @@ module Celluloid
       @name      = nil
 
       @thread = ThreadHandle.new do
-        Thread.current[:actor]   = self
-        Thread.current[:mailbox] = @mailbox
+        Thread.current[:celluloid_actor]   = self
+        Thread.current[:celluloid_mailbox] = @mailbox
         run
       end
 
-      @proxy = ActorProxy.new(self)
+      @proxy = @proxy_class.new(self)
+      @subject.instance_variable_set(OWNER_IVAR, self)
     end
 
     # Run the actor loop
@@ -306,7 +309,8 @@ module Celluloid
 
     # Sleep for the given amount of time
     def sleep(interval)
-      if task = Thread.current[:task]
+      task = Thread.current[:celluloid_task]
+      if task && !Celluloid.exclusive?
         @timers.after(interval) { task.resume }
         Task.suspend :sleeping
       else
@@ -345,6 +349,8 @@ module Celluloid
 
     # Handle exit events received by this actor
     def handle_exit_event(event)
+      @links.delete event.actor
+
       # Run the exit handler if available
       return @subject.send(@exit_handler, event.actor, event.reason) if @exit_handler
 
@@ -366,8 +372,8 @@ module Celluloid
       run_finalizer
       cleanup exit_event
     ensure
-      Thread.current[:actor]   = nil
-      Thread.current[:mailbox] = nil
+      Thread.current[:celluloid_actor]   = nil
+      Thread.current[:celluloid_mailbox] = nil
     end
 
     # Run the user-defined finalizer, if one is set

data/lib/celluloid/calls.rb

@@ -7,70 +7,29 @@ module Celluloid
       @method, @arguments, @block = method, arguments, block
     end
 
-    def check_signature(obj)
-      unless obj.respond_to? @method
-        raise NoMethodError, "undefined method `#{@method}' for #{obj.to_s}"
-      end
-
-      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})"
-        end
-      elsif arity < -1
-        mandatory_args = -arity - 1
-        if arguments.size < mandatory_args
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{mandatory_args})"
-        end
-      end
-    end
   end
 
   # Synchronous calls wait for a response
   class SyncCall < Call
     attr_reader :caller, :task
 
-    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:task])
+    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:celluloid_task])
       super(method, arguments, block)
       @caller = caller
       @task = task
     end
 
     def dispatch(obj)
-      begin
-        check_signature(obj)
-      rescue => ex
-        respond ErrorResponse.new(self, AbortError.new(ex))
-        return
-      end
-
-      begin
-        result = obj.send @method, *@arguments, &@block
-      rescue Exception => exception
-        # Exceptions that occur during synchronous calls are reraised in the
-        # context of the caller
-        respond ErrorResponse.new(self, exception)
-
-        if exception.is_a? AbortError
-          # Aborting indicates a protocol error on the part of the caller
-          # It should crash the caller, but the exception isn't reraised
-          return
-        else
-          # Otherwise, it's a bug in this actor and should be reraised
-          raise exception
-        end
-      end
-
+      result = obj.public_send(@method, *@arguments, &@block)
       respond SuccessResponse.new(self, result)
+    rescue Exception => ex
+      # Exceptions that occur during synchronous calls are reraised in the
+      # context of the caller
+      respond ErrorResponse.new(self, ex)
+      # Aborting indicates a protocol error on the part of the caller
+      # It should crash the caller, but the exception isn't reraised
+      # Otherwise, it's a bug in this actor and should be reraised
+      ex.is_a?(AbortError) ? nil : raise
     end
 
     def cleanup
@@ -84,23 +43,19 @@ module Celluloid
       # It's possible the caller exited or crashed before we could send a
       # response to them.
     end
+
   end
 
   # Asynchronous calls don't wait for a response
   class AsyncCall < Call
-    def dispatch(obj)
-      begin
-        check_signature(obj)
-      rescue Exception => ex
-        Logger.crash("#{obj.class}: async call `#{@method}' failed!", ex)
-        return
-      end
 
-      obj.send(@method, *@arguments, &@block)
+    def dispatch(obj)
+      obj.public_send(@method, *@arguments, &@block)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
-      Logger.crash("#{obj.class}: async call `#{@method}' aborted!", ex.cause)
+      Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
     end
+
   end
-end
 
+end

data/lib/celluloid/core_ext.rb

@@ -6,7 +6,7 @@ class Thread
 
   # Retrieve the mailbox for the current thread or lazily initialize it
   def self.mailbox
-    current[:mailbox] ||= Celluloid::Mailbox.new
+    current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
   end
 
   # Receive a message either as an actor or through the local mailbox

data/lib/celluloid/internal_pool.rb

@@ -23,7 +23,7 @@ module Celluloid
             end
           end until thread.status # handle crashed threads
 
-          thread[:queue] << block
+          thread[:celluloid_queue] << block
           thread
         end
       end
@@ -32,7 +32,7 @@ module Celluloid
       def put(thread)
         @mutex.synchronize do
           if @pool.size >= @max_idle
-            thread[:queue] << nil
+            thread[:celluloid_queue] << nil
           else
             @pool << thread
           end
@@ -54,7 +54,7 @@ module Celluloid
           end
         end
 
-        thread[:queue] = queue
+        thread[:celluloid_queue] = queue
         thread
       end
     end

data/lib/celluloid/pool_manager.rb

@@ -80,12 +80,20 @@ module Celluloid
       @size
     end
 
+    def busy_size
+      @busy.length
+    end
+
+    def idle_size
+      @idle.length
+    end
+
     # Provision a new worker
     def __provision_worker
       while @idle.empty?
         # Wait for responses from one of the busy workers
         response = exclusive { receive { |msg| msg.is_a?(Response) } }
-        Thread.current[:actor].handle_message(response)
+        Thread.current[:celluloid_actor].handle_message(response)
       end
 
       worker = @idle.shift

data/lib/celluloid/proxies/actor_proxy.rb

@@ -10,7 +10,10 @@ module Celluloid
       @async_proxy  = AsyncProxy.new(actor)
       @future_proxy = FutureProxy.new(actor)
     end
-
+    
+    # allow querying the real class
+    alias :__class__ :class
+    
     def class
       Actor.call @mailbox, :__send__, :class
     end
@@ -20,7 +23,7 @@ module Celluloid
     end
 
     def inspect
-      Actor.call(@mailbox, :inspect).sub(::Celluloid::BARE_OBJECT_WARNING_MESSAGE, "Celluloid::Actor")
+      Actor.call(@mailbox, :inspect)
     rescue DeadActorError
       "#<Celluloid::Actor(#{@klass}) dead>"
     end

data/lib/celluloid/task.rb

@@ -14,7 +14,7 @@ module Celluloid
 
     # Obtain the current task
     def self.current
-      Thread.current[:task] or raise NotTaskError, "not within a task context"
+      Thread.current[:celluloid_task] or raise NotTaskError, "not within a task context"
     end
 
     # Suspend the running task, deferring to the scheduler

data/lib/celluloid/tasks/task_fiber.rb

@@ -1,4 +1,6 @@
 module Celluloid
+  class FiberStackError < StandardError; end
+
   # Tasks with a Fiber backend
   class TaskFiber
     attr_reader :type, :status
@@ -8,14 +10,14 @@ module Celluloid
       @type   = type
       @status = :new
 
-      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      actor, mailbox = Thread.current[:celluloid_actor], Thread.current[:celluloid_mailbox]
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
       @fiber = Fiber.new do
         @status = :running
-        Thread.current[:actor]   = actor
-        Thread.current[:mailbox] = mailbox
-        Thread.current[:task]    = self
+        Thread.current[:celluloid_actor]   = actor
+        Thread.current[:celluloid_mailbox] = mailbox
+        Thread.current[:celluloid_task]    = self
         actor.tasks << self
 
         begin
@@ -43,8 +45,10 @@ module Celluloid
     def resume(value = nil)
       @fiber.resume value
       nil
-    rescue FiberError
-      raise DeadTaskError, "cannot resume a dead task"
+    rescue SystemStackError => ex
+      raise FiberStackError, "#{ex} (please see https://github.com/celluloid/celluloid/wiki/Fiber-stack-errors)"
+    rescue FiberError => ex
+      raise DeadTaskError, "cannot resume a dead task (#{ex})"
     end
 
     # Terminate this task

data/lib/celluloid/tasks/task_thread.rb

@@ -12,16 +12,16 @@ module Celluloid
       @yield_mutex  = Mutex.new
       @yield_cond   = ConditionVariable.new
 
-      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      actor, mailbox = Thread.current[:celluloid_actor], Thread.current[:celluloid_mailbox]
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
       @thread = InternalPool.get do
         begin
           unless @resume_queue.pop.is_a?(Task::TerminatedError)
             @status = :running
-            Thread.current[:actor]   = actor
-            Thread.current[:mailbox] = mailbox
-            Thread.current[:task]    = self
+            Thread.current[:celluloid_actor]   = actor
+            Thread.current[:celluloid_mailbox] = mailbox
+            Thread.current[:celluloid_task]    = self
             actor.tasks << self
 
             yield

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.12.3'
+  VERSION = '0.12.4.pre'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -211,21 +211,22 @@ shared_context "a Celluloid Actor" do |included_module|
     actor = actor_class.new "Troy McClure"
 
     actor.inspect.should_not include Celluloid::BARE_OBJECT_WARNING_MESSAGE
+    actor.inspect_thunk.should_not include Celluloid::BARE_OBJECT_WARNING_MESSAGE
     actor.wrapped_object.inspect.should include Celluloid::BARE_OBJECT_WARNING_MESSAGE
   end
 
-  describe 'mocking methods' do
+  context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 
     before do
       actor.wrapped_object.should_receive(:external_hello).once.and_return "World"
     end
 
-    it 'works externally via the proxy' do
+    it "works externally via the proxy" do
       actor.external_hello.should == "World"
     end
 
-    it 'works internally when called on self' do
+    it "works internally when called on self" do
       actor.internal_hello.should == "World"
     end
   end
@@ -364,6 +365,18 @@ shared_context "a Celluloid Actor" do |included_module|
       sleep 0.1 # hax to prevent a race between exit handling and the next call
       chuck.should be_subordinate_lambasted
     end
+
+    it "unlinks from a dead linked actor" do
+      chuck = supervisor_class.new "Chuck Lorre"
+      chuck.link @charlie
+
+      expect do
+        @charlie.crash
+      end.to raise_exception(ExampleCrash)
+
+      sleep 0.1 # hax to prevent a race between exit handling and the next call
+      chuck.links.count.should == 0
+    end
   end
 
   context :signaling do
@@ -440,12 +453,30 @@ shared_context "a Celluloid Actor" do |included_module|
           @tasks = []
         end
 
-        def exclusive_example(input = nil, sleep = false)
-          sleep Celluloid::TIMER_QUANTUM if sleep
-          @tasks << input
-          exclusive?
+        def log_task(task)
+          @tasks << task
+        end
+
+        def exclusive_with_block_log_task(task)
+          exclusive do
+            sleep Celluloid::TIMER_QUANTUM
+            log_task(task)
+          end
+        end
+
+        def exclusive_log_task(task)
+          sleep Celluloid::TIMER_QUANTUM
+          log_task(task)
+        end
+        exclusive :exclusive_log_task
+
+        def check_not_exclusive
+          Celluloid.exclusive?
+        end
+
+        def check_exclusive
+          exclusive { Celluloid.exclusive? }
         end
-        exclusive :exclusive_example
 
         def nested_exclusive_example
           exclusive { exclusive { nil }; Celluloid.exclusive? }
@@ -453,20 +484,28 @@ shared_context "a Celluloid Actor" do |included_module|
       end.new
     end
 
-    it "supports exclusive methods" do
-      subject.exclusive_example.should be_true
-    end
-
-    it "remains in exclusive mode inside nested blocks" do
-      subject.nested_exclusive_example.should be_true
+    it "executes methods in the proper order with block form" do
+      subject.async.exclusive_with_block_log_task(:one)
+      subject.async.log_task(:two)
+      sleep Celluloid::TIMER_QUANTUM * 2
+      subject.tasks.should == [:one, :two]
     end
 
-    it "executes the method in an exclusive order" do
-      subject.exclusive_example! :one, true
-      subject.exclusive_example! :two
+    it "executes methods in the proper order with a class-level annotation" do
+      subject.async.exclusive_log_task :one
+      subject.async.log_task :two
       sleep Celluloid::TIMER_QUANTUM * 2
       subject.tasks.should == [:one, :two]
     end
+
+    it "knows when it's in exclusive mode" do
+      subject.check_not_exclusive.should be_false
+      subject.check_exclusive.should be_true
+    end
+
+    it "remains in exclusive mode inside nested blocks" do
+      subject.nested_exclusive_example.should be_true
+    end
   end
 
   context "exclusive classes" do
@@ -677,6 +716,26 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context :proxy_class do
+    class ExampleProxy < Celluloid::ActorProxy; end
+
+    subject do
+      Class.new do
+        include included_module
+        proxy_class ExampleProxy
+      end
+    end
+
+    it "uses user-specified proxy" do
+      subject.new.__class__.should == ExampleProxy
+    end
+
+    it "retains custom proxy when subclassed" do
+      subclass = Class.new(subject)
+      subclass.new.__class__.should == ExampleProxy
+    end
+  end
+
   context :use_mailbox do
     class ExampleMailbox < Celluloid::Mailbox; end
 

data/spec/support/example_actor_class.rb

@@ -51,6 +51,10 @@ module ExampleActorClass
         "Hello"
       end
 
+      def inspect_thunk
+        inspect
+      end
+
       def method_missing(method_name, *args, &block)
         if delegates?(method_name)
           @delegate.send method_name, *args, &block

data/spec/support/task_examples.rb

@@ -14,11 +14,11 @@ shared_context "a Celluloid Task" do |task_class|
   subject { task_class.new(task_type) { Celluloid::Task.suspend(suspend_state) } }
 
   before :each do
-    Thread.current[:actor] = actor
+    Thread.current[:celluloid_actor] = actor
   end
 
   after :each do
-    Thread.current[:actor] = nil
+    Thread.current[:celluloid_actor] = nil
   end
 
   it "begins with status :new" do

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.12.3
-  prerelease: 
+  version: 0.12.4.pre
+  prerelease: 7
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-25 00:00:00.000000000 Z
+date: 2012-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
-  requirement: &70118227807960 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70118227807960
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: facter
-  requirement: &70118227807500 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: 1.6.12
   type: :runtime
   prerelease: false
-  version_requirements: *70118227807500
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.12
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70118227807120 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70118227807120
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70118227806660 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70118227806660
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
-  requirement: &70118227806240 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +85,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70118227806240
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 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:
@@ -140,9 +165,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Actor-based concurrent object framework for Ruby
 test_files: []
-has_rdoc: