scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/task_set.rb

@@ -0,0 +1,49 @@
+require 'set'
+require 'forwardable'
+
+module Celluloid
+  if defined? JRUBY_VERSION
+    require 'jruby/synchronized'
+
+    class TaskSet
+      extend  Forwardable
+      include JRuby::Synchronized
+
+      def_delegators :@tasks, :<<, :delete, :first, :empty?, :to_a
+
+      def initialize
+        @tasks = Set.new
+      end
+    end
+  elsif defined? Rubinius
+    class TaskSet
+      def initialize
+        @tasks = Set.new
+      end
+
+      def <<(task)
+        Rubinius.synchronize(self) { @tasks << task }
+      end
+
+      def delete(task)
+        Rubinius.synchronize(self) { @tasks.delete task }
+      end
+
+      def first
+        Rubinius.synchronize(self) { @tasks.first }
+      end
+
+      def empty?
+        Rubinius.synchronize(self) { @tasks.empty? }
+      end
+
+      def to_a
+        Rubinius.synchronize(self) { @tasks.to_a }
+      end
+    end
+  else
+    # Assume we're on MRI, where we have the GIL. But what about IronRuby?
+    # Or MacRuby. Do people care? This will break Celluloid::StackDumps
+    TaskSet = Set
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/tasks/task_fiber.rb

@@ -0,0 +1,43 @@
+module Celluloid
+  class FiberStackError < Celluloid::Error; end
+
+  # Tasks with a Fiber backend
+  class TaskFiber < Task
+
+    def create
+      queue = Thread.current[:celluloid_queue]
+      actor_system = Thread.current[:celluloid_actor_system]
+      @fiber = Fiber.new do
+        # FIXME: cannot use the writer as specs run inside normal Threads
+        Thread.current[:celluloid_role] = :actor
+        Thread.current[:celluloid_queue] = queue
+        Thread.current[:celluloid_actor_system] = actor_system
+        yield
+      end
+    end
+
+    def signal
+      Fiber.yield
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def deliver(value)
+      @fiber.resume value
+    rescue SystemStackError => ex
+      raise FiberStackError, "#{ex} (please see https://github.com/celluloid/celluloid/wiki/Fiber-stack-errors)"
+    rescue FiberError => ex
+      raise DeadTaskError, "cannot resume a dead task (#{ex})"
+    end
+
+    # Terminate this task
+    def terminate
+      super
+    rescue FiberError
+      # If we're getting this the task should already be dead
+    end
+
+    def backtrace
+      ["#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::TaskThread` if you need backtraces here."]
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/tasks/task_thread.rb

@@ -0,0 +1,53 @@
+module Celluloid
+  # Tasks with a Thread backend
+  class TaskThread < Task
+    # Run the given block within a task
+    def initialize(type, meta)
+      @resume_queue = Queue.new
+      @exception_queue = Queue.new
+      @yield_mutex  = Mutex.new
+      @yield_cond   = ConditionVariable.new
+
+      super
+    end
+
+    def create
+      # TODO: move this to ActorSystem#get_thread (ThreadHandle inside InternalPool)
+      @thread = ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
+        begin
+          ex = @resume_queue.pop
+          raise ex if ex.is_a?(Task::TerminatedError)
+
+          yield
+        rescue Exception => ex
+          @exception_queue << ex
+        ensure
+          @yield_cond.signal
+        end
+      end
+    end
+
+    def signal
+      @yield_cond.signal
+      @resume_queue.pop
+    end
+
+    def deliver(value)
+      raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
+
+      @yield_mutex.synchronize do
+        @resume_queue.push(value)
+        @yield_cond.wait(@yield_mutex)
+        while @exception_queue.size > 0
+          raise @exception_queue.pop
+        end
+      end
+    rescue ThreadError
+      raise DeadTaskError, "cannot resume a dead task"
+    end
+
+    def backtrace
+      @thread.backtrace
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/tasks.rb

@@ -0,0 +1,176 @@
+module Celluloid
+  # Asked to do task-related things outside a task
+  class NotTaskError < Celluloid::Error; end
+
+  # Trying to resume a dead task
+  class DeadTaskError < Celluloid::Error; end
+
+  # Errors which should be resumed automatically
+  class ResumableError < Celluloid::Error; end
+
+  # Tasks are interruptable/resumable execution contexts used to run methods
+  class Task
+    class TerminatedError < ResumableError; end # kill a running task after terminate
+
+    class TimeoutError < ResumableError; end # kill a running task after timeout
+
+    # Obtain the current task
+    def self.current
+      Thread.current[:celluloid_task] or raise NotTaskError, "not within a task context"
+    end
+
+    # Suspend the running task, deferring to the scheduler
+    def self.suspend(status)
+      Task.current.suspend(status)
+    end
+
+    attr_reader :type, :meta, :status
+    attr_accessor :chain_id, :guard_warnings
+
+    # Create a new task
+    def initialize(type, meta)
+      @type     = type
+      @meta     = meta
+      @status   = :new
+
+      @exclusive         = false
+      @dangerous_suspend = @meta ? @meta.delete(:dangerous_suspend) : false
+      @guard_warnings    = false
+
+      actor     = Thread.current[:celluloid_actor]
+      @chain_id = CallChain.current_id
+
+      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
+        begin
+          @status = :running
+          actor.setup_thread
+
+          name_current_thread thread_metadata
+
+          Thread.current[:celluloid_task] = self
+          CallChain.current_id = @chain_id
+
+          actor.tasks << self
+          yield
+        rescue Task::TerminatedError
+          # Task was explicitly terminated
+        ensure
+          name_current_thread nil
+          @status = :dead
+          actor.tasks.delete self
+        end
+      end
+    end
+
+    def create(&block)
+      raise "Implement #{self.class}#create"
+    end
+
+    # Suspend the current task, changing the status to the given argument
+    def suspend(status)
+      raise "Cannot suspend while in exclusive mode" if exclusive?
+      raise "Cannot suspend a task from outside of itself" unless Task.current == self
+
+      @status = status
+
+      if $CELLULOID_DEBUG && @dangerous_suspend
+        Logger.with_backtrace(caller[2...8]) do |logger|
+          logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        end
+      end
+
+      value = signal
+
+      @status = :running
+      raise value if value.is_a?(Celluloid::ResumableError)
+
+      value
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      guard "Cannot resume a task from inside of a task" if Thread.current[:celluloid_task]
+      deliver(value)
+      nil
+    end
+
+    # Execute a code block in exclusive mode.
+    def exclusive
+      if @exclusive
+        yield
+      else
+        begin
+          @exclusive = true
+          yield
+        ensure
+          @exclusive = false
+        end
+      end
+    end
+
+    # Terminate this task
+    def terminate
+      raise "Cannot terminate an exclusive task" if exclusive?
+
+      if running?
+        Logger.with_backtrace(backtrace) do |logger|
+          logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        end
+        exception = Task::TerminatedError.new("task was terminated")
+        exception.set_backtrace(caller)
+        resume exception
+      else
+        raise DeadTaskError, "task is already dead"
+      end
+    end
+
+    # Is this task running in exclusive mode?
+    def exclusive?
+      @exclusive
+    end
+
+    def backtrace
+    end
+
+    # Is the current task still running?
+    def running?; @status != :dead; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @meta=#{@meta.inspect}, @status=#{@status.inspect}>"
+    end
+
+    def guard(message)
+      if @guard_warnings
+        Logger.warn message if $CELLULOID_DEBUG
+      else
+        raise message if $CELLULOID_DEBUG
+      end
+    end
+
+    private
+
+    def name_current_thread(new_name)
+      return unless RUBY_PLATFORM == "java"
+      if new_name.nil?
+        new_name = Thread.current[:celluloid_original_thread_name]
+        Thread.current[:celluloid_original_thread_name] = nil
+      else
+        Thread.current[:celluloid_original_thread_name] = Thread.current.to_java.getNativeThread.get_name
+      end
+      Thread.current.to_java.getNativeThread.set_name(new_name)
+    end
+
+    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>"
+      format("[Celluloid] %s#%s", klass, method)
+    end
+  end
+end
+
+require 'celluloid/tasks/task_fiber'
+require 'celluloid/tasks/task_thread'

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/test.rb

@@ -0,0 +1,3 @@
+$CELLULOID_TEST = true
+
+require 'celluloid'

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/thread.rb

@@ -0,0 +1,40 @@
+require 'celluloid/fiber'
+
+module Celluloid
+  class Thread < ::Thread
+    def celluloid?
+      true
+    end
+
+    attr_accessor :busy
+
+    # Obtain the role of this thread
+    def role
+      self[:celluloid_role]
+    end
+
+    def role=(role)
+      self[:celluloid_role] = role
+    end
+
+    # Obtain the Celluloid::Actor object for this thread
+    def actor
+      self[:celluloid_actor]
+    end
+
+    # Obtain the Celluloid task object for this thread
+    def task
+      self[:celluloid_task]
+    end
+
+    # Obtain the Celluloid mailbox for this thread
+    def mailbox
+      self[:celluloid_mailbox]
+    end
+
+    # Obtain the call chain ID for this thread
+    def call_chain_id
+      self[:celluloid_chain_id]
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/thread_handle.rb

@@ -0,0 +1,50 @@
+module Celluloid
+  # An abstraction around threads from the InternalPool which ensures we don't
+  # accidentally do things to threads which have been returned to the pool,
+  # such as, say, killing them
+  class ThreadHandle
+    def initialize(actor_system, role = nil)
+      @mutex = Mutex.new
+      @join  = ConditionVariable.new
+
+      @thread = actor_system.get_thread do
+        Thread.current.role = role
+        begin
+          yield
+        ensure
+          @mutex.synchronize do
+            @thread = nil
+            @join.broadcast
+          end
+        end
+      end
+    end
+
+    # Is the thread running?
+    def alive?
+      @mutex.synchronize { @thread.alive? if @thread }
+    end
+
+    # Forcibly kill the thread
+    def kill
+      !!@mutex.synchronize { @thread.kill if @thread }
+      self
+    end
+
+    # Join to a running thread, blocking until it terminates
+    def join(limit = nil)
+      raise ThreadError, "Target thread must not be current thread" if @thread == Thread.current
+      @mutex.synchronize { @join.wait(@mutex, limit) if @thread }
+      self
+    end
+
+    # Obtain the backtrace for this thread
+    def backtrace
+      @thread.backtrace
+    rescue NoMethodError
+      # undefined method `backtrace' for nil:NilClass
+      # Swallow this in case this ThreadHandle was terminated and @thread was
+      # set to nil
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/uuid.rb

@@ -0,0 +1,38 @@
+require 'securerandom'
+
+module Celluloid
+  # Clearly Ruby doesn't have enough UUID libraries
+  # This one aims to be fast and simple with good support for multiple threads
+  # If there's a better UUID library I can use with similar multithreaded
+  # performance, I certainly wouldn't mind using a gem for this!
+  module UUID
+    values = SecureRandom.hex(9).match(/(.{8})(.{4})(.{3})(.{3})/)
+    PREFIX = "#{values[1]}-#{values[2]}-4#{values[3]}-8#{values[4]}".freeze
+    BLOCK_SIZE = 0x10000
+
+    @counter = 0
+    @counter_mutex = Mutex.new
+
+    def self.generate
+      thread = Thread.current
+
+      unless thread.uuid_limit
+        @counter_mutex.synchronize do
+          block_base = @counter
+          @counter += BLOCK_SIZE
+          thread.uuid_counter = block_base
+          thread.uuid_limit   = @counter - 1
+        end
+      end
+
+      counter = thread.uuid_counter
+      if thread.uuid_counter >= thread.uuid_limit
+        thread.uuid_counter = thread.uuid_limit = nil
+      else
+        thread.uuid_counter += 1
+      end
+
+      "#{PREFIX}-#{sprintf("%012x", counter)}".freeze
+    end
+  end
+end