scoot 0.0.4 → 0.0.6

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

@@ -1,3 +0,0 @@
-require 'celluloid'
-
-Celluloid.start

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

@@ -1,13 +0,0 @@
-module Celluloid
-  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

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

@@ -1,151 +0,0 @@
-module Celluloid
-  # Calls represent requests to an actor
-  class Call
-    attr_reader :method, :arguments, :block
-
-    def initialize(method, arguments = [], block = nil)
-      @method, @arguments = method, arguments
-      if block
-        if Celluloid.exclusive?
-          # FIXME: nicer exception
-          raise "Cannot execute blocks on sender in exclusive mode"
-        end
-        @block = BlockProxy.new(self, Celluloid.mailbox, block)
-      else
-        @block = nil
-      end
-    end
-
-    def execute_block_on_receiver
-      @block && @block.execution = :receiver
-    end
-
-    def dispatch(obj)
-      check(obj)
-      _block = @block && @block.to_proc
-      obj.public_send(@method, *@arguments, &_block)
-    end
-
-    def check(obj)
-      raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}" unless obj.respond_to? @method
-
-      begin
-        arity = obj.method(@method).arity
-      rescue NameError
-        return
-      end
-
-      if arity >= 0
-        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{arity})" if @arguments.size != arity
-      elsif arity < -1
-        mandatory_args = -arity - 1
-        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{mandatory_args}+)" if arguments.size < mandatory_args
-      end
-    rescue => ex
-      raise AbortError.new(ex)
-    end
-  end
-
-  # Synchronous calls wait for a response
-  class SyncCall < Call
-    attr_reader :sender, :task, :chain_id
-
-    def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = CallChain.current_id)
-      super(method, arguments, block)
-
-      @sender   = sender
-      @task     = task
-      @chain_id = chain_id || Celluloid.uuid
-    end
-
-    def dispatch(obj)
-      CallChain.current_id = @chain_id
-      result = super(obj)
-      respond SuccessResponse.new(self, result)
-    rescue Exception => ex
-      # Exceptions that occur during synchronous calls are reraised in the
-      # context of the sender
-      respond ErrorResponse.new(self, ex)
-
-      # Aborting indicates a protocol error on the part of the sender
-      # It should crash the sender, but the exception isn't reraised
-      # Otherwise, it's a bug in this actor and should be reraised
-      raise unless ex.is_a?(AbortError)
-    ensure
-      CallChain.current_id = nil
-    end
-
-    def cleanup
-      exception = DeadActorError.new("attempted to call a dead actor")
-      respond ErrorResponse.new(self, exception)
-    end
-
-    def respond(message)
-      @sender << message
-    end
-
-    def response
-      Celluloid.suspend(:callwait, self)
-    end
-
-    def value
-      response.value
-    end
-
-    def wait
-      loop do
-        message = Celluloid.mailbox.receive do |msg|
-          msg.respond_to?(:call) and msg.call == self
-        end
-
-        if message.is_a?(SystemEvent)
-          Thread.current[:celluloid_actor].handle_system_event(message)
-        else
-          # FIXME: add check for receiver block execution
-          if message.respond_to?(:value)
-            # FIXME: disable block execution if on :sender and (exclusive or outside of task)
-            # probably now in Call
-            break message
-          else
-            message.dispatch
-          end
-        end
-      end
-    end
-  end
-
-  # Asynchronous calls don't wait for a response
-  class AsyncCall < Call
-
-    def dispatch(obj)
-      CallChain.current_id = Celluloid.uuid
-      super(obj)
-    rescue AbortError => ex
-      # Swallow aborted async calls, as they indicate the sender made a mistake
-      Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
-    ensure
-      CallChain.current_id = nil
-    end
-
-  end
-
-  class BlockCall
-    def initialize(block_proxy, sender, arguments, task = Thread.current[:celluloid_task])
-      @block_proxy = block_proxy
-      @sender = sender
-      @arguments = arguments
-      @task = task
-    end
-    attr_reader :task
-
-    def call
-      @block_proxy.call
-    end
-
-    def dispatch
-      response = @block_proxy.block.call(*@arguments)
-      @sender << BlockResponse.new(self, response)
-    end
-  end
-
-end

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

@@ -1,89 +0,0 @@
-module Celluloid
-  OWNER_IVAR = :@celluloid_owner # reference to owning actor
-
-  # Wrap the given subject with an Cell
-  class Cell
-    class ExitHandler
-      def initialize(behavior, subject, method_name)
-        @behavior = behavior
-        @subject = subject
-        @method_name = method_name
-      end
-
-      def call(event)
-        @behavior.task(:exit_handler, @method_name) do
-          @subject.send(@method_name, event.actor, event.reason)
-        end
-      end
-    end
-
-    def initialize(subject, options, actor_options)
-      @actor                      = Actor.new(self, actor_options)
-      @subject                    = subject
-      @receiver_block_executions  = options[:receiver_block_executions]
-      @exclusive_methods          = options[:exclusive_methods]
-      @finalizer                  = options[:finalizer]
-
-      @subject.instance_variable_set(OWNER_IVAR, @actor)
-
-      if exit_handler_name = options[:exit_handler_name]
-        @actor.exit_handler = ExitHandler.new(self, @subject, exit_handler_name)
-      end
-
-      @actor.handle(Call) do |message|
-        invoke(message)
-      end
-      @actor.handle(BlockCall) do |message|
-        task(:invoke_block) { message.dispatch }
-      end
-      @actor.handle(BlockResponse, Response) do |message|
-        message.dispatch
-      end
-
-      @actor.start
-      @proxy = (options[:proxy_class] || CellProxy).new(@actor.proxy, @actor.mailbox, @subject.class.to_s)
-    end
-    attr_reader :proxy, :subject
-
-    def invoke(call)
-      meth = call.method
-      if meth == :__send__
-        meth = call.arguments.first
-      end
-      if @receiver_block_executions && meth
-        if @receiver_block_executions.include?(meth.to_sym)
-          call.execute_block_on_receiver
-        end
-      end
-
-      task(:call, meth, :dangerous_suspend => meth == :initialize) {
-        call.dispatch(@subject)
-      }
-    end
-
-    def task(task_type, method_name = nil, meta = nil, &block)
-      meta ||= {}
-      meta.merge!(: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 }
-        else
-          yield
-        end
-      end
-    end
-
-    # Run the user-defined finalizer, if one is set
-    def shutdown
-      return unless @finalizer && @subject.respond_to?(@finalizer, true)
-
-      task(:finalizer, @finalizer, :dangerous_suspend => true) do
-        begin
-          @subject.__send__(@finalizer)
-        rescue => ex
-          Logger.crash("#{@subject.class} finalizer crashed!", ex)
-        end
-      end
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-module Celluloid
-  class ConditionError < Celluloid::Error; end
-
-  # ConditionVariable-like signaling between tasks and threads
-  class Condition
-    class Waiter
-      def initialize(condition, task, mailbox, timeout)
-        @condition = condition
-        @task = task
-        @mailbox = mailbox
-        @timeout = timeout
-      end
-      attr_reader :condition, :task
-
-      def <<(message)
-        @mailbox << message
-      end
-
-      def wait
-        begin
-          message = @mailbox.receive(@timeout) do |msg|
-            msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
-          end
-        rescue TimeoutError
-          raise ConditionError, "timeout after #{@timeout.inspect} seconds"
-        end until message
-
-        message.value
-      end
-    end
-
-    def initialize
-      @mutex = Mutex.new
-      @waiters = []
-    end
-
-    # Wait for the given signal and return the associated value
-    def wait(timeout = nil)
-      raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
-
-      if actor = Thread.current[:celluloid_actor]
-        task = Task.current
-        if timeout
-          bt = caller
-          timer = actor.timers.after(timeout) do
-            exception = ConditionError.new("timeout after #{timeout.inspect} seconds")
-            exception.set_backtrace bt
-            task.resume exception
-          end
-        end
-      else
-        task = Thread.current
-      end
-      waiter = Waiter.new(self, task, Celluloid.mailbox, timeout)
-
-      @mutex.synchronize do
-        @waiters << waiter
-      end
-
-      result = Celluloid.suspend :condwait, waiter
-      timer.cancel if timer
-      raise result if result.is_a? ConditionError
-      result
-    end
-
-    # Send a signal to the first task waiting on this condition
-    def signal(value = nil)
-      @mutex.synchronize do
-        if waiter = @waiters.shift
-          waiter << SignalConditionRequest.new(waiter.task, value)
-        else
-          Logger.with_backtrace(caller(3)) do |logger|
-            logger.debug("Celluloid::Condition signaled spuriously")
-          end
-        end
-      end
-    end
-
-    # Broadcast a value to all waiting tasks and threads
-    def broadcast(value = nil)
-      @mutex.synchronize do
-        @waiters.each { |waiter| waiter << SignalConditionRequest.new(waiter.task, value) }
-        @waiters.clear
-      end
-    end
-
-    alias_method :inspect, :to_s
-  end
-end

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

@@ -1,9 +0,0 @@
-require 'celluloid/fiber'
-
-class Thread
-  attr_accessor :uuid_counter, :uuid_limit
-
-  def celluloid?
-    false
-  end
-end

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

@@ -1,34 +0,0 @@
-module Celluloid
-  module CPUCounter
-    class << self
-      def cores
-        @cores ||= count_cores
-      end
-
-      private
-
-      def count_cores
-        result = from_env || from_sysdev || from_sysctl
-        Integer(result.to_s[/\d+/], 10) if result
-      end
-
-      def from_env
-        result = ENV['NUMBER_OF_PROCESSORS']
-        result if result
-      end
-
-      def from_sysdev
-        ::IO.read('/sys/devices/system/cpu/present').split('-').last.to_i + 1
-      rescue Errno::ENOENT
-        result = Dir['/sys/devices/system/cpu/cpu*'].count { |n| n =~ /cpu\d+/ }
-        result unless result.zero?
-      end
-
-      def from_sysctl
-        result = `sysctl -n hw.ncpu`
-        result if $?.success?
-      rescue Errno::ENOENT
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-module Celluloid
-  # An alternative implementation of Celluloid::Mailbox using Reactor
-  class EventedMailbox < Celluloid::Mailbox
-    attr_reader :reactor
-
-    def initialize(reactor_class)
-      super()
-      # @condition won't be used in the class.
-      @reactor = reactor_class.new
-    end
-
-    # Add a message to the Mailbox
-    def <<(message)
-      @mutex.lock
-      begin
-        if mailbox_full || @dead
-          dead_letter(message)
-          return
-        end
-        if message.is_a?(SystemEvent)
-          # SystemEvents are high priority messages so they get added to the
-          # head of our message queue instead of the end
-          @messages.unshift message
-        else
-          @messages << message
-        end
-
-        current_actor = Thread.current[:celluloid_actor]
-        @reactor.wakeup unless current_actor && current_actor.mailbox == self
-      rescue IOError
-        Logger.crash "reactor crashed", $!
-        dead_letter(message)
-      ensure
-        @mutex.unlock rescue nil
-      end
-      nil
-    end
-
-    # Receive a message from the Mailbox
-    def check(timeout = nil, &block)
-      # Get a message if it is available and process it immediately if possible:
-      if message = next_message(block)
-        return message
-      end
-
-      # ... otherwise, run the reactor once, either blocking or will return
-      # after the given timeout:
-      @reactor.run_once(timeout)
-
-      # No message was received:
-      return nil
-    rescue IOError
-      raise MailboxShutdown, "mailbox shutdown called during receive"
-    end
-
-    # Obtain the next message from the mailbox that matches the given block
-    def next_message(block)
-      @mutex.lock
-      begin
-        super(&block)
-      ensure
-        @mutex.unlock rescue nil
-      end
-    end
-
-    # Cleanup any IO objects this Mailbox may be using
-    def shutdown
-      super do
-        @reactor.shutdown
-      end
-    end
-  end
-end