scoot 0.0.4 → 0.0.6

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

@@ -1,22 +0,0 @@
-module Celluloid
-  # Supervisors are actors that watch over other actors and restart them if
-  # they crash
-  class Supervisor
-    class << self
-      # Define the root of the supervision tree
-      attr_accessor :root
-
-      def supervise(klass, *args, &block)
-        SupervisionGroup.new do |group|
-          group.supervise klass, *args, &block
-        end
-      end
-
-      def supervise_as(name, klass, *args, &block)
-        SupervisionGroup.new do |group|
-          group.supervise_as name, klass, *args, &block
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-module Celluloid
-  # High-priority internal system events
-  class SystemEvent; end
-
-  # Request to link with another actor
-  class LinkingRequest < SystemEvent
-    attr_reader :actor, :type
-
-    def initialize(actor, type)
-      @actor, @type = actor, type.to_sym
-      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
-    end
-
-    def process(links)
-      case type
-      when :link   then links << actor
-      when :unlink then links.delete actor
-      end
-
-      actor.mailbox << LinkingResponse.new(Actor.current, type)
-    end
-  end
-
-  # Response to a link request
-  class LinkingResponse
-    attr_reader :actor, :type
-
-    def initialize(actor, type)
-      @actor, @type = actor, type.to_sym
-      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
-    end
-  end
-
-  # An actor has exited for the given reason
-  class ExitEvent < SystemEvent
-    attr_reader :actor, :reason
-
-    def initialize(actor, reason = nil)
-      @actor, @reason = actor, reason
-    end
-  end
-
-  # Name an actor at the time it's registered
-  class NamingRequest < SystemEvent
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-    end
-  end
-
-  # Request for an actor to terminate
-  class TerminationRequest < SystemEvent; end
-
-  # Signal a condition
-  class SignalConditionRequest < SystemEvent
-    def initialize(task, value)
-      @task, @value = task, value
-    end
-    attr_reader :task, :value
-
-    def call
-      @task.resume(@value)
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-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.rb

@@ -1,176 +0,0 @@
-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/tasks/task_fiber.rb

@@ -1,43 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/test.rb

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

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

@@ -1,40 +0,0 @@
-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