celluloid 0.16.0 → 0.17.3

data/lib/celluloid/proxies/async_proxy.rb

@@ -1,31 +0,0 @@
-module Celluloid
-  # A proxy which sends asynchronous calls to an actor
-  class AsyncProxy < AbstractProxy
-    attr_reader :mailbox
-
-    # Used for reflecting on proxy objects themselves
-    def __class__; AsyncProxy; end
-
-    def initialize(mailbox, klass)
-      @mailbox, @klass = mailbox, klass
-    end
-
-    def inspect
-      "#<Celluloid::AsyncProxy(#{@klass})>"
-    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
-        raise "Cannot use blocks with async yet"
-      end
-
-      @mailbox << AsyncCall.new(meth, args, block)
-    end
-  end
-end

data/lib/celluloid/proxies/block_proxy.rb

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

data/lib/celluloid/proxies/cell_proxy.rb

@@ -1,68 +0,0 @@
-module Celluloid
-  # A proxy object returned from Celluloid::Actor.new/new_link which converts
-  # the normal Ruby method protocol into an inter-actor message protocol
-  class CellProxy < SyncProxy
-    # Used for reflecting on proxy objects themselves
-    def __class__; CellProxy; end
-
-    def initialize(actor_proxy, mailbox, klass)
-      super(mailbox, klass)
-      @actor_proxy  = actor_proxy
-      @sync_proxy   = SyncProxy.new(mailbox, klass)
-      @async_proxy  = AsyncProxy.new(mailbox, klass)
-      @future_proxy = FutureProxy.new(mailbox, klass)
-    end
-
-    def _send_(meth, *args, &block)
-      method_missing :__send__, meth, *args, &block
-    end
-
-    def inspect
-      method_missing :inspect
-    rescue DeadActorError
-      "#<Celluloid::CellProxy(#{@klass}) dead>"
-    end
-
-    def method(name)
-      Method.new(self, name)
-    end
-
-    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 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 thread
-      @actor_proxy.thread
-    end
-
-    # Terminate the associated actor
-    def terminate
-      @actor_proxy.terminate
-    end
-
-    # Terminate the associated actor asynchronously
-    def terminate!
-      @actor_proxy.terminate!
-    end
-  end
-end

data/lib/celluloid/proxies/future_proxy.rb

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

data/lib/celluloid/proxies/sync_proxy.rb

@@ -1,36 +0,0 @@
-module Celluloid
-  # A proxy which sends synchronous calls to an actor
-  class SyncProxy < AbstractProxy
-    attr_reader :mailbox
-
-    # Used for reflecting on proxy objects themselves
-    def __class__; SyncProxy; end
-
-    def initialize(mailbox, klass)
-      @mailbox, @klass = mailbox, klass
-    end
-
-    def inspect
-      "#<Celluloid::SyncProxy(#{@klass})>"
-    end
-
-    def respond_to?(meth, include_private = false)
-      __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
-    end
-
-    def method_missing(meth, *args, &block)
-      unless @mailbox.alive?
-        raise DeadActorError, "attempted to call a dead actor"
-      end
-
-      if @mailbox == ::Thread.current[:celluloid_mailbox]
-        args.unshift meth
-        meth = :__send__
-      end
-
-      call = SyncCall.new(::Celluloid.mailbox, meth, args, block)
-      @mailbox << call
-      call.value
-    end
-  end
-end

data/lib/celluloid/receivers.rb

@@ -1,63 +0,0 @@
-require 'set'
-
-require 'timers'
-
-module Celluloid
-  # Allow methods to directly interact with the actor protocol
-  class Receivers
-    def initialize(timers)
-      @receivers = Set.new
-      @timers = timers
-    end
-
-    # Receive an asynchronous message
-    def receive(timeout = nil, &block)
-      if Celluloid.exclusive?
-        Celluloid.mailbox.receive(timeout, &block)
-      else
-        receiver = Receiver.new block
-
-        if timeout
-          receiver.timer = @timers.after(timeout) do
-            @receivers.delete receiver
-            receiver.resume
-          end
-        end
-
-        @receivers << receiver
-        Task.suspend :receiving
-      end
-    end
-
-    # Handle incoming messages
-    def handle_message(message)
-      receiver = @receivers.find { |r| r.match(message) }
-      return unless receiver
-
-      @receivers.delete receiver
-      receiver.timer.cancel if receiver.timer
-      receiver.resume message
-      message
-    end
-  end
-
-  # Methods blocking on a call to receive
-  class Receiver
-    attr_accessor :timer
-
-    def initialize(block)
-      @block = block
-      @task  = Task.current
-      @timer = nil
-    end
-
-    # Match a message with this receiver's block
-    def match(message)
-      @block ? @block.call(message) : true
-    end
-
-    def resume(message = nil)
-      @task.resume message
-    end
-  end
-end

data/lib/celluloid/registry.rb

@@ -1,57 +0,0 @@
-require 'thread'
-
-module Celluloid
-  # The Registry allows us to refer to specific actors by human-meaningful names
-  class Registry
-    def initialize
-      @registry = {}
-      @registry_lock = Mutex.new
-    end
-
-    # Register an Actor
-    def []=(name, actor)
-      actor_singleton = class << actor; self; end
-      unless actor_singleton.ancestors.include? AbstractProxy
-        raise TypeError, "not an actor"
-      end
-
-      @registry_lock.synchronize do
-        @registry[name.to_sym] = actor
-      end
-
-      actor.mailbox << NamingRequest.new(name.to_sym)
-    end
-
-    # Retrieve an actor by name
-    def [](name)
-      @registry_lock.synchronize do
-        @registry[name.to_sym]
-      end
-    end
-
-    alias_method :get, :[]
-    alias_method :set, :[]=
-
-    def delete(name)
-      @registry_lock.synchronize do
-        @registry.delete name.to_sym
-      end
-    end
-
-    # List all registered actors by name
-    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

@@ -1,44 +0,0 @@
-module Celluloid
-  # Responses to calls
-  class Response
-    attr_reader :call, :value
-
-    def initialize(call, value)
-      @call, @value = call, value
-    end
-
-    def dispatch
-      @call.task.resume self
-    end
-  end
-
-  # Call completed successfully
-  class SuccessResponse < Response; end
-
-  # Call was aborted due to sender error
-  class ErrorResponse < Response
-    def value
-      ex = super
-      ex = ex.cause if ex.is_a? AbortError
-
-      if ex.backtrace
-        ex.backtrace << "(celluloid):0:in `remote procedure call'"
-        ex.backtrace.concat(caller)
-      end
-
-      raise ex
-    end
-  end
-
-  class BlockResponse
-    def initialize(call, result)
-      @call = call
-      @result = result
-    end
-
-    def dispatch
-      @call.task.resume(@result)
-    end
-  end
-
-end