scoot 0.0.4 → 0.0.6

data/.bundle/gems/ruby/2.2.0/extensions/x86_64-darwin-14/2.2.0-static/hitimes-1.2.2/gem_make.out

@@ -1,16 +0,0 @@
-/Users/denverwebco/.rubies/ruby-2.2.2/bin/ruby -r ./siteconf20150715-21778-s2s1am.rb extconf.rb
-creating Makefile
-
-make "DESTDIR=" clean
-
-make "DESTDIR="
-compiling hitimes.c
-compiling hitimes_instant_clock_gettime.c
-compiling hitimes_instant_osx.c
-compiling hitimes_instant_windows.c
-compiling hitimes_interval.c
-compiling hitimes_stats.c
-linking shared-object hitimes/2.2/hitimes.bundle
-
-make "DESTDIR=" install
-/usr/bin/install -c -m 0755 hitimes.bundle ./.gem.20150715-21778-u2nqnh/hitimes/2.2

data/.bundle/gems/ruby/2.2.0/gems/blankslate-2.1.2.4/README

@@ -1,31 +0,0 @@
-BlankSlate
-===
-
-BlankSlate provides an abstract base class with no predefined
-methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
-BlankSlate is useful as a base class when writing classes that
-depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-
-Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
-All rights reserved.
-
-
-Extracted from Builder because, for no conceivable reason,
-blankslate isn't in its own gem. Gemified by David Masover,
-moved to gemcutter by Jack Danger Canty (gemcutter@6brand.com
-if you'd like to own this gem).
-
-Explanation on extraction from David Masover:
-
-So, Builder seems to have the most complete implementation of
-BlankSlate, short of Ruby 1.9's BasicObject. The problem is,
-this is part of Builder, and still inside the Builder gem.
-
-It's especially frustrating, because the Builder source
-(lib/builder/blankslate.rb) seems to acknowledge that there
-should be a separate gem. But the only reference I can find
-refers to onestepback.org's gem repository, which isn't working.
-
-So I built my own. I'll try to keep it up to date with Builder.
-The first three parts of the version number are
-the Builder version; the last part is my revision.

data/.bundle/gems/ruby/2.2.0/gems/blankslate-2.1.2.4/Rakefile

@@ -1,13 +0,0 @@
-
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-task :default => :spec
-
-require 'rake/testtask'
-Rake::TestTask.new(:spec) do |test|
-  test.libs << '.'
-  test.ruby_opts = ['-rubygems']
-  test.pattern = 'spec/*_spec.rb'
-  test.verbose = true
-end

data/.bundle/gems/ruby/2.2.0/gems/blankslate-2.1.2.4/VERSION

@@ -1 +0,0 @@
-2.1.2.4

data/.bundle/gems/ruby/2.2.0/gems/blankslate-2.1.2.4/blankslate.gemspec

@@ -1,22 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "blankslate"
-
-Gem::Specification.new do |s|
-  s.name        = "blankslate"
-  s.version     = File.read('VERSION')
-  s.platform    = Gem::Platform::RUBY
-  s.summary     = 'BlankSlate extracted from Builder.'
-  s.email       = 'rubygems@6brand.com'
-  s.authors     = ['Jim Weirich', 'David Masover', 'Jack Danger Canty']
-  s.email       = "rubygems@6brand.com"
-  s.homepage    = "http://github.com/masover/blankslate"
-
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'bundler'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end

data/.bundle/gems/ruby/2.2.0/gems/blankslate-2.1.2.4/lib/blankslate.rb

@@ -1,109 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-######################################################################
-# BlankSlate provides an abstract base class with no predefined
-# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
-# BlankSlate is useful as a base class when writing classes that
-# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-#
-class BlankSlate
-  class << self
-    
-    # Hide the method named +name+ in the BlankSlate class.  Don't
-    # hide +instance_eval+ or any method beginning with "__".
-    def hide(name)
-      if instance_methods.map(&:to_sym).include?(name.to_sym) and
-        name !~ /^(__|instance_eval|object_id)/
-        @hidden_methods ||= {}
-        @hidden_methods[name.to_sym] = instance_method(name)
-        undef_method name
-      end
-    end
-
-    def find_hidden_method(name)
-      @hidden_methods ||= {}
-      @hidden_methods[name] || superclass.find_hidden_method(name)
-    end
-
-    # Redefine a previously hidden method so that it may be called on a blank
-    # slate object.
-    def reveal(name)
-      hidden_method = find_hidden_method(name)
-      fail "Don't know how to reveal method '#{name}'" unless hidden_method
-      define_method(name, hidden_method)
-    end
-  end
-  
-  instance_methods.each { |m| hide(m) }
-end
-
-######################################################################
-# Since Ruby is very dynamic, methods added to the ancestors of
-# BlankSlate <em>after BlankSlate is defined</em> will show up in the
-# list of available BlankSlate methods.  We handle this by defining a
-# hook in the Object and Kernel classes that will hide any method
-# defined after BlankSlate has been loaded.
-#
-module Kernel
-  class << self
-    alias_method :blank_slate_method_added, :method_added
-
-    # Detect method additions to Kernel and remove them in the
-    # BlankSlate class.
-    def method_added(name)
-      result = blank_slate_method_added(name)
-      return result if self != Kernel
-      BlankSlate.hide(name)
-      result
-    end
-  end
-end
-
-######################################################################
-# Same as above, except in Object.
-#
-class Object
-  class << self
-    alias_method :blank_slate_method_added, :method_added
-
-    # Detect method additions to Object and remove them in the
-    # BlankSlate class.
-    def method_added(name)
-      result = blank_slate_method_added(name)
-      return result if self != Object
-      BlankSlate.hide(name)
-      result
-    end
-
-    def find_hidden_method(name)
-      nil
-    end
-  end
-end
-
-######################################################################
-# Also, modules included into Object need to be scanned and have their
-# instance methods removed from blank slate.  In theory, modules
-# included into Kernel would have to be removed as well, but a
-# "feature" of Ruby prevents late includes into modules from being
-# exposed in the first place.
-#
-class Module
-  alias blankslate_original_append_features append_features
-  def append_features(mod)
-    result = blankslate_original_append_features(mod)
-    return result if mod != Object
-    instance_methods.each do |name|
-      BlankSlate.hide(name)
-    end
-    result
-  end
-end

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

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

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

@@ -1,172 +0,0 @@
-![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.rb

@@ -1,516 +0,0 @@
-require 'logger'
-require 'thread'
-require 'timeout'
-require 'set'
-
-module Celluloid
-  # Expose all instance methods as singleton methods
-  extend self
-
-  VERSION = '0.16.0'
-
-  # Linking times out after 5 seconds
-  LINKING_TIMEOUT = 5
-
-  # Warning message added to Celluloid objects accessed outside their actors
-  BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
-
-  class << self
-    attr_writer   :actor_system     # Default Actor System
-    attr_accessor :logger           # Thread-safe logger class
-    attr_accessor :task_class       # Default task type to use
-    attr_accessor :shutdown_timeout # How long actors have to terminate
-
-    def actor_system
-      if Thread.current.celluloid?
-        Thread.current[:celluloid_actor_system] or raise Error, "actor system not running"
-      else
-        Thread.current[:celluloid_actor_system] || @actor_system or raise Error, "Celluloid is not yet started; use Celluloid.boot"
-      end
-    end
-
-    def included(klass)
-      klass.send :extend,  ClassMethods
-      klass.send :include, InstanceMethods
-
-      klass.send :extend, Properties
-
-      klass.property :mailbox_class, :default => Celluloid::Mailbox
-      klass.property :proxy_class,   :default => Celluloid::CellProxy
-      klass.property :task_class,    :default => Celluloid.task_class
-      klass.property :mailbox_size
-
-      klass.property :exclusive_actor, :default => false
-      klass.property :exclusive_methods, :multi => true
-      klass.property :execute_block_on_receiver,
-        :default => [:after, :every, :receive],
-        :multi   => true
-
-      klass.property :finalizer
-      klass.property :exit_handler_name
-
-      klass.send(:define_singleton_method, :trap_exit) do |*args|
-        exit_handler_name(*args)
-      end
-
-      klass.send(:define_singleton_method, :exclusive) do |*args|
-        if args.any?
-          exclusive_methods(*exclusive_methods, *args)
-        else
-          exclusive_actor true
-        end
-      end
-    end
-
-    # Are we currently inside of an actor?
-    def actor?
-      !!Thread.current[:celluloid_actor]
-    end
-
-    # Retrieve the mailbox for the current thread or lazily initialize it
-    def mailbox
-      Thread.current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
-    end
-
-    # Generate a Universally Unique Identifier
-    def uuid
-      UUID.generate
-    end
-
-    # Obtain the number of CPUs in the system
-    def cores
-     CPUCounter.cores
-    end
-    alias_method :cpus, :cores
-    alias_method :ncpus, :cores
-
-    # Perform a stack dump of all actors to the given output object
-    def stack_dump(output = STDERR)
-      actor_system.stack_dump.print(output)
-    end
-    alias_method :dump, :stack_dump
-
-    # Detect if a particular call is recursing through multiple actors
-    def detect_recursion
-      actor = Thread.current[:celluloid_actor]
-      return unless actor
-
-      task = Thread.current[:celluloid_task]
-      return unless task
-
-      chain_id = CallChain.current_id
-      actor.tasks.to_a.any? { |t| t != task && t.chain_id == chain_id }
-    end
-
-    # Define an exception handler for actor crashes
-    def exception_handler(&block)
-      Logger.exception_handler(&block)
-    end
-
-    def suspend(status, waiter)
-      task = Thread.current[:celluloid_task]
-      if task && !Celluloid.exclusive?
-        waiter.before_suspend(task) if waiter.respond_to?(:before_suspend)
-        Task.suspend(status)
-      else
-        waiter.wait
-      end
-    end
-
-    def boot
-      init
-      start
-    end
-
-    def init
-      @actor_system = ActorSystem.new
-    end
-
-    def start
-      actor_system.start
-    end
-
-    def running?
-      actor_system && actor_system.running?
-    end
-
-    def register_shutdown
-      return if @shutdown_registered
-      # Terminate all actors at exit
-      at_exit do
-        if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
-          # workaround for MRI bug losing exit status in at_exit block
-          # http://bugs.ruby-lang.org/issues/5218
-          exit_status = $!.status if $!.is_a?(SystemExit)
-          Celluloid.shutdown
-          exit exit_status if exit_status
-        else
-          Celluloid.shutdown
-        end
-      end
-      @shutdown_registered = true
-    end
-
-    # Shut down all running actors
-    def shutdown
-      actor_system.shutdown
-    end
-
-    def version
-      VERSION
-    end
-  end
-
-  # Class methods added to classes which include Celluloid
-  module ClassMethods
-    # Create a new actor
-    def new(*args, &block)
-      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
-      proxy._send_(:initialize, *args, &block)
-      proxy
-    end
-    alias_method :spawn, :new
-
-    # Create a new actor and link to the current one
-    def new_link(*args, &block)
-      raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-
-      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
-      Actor.link(proxy)
-      proxy._send_(:initialize, *args, &block)
-      proxy
-    end
-    alias_method :spawn_link, :new_link
-
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails
-    def supervise(*args, &block)
-      Supervisor.supervise(self, *args, &block)
-    end
-
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails, and keep the actor registered under a given name
-    def supervise_as(name, *args, &block)
-      Supervisor.supervise_as(name, self, *args, &block)
-    end
-
-    # Create a new pool of workers. Accepts the following options:
-    #
-    # * size: how many workers to create. Default is worker per CPU core
-    # * args: array of arguments to pass when creating a worker
-    #
-    def pool(options = {})
-      PoolManager.new(self, options)
-    end
-
-    # Same as pool, but links to the pool manager
-    def pool_link(options = {})
-      PoolManager.new_link(self, options)
-    end
-
-    # Run an actor in the foreground
-    def run(*args, &block)
-      Actor.join(new(*args, &block))
-    end
-
-    def actor_system
-      Celluloid.actor_system
-    end
-
-    # Configuration options for Actor#new
-    def actor_options
-      {
-        :actor_system      => actor_system,
-        :mailbox_class     => mailbox_class,
-        :mailbox_size      => mailbox_size,
-        :task_class        => task_class,
-        :exclusive         => exclusive_actor,
-      }
-    end
-
-    def behavior_options
-      {
-        :proxy_class               => proxy_class,
-        :exclusive_methods         => exclusive_methods,
-        :exit_handler_name         => exit_handler_name,
-        :finalizer                 => finalizer,
-        :receiver_block_executions => execute_block_on_receiver,
-      }
-    end
-
-    def ===(other)
-      other.kind_of? self
-    end
-  end
-
-  # These are methods we don't want added to the Celluloid singleton but to be
-  # defined on all classes that use Celluloid
-  module InstanceMethods
-    # Obtain the bare Ruby object the actor is wrapping. This is useful for
-    # only a limited set of use cases like runtime metaprogramming. Interacting
-    # directly with the bare object foregoes any kind of thread safety that
-    # Celluloid would ordinarily provide you, and the object is guaranteed to
-    # be shared with at least the actor thread. Tread carefully.
-    #
-    # Bare objects can be identified via #inspect output:
-    #
-    #     >> actor
-    #      => #<Celluloid::Actor(Foo:0x3fefcb77c194)>
-    #     >> actor.bare_object
-    #      => #<WARNING: BARE CELLULOID OBJECT (Foo:0x3fefcb77c194)>
-    #
-    def bare_object; self; end
-    alias_method :wrapped_object, :bare_object
-
-    # Are we being invoked in a different thread from our owner?
-    def leaked?
-      @celluloid_owner != Thread.current[:celluloid_actor]
-    end
-
-    def tap
-      yield current_actor
-      current_actor
-    end
-
-    # Obtain the name of the current actor
-    def registered_name
-      Actor.registered_name
-    end
-    alias_method :name, :registered_name
-
-    def inspect
-      return "..." if Celluloid.detect_recursion
-
-      str = "#<"
-
-      if leaked?
-        str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
-      else
-        str << "Celluloid::CellProxy"
-      end
-
-      str << "(#{self.class}:0x#{object_id.to_s(16)})"
-      str << " " unless instance_variables.empty?
-
-      instance_variables.each do |ivar|
-        next if ivar == Celluloid::OWNER_IVAR
-        str << "#{ivar}=#{instance_variable_get(ivar).inspect} "
-      end
-
-      str.sub!(/\s$/, '>')
-    end
-  end
-
-  #
-  # The following methods are available on both the Celluloid singleton and
-  # directly inside of all classes that include Celluloid
-  #
-
-  # Raise an exception in sender context, but stay running
-  def abort(cause)
-    cause = case cause
-      when String then RuntimeError.new(cause)
-      when Exception then cause
-      else raise TypeError, "Exception object/String expected, but #{cause.class} received"
-    end
-    raise AbortError.new(cause)
-  end
-
-  # Terminate this actor
-  def terminate
-    Thread.current[:celluloid_actor].behavior_proxy.terminate!
-  end
-
-  # Send a signal with the given name to all waiting methods
-  def signal(name, value = nil)
-    Thread.current[:celluloid_actor].signal name, value
-  end
-
-  # Wait for the given signal
-  def wait(name)
-    Thread.current[:celluloid_actor].wait name
-  end
-
-  # Obtain the current_actor
-  def current_actor
-    Actor.current
-  end
-
-  # Obtain the UUID of the current call chain
-  def call_chain_id
-    CallChain.current_id
-  end
-
-  # Obtain the running tasks for this actor
-  def tasks
-    Thread.current[:celluloid_actor].tasks.to_a
-  end
-
-  # Obtain the Celluloid::Links for this actor
-  def links
-    Thread.current[:celluloid_actor].links
-  end
-
-  # Watch for exit events from another actor
-  def monitor(actor)
-    Actor.monitor(actor)
-  end
-
-  # Stop waiting for exit events from another actor
-  def unmonitor(actor)
-    Actor.unmonitor(actor)
-  end
-
-  # Link this actor to another, allowing it to crash or react to errors
-  def link(actor)
-    Actor.link(actor)
-  end
-
-  # Remove links to another actor
-  def unlink(actor)
-    Actor.unlink(actor)
-  end
-
-  # Are we monitoring another actor?
-  def monitoring?(actor)
-    Actor.monitoring?(actor)
-  end
-
-  # Is this actor linked to another?
-  def linked_to?(actor)
-    Actor.linked_to?(actor)
-  end
-
-  # Receive an asynchronous message via the actor protocol
-  def receive(timeout = nil, &block)
-    actor = Thread.current[:celluloid_actor]
-    if actor
-      actor.receive(timeout, &block)
-    else
-      Celluloid.mailbox.receive(timeout, &block)
-    end
-  end
-
-  # Sleep letting the actor continue processing messages
-  def sleep(interval)
-    actor = Thread.current[:celluloid_actor]
-    if actor
-      actor.sleep(interval)
-    else
-      Kernel.sleep interval
-    end
-  end
-
-  # Timeout on task suspension (eg Sync calls to other actors)
-  def timeout(duration)
-    Thread.current[:celluloid_actor].timeout(duration) do
-      yield
-    end
-  end
-
-  # Run given block in an exclusive mode: all synchronous calls block the whole
-  # actor, not only current message processing.
-  def exclusive(&block)
-    Thread.current[:celluloid_task].exclusive(&block)
-  end
-
-  # Are we currently exclusive
-  def exclusive?
-    task = Thread.current[:celluloid_task]
-    task && task.exclusive?
-  end
-
-  # Call a block after a given interval, returning a Celluloid::Timer object
-  def after(interval, &block)
-    Thread.current[:celluloid_actor].after(interval, &block)
-  end
-
-  # Call a block every given interval, returning a Celluloid::Timer object
-  def every(interval, &block)
-    Thread.current[:celluloid_actor].every(interval, &block)
-  end
-
-  # Perform a blocking or computationally intensive action inside an
-  # asynchronous thread pool, allowing the sender to continue processing other
-  # messages in its mailbox in the meantime
-  def defer(&block)
-    # This implementation relies on the present implementation of
-    # Celluloid::Future, which uses a thread from InternalPool to run the block
-    Future.new(&block).value
-  end
-
-  # Handle async calls within an actor itself
-  def async(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].behavior_proxy.async meth, *args, &block
-  end
-
-  # Handle calls to future within an actor itself
-  def future(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].behavior_proxy.future meth, *args, &block
-  end
-end
-
-if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
-  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
-end
-
-require 'celluloid/exceptions'
-
-require 'celluloid/calls'
-require 'celluloid/call_chain'
-require 'celluloid/condition'
-require 'celluloid/thread'
-require 'celluloid/core_ext'
-require 'celluloid/cpu_counter'
-require 'celluloid/fiber'
-require 'celluloid/fsm'
-require 'celluloid/internal_pool'
-require 'celluloid/links'
-require 'celluloid/logger'
-require 'celluloid/mailbox'
-require 'celluloid/evented_mailbox'
-require 'celluloid/method'
-require 'celluloid/properties'
-require 'celluloid/handlers'
-require 'celluloid/receivers'
-require 'celluloid/registry'
-require 'celluloid/responses'
-require 'celluloid/signals'
-require 'celluloid/stack_dump'
-require 'celluloid/system_events'
-require 'celluloid/tasks'
-require 'celluloid/task_set'
-require 'celluloid/thread_handle'
-require 'celluloid/uuid'
-
-require 'celluloid/proxies/abstract_proxy'
-require 'celluloid/proxies/sync_proxy'
-require 'celluloid/proxies/cell_proxy'
-require 'celluloid/proxies/actor_proxy'
-require 'celluloid/proxies/async_proxy'
-require 'celluloid/proxies/future_proxy'
-require 'celluloid/proxies/block_proxy'
-
-require 'celluloid/actor'
-require 'celluloid/cell'
-require 'celluloid/future'
-require 'celluloid/actor_system'
-require 'celluloid/pool_manager'
-require 'celluloid/supervision_group'
-require 'celluloid/supervisor'
-require 'celluloid/notifications'
-require 'celluloid/logging'
-
-require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
-
-$CELLULOID_MONITORING = false
-
-# Configure default systemwide settings
-Celluloid.task_class = Celluloid::TaskFiber
-Celluloid.logger     = Logger.new(STDERR)
-Celluloid.shutdown_timeout = 10
-
-unless $CELLULOID_TEST
-  Celluloid.register_shutdown
-  Celluloid.init
-end