celluloid 0.18.0.pre → 0.18.0

data/lib/celluloid/system_events.rb

@@ -5,7 +5,10 @@ module Celluloid
       if handler = SystemEvent.handle(event.class)
         send(handler, event)
       else
+        # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+        # rubocop:disable Style/GlobalVars
         Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+        # rubocop:enable Style/GlobalVars
       end
     end
   end
@@ -18,7 +21,7 @@ module Celluloid
       end
 
       def handler(&block)
-        fail ArgumentError, "SystemEvent handlers must be defined with a block." unless block
+        raise ArgumentError, "SystemEvent handlers must be defined with a block." unless block
         method = begin
           handler = name
                     .split("::").last
@@ -38,7 +41,7 @@ module Celluloid
       def initialize(actor, type)
         @actor = actor
         @type = type.to_sym
-        fail ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+        raise ArgumentError, "type must be link or unlink" unless %i[link unlink].include?(@type)
       end
     end
   end
@@ -87,7 +90,11 @@ module Celluloid
 
     handler do |event|
       @name = event.name
+
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+      # rubocop:enable Style/GlobalVars
     end
 
     def initialize(name)
@@ -97,7 +104,7 @@ module Celluloid
 
   # Request for an actor to terminate
   class TerminationRequest < SystemEvent
-    handler do |event|
+    handler do |_event|
       terminate
     end
   end
@@ -110,9 +117,7 @@ module Celluloid
     end
     attr_reader :task, :value
 
-    handler do |event|
-      event.call
-    end
+    handler(&:call)
 
     def call
       @task.resume(@value)

data/lib/celluloid/task.rb

@@ -3,7 +3,7 @@ module Celluloid
   class Task
     # Obtain the current task
     def self.current
-      Thread.current[:celluloid_task] || fail(NotTaskError, "not within a task context")
+      Thread.current[:celluloid_task] || raise(NotTaskError, "not within a task context")
     end
 
     # Suspend the running task, deferring to the scheduler
@@ -27,7 +27,7 @@ module Celluloid
       actor     = Thread.current[:celluloid_actor]
       @chain_id = Internals::CallChain.current_id
 
-      fail NotActorError, "can't create tasks outside of actors" unless actor
+      raise NotActorError, "can't create tasks outside of actors" unless actor
       guard "can't create tasks inside of tasks" if Thread.current[:celluloid_task]
 
       create do
@@ -53,26 +53,29 @@ module Celluloid
     end
 
     def create(&_block)
-      fail "Implement #{self.class}#create"
+      raise "Implement #{self.class}#create"
     end
 
     # Suspend the current task, changing the status to the given argument
     def suspend(status)
-      fail "Cannot suspend while in exclusive mode" if exclusive?
-      fail "Cannot suspend a task from outside of itself" unless Task.current == self
+      raise "Cannot suspend while in exclusive mode" if exclusive?
+      raise "Cannot suspend a task from outside of itself" unless Task.current == self
 
       @status = status
 
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       if $CELLULOID_DEBUG && @dangerous_suspend
         Internals::Logger.with_backtrace(caller[2...8]) do |logger|
           logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
         end
       end
+      # rubocop:enable Style/GlobalVars
 
       value = signal
 
       @status = :running
-      fail value if value.is_a?(Celluloid::Interruption)
+      raise value if value.is_a?(Celluloid::Interruption)
       value
     end
 
@@ -82,7 +85,9 @@ module Celluloid
       if running?
         deliver(value)
       else
+        # rubocop:disable Metrics/LineLength
         Internals::Logger.warn "Attempted to resume a dead task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        # rubocop:enable Metrics/LineLength
       end
       nil
     end
@@ -103,20 +108,24 @@ module Celluloid
 
     # Terminate this task
     def terminate
-      fail "Cannot terminate an exclusive task" if exclusive?
+      raise "Cannot terminate an exclusive task" if exclusive?
 
       if running?
+        # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+        # rubocop:disable Style/GlobalVars
         if $CELLULOID_DEBUG
           Internals::Logger.with_backtrace(backtrace) do |logger|
             type = @dangerous_suspend ? :warn : :debug
             logger.send(type, "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}")
           end
         end
+        # rubocop:enable Style/GlobalVars
+
         exception = TaskTerminated.new("task was terminated")
         exception.set_backtrace(caller)
         resume exception
       else
-        fail DeadTaskError, "task is already dead"
+        raise DeadTaskError, "task is already dead"
       end
     end
 
@@ -125,8 +134,7 @@ module Celluloid
       @exclusive
     end
 
-    def backtrace
-    end
+    def backtrace; end
 
     # Is the current task still running?
     def running?
@@ -139,11 +147,14 @@ module Celluloid
     end
 
     def guard(message)
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       if @guard_warnings
         Internals::Logger.warn message if $CELLULOID_DEBUG
       else
-        fail message if $CELLULOID_DEBUG
+        raise message if $CELLULOID_DEBUG
       end
+      # rubocop:enable Style/GlobalVars
     end
 
     private
@@ -161,7 +172,9 @@ module Celluloid
 
     def thread_metadata
       method = @meta && @meta[:method_name] || "<no method>"
-      klass = Thread.current[:celluloid_actor] && Thread.current[:celluloid_actor].behavior.subject.bare_object.class || "<no actor>"
+      klass = Thread.current[:celluloid_actor] &&
+              Thread.current[:celluloid_actor].behavior.subject.bare_object.class ||
+              "<no actor>"
       format("[Celluloid] %s#%s", klass, method)
     end
   end

data/lib/celluloid/task/fibered.rb

@@ -40,7 +40,9 @@ module Celluloid
       end
 
       def backtrace
+        # rubocop:disable Metrics/LineLength
         ["#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::Task::Threaded` if you need backtraces here."]
+        # rubocop:enable Metrics/LineLength
       end
     end
   end

data/lib/celluloid/task/threaded.rb

@@ -18,7 +18,7 @@ module Celluloid
         thread = Internals::ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
           begin
             ex = @resume_queue.pop
-            fail ex if ex.is_a?(TaskTerminated)
+            raise ex if ex.is_a?(TaskTerminated)
 
             yield
           rescue ::Exception => ex
@@ -40,12 +40,12 @@ module Celluloid
       end
 
       def deliver(value)
-        fail DeadTaskError, "cannot resume a dead task" unless @thread.alive?
+        raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
 
         @yield_mutex.synchronize do
           @resume_queue.push(value)
           @yield_cond.wait(@yield_mutex)
-          fail @exception_queue.pop while @exception_queue.size > 0
+          raise @exception_queue.pop until @exception_queue.empty?
         end
       rescue ThreadError
         raise DeadTaskError, "cannot resume a dead task"

data/lib/celluloid/test.rb

@@ -1,3 +1,6 @@
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
 $CELLULOID_TEST = true
-
-require "celluloid"
+# rubocop:enable Style/GlobalVars
+#
+require "celluloid/autostart"

data/lib/celluloid/thread.rb

@@ -1,5 +1,3 @@
-require "celluloid/fiber"
-
 module Celluloid
   class Thread < ::Thread
     def celluloid?

data/lib/celluloid/version.rb

@@ -1,3 +1,3 @@
 module Celluloid
-  VERSION = "0.18.0.pre"
+  VERSION = "0.18.0".freeze
 end

data/spec/celluloid/block_spec.rb

@@ -2,19 +2,20 @@ RSpec.describe "Blocks", actor_system: :global do
   class MyBlockActor
     include Celluloid
 
-    def initialize(name)
+    def initialize(name, data)
       @name = name
+      @data = data
     end
     attr_reader :name
 
     def ask_for_something(other)
       sender_actor = current_actor
-      $data << [:outside, @name, current_actor.name]
-      other.do_something_and_callback do |value|
-        $data << [:yielded, @name, current_actor.name]
-        $data << receive_result(:self)
-        $data << current_actor.receive_result(:current_actor)
-        $data << sender_actor.receive_result(:sender)
+      @data << [:outside, @name, current_actor.name]
+      other.do_something_and_callback do |_value|
+        @data << [:yielded, @name, current_actor.name]
+        @data << receive_result(:self)
+        @data << current_actor.receive_result(:current_actor)
+        @data << sender_actor.receive_result(:sender)
         :pete_the_polyglot_alien
       end
     end
@@ -34,20 +35,20 @@ RSpec.describe "Blocks", actor_system: :global do
     def defer_for_something(other, &_block)
       sender_actor = current_actor
       defer do
-        $data << [:outside, @name, current_actor.name]
-        other.do_something_and_callback do |value|
-          $data << [:yielded, @name, current_actor.name]
-          $data << receive_result(:self)
-          $data << current_actor.receive_result(:current_actor)
-          $data << sender_actor.receive_result(:sender)
+        @data << [:outside, @name, current_actor.name]
+        other.do_something_and_callback do |_value|
+          @data << [:yielded, @name, current_actor.name]
+          @data << receive_result(:self)
+          @data << current_actor.receive_result(:current_actor)
+          @data << sender_actor.receive_result(:sender)
           :pete_the_polyglot_alien
         end
       end
     end
 
     def do_something_and_callback
-      $data << [:something, @name, current_actor.name]
-      $data << yield(:foo)
+      @data << [:something, @name, current_actor.name]
+      @data << yield(:foo)
     end
 
     def receive_result(result)
@@ -56,10 +57,10 @@ RSpec.describe "Blocks", actor_system: :global do
   end
 
   it "work between actors" do
-    $data = []
+    data = []
 
-    a1 = MyBlockActor.new("one")
-    a2 = MyBlockActor.new("two")
+    a1 = MyBlockActor.new("one", data)
+    a2 = MyBlockActor.new("two", data)
 
     a1.ask_for_something a2
 
@@ -70,33 +71,29 @@ RSpec.describe "Blocks", actor_system: :global do
       [:self, "one", "one"],
       [:current_actor, "one", "one"],
       [:sender, "one", "one"],
-      :pete_the_polyglot_alien,
+      :pete_the_polyglot_alien
     ]
 
-    expect($data).to eq(expected)
+    expect(data).to eq(expected)
   end
 
   execute_deferred = proc do
-    a1 = MyBlockActor.new("one")
+    a1 = MyBlockActor.new("one", [])
     expect(a1.deferred_excecution(:pete_the_polyglot_alien) { |v| v })
-    .to eq(:pete_the_polyglot_alien)
+      .to eq(:pete_the_polyglot_alien)
   end
 
-  # unless RUBY_ENGINE == 'jruby'
   xit("can be deferred", &execute_deferred)
-  # else
-  #   it("can be deferred", &execute_deferred)
-  # end
 
   xit "can execute deferred blocks referencing current_actor" do
-    a1 = MyBlockActor.new("one")
+    a1 = MyBlockActor.new("one", [])
     expect(a1.deferred_current_actor { |v| v }).to be("one")
   end
 
   xit "can execute deferred blocks with another actor" do
-    $data = []
-    a1 = MyBlockActor.new("one")
-    a2 = MyBlockActor.new("two")
+    data = []
+    a1 = MyBlockActor.new("one", data)
+    a2 = MyBlockActor.new("two", data)
     a1.defer_for_something a2
     expected = [
       [:outside, "one", "one"],
@@ -105,9 +102,9 @@ RSpec.describe "Blocks", actor_system: :global do
       [:self, "one", "one"],
       [:current_actor, "one", "one"],
       [:sender, "one", "one"],
-      :pete_the_polyglot_alien,
+      :pete_the_polyglot_alien
     ]
 
-    expect($data).to eq(expected)
+    expect(data).to eq(expected)
   end
 end

data/spec/celluloid/calls_spec.rb

@@ -5,27 +5,17 @@ RSpec.describe Celluloid::Call::Sync, actor_system: :global do
   let(:logger) { Specs::FakeLogger.current }
 
   context "when obj does not respond to a method" do
-    # bypass this until rubinius/rubinius#3373 is resolved
-    # under Rubinius, `method` calls `inspect` on an object when a method is not found
-    unless RUBY_ENGINE == "rbx"
-      it "raises a NoMethodError" do
-        allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
+    it "raises a NoMethodError" do
+      allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
 
-        expect do
-          actor.the_method_that_wasnt_there
-        end.to raise_exception(NoMethodError)
-      end
+      expect do
+        actor.the_method_that_was_not_there
+      end.to raise_exception(NoMethodError)
     end
 
     context "when obj raises during inspect" do
       it "should emulate obj.inspect" do
         allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
-
-        if RUBY_ENGINE == "rbx"
-          expected = /undefined method `no_such_method' on an instance of CallExampleActor/
-        else
-          expected = /undefined method `no_such_method' for #\<CallExampleActor:0x[a-f0-9]+\>/
-        end
       end
     end
   end

data/spec/celluloid/future_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Celluloid::Future, actor_system: :global do
   it "reraises exceptions that occur when the value is retrieved" do
     class ExampleError < StandardError; end
 
-    future = Celluloid::Future.new { fail ExampleError, "oh noes crash!" }
+    future = Celluloid::Future.new { raise ExampleError, "oh noes crash!" }
     expect { future.value }.to raise_exception(ExampleError)
   end
 
@@ -35,7 +35,7 @@ RSpec.describe Celluloid::Future, actor_system: :global do
 
   it "cancels future" do
     future = Celluloid::Future.new { sleep 3600 }
-    future.cancel(StandardError.new('cancelled'))
+    future.cancel(StandardError.new("cancelled"))
     expect { future.value }.to raise_exception(StandardError, "cancelled")
   end
 end

data/spec/celluloid/internals/cpu_counter_spec.rb

@@ -0,0 +1,129 @@
+RSpec.describe Celluloid::Internals::CPUCounter do
+  describe "#cores" do
+    subject { described_class.cores }
+
+    let(:num_cores) { 1024 }
+
+    before do
+      allow(described_class).to receive(:`) { raise "backtick stub called" }
+      allow(::IO).to receive(:open).and_raise("IO.open stub called!")
+      described_class.instance_variable_set(:@cores, nil)
+    end
+
+    after do
+      ENV["NUMBER_OF_PROCESSORS"] = nil
+      described_class.instance_variable_set(:@cores, nil)
+    end
+
+    context "with from_env" do
+      context "valid env value" do
+        before { ENV["NUMBER_OF_PROCESSORS"] = num_cores.to_s }
+        it { is_expected.to eq num_cores }
+      end
+
+      context "invalid env value" do
+        before { ENV["NUMBER_OF_PROCESSORS"] = "" }
+        subject { described_class.from_env }
+        it { is_expected.to be nil }
+      end
+    end
+
+    context "with from_sysdev" do
+      subject { described_class.from_sysdev }
+
+      context "when /sys/devices/system/cpu/present exists" do
+        before do
+          expect(::IO).to receive(:read).with("/sys/devices/system/cpu/present")
+                                        .and_return("dunno-whatever-#{num_cores - 1}")
+        end
+        it { is_expected.to eq num_cores }
+      end
+
+      context "when /sys/devices/system/cpu/present does NOT exist" do
+        before do
+          expect(::IO).to receive(:read).with("/sys/devices/system/cpu/present")
+                                        .and_raise(Errno::ENOENT)
+        end
+
+        context "when /sys/devices/system/cpu/cpu* files exist" do
+          before do
+            cpu_entries = (1..num_cores).map { |n| "cpu#{n}" }
+            cpu_entries << "non-cpu-entry-to-ignore"
+            expect(Dir).to receive(:[]).with("/sys/devices/system/cpu/cpu*")
+                                       .and_return(cpu_entries)
+          end
+          it { is_expected.to eq num_cores }
+        end
+      end
+
+      context "when /sys/devices/system/cpu/cpu* files DO NOT exist" do
+        before do
+          expect(Dir).to receive(:[]).with("/sys/devices/system/cpu/cpu*")
+                                     .and_return([])
+        end
+      end
+    end
+
+    context "with from_java" do
+      subject { described_class.from_java }
+
+      xit "not yet tested" do
+      end
+    end
+
+    context "with from_proc" do
+      subject { described_class.from_proc }
+
+      xit "not yet tested" do
+      end
+    end
+
+    context "with from_win32ole" do
+      subject { described_class.from_win32ole }
+
+      xit "not yet tested" do
+      end
+    end
+
+    context "with from_sysctl" do
+      subject { described_class.from_sysctl }
+
+      context "when sysctl blows up" do
+        before { allow(described_class).to receive(:`).and_raise(Errno::EINTR) }
+        it { is_expected.to be nil }
+      end
+
+      context "when sysctl fails" do
+        before { allow(described_class).to receive(:`).and_return(`false`) }
+        it { is_expected.to be nil }
+      end
+
+      context "when sysctl succeeds" do
+        before do
+          expect(described_class).to receive(:`).with("sysctl -n hw.ncpu 2>/dev/null")
+                                                .and_return(num_cores.to_s)
+          `true`
+        end
+        it { is_expected.to eq num_cores }
+      end
+    end
+
+    xit "when all guesses fail" do
+    end
+
+    context "with from_result" do
+      context "when passed a symbol" do
+        subject { described_class.from_result(:foo) }
+        it { is_expected.to be nil }
+      end
+      context "when passed 0" do
+        subject { described_class.from_result(:foo) }
+        it { is_expected.to be nil }
+      end
+      context "when passed valid integer" do
+        subject { described_class.from_result(num_cores) }
+        it { is_expected.to be num_cores }
+      end
+    end
+  end
+end