celluloid 0.18.0.pre → 0.18.0.pre2

data/lib/celluloid/actor.rb

@@ -16,14 +16,14 @@ module Celluloid
       # Obtain the current actor
       def current
         actor = Thread.current[:celluloid_actor]
-        fail NotActorError, "not in actor scope" unless actor
+        raise NotActorError, "not in actor scope" unless actor
         actor.behavior_proxy
       end
 
       # Obtain the name of the current actor
       def registered_name
         actor = Thread.current[:celluloid_actor]
-        fail NotActorError, "not in actor scope" unless actor
+        raise NotActorError, "not in actor scope" unless actor
         actor.name
       end
 
@@ -52,13 +52,13 @@ module Celluloid
 
       # Watch for exit events from another actor
       def monitor(actor)
-        fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
         Thread.current[:celluloid_actor].linking_request(actor, :link)
       end
 
       # Stop waiting for exit events from another actor
       def unmonitor(actor)
-        fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
         Thread.current[:celluloid_actor].linking_request(actor, :unlink)
       end
 
@@ -132,8 +132,11 @@ module Celluloid
       end
 
       @proxy = Proxy::Actor.new(@mailbox, @thread)
+
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
-      Celluloid::Actor::Manager.actor_created(self) if $CELLULOID_MANAGED
+      # rubocop:enable Style/GlobalVars
     end
 
     def behavior_proxy
@@ -187,25 +190,28 @@ module Celluloid
           begin
             message = @mailbox.receive(remaining) do |msg|
               msg.is_a?(LinkingResponse) &&
-              msg.actor.mailbox.address == receiver.mailbox.address &&
-              msg.type == type
+                msg.actor.mailbox.address == receiver.mailbox.address &&
+                msg.type == type
             end
           rescue TaskTimeout
             next # IO reactor did something, no message in queue yet.
           end
 
           if message.instance_of? LinkingResponse
+            # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+            # rubocop:disable Style/GlobalVars
             Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
+            # rubocop:enable Style/GlobalVars
             system_events.each { |ev| @mailbox << ev }
             return
           elsif message.is_a? SystemEvent
             # Queue up pending system events to be processed after we've successfully linked
             system_events << message
-          else fail "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
+          else raise "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
           end
         end
 
-        fail TaskTimeout, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
+        raise TaskTimeout, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
       end
     end
 
@@ -218,7 +224,7 @@ module Celluloid
     def wait(name)
       @signals.wait name
     end
-    
+
     # Register a new handler for a given pattern
     def handle(*patterns, &block)
       @handlers.handle(*patterns, &block)
@@ -226,7 +232,7 @@ module Celluloid
 
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
-      while true
+      loop do
         message = @receivers.receive(timeout, &block)
         return message unless message.is_a?(SystemEvent)
 
@@ -280,16 +286,16 @@ module Celluloid
 
     # Handle standard low-priority messages
     def handle_message(message)
-      unless @handlers.handle_message(message)
-        unless @receivers.handle_message(message)
-          Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
-        end
-      end
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Metrics/LineLength, Style/GlobalVars
+      Internals::Logger.debug "Discarded message (unhandled): #{message}" if !@handlers.handle_message(message) && !@receivers.handle_message(message) && $CELLULOID_DEBUG
+      # rubocop:enable Metrics/LineLength, Style/GlobalVars
+
       message
     end
 
     def default_exit_handler(event)
-      fail event.reason if event.reason
+      raise event.reason if event.reason
     end
 
     # Handle any exceptions that occur within a running actor
@@ -312,7 +318,11 @@ module Celluloid
 
     # Clean up after this actor
     def cleanup(exit_event)
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
+      # rubocop:enable Style/GlobalVars
+
       @mailbox.shutdown
       @links.each do |actor|
         actor.mailbox << exit_event if actor.mailbox.alive?

data/lib/celluloid/actor/system.rb

@@ -7,33 +7,18 @@ module Celluloid
       extend Forwardable
       def_delegators :@registry, :[], :get, :[]=, :set, :delete
 
-      ROOT_SERVICES = begin
-        root_services = [
-          {
-            as: :notifications_fanout,
-            type: Celluloid::Notifications::Fanout,
-          },
-          {
-            as: :incident_reporter,
-            type: Celluloid::IncidentReporter,
-            args: [STDERR],
-          },
-          {
-            as: :public_services,
-            type: Celluloid::Supervision::Service::Public,
-            accessors: [:services],
-            supervise: [],
-          },
-        ]
-        if $CELLULOID_MANAGED
-          root_services << {
-            as: :actor_manager,
-            type: Celluloid::Actor::Manager,
-            accessors: [:manager],
-          }
-        end
-        root_services
-      end
+      ROOT_SERVICES = [
+        {
+          as: :notifications_fanout,
+          type: Celluloid::Notifications::Fanout
+        },
+        {
+          as: :public_services,
+          type: Celluloid::Supervision::Service::Public,
+          accessors: [:services],
+          supervise: []
+        }
+      ].freeze
 
       attr_reader :registry, :group
 
@@ -59,7 +44,6 @@ module Celluloid
         within do
           @root = Supervision::Service::Root.define
           @tree = root_configuration.deploy
-          # de root_services[:group_manager].manage! @group
         end
         true
       end
@@ -119,7 +103,7 @@ module Celluloid
       def shutdown
         actors = running
         Timeout.timeout(shutdown_timeout) do
-          Internals::Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
+          Internals::Logger.debug "Terminating #{actors.size} #{actors.size > 1 ? 'actors' : 'actor'}..." unless actors.empty?
 
           # Actors cannot self-terminate, you must do it for them
           actors.each do |actor|

data/lib/celluloid/autostart.rb

@@ -1,8 +1,8 @@
 require "celluloid"
 
-Celluloid.start
+Celluloid.boot
 
-unless defined?($CELLULOID_TEST) && $CELLULOID_TEST
-  Celluloid.register_shutdown
-  Celluloid.init
-end
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
+Celluloid.register_shutdown unless defined?($CELLULOID_TEST) && $CELLULOID_TEST
+# rubocop:enable Style/GlobalVars

data/lib/celluloid/backported.rb

@@ -1,2 +1,6 @@
-$CELLULOID_BACKPORTED = true
-require "celluloid/autostart"
+raise NotImplementedError, <<-MSG.strip.gsub(/\s+/, " ")
+  Celluloid 0.18 no-longer supports the "backported" API.
+  Please switch to using: `require 'celluloid'`
+  For more information, see:
+  https://github.com/celluloid/celluloid/wiki/0.18-API-changes
+MSG

data/lib/celluloid/call/async.rb

@@ -7,7 +7,9 @@ module Celluloid
         super(obj)
       rescue AbortError => ex
         # Swallow aborted async calls, as they indicate the sender made a mistake
+        # rubocop:disable Metrics/LineLength
         Internals::Logger.debug("#{obj.class}: async call `#{@method}` aborted!\n#{Internals::Logger.format_exception(ex.cause)}")
+        # rubocop:enable Metrics/LineLength
       ensure
         Internals::CallChain.current_id = nil
       end

data/lib/celluloid/call/sync.rb

@@ -4,7 +4,14 @@ module Celluloid
     class Sync < Call
       attr_reader :sender, :task, :chain_id
 
-      def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Internals::CallChain.current_id)
+      def initialize(
+          sender,
+          method,
+          arguments = [],
+          block = nil,
+          task = Thread.current[:celluloid_task],
+          chain_id = Internals::CallChain.current_id
+        )
         super(method, arguments, block)
         @sender   = sender
         @task     = task
@@ -29,7 +36,7 @@ module Celluloid
       end
 
       def cleanup
-        exception = DeadActorError.new("attempted to call a dead actor: #{self.method}")
+        exception = DeadActorError.new("attempted to call a dead actor: #{method}")
         respond Internals::Response::Error.new(self, exception)
       end
 
@@ -46,7 +53,7 @@ module Celluloid
       end
 
       def wait
-        while true
+        loop do
           message = Celluloid.mailbox.receive do |msg|
             msg.respond_to?(:call) && msg.call == self
           end

data/lib/celluloid/calls.rb

@@ -10,7 +10,7 @@ module Celluloid
       if block
         if Celluloid.exclusive?
           # FIXME: nicer exception
-          fail "Cannot execute blocks on sender in exclusive mode"
+          raise "Cannot execute blocks on sender in exclusive mode"
         end
         @block = Proxy::Block.new(Celluloid.mailbox, self, block)
       else
@@ -24,14 +24,7 @@ module Celluloid
 
     def dispatch(obj)
       check(obj)
-      _b = @block && @block.to_proc
-      obj.public_send(@method, *@arguments, &_b)
-      #     rescue Celluloid::TaskTimeout => ex
-      #       raise ex unless ( @retry += 1 ) <= RETRY_CALL_LIMIT
-      #       puts "retrying"
-      #       Internals::Logger.warn("TaskTimeout at Call dispatch. Retrying in #{RETRY_CALL_WAIT} seconds. ( Attempt #{@retry} of #{RETRY_CALL_LIMIT} )")
-      #       sleep RETRY_CALL_WAIT
-      #       retry
+      obj.public_send(@method, *@arguments, &(@block && @block.to_proc))
     end
 
     def check(obj)
@@ -48,18 +41,18 @@ module Celluloid
         if @arguments.size != arity
           e = ArgumentError.new("wrong number of arguments (#{@arguments.size} for #{arity})")
           e.set_backtrace(caller << "#{meth.source_location.join(':')}: in `#{meth.name}`")
-          fail e
+          raise e
         end
       elsif arity < -1
         mandatory_args = -arity - 1
         if arguments.size < mandatory_args
           e = ArgumentError.new("wrong number of arguments (#{@arguments.size} for #{mandatory_args}+)")
           e.set_backtrace(caller << "#{meth.source_location.join(':')}: in `#{meth.name}`")
-          fail e
+          raise e
         end
       end
     rescue => ex
-      raise AbortError.new(ex)
+      raise AbortError, ex
     end
   end
 end

data/lib/celluloid/cell.rb

@@ -36,9 +36,7 @@ module Celluloid
       @actor.handle(Call::Block) do |message|
         task(:invoke_block) { message.dispatch }
       end
-      @actor.handle(Internals::Response::Block, Internals::Response) do |message|
-        message.dispatch
-      end
+      @actor.handle(Internals::Response::Block, Internals::Response, &:dispatch)
 
       @actor.start
       @proxy = (options[:proxy_class] || Proxy::Cell).new(@actor.mailbox, @actor.proxy, @subject.class.to_s)
@@ -57,18 +55,16 @@ module Celluloid
       meth = call.method
       meth = call.arguments.first if meth == :__send__
       if @receiver_block_executions && meth
-        if @receiver_block_executions.include?(meth.to_sym)
-          call.execute_block_on_receiver
-        end
+        call.execute_block_on_receiver if @receiver_block_executions.include?(meth.to_sym)
       end
 
-      task(:call, meth, {call: call, subject: @subject},
+      task(:call, meth, { call: call, subject: @subject },
            dangerous_suspend: meth == :initialize, &Cell.dispatch)
     end
 
     def task(task_type, method_name = nil, subject = nil, meta = nil, &_block)
       meta ||= {}
-      meta.merge!(method_name: method_name)
+      meta[:method_name] = method_name
       @actor.task(task_type, meta) do
         if @exclusive_methods && method_name && @exclusive_methods.include?(method_name.to_sym)
           Celluloid.exclusive { yield subject }
@@ -94,7 +90,7 @@ module Celluloid
     def shutdown
       return unless @finalizer && @subject.respond_to?(@finalizer, true)
 
-      task(:finalizer, @finalizer, {call: @finalizer, subject: @subject},
+      task(:finalizer, @finalizer, { call: @finalizer, subject: @subject },
            dangerous_suspend: true, &Cell.shutdown)
     end
   end

data/lib/celluloid/condition.rb

@@ -34,7 +34,7 @@ module Celluloid
 
     # Wait for the given signal and return the associated value
     def wait(timeout = nil)
-      fail ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
+      raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
       if actor = Thread.current[:celluloid_actor]
         task = Task.current
@@ -57,7 +57,7 @@ module Celluloid
 
       result = Celluloid.suspend :condwait, waiter
       timer.cancel if timer
-      fail result if result.is_a?(ConditionError)
+      raise result if result.is_a?(ConditionError)
       return yield(result) if block_given?
       result
     end
@@ -83,6 +83,6 @@ module Celluloid
       end
     end
 
-    alias_method :inspect, :to_s
+    alias inspect to_s
   end
 end

data/lib/celluloid/core_ext.rb

@@ -1,5 +1,3 @@
-require "celluloid/fiber"
-
 class Thread
   attr_accessor :uuid_counter, :uuid_limit
 

data/lib/celluloid/current.rb

@@ -1,2 +1,4 @@
-$CELLULOID_BACKPORTED = false
+# Legacy support for the prescribed 0.17 API
+# TODO: remove this in a future release
+
 require "celluloid"

data/lib/celluloid/debug.rb

@@ -1 +1,4 @@
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
 $CELLULOID_DEBUG = true
+# rubocop:enable Style/GlobalVars

data/lib/celluloid/exceptions.rb

@@ -1,6 +1,6 @@
 module Celluloid
   class Error < StandardError; end
-  class Interruption < Exception; end
+  class Interruption < RuntimeError; end
   class TimedOut < Celluloid::Interruption; end # Distinguished from `Timeout`
   class StillActive < Celluloid::Error; end
   class NotActive < Celluloid::Error; end
@@ -9,7 +9,7 @@ module Celluloid
   class NotTaskError < Celluloid::Error; end # Asked to do task-related things outside a task
   class DeadTaskError < Celluloid::Error; end # Trying to resume a dead task
   class TaskTerminated < Celluloid::Interruption; end # Kill a running task after terminate
-  class TaskTimeout < Celluloid::TimedOut; end # A timeout occured before the given request could complete
+  class TaskTimeout < Celluloid::TimedOut; end # A timeout occurred before the given request could complete
   class ConditionError < Celluloid::Error; end
   class AbortError < Celluloid::Error # The sender made an error, not the current actor
     attr_reader :cause

data/lib/celluloid/future.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
@@ -50,7 +48,7 @@ module Celluloid
     # Execute the given method in future context
     def execute(receiver, method, args, block)
       @mutex.synchronize do
-        fail "already calling" if @call
+        raise "already calling" if @call
         @call = Call::Sync.new(self, method, args, block)
       end
 
@@ -93,12 +91,12 @@ module Celluloid
       end
 
       if result
-        (result.respond_to?(:value)) ? result.value : result
+        result.respond_to?(:value) ? result.value : result
       else
-        fail TimedOut, "Timed out"
+        raise TimedOut, "Timed out"
       end
     end
-    alias_method :call, :value
+    alias call value
 
     # Signal this future with the given result value
     def signal(value)
@@ -106,7 +104,7 @@ module Celluloid
       result = Result.new(value, self)
 
       @mutex.synchronize do
-        fail "the future has already happened!" if @ready
+        raise "the future has already happened!" if @ready
 
         if @forwards
           @forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
@@ -116,7 +114,7 @@ module Celluloid
         @ready = true
       end
     end
-    alias_method :<<, :signal
+    alias << signal
 
     def cancel(error)
       response = Internals::Response::Error.new(@call, error)
@@ -127,7 +125,7 @@ module Celluloid
     end
 
     # Inspect this Celluloid::Future
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # Wrapper for result values to distinguish them in mailboxes
     class Result