scoot 0.0.4 → 0.0.6

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

@@ -1,23 +0,0 @@
-module Celluloid
-  # Base class of all Celluloid errors
-  Error = Class.new(StandardError)
-
-  # Don't do Actor-like things outside Actor scope
-  NotActorError = Class.new(Celluloid::Error)
-
-  # Trying to do something to a dead actor
-  DeadActorError = Class.new(Celluloid::Error)
-
-  # A timeout occured before the given request could complete
-  TimeoutError = Class.new(Celluloid::Error)
-
-  # The sender made an error, not the current actor
-  class AbortError < Celluloid::Error
-    attr_reader :cause
-
-    def initialize(cause)
-      @cause = cause
-      super "caused by #{cause.inspect}: #{cause.to_s}"
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# Fibers are hard... let's go shopping!
-begin
-  require 'fiber'
-rescue LoadError => ex
-  if defined? JRUBY_VERSION
-    if RUBY_VERSION < "1.9.2"
-      raise LoadError, "Celluloid requires JRuby 1.9 mode. Please pass the --1.9 flag or set JRUBY_OPTS=--1.9"
-    end
-
-    # Fibers are broken on JRuby 1.6.5. This works around the issue
-    if JRUBY_VERSION[/^1\.6\.5/]
-      require 'jruby'
-      org.jruby.ext.fiber.FiberExtLibrary.new.load(JRuby.runtime, false)
-      class org::jruby::ext::fiber::ThreadFiber
-        field_accessor :state
-      end
-
-      class Fiber
-        def alive?
-          JRuby.reference(self).state != org.jruby.ext.fiber.ThreadFiberState::FINISHED
-        end
-      end
-    else
-      # Just in case subsequent JRuby releases have broken fibers :/
-      raise ex
-    end
-  elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
-    raise LoadError, "Celluloid requires Rubinius 1.9 mode. Please pass the -X19 flag."
-  else
-    raise ex
-  end
-end

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

@@ -1,186 +0,0 @@
-module Celluloid
-  # Simple finite state machines with integrated Celluloid timeout support
-  # Inspired by Erlang's gen_fsm (http://www.erlang.org/doc/man/gen_fsm.html)
-  #
-  # Basic usage:
-  #
-  #     class MyMachine
-  #       include Celluloid::FSM # NOTE: this does NOT pull in the Celluloid module
-  #     end
-  #
-  # Inside an actor:
-  #
-  #     #
-  #     machine = MyMachine.new(current_actor)
-  module FSM
-    class UnattachedError < Celluloid::Error; end # Not attached to an actor
-
-    DEFAULT_STATE = :default # Default state name unless one is explicitly set
-
-    # Included hook to extend class methods
-    def self.included(klass)
-      klass.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-      # Obtain or set the default state
-      # Passing a state name sets the default state
-      def default_state(new_default = nil)
-        if new_default
-          @default_state = new_default.to_sym
-        else
-          defined?(@default_state) ? @default_state : DEFAULT_STATE
-        end
-      end
-
-      # Obtain the valid states for this FSM
-      def states
-        @states ||= {}
-      end
-
-      # Declare an FSM state and optionally provide a callback block to fire
-      # Options:
-      # * to: a state or array of states this state can transition to
-      def state(*args, &block)
-        if args.last.is_a? Hash
-          # Stringify keys :/
-          options = args.pop.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-        else
-          options = {}
-        end
-
-        args.each do |name|
-          name = name.to_sym
-          default_state name if options['default']
-          states[name] = State.new(name, options['to'], &block)
-        end
-      end
-    end
-
-    attr_reader :actor
-
-    # Be kind and call super if you must redefine initialize
-    def initialize(actor = nil)
-      @state = self.class.default_state
-      @delayed_transition = nil
-      @actor = actor
-      @actor ||= Celluloid.current_actor if Celluloid.actor?
-    end
-
-    # Obtain the current state of the FSM
-    attr_reader :state
-
-    # Attach this FSM to an actor. This allows FSMs to wait for and initiate
-    # events in the context of a particular actor
-    def attach(actor)
-      @actor = actor
-    end
-    alias_method :actor=, :attach
-
-    # Transition to another state
-    # Options:
-    # * delay: don't transition immediately, wait the given number of seconds.
-    #          This will return a Celluloid::Timer object you can use to
-    #          cancel the pending state transition.
-    #
-    # Note: making additional state transitions will cancel delayed transitions
-    def transition(state_name, options = {})
-      new_state = validate_and_sanitize_new_state(state_name)
-      return unless new_state
-
-      if handle_delayed_transitions(new_state, options[:delay])
-        return @delayed_transition
-      end
-
-      transition_with_callbacks!(new_state)
-    end
-
-    # Immediate state transition with no sanity checks, or callbacks. "Dangerous!"
-    def transition!(state_name)
-      @state = state_name
-    end
-
-    protected
-
-    def validate_and_sanitize_new_state(state_name)
-      state_name = state_name.to_sym
-
-      return if current_state_name == state_name
-
-      if current_state and not current_state.valid_transition? state_name
-        valid = current_state.transitions.map(&:to_s).join(", ")
-        raise ArgumentError, "#{self.class} can't change state from '#{@state}' to '#{state_name}', only to: #{valid}"
-      end
-
-      new_state = states[state_name]
-
-      unless new_state
-        return if state_name == default_state
-        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
-      end
-
-      new_state
-    end
-
-    def transition_with_callbacks!(state_name)
-      transition! state_name.name
-      state_name.call(self)
-    end
-
-    def states
-      self.class.states
-    end
-
-    def default_state
-      self.class.default_state
-    end
-
-    def current_state
-      states[@state]
-    end
-
-    def current_state_name
-      current_state && current_state.name || ''
-    end
-
-    def handle_delayed_transitions(new_state, delay)
-      if delay
-        raise UnattachedError, "can't delay unless attached" unless @actor
-        @delayed_transition.cancel if @delayed_transition
-
-        @delayed_transition = @actor.after(delay) do
-          transition_with_callbacks!(new_state)
-        end
-
-        return @delayed_transition
-      end
-
-      if defined?(@delayed_transition) and @delayed_transition
-        @delayed_transition.cancel
-        @delayed_transition = nil
-      end
-    end
-
-    # FSM states as declared by Celluloid::FSM.state
-    class State
-      attr_reader :name, :transitions
-
-      def initialize(name, transitions = nil, &block)
-        @name, @block = name, block
-        @transitions = nil
-        @transitions = Array(transitions).map { |t| t.to_sym } if transitions
-      end
-
-      def call(obj)
-        obj.instance_eval(&@block) if @block
-      end
-
-      def valid_transition?(new_state)
-        # All transitions are allowed unless expressly
-        return true unless @transitions
-
-        @transitions.include? new_state.to_sym
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-require 'thread'
-
-module Celluloid
-  # Celluloid::Future objects allow methods and blocks to run in the
-  # background, their values requested later
-  class Future
-    def self.new(*args, &block)
-      return super unless block
-
-      future = new
-      Celluloid::ThreadHandle.new(Celluloid.actor_system, :future) do
-        begin
-          call = SyncCall.new(future, :call, args)
-          call.dispatch(block)
-        rescue
-          # Exceptions in blocks will get raised when the value is retrieved
-        end
-      end
-      future
-    end
-
-    attr_reader :address
-
-    def initialize
-      @address = Celluloid.uuid
-      @mutex = Mutex.new
-      @ready = false
-      @result = nil
-      @forwards = nil
-    end
-
-    # Check if this future has a value yet
-    def ready?
-      @ready
-    end
-
-    # Obtain the value for this Future
-    def value(timeout = nil)
-      ready = result = nil
-
-      begin
-        @mutex.lock
-
-        if @ready
-          ready = true
-          result = @result
-        else
-          case @forwards
-          when Array
-            @forwards << Celluloid.mailbox
-          when NilClass
-            @forwards = Celluloid.mailbox
-          else
-            @forwards = [@forwards, Celluloid.mailbox]
-          end
-        end
-      ensure
-        @mutex.unlock
-      end
-
-      unless ready
-        result = Celluloid.receive(timeout) do |msg|
-          msg.is_a?(Future::Result) && msg.future == self
-        end
-      end
-
-      if result
-        result.value
-      else
-        raise TimeoutError, "Timed out"
-      end
-    end
-    alias_method :call, :value
-
-    # Signal this future with the given result value
-    def signal(value)
-      result = Result.new(value, self)
-
-      @mutex.synchronize do
-        raise "the future has already happened!" if @ready
-
-        if @forwards
-          @forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
-        end
-
-        @result = result
-        @ready = true
-      end
-    end
-    alias_method :<<, :signal
-
-    # Inspect this Celluloid::Future
-    alias_method :inspect, :to_s
-
-    # Wrapper for result values to distinguish them in mailboxes
-    class Result
-      attr_reader :future
-
-      def initialize(result, future)
-        @result, @future = result, future
-      end
-
-      def value
-        @result.value
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'set'
-
-module Celluloid
-  class Handlers
-    def initialize
-      @handlers = Set.new
-    end
-
-    def handle(*patterns, &block)
-      patterns.each do |pattern|
-        handler = Handler.new pattern, block
-        @handlers << handler
-      end
-    end
-
-    # Handle incoming messages
-    def handle_message(message)
-      if handler = @handlers.find { |h| h.match(message) }
-        handler.call message
-        handler
-      end
-    end
-  end
-
-  # Methods blocking on a call to receive
-  class Handler
-    def initialize(pattern, block)
-      @pattern = pattern
-      @block = block
-    end
-
-    # Match a message with this receiver's block
-    def match(message)
-      @pattern === message
-    end
-
-    def call(message)
-      @block.call message
-    end
-  end
-end

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

@@ -1,159 +0,0 @@
-require 'thread'
-
-module Celluloid
-  # Maintain a thread pool FOR SPEED!!
-  class InternalPool
-    attr_accessor :max_idle
-
-    def initialize
-      @mutex = Mutex.new
-      @idle_threads = []
-      @all_threads  = []
-      @busy_size = 0
-      @idle_size = 0
-
-      # TODO: should really adjust this based on usage
-      @max_idle = 16
-      @running = true
-    end
-
-    def busy_size
-      @busy_size
-    end
-
-    def idle_size
-      @idle_size
-    end
-
-    def assert_running
-      raise Error, "Thread pool is not running" unless running?
-    end
-
-    def assert_inactive
-      if active?
-        message = "Thread pool is still active"
-        if defined?(JRUBY_VERSION)
-          Celluloid.logger.warn message
-        else
-          raise Error, message
-        end
-      end
-    end
-
-    def running?
-      @running
-    end
-
-    def active?
-      busy_size + idle_size > 0
-    end
-
-    def each
-      to_a.each {|thread| yield thread }
-    end
-
-    def to_a
-      @mutex.synchronize { @all_threads.dup }
-    end
-
-    # Get a thread from the pool, running the given block
-    def get(&block)
-      @mutex.synchronize do
-        assert_running
-
-        begin
-          if @idle_threads.empty?
-            thread = create
-          else
-            thread = @idle_threads.pop
-            @idle_size = @idle_threads.length
-          end
-        end until thread.status # handle crashed threads
-
-        thread.busy = true
-        @busy_size += 1
-        thread[:celluloid_queue] << block
-        thread
-      end
-    end
-
-    # Return a thread to the pool
-    def put(thread)
-      @mutex.synchronize do
-        thread.busy = false
-        if idle_size + 1 >= @max_idle
-          thread[:celluloid_queue] << nil
-          @busy_size -= 1
-          @all_threads.delete(thread)
-        else
-          @idle_threads.push thread
-          @busy_size -= 1
-          @idle_size = @idle_threads.length
-          clean_thread_locals(thread)
-        end
-      end
-    end
-
-    def shutdown
-      @mutex.synchronize do
-        finalize
-        @all_threads.each do |thread|
-          thread[:celluloid_queue] << nil
-        end
-        @all_threads.clear
-        @idle_threads.clear
-        @busy_size = 0
-        @idle_size = 0
-      end
-    end
-
-    def kill
-      @mutex.synchronize do
-        finalize
-        @running = false
-
-        @all_threads.shift.kill until @all_threads.empty?
-        @idle_threads.clear
-        @busy_size = 0
-        @idle_size = 0
-      end
-    end
-
-    private
-
-    # Create a new thread with an associated queue of procs to run
-    def create
-      queue = Queue.new
-      thread = Thread.new do
-        while proc = queue.pop
-          begin
-            proc.call
-          rescue => ex
-            Logger.crash("thread crashed", ex)
-          end
-
-          put thread
-        end
-      end
-
-      thread[:celluloid_queue] = queue
-      # @idle_threads << thread
-      @all_threads << thread
-      thread
-    end
-
-    # Clean the thread locals of an incoming thread
-    def clean_thread_locals(thread)
-      thread.keys.each do |key|
-        next if key == :celluloid_queue
-
-        # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
-        thread[key] = nil
-      end
-    end
-
-    def finalize
-      @max_idle = 0
-    end
-  end
-end