celluloid 0.17.0 → 0.17.1

data/lib/celluloid/proxy/async.rb

@@ -1,36 +1,31 @@
-module Celluloid
-  module Proxy
-    # A proxy which sends asynchronous calls to an actor
-    class Async < Abstract
-      attr_reader :mailbox
+# A proxy which sends asynchronous calls to an actor
+class Celluloid::Proxy::Async < Celluloid::Proxy::Abstract
+  attr_reader :mailbox
 
-      # Used for reflecting on proxy objects themselves
-      def __class__
-        Proxy::Async
-      end
-
-      def initialize(mailbox, klass)
-        @mailbox = mailbox
-        @klass = klass
-      end
-
-      def inspect
-        "#<Celluloid::Proxy::Async(#{@klass})>"
-      end
+  # Used for reflecting on proxy objects themselves
+  def __class__
+    ::Celluloid::Proxy::Async
+  end
 
-      def method_missing(meth, *args, &block)
-        if @mailbox == ::Thread.current[:celluloid_mailbox]
-          args.unshift meth
-          meth = :__send__
-        end
+  def initialize(mailbox, klass)
+    @mailbox = mailbox
+    @klass = klass
+  end
 
-        if block_given?
-          # FIXME: nicer exception
-          fail "Cannot use blocks with async yet"
-        end
+  def inspect
+    "#<Celluloid::Proxy::Async(#{@klass})>"
+  end
 
-        @mailbox << Call::Async.new(meth, args, block)
-      end
+  def method_missing(meth, *args, &block)
+    if @mailbox == ::Thread.current[:celluloid_mailbox]
+      args.unshift meth
+      meth = :__send__
+    end
+    if block_given?
+      # FIXME: nicer exception
+      fail "Cannot use blocks with async yet"
     end
+    @mailbox << ::Celluloid::Call::Async.new(meth, args, block)
+    self
   end
 end

data/lib/celluloid/proxy/block.rb

@@ -1,31 +1,27 @@
-module Celluloid
-  module Proxy
-    class Block
-      def initialize(call, mailbox, block)
-        @call = call
-        @mailbox = mailbox
-        @block = block
-        @execution = :sender
-      end
-      attr_writer :execution
-      attr_reader :call, :block
+class Celluloid::Proxy::Block
+  attr_writer :execution
+  attr_reader :call, :block
+  def initialize(mailbox, call, block)
+    @mailbox = mailbox
+    @call = call
+    @block = block
+    @execution = :sender
+  end
 
-      def to_proc
-        if @execution == :sender
-          lambda do |*values|
-            if task = Thread.current[:celluloid_task]
-              @mailbox << Call::Block.new(self, Celluloid::Actor.current.mailbox, values)
-              # TODO: if respond fails, the Task will never be resumed
-              task.suspend(:invokeblock)
-            else
-              # FIXME: better exception
-              fail "No task to suspend"
-            end
-          end
+  def to_proc
+    if @execution == :sender
+      lambda do |*values|
+        if task = Thread.current[:celluloid_task]
+          @mailbox << ::Celluloid::Call::Block.new(self, ::Celluloid::Actor.current.mailbox, values)
+          # TODO: if respond fails, the Task will never be resumed
+          task.suspend(:invokeblock)
         else
-          @block
+          # FIXME: better exception
+          fail "No task to suspend"
         end
       end
+    else
+      @block
     end
   end
 end

data/lib/celluloid/proxy/cell.rb

@@ -1,76 +1,72 @@
-module Celluloid
-  module Proxy
-    # A proxy object returned from Celluloid::Actor.new/new_link which converts
-    # the normal Ruby method protocol into an inter-actor message protocol
-    class Cell < Sync
-      # Used for reflecting on proxy objects themselves
-      def __class__
-        Proxy::Cell
-      end
+# A proxy object returned from Celluloid::Actor.new/new_link which converts
+# the normal Ruby method protocol into an inter-actor message protocol
+class Celluloid::Proxy::Cell < Celluloid::Proxy::Sync
+  # Used for reflecting on proxy objects themselves
+  def __class__
+    ::Celluloid::Proxy::Cell
+  end
 
-      def initialize(actor_proxy, mailbox, klass)
-        super(mailbox, klass)
-        @actor_proxy  = actor_proxy
-        @sync_proxy   = Sync.new(mailbox, klass)
-        @async_proxy  = Async.new(mailbox, klass)
-        @future_proxy = Future.new(mailbox, klass)
-      end
+  def initialize(mailbox, actor_proxy, klass)
+    super(mailbox, klass)
+    @actor_proxy  = actor_proxy
+    @sync_proxy   = ::Celluloid::Proxy::Sync.new(mailbox, klass)
+    @async_proxy  = ::Celluloid::Proxy::Async.new(mailbox, klass)
+    @future_proxy = ::Celluloid::Proxy::Future.new(mailbox, klass)
+  end
 
-      def _send_(meth, *args, &block)
-        method_missing :__send__, meth, *args, &block
-      end
+  def _send_(meth, *args, &block)
+    method_missing :__send__, meth, *args, &block
+  end
 
-      def inspect
-        method_missing :inspect
-      rescue DeadActorError
-        "#<Celluloid::Proxy::Cell(#{@klass}) dead>"
-      end
+  def inspect
+    method_missing :inspect
+  rescue ::Celluloid::DeadActorError
+    "#<::Celluloid::Proxy::Cell(#{@klass}) dead>"
+  end
 
-      def method(name)
-        Internals::Method.new(self, name)
-      end
+  def method(name)
+    ::Celluloid::Internals::Method.new(self, name)
+  end
 
-      alias_method :sync, :method_missing
+  alias_method :sync, :method_missing
 
-      # Obtain an async proxy or explicitly invoke a named async method
-      def async(method_name = nil, *args, &block)
-        if method_name
-          @async_proxy.method_missing method_name, *args, &block
-        else
-          @async_proxy
-        end
-      end
+  # Obtain an async proxy or explicitly invoke a named async method
+  def async(method_name = nil, *args, &block)
+    if method_name
+      @async_proxy.method_missing method_name, *args, &block
+    else
+      @async_proxy
+    end
+  end
 
-      # Obtain a future proxy or explicitly invoke a named future method
-      def future(method_name = nil, *args, &block)
-        if method_name
-          @future_proxy.method_missing method_name, *args, &block
-        else
-          @future_proxy
-        end
-      end
+  # Obtain a future proxy or explicitly invoke a named future method
+  def future(method_name = nil, *args, &block)
+    if method_name
+      @future_proxy.method_missing method_name, *args, &block
+    else
+      @future_proxy
+    end
+  end
 
-      def alive?
-        @actor_proxy.alive?
-      end
+  def alive?
+    @actor_proxy.alive?
+  end
 
-      def dead?
-        @actor_proxy.dead?
-      end
+  def dead?
+    @actor_proxy.dead?
+  end
 
-      def thread
-        @actor_proxy.thread
-      end
+  def thread
+    @actor_proxy.thread
+  end
 
-      # Terminate the associated actor
-      def terminate
-        @actor_proxy.terminate
-      end
+  # Terminate the associated actor
+  def terminate
+    @actor_proxy.terminate
+  end
 
-      # Terminate the associated actor asynchronously
-      def terminate!
-        @actor_proxy.terminate!
-      end
-    end
+  # Terminate the associated actor asynchronously
+  def terminate!
+    @actor_proxy.terminate!
   end
 end

data/lib/celluloid/proxy/future.rb

@@ -1,40 +1,36 @@
-module Celluloid
-  module Proxy
-    # A proxy which creates future calls to an actor
-    class Future < Abstract
-      attr_reader :mailbox
-
-      # Used for reflecting on proxy objects themselves
-      def __class__
-        Proxy::Future
-      end
-
-      def initialize(mailbox, klass)
-        @mailbox = mailbox
-        @klass = klass
-      end
-
-      def inspect
-        "#<Celluloid::Proxy::Future(#{@klass})>"
-      end
-
-      def method_missing(meth, *args, &block)
-        unless @mailbox.alive?
-          fail DeadActorError, "attempted to call a dead actor"
-        end
-
-        if block_given?
-          # FIXME: nicer exception
-          fail "Cannot use blocks with futures yet"
-        end
-
-        future = ::Celluloid::Future.new
-        call = Call::Sync.new(future, meth, args, block)
-
-        @mailbox << call
-
-        future
-      end
+# A proxy which creates future calls to an actor
+class Celluloid::Proxy::Future < Celluloid::Proxy::Abstract
+  attr_reader :mailbox
+
+  # Used for reflecting on proxy objects themselves
+  def __class__
+    ::Celluloid::Proxy::Future
+  end
+
+  def initialize(mailbox, klass)
+    @mailbox = mailbox
+    @klass = klass
+  end
+
+  def inspect
+    "#<Celluloid::Proxy::Future(#{@klass})>"
+  end
+
+  def method_missing(meth, *args, &block)
+    unless @mailbox.alive?
+      fail ::Celluloid::DeadActorError, "attempted to call a dead actor"
+    end
+
+    if block_given?
+      # FIXME: nicer exception
+      fail "Cannot use blocks with futures yet"
     end
+
+    future = ::Celluloid::Future.new
+    call = ::Celluloid::Call::Sync.new(future, meth, args, block)
+
+    @mailbox << call
+
+    future
   end
 end

data/lib/celluloid/proxy/sync.rb

@@ -1,44 +1,40 @@
-module Celluloid
-  module Proxy
-    # A proxy which sends synchronous calls to an actor
-    class Sync < Abstract
-      attr_reader :mailbox
+# A proxy which sends synchronous calls to an actor
+class Celluloid::Proxy::Sync < Celluloid::Proxy::Abstract
+  attr_reader :mailbox
 
-      # Used for reflecting on proxy objects themselves
-      def __class__
-        Proxy::Sync
-      end
-
-      def initialize(mailbox, klass)
-        @mailbox = mailbox
-        @klass = klass
-      end
+  # Used for reflecting on proxy objects themselves
+  def __class__
+    ::Celluloid::Proxy::Sync
+  end
 
-      def inspect
-        "#<Celluloid::Proxy::Sync(#{@klass})>"
-      end
+  def initialize(mailbox, klass)
+    @mailbox = mailbox
+    @klass = klass
+  end
 
-      def respond_to?(meth, include_private = false)
-        __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
-      end
+  def inspect
+    "#<Celluloid::Proxy::Sync(#{@klass})>"
+  end
 
-      def method_missing(meth, *args, &block)
-        unless @mailbox.alive?
-          fail DeadActorError, "attempted to call a dead actor"
-        end
+  def respond_to?(meth, include_private = false)
+    __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
+  end
 
-        if @mailbox == ::Thread.current[:celluloid_mailbox]
-          args.unshift meth
-          meth = :__send__
-          # actor = Thread.current[:celluloid_actor]
-          # actor = actor.behavior.subject.bare_object
-          # return actor.__send__(*args, &block)
-        end
+  def method_missing(meth, *args, &block)
+    unless @mailbox.alive?
+      fail ::Celluloid::DeadActorError, "attempted to call a dead actor"
+    end
 
-        call = Call::Sync.new(::Celluloid.mailbox, meth, args, block)
-        @mailbox << call
-        call.value
-      end
+    if @mailbox == ::Thread.current[:celluloid_mailbox]
+      args.unshift meth
+      meth = :__send__
+      # actor = Thread.current[:celluloid_actor]
+      # actor = actor.behavior.subject.bare_object
+      # return actor.__send__(*args, &block)
     end
+
+    call = ::Celluloid::Call::Sync.new(::Celluloid.mailbox, meth, args, block)
+    @mailbox << call
+    call.value
   end
 end

data/lib/celluloid/system_events.rb

@@ -1,6 +1,38 @@
 module Celluloid
+  class Actor
+    # Handle high-priority system event messages
+    def handle_system_event(event)
+      if handler = SystemEvent.handle(event.class)
+        send(handler, event)
+      else
+        Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+      end
+    end
+  end
   # High-priority internal system events
   class SystemEvent
+    class << self
+      @@system_events = {}
+      def handle(type)
+        @@system_events[type]
+      end
+
+      def handler(&block)
+        fail ArgumentError, "SystemEvent handlers must be defined with a block." unless block
+        method = begin
+          handler = name
+                    .split("::").last
+                    .gsub(/([A-Z]+)([A-Z][a-z])/, "\1_\2")
+                    .gsub(/([a-z\d])([A-Z])/, "\1_\2")
+                    .tr("-", "_")
+                    .downcase
+          :"handle_#{handler}"
+        end
+        Actor.send(:define_method, method, &block)
+        @@system_events[self] = method
+      end
+    end
+
     class LinkingEvent < SystemEvent
       # Shared initializer for LinkingRequest and LinkingResponse
       def initialize(actor, type)
@@ -15,6 +47,10 @@ module Celluloid
   class LinkingRequest < SystemEvent::LinkingEvent
     attr_reader :actor, :type
 
+    handler do |event|
+      event.process(links)
+    end
+
     def process(links)
       case type
       when :link   then links << actor
@@ -34,6 +70,11 @@ module Celluloid
   class ExitEvent < SystemEvent
     attr_reader :actor, :reason
 
+    handler do |event|
+      @links.delete event.actor
+      @exit_handler.call(event)
+    end
+
     def initialize(actor, reason = nil)
       @actor = actor
       @reason = reason
@@ -44,13 +85,22 @@ module Celluloid
   class NamingRequest < SystemEvent
     attr_reader :name
 
+    handler do |event|
+      @name = event.name
+      Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+    end
+
     def initialize(name)
       @name = name
     end
   end
 
   # Request for an actor to terminate
-  class TerminationRequest < SystemEvent; end
+  class TerminationRequest < SystemEvent
+    handler do |event|
+      terminate
+    end
+  end
 
   # Signal a condition
   class SignalConditionRequest < SystemEvent
@@ -60,6 +110,8 @@ module Celluloid
     end
     attr_reader :task, :value
 
+    handler(&:call)
+
     def call
       @task.resume(@value)
     end