celluloid 0.17.4 → 0.18.0

data/spec/support/examples/stack_classes.rb

@@ -0,0 +1,58 @@
+class StackWaiter
+  QUEUE = Queue.new
+  WAITERS = Queue.new
+  ACTORS = Queue.new
+
+  class << self
+    def forever
+      WAITERS << Thread.current
+      # de QUEUE.pop
+      sleep
+    end
+
+    def no_longer
+      StackWaiter::ACTORS.pop.terminate until StackWaiter::ACTORS.empty?
+
+      loop do
+        break if WAITERS.empty?
+        QUEUE << nil
+        nicely_end_thread(WAITERS.pop)
+      end
+    end
+
+    def nicely_end_thread(th)
+      return if jruby_fiber?(th)
+
+      status = th.status
+      case status
+      when nil, false, "dead"
+      when "aborting"
+        th.join(2) || STDERR.puts("Thread join timed out...")
+      when "sleep", "run"
+        th.kill
+        th.join(2) || STDERR.puts("Thread join timed out...")
+      else
+        STDERR.puts "unknown status: #{th.status.inspect}"
+      end
+    end
+
+    def jruby_fiber?(th)
+      return false unless RUBY_PLATFORM == "java" && (java_th = th.to_java.getNativeThread)
+      /Fiber/ =~ java_th.get_name
+    end
+  end
+end
+
+class StackBlocker
+  include Celluloid
+
+  def initialize(threads)
+    @threads = threads
+  end
+
+  def blocking
+    StackWaiter::ACTORS << Thread.current
+    @threads << Thread.current
+    StackWaiter.forever
+  end
+end

data/spec/support/examples/stack_methods.rb

@@ -0,0 +1,23 @@
+def create_async_blocking_actor(task_klass)
+  actor_klass = Class.new(StackBlocker) do
+    task_class task_klass
+  end
+
+  actor = actor_system.within do
+    actor_klass.new(threads)
+  end
+
+  actor.async.blocking
+end
+
+def create_thread_with_role(threads, role)
+  resume = Queue.new
+  thread = actor_system.get_thread do
+    resume.pop # to avoid race for 'thread' variable
+    thread.role = role
+    threads << thread
+    StackWaiter.forever
+  end
+  resume << nil # to avoid race for 'thread' variable
+  thread
+end

data/spec/support/examples/subordinate_class.rb

@@ -0,0 +1,19 @@
+class SubordinateDead < Celluloid::Error; end
+
+class Subordinate
+  include Celluloid
+  attr_reader :state
+
+  def initialize(state)
+    @state = state
+  end
+
+  def crack_the_whip
+    case @state
+    when :idle
+      @state = :working
+    else
+      raise SubordinateDead, "the spec purposely crashed me :("
+    end
+  end
+end

data/spec/support/logging.rb

@@ -1,21 +1,7 @@
 module Specs
   class << self
-    def log
-      # Setup ENV variable handling with sane defaults
-      @log ||= Nenv("celluloid_specs_log") do |env|
-        env.create_method(:file) { |f| f || "log/default.log" }
-        env.create_method(:sync?) { |s| s || !Nenv.ci? }
-
-        env.create_method(:strategy) do |strategy|
-          strategy || default_strategy
-        end
-
-        env.create_method(:level) { |level| default_level_for(env, level) }
-      end
-    end
-
     def logger
-      @logger ||= default_logger.tap { |logger| logger.level = log.level }
+      @logger ||= default_logger.tap { |log| log.level = Logger::WARN }
     end
 
     attr_writer :logger
@@ -23,33 +9,16 @@ module Specs
     private
 
     def default_logger
-      case log.strategy
-      when "stderr"
-        Logger.new(STDERR)
-      when "single"
-        Logger.new(open_logfile(log.file, log.sync?))
-      else
-        fail "Unknown logger strategy: #{strategy.inspect}."\
-          " Expected 'single' or 'stderr'."
-      end
+      Logger.new(STDERR)
     end
 
     def open_logfile(rel_path, sync)
       root = Pathname(__FILE__).dirname.dirname.dirname
       log_path = root + rel_path
+      log_path.dirname.mkpath
       logfile = File.open(log_path.to_s, "a")
       logfile.sync if sync
       logfile
     end
-
-    def default_strategy
-      (Nenv.ci? ? "stderr" : "single")
-    end
-
-    def default_level_for(env, level)
-      Integer(level)
-    rescue
-      env.strategy == "stderr" ? Logger::WARN : Logger::DEBUG
-    end
   end
 end

data/spec/support/loose_threads.rb

@@ -13,20 +13,7 @@ module Specs
           backtrace = thread.backtrace # avoid race maybe
           next unless backtrace
           next if backtrace.empty? # possibly a timer thread
-        end
-
-        if RUBY_ENGINE == "rbx"
-          # Avoid disrupting Rubinious thread
-          next if thread.backtrace.first =~ %r{rubysl/timeout/timeout\.rb}
-
-          if Specs::ALLOW_SLOW_MAILBOXES
-            if thread.backtrace.first =~ /wait/
-              next if thread.backtrace[1] =~ /mailbox\.rb/ && thread.backtrace[1] =~ /check/
-            end
-          end
-        end
-
-        if RUBY_ENGINE == "ruby"
+        else
           # Sometimes stays
           next if thread.backtrace.nil?
           next unless thread.backtrace.is_a?(Array)
@@ -39,7 +26,7 @@ module Specs
     end
 
     def thread_name(thread)
-      (RUBY_PLATFORM == "java") ? thread.to_java.getNativeThread.get_name : ""
+      RUBY_PLATFORM == "java" ? thread.to_java.getNativeThread.get_name : ""
     end
 
     def assert_no_loose_threads!(location)
@@ -61,7 +48,7 @@ module Specs
         sleep
       end
 
-      fail Celluloid::ThreadLeak, "Aborted due to runaway threads (#{location})\n"\
+      raise Celluloid::ThreadLeak, "Aborted due to runaway threads (#{location})\n"\
         "List: (#{loose.map(&:inspect)})\n:#{backtraces.join("\n")}"
     end
   end

data/spec/support/reset_class_variables.rb

@@ -2,7 +2,7 @@ module Specs
   class << self
     def reset_class_variables(description)
       # build uuid from example ending (most unique)
-      uuid_prefix = description[-([description.size, 20].min)..-1]
+      uuid_prefix = description[-[description.size, 20].min..-1]
       reset_uuid(uuid_prefix)
 
       reset_probe(Queue.new)
@@ -11,7 +11,11 @@ module Specs
     end
 
     def reset_probe(value)
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       $CELLULOID_MONITORING = !value.nil?
+      # rubocop:enable Style/GlobalVars
+
       replace_const(Celluloid::Probe, :EVENTS_BUFFER, value)
     end
 

data/spec/support/stubbing.rb

@@ -3,7 +3,7 @@ module Specs
     meta = (class << mod; self; end)
     original_meth = "original_#{meth}".to_sym
 
-    fail "ALREADY TRACED: #{mod}.#{meth}" if mod.respond_to?(original_meth)
+    raise "ALREADY TRACED: #{mod}.#{meth}" if mod.respond_to?(original_meth)
 
     meta.send(:alias_method, original_meth, meth)
     meta.send(:define_method, meth) do |*args, &block|