scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/blankslate-2.1.2.4/spec/blankslate_spec.rb

@@ -0,0 +1,39 @@
+require 'blankslate'
+require 'rspec'
+
+describe BlankSlate do
+  let(:blank_slate) { BlankSlate.new }
+  
+  def call(obj, meth, *args)
+    BlankSlate.find_hidden_method(meth).bind(obj).call(*args)
+  end
+  
+  describe "cleanliness" do
+    it "should not have many methods" do
+      BlankSlate.instance_methods.
+        map(&:to_s).sort.
+        should == ["__id__", "__send__", "instance_eval", "object_id"]
+    end 
+  end
+  
+  context "when methods are added to Object" do
+    after(:each) { 
+      class Object
+        undef :foo
+      end
+    }
+
+    it "should still be blank" do
+      class Object 
+        def foo
+        end
+      end
+      Object.new.foo
+      
+      lambda {
+        BlankSlate.new.foo
+      }.should raise_error(NoMethodError)
+    end 
+    
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2014 Tony Arcieri
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/README.md

@@ -0,0 +1,172 @@
+![Celluloid](https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png)
+=========
+[![Gem Version](https://badge.fury.io/rb/celluloid.png)](http://rubygems.org/gems/celluloid)
+[![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
+[![Code Climate](https://codeclimate.com/github/celluloid/celluloid.png)](https://codeclimate.com/github/celluloid/celluloid)
+[![Coverage Status](https://coveralls.io/repos/celluloid/celluloid/badge.png?branch=master)](https://coveralls.io/r/celluloid/celluloid)
+
+> "I thought of objects being like biological cells and/or individual
+> computers on a network, only able to communicate with messages"
+> _--Alan Kay, creator of Smalltalk, on the meaning of "object oriented programming"_
+
+Celluloid provides a simple and natural way to build fault-tolerant concurrent
+programs in Ruby. With Celluloid, you can build systems out of concurrent
+objects just as easily as you build sequential programs out of regular objects.
+Recommended for any developer, including novices, Celluloid should help ease
+your worries about building multithreaded Ruby programs.
+
+Much of the difficulty with building concurrent programs in Ruby arises because
+the object-oriented mechanisms for structuring code, such as classes and
+inheritance, are separate from the concurrency mechanisms, such as threads and
+locks. Celluloid combines these into a single structure, an active object
+running within a thread, called an "actor", or in Celluloid vernacular, a "cell".
+
+By combining concurrency with object oriented programming, Celluloid frees you
+up from worry about where to use threads and locks. Celluloid combines them
+together into a single concurrent object oriented programming model,
+encapsulating state in concurrent objects and thus avoiding many of the
+problems associated with multithreaded programming. Celluloid provides many
+features which make concurrent programming simple, easy, and fun:
+
+* __Automatic "deadlock-free" synchronization:__ Celluloid uses a concurrent
+  object model which combines method dispatch and thread synchronization.
+  Each actor is a concurrent object running in its own thread, and every method
+  invocation is wrapped in a fiber that can be suspended whenever it calls
+  out to other actors, and resumed when the response is available. This means
+  methods which are waiting for responses from other actors, external messages,
+  or other system events (including I/O with Celluloid::IO) can be suspended
+  and will never block other methods that are ready to run. This won't prevent
+  bugs in Celluloid, bugs in other thread-safe libraries you use, and even
+  certain "dangerous" features of Celluloid from causing your program to
+  deadlock, but in general, programs built with Celluloid will be naturally
+  immune to deadlocks.
+
+* __Fault-tolerance:__ Celluloid has taken to heart many of Erlang's ideas
+  about fault-tolerance in order to enable self-healing applications.
+  The central idea: have you tried turning it off and on again? Celluloid
+  takes care of rebooting subcomponents of your application when they crash,
+  whether it's a single actor, or large (potentially multi-tiered) groups of
+  actors that are all interdependent. This means rather than worrying about
+  rescuing every last exception, you can just sit back, relax, and let parts
+  of your program crash, knowing Celluloid will automatically reboot them in
+  a clean state. Celluloid provides its own implementation of the core
+  fault-tolerance concepts in Erlang including [linking](https://github.com/celluloid/celluloid/wiki/Linking),
+  [supervisors](https://github.com/celluloid/celluloid/wiki/Supervisors),
+  and [supervision groups](https://github.com/celluloid/celluloid/wiki/Supervision-Groups).
+
+* __[Futures](https://github.com/celluloid/celluloid/wiki/futures):__
+  Ever wanted to call a method "in the background" and retrieve the
+  value it returns later? Celluloid futures do just that. It's like
+  calling ahead to a restaurant to place an order, so they can work
+  on preparing your food while you're on your way to pick it up.
+  When you ask for a method's return value, it's returned immediately
+  if the method has already completed, or otherwise the current method is
+  suspended until the value becomes available.
+
+You can also build distributed systems with Celluloid using its
+[sister project DCell](https://github.com/celluloid/dcell). Evented IO similar
+to EventMachine (with a synchronous API instead of callback/deferrable soup)
+is available through the [Celluloid::IO](https://github.com/celluloid/celluloid-io)
+library.
+
+Like Celluloid? [Join the mailing list/Google Group](http://groups.google.com/group/celluloid-ruby)
+or visit us on IRC at #celluloid on freenode
+
+### Is it any good?
+
+[Yes](http://news.ycombinator.com/item?id=3067434)
+
+### Is It "Production Ready™"?
+
+Yes, many users are now running Celluloid in production by using
+[Sidekiq](http://sidekiq.org) and [Adhearsion](http://adhearsion.com/)
+
+Documentation
+-------------
+
+[Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
+for more detailed documentation and usage notes.
+
+The following API documentation is also available:
+
+* [YARD API documentation](http://rubydoc.info/gems/celluloid/frames)
+* [Celluloid module (primary API)](http://rubydoc.info/gems/celluloid/Celluloid)
+* [Celluloid class methods](http://rubydoc.info/gems/celluloid/Celluloid/ClassMethods)
+* [All Celluloid classes](http://rubydoc.info/gems/celluloid/index)
+
+Related Projects
+----------------
+
+Celluloid is the parent project of a related ecosystem of other projects. If you
+like Celluloid we definitely recommend you check them out:
+
+* [Celluloid::IO][celluloid-io]: "Evented" IO support for Celluloid actors
+* [Celluloid::ZMQ][celluloid-zmq]: "Evented" 0MQ support for Celluloid actors
+* [DCell][dcell]: The Celluloid actor protocol distributed over 0MQ
+* [Reel][reel]: An "evented" web server based on Celluloid::IO
+* [Lattice][lattice]: A concurrent realtime web framework based on Celluloid::IO
+* [nio4r][nio4r]: "New IO for Ruby": high performance IO selectors
+* [Timers][timers]: A generic Ruby timer library for event-based systems
+
+[celluloid-io]: https://github.com/celluloid/celluloid-io/
+[celluloid-zmq]: https://github.com/celluloid/celluloid-zmq/
+[dcell]: https://github.com/celluloid/dcell/
+[reel]: https://github.com/celluloid/reel/
+[lattice]: https://github.com/celluloid/lattice/
+[nio4r]: https://github.com/celluloid/nio4r/
+[timers]: https://github.com/celluloid/timers/
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'celluloid'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install celluloid
+
+Inside of your Ruby program, require Celluloid with:
+
+```ruby
+require 'celluloid/autostart'
+```
+
+Supported Platforms
+-------------------
+
+Celluloid works on Ruby 1.9.3, 2.0.0, JRuby 1.6+, and Rubinius 2.0.
+
+JRuby or Rubinius are the preferred platforms as they support true thread-level
+parallelism when executing Ruby code, whereas MRI/YARV is constrained by a global
+interpreter lock (GIL) and can only execute one thread at a time.
+
+Celluloid requires Ruby 1.9 mode on all interpreters.
+
+Additional Reading
+------------------
+
+* [Concurrent Object-Oriented Programming in Python with
+  ATOM](http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=11A3EACE78AAFF6D6D62A64118AFCA7C?doi=10.1.1.47.5074&rep=rep1&type=pdf):
+  a similar system to Celluloid written in Python
+
+Contributing to Celluloid
+-------------------------
+
+* Fork this repository on github
+* Make your changes and send us a pull request
+* If we like them we'll merge them
+* If we've accepted a patch, feel free to ask for commit access
+
+License
+-------
+
+Copyright (c) 2011-2014 Tony Arcieri. Distributed under the MIT License. See
+LICENSE.txt for further details.

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

@@ -0,0 +1,362 @@
+
+require 'timers'
+
+module Celluloid
+  # Actors are Celluloid's concurrency primitive. They're implemented as
+  # normal Ruby objects wrapped in threads which communicate with asynchronous
+  # messages.
+  class Actor
+    attr_reader :behavior, :proxy, :tasks, :links, :mailbox, :thread, :name, :timers
+    attr_writer :exit_handler
+
+    class << self
+      extend Forwardable
+
+      def_delegators "Celluloid.actor_system", :[], :[]=, :delete, :registered, :clear_registry
+
+      # Obtain the current actor
+      def current
+        actor = Thread.current[:celluloid_actor]
+        raise NotActorError, "not in actor scope" unless actor
+        actor.behavior_proxy
+      end
+
+      # Obtain the name of the current actor
+      def registered_name
+        actor = Thread.current[:celluloid_actor]
+        raise NotActorError, "not in actor scope" unless actor
+        actor.name
+      end
+
+      # Invoke a method on the given actor via its mailbox
+      def call(mailbox, meth, *args, &block)
+        proxy = SyncProxy.new(mailbox, "UnknownClass")
+        proxy.method_missing(meth, *args, &block)
+      end
+
+      # Invoke a method asynchronously on an actor via its mailbox
+      def async(mailbox, meth, *args, &block)
+        proxy = AsyncProxy.new(mailbox, "UnknownClass")
+        proxy.method_missing(meth, *args, &block)
+      end
+
+      # Call a method asynchronously and retrieve its value later
+      def future(mailbox, meth, *args, &block)
+        proxy = FutureProxy.new(mailbox, "UnknownClass")
+        proxy.method_missing(meth, *args, &block)
+      end
+
+      # Obtain all running actors in the system
+      def all
+        Celluloid.actor_system.running
+      end
+
+      # Watch for exit events from another actor
+      def monitor(actor)
+        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        Thread.current[:celluloid_actor].linking_request(actor, :link)
+      end
+
+      # Stop waiting for exit events from another actor
+      def unmonitor(actor)
+        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        Thread.current[:celluloid_actor].linking_request(actor, :unlink)
+      end
+
+      # Link to another actor
+      def link(actor)
+        monitor actor
+        Thread.current[:celluloid_actor].links << actor
+      end
+
+      # Unlink from another actor
+      def unlink(actor)
+        unmonitor actor
+        Thread.current[:celluloid_actor].links.delete actor
+      end
+
+      # Are we monitoring the given actor?
+      def monitoring?(actor)
+        actor.links.include? Actor.current
+      end
+
+      # Are we bidirectionally linked to the given actor?
+      def linked_to?(actor)
+        monitoring?(actor) && Thread.current[:celluloid_actor].links.include?(actor)
+      end
+
+      # Forcibly kill a given actor
+      def kill(actor)
+        actor.thread.kill
+        actor.mailbox.shutdown if actor.mailbox.alive?
+      end
+
+      # Wait for an actor to terminate
+      def join(actor, timeout = nil)
+        actor.thread.join(timeout)
+        actor
+      end
+    end
+
+    def initialize(behavior, options)
+      @behavior         = behavior
+
+      @actor_system     = options.fetch(:actor_system)
+      @mailbox          = options.fetch(:mailbox_class, Mailbox).new
+      @mailbox.max_size = options.fetch(:mailbox_size, nil)
+
+      @task_class   = options[:task_class] || Celluloid.task_class
+      @exit_handler = method(:default_exit_handler)
+      @exclusive    = options.fetch(:exclusive, false)
+
+      @tasks     = TaskSet.new
+      @links     = Links.new
+      @signals   = Signals.new
+      @timers    = Timers::Group.new
+      @receivers = Receivers.new(@timers)
+      @handlers  = Handlers.new
+      @running   = false
+      @name      = nil
+
+      handle(SystemEvent) do |message|
+        handle_system_event message
+      end
+    end
+
+    def start
+      @running = true
+      @thread = ThreadHandle.new(@actor_system, :actor) do
+        setup_thread
+        run
+      end
+
+      @proxy = ActorProxy.new(@thread, @mailbox)
+      Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
+    end
+
+    def behavior_proxy
+      @behavior.proxy
+    end
+
+    def setup_thread
+      Thread.current[:celluloid_actor]   = self
+      Thread.current[:celluloid_mailbox] = @mailbox
+    end
+
+    # Run the actor loop
+    def run
+      while @running
+        begin
+          @timers.wait do |interval|
+            interval = 0 if interval and interval < 0
+            
+            if message = @mailbox.check(interval)
+              handle_message(message)
+
+              break unless @running
+            end
+          end
+        rescue MailboxShutdown
+          @running = false
+        end
+      end
+
+      shutdown
+    rescue Exception => ex
+      handle_crash(ex)
+      raise unless ex.is_a? StandardError
+    end
+
+    # Terminate this actor
+    def terminate
+      @running = false
+    end
+
+    # Perform a linking request with another actor
+    def linking_request(receiver, type)
+      Celluloid.exclusive do
+        receiver.mailbox << LinkingRequest.new(Actor.current, type)
+        system_events = []
+
+        Timers::Wait.for(LINKING_TIMEOUT) do |remaining|
+          begin
+            message = @mailbox.receive(remaining) do |msg|
+              msg.is_a?(LinkingResponse) &&
+              msg.actor.mailbox.address == receiver.mailbox.address &&
+              msg.type == type
+            end
+          rescue TimeoutError
+            next # IO reactor did something, no message in queue yet.
+          end
+
+          if message.instance_of? LinkingResponse
+            Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
+
+            # We're done!
+            system_events.each { |ev| @mailbox << ev }
+
+            return
+          elsif message.is_a? SystemEvent
+            # Queue up pending system events to be processed after we've successfully linked
+            system_events << message
+          else raise "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
+          end
+        end
+
+        raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
+      end
+    end
+
+    # Send a signal with the given name to all waiting methods
+    def signal(name, value = nil)
+      @signals.broadcast name, value
+    end
+
+    # Wait for the given signal
+    def wait(name)
+      @signals.wait name
+    end
+
+    def handle(*patterns, &block)
+      @handlers.handle(*patterns, &block)
+    end
+
+    # Receive an asynchronous message
+    def receive(timeout = nil, &block)
+      loop do
+        message = @receivers.receive(timeout, &block)
+        break message unless message.is_a?(SystemEvent)
+
+        handle_system_event(message)
+      end
+    end
+
+    # Schedule a block to run at the given time
+    def after(interval, &block)
+      @timers.after(interval) { task(:timer, &block) }
+    end
+
+    # Schedule a block to run at the given time
+    def every(interval, &block)
+      @timers.every(interval) { task(:timer, &block) }
+    end
+
+    def timeout(duration)
+      bt = caller
+      task = Task.current
+      timer = @timers.after(duration) do
+        exception = Task::TimeoutError.new("execution expired")
+        exception.set_backtrace bt
+        task.resume exception
+      end
+      yield
+    ensure
+      timer.cancel if timer
+    end
+
+    class Sleeper
+      def initialize(timers, interval)
+        @timers = timers
+        @interval = interval
+      end
+
+      def before_suspend(task)
+        @timers.after(@interval) { task.resume }
+      end
+
+      def wait
+        Kernel.sleep(@interval)
+      end
+    end
+
+    # Sleep for the given amount of time
+    def sleep(interval)
+      sleeper = Sleeper.new(@timers, interval)
+      Celluloid.suspend(:sleeping, sleeper)
+    end
+
+    # Handle standard low-priority messages
+    def handle_message(message)
+      unless @handlers.handle_message(message)
+        unless @receivers.handle_message(message)
+          Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+        end
+      end
+      message
+    end
+
+    # Handle high-priority system event messages
+    def handle_system_event(event)
+      if event.instance_of? ExitEvent
+        handle_exit_event(event)
+      elsif event.instance_of? LinkingRequest
+        event.process(links)
+      elsif event.instance_of? NamingRequest
+        @name = event.name
+        Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+      elsif event.instance_of? TerminationRequest
+        terminate
+      elsif event.instance_of? SignalConditionRequest
+        event.call
+      else
+        Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+      end
+    end
+
+    # Handle exit events received by this actor
+    def handle_exit_event(event)
+      @links.delete event.actor
+
+      @exit_handler.call(event)
+    end
+
+    def default_exit_handler(event)
+      raise event.reason if event.reason
+    end
+
+    # Handle any exceptions that occur within a running actor
+    def handle_crash(exception)
+      # TODO: add meta info
+      Logger.crash("Actor crashed!", exception)
+      shutdown ExitEvent.new(behavior_proxy, exception)
+    rescue => ex
+      Logger.crash("ERROR HANDLER CRASHED!", ex)
+    end
+
+    # Handle cleaning up this actor after it exits
+    def shutdown(exit_event = ExitEvent.new(behavior_proxy))
+      @behavior.shutdown
+      cleanup exit_event
+    ensure
+      Thread.current[:celluloid_actor]   = nil
+      Thread.current[:celluloid_mailbox] = nil
+    end
+
+    # Clean up after this actor
+    def cleanup(exit_event)
+      Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
+      @mailbox.shutdown
+      @links.each do |actor|
+        if actor.mailbox.alive?
+          actor.mailbox << exit_event
+        end
+      end
+
+      tasks.to_a.each(&:terminate)
+    rescue => ex
+      # TODO: metadata
+      Logger.crash("CLEANUP CRASHED!", ex)
+    end
+
+    # Run a method inside a task unless it's exclusive
+    def task(task_type, meta = nil)
+      @task_class.new(task_type, meta) {
+        if @exclusive
+          Celluloid.exclusive { yield }
+        else
+          yield
+        end
+      }.resume
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Celluloid
+  class ActorSystem
+    extend Forwardable
+
+    def initialize
+      @internal_pool = InternalPool.new
+      @registry      = Registry.new
+    end
+    attr_reader :registry
+
+    # Launch default services
+    # FIXME: We should set up the supervision hierarchy here
+    def start
+      within do
+        Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+        Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+      end
+      true
+    end
+
+    def within
+      old = Thread.current[:celluloid_actor_system]
+      Thread.current[:celluloid_actor_system] = self
+      yield
+    ensure
+      Thread.current[:celluloid_actor_system] = old
+    end
+
+    def get_thread
+      @internal_pool.get do
+        Thread.current[:celluloid_actor_system] = self
+        yield
+      end
+    end
+
+    def stack_dump
+      Celluloid::StackDump.new(@internal_pool)
+    end
+
+    def_delegators "@registry", :[], :get, :[]=, :set, :delete
+
+    def registered
+      @registry.names
+    end
+
+    def clear_registry
+      @registry.clear
+    end
+
+    def running
+      actors = []
+      @internal_pool.each do |t|
+        next unless t.role == :actor
+        actors << t.actor.behavior_proxy if t.actor && t.actor.respond_to?(:behavior_proxy)
+      end
+      actors
+    end
+
+    def running?
+      @internal_pool.running?
+    end
+
+    # Shut down all running actors
+    def shutdown
+      actors = running
+      Timeout.timeout(shutdown_timeout) do
+        Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
+
+        # Actors cannot self-terminate, you must do it for them
+        actors.each do |actor|
+          begin
+            actor.terminate!
+          rescue DeadActorError
+          end
+        end
+
+        actors.each do |actor|
+          begin
+            Actor.join(actor)
+          rescue DeadActorError
+          end
+        end
+
+        @internal_pool.shutdown
+      end
+    rescue Timeout::Error
+      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
+      actors.each do |actor|
+        begin
+          Actor.kill(actor)
+        rescue DeadActorError, MailboxDead
+        end
+      end
+    ensure
+      @internal_pool.kill
+      clear_registry
+    end
+
+    def assert_inactive
+      @internal_pool.assert_inactive
+    end
+
+    def shutdown_timeout
+      Celluloid.shutdown_timeout
+    end
+  end
+end

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

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