celluloid 0.18.0.pre → 0.18.0

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/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/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

data/lib/celluloid/group.rb

@@ -3,14 +3,14 @@ module Celluloid
     attr_accessor :group
 
     def initialize
-      @pid = $$
+      @pid = $PROCESS_ID
       @mutex = Mutex.new
       @group = []
       @running = true
     end
 
     def assert_active
-      fail Celluloid::NotActive unless active?
+      raise Celluloid::NotActive unless active?
     end
 
     def assert_inactive
@@ -18,7 +18,7 @@ module Celluloid
       if RUBY_PLATFORM == "java"
         Celluloid.logger.warn "Group is still active"
       else
-        fail Celluloid::StillActive
+        raise Celluloid::StillActive
       end
     end
 
@@ -27,7 +27,7 @@ module Celluloid
     end
 
     def forked?
-      @pid != $$
+      @pid != $PROCESS_ID
     end
 
     def to_a
@@ -40,7 +40,11 @@ module Celluloid
     def purge(thread)
       @mutex.synchronize do
         @group.delete(thread)
-        thread.kill rescue nil
+        begin
+          thread.kill
+        rescue
+          nil
+        end
       end
     end
 
@@ -53,15 +57,15 @@ module Celluloid
     end
 
     def get
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def create
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def shutdown
-      fail NotImplementedError
+      raise NotImplementedError
     end
   end
 end

data/lib/celluloid/group/pool.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Celluloid
   class Group
     class Pool < Group
@@ -12,7 +10,7 @@ module Celluloid
         super
         @mutex = Mutex.new
         @idle_threads = []
-        @group  = []
+        @group = []
         @busy_size = 0
         @idle_size = 0
 

data/lib/celluloid/group/spawner.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Celluloid
   class Group
     class Spawner < Group
@@ -11,7 +9,7 @@ module Celluloid
 
       def get(&block)
         assert_active
-        fail ArgumentError.new("No block sent to Spawner.get()") unless block_given?
+        raise ArgumentError, "No block sent to Spawner.get()" unless block_given?
         instantiate block
       end
 
@@ -52,9 +50,7 @@ module Celluloid
             Internals::Logger.crash("thread crashed", ex)
             Thread.current[:celluloid_thread_state] = :error
           ensure
-            unless Thread.current[:celluloid_thread_state] == :error
-              Thread.current[:celluloid_thread_state] = :finished
-            end
+            Thread.current[:celluloid_thread_state] = :finished unless Thread.current[:celluloid_thread_state] == :error
             @mutex.synchronize { @group.delete Thread.current }
             Thread.exit
           end

data/lib/celluloid/internals/call_chain.rb

@@ -0,0 +1,15 @@
+module Celluloid
+  module Internals
+    class CallChain
+      def self.current_id=(value)
+        Thread.current[:celluloid_chain_id] = value
+        task = Thread.current[:celluloid_task]
+        task.chain_id = value if task
+      end
+
+      def self.current_id
+        Thread.current[:celluloid_chain_id]
+      end
+    end
+  end
+end