sidekiq-statsd 0.1.1 → 0.1.2

data/vendor/ruby/1.9.1/gems/activesupport-3.2.13/lib/active_support.rb

@@ -1,82 +0,0 @@
-#--
-# Copyright (c) 2005-2011 David Heinemeier Hansson
-#
-# 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.
-#++
-
-require 'securerandom'
-
-module ActiveSupport
-  class << self
-    attr_accessor :load_all_hooks
-    def on_load_all(&hook) load_all_hooks << hook end
-    def load_all!; load_all_hooks.each { |hook| hook.call } end
-  end
-  self.load_all_hooks = []
-
-  on_load_all do
-    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte]
-  end
-end
-
-require "active_support/dependencies/autoload"
-require "active_support/version"
-
-module ActiveSupport
-  extend ActiveSupport::Autoload
-
-  autoload :DescendantsTracker
-  autoload :FileUpdateChecker
-  autoload :LogSubscriber
-  autoload :Notifications
-
-  # TODO: Narrow this list down
-  eager_autoload do
-    autoload :BacktraceCleaner
-    autoload :Base64
-    autoload :BasicObject
-    autoload :Benchmarkable
-    autoload :BufferedLogger
-    autoload :Cache
-    autoload :Callbacks
-    autoload :Concern
-    autoload :Configurable
-    autoload :Deprecation
-    autoload :Gzip
-    autoload :Inflector
-    autoload :JSON
-    autoload :Memoizable
-    autoload :MessageEncryptor
-    autoload :MessageVerifier
-    autoload :Multibyte
-    autoload :OptionMerger
-    autoload :OrderedHash
-    autoload :OrderedOptions
-    autoload :Rescuable
-    autoload :StringInquirer
-    autoload :TaggedLogging
-    autoload :XmlMini
-  end
-
-  autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
-  autoload :TestCase
-end
-
-autoload :I18n, "active_support/i18n"

data/vendor/ruby/1.9.1/gems/celluloid-0.14.0/README.md

@@ -1,145 +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)
-
-Installation
-------------
-
-Add this line to your application's Gemfile:
-
-    gem 'celluloid'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install celluloid
-
-Inside of your Ruby program, require Celluloid with:
-
-    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://python.org/workshops/1997-10/proceedings/atom/):
-  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) 2013 Tony Arcieri. Distributed under the MIT License. See
-LICENSE.txt for further details.

data/vendor/ruby/1.9.1/gems/celluloid-0.14.0/lib/celluloid/actor.rb

@@ -1,428 +0,0 @@
-require 'timers'
-
-module Celluloid
-  # Don't do Actor-like things outside Actor scope
-  class NotActorError < StandardError; end
-
-  # Trying to do something to a dead actor
-  class DeadActorError < StandardError; end
-
-  # A timeout occured before the given request could complete
-  class TimeoutError < StandardError; end
-
-  # The sender made an error, not the current actor
-  class AbortError < StandardError
-    attr_reader :cause
-
-    def initialize(cause)
-      @cause = cause
-      super "caused by #{cause.inspect}: #{cause.to_s}"
-    end
-  end
-
-  LINKING_TIMEOUT = 5 # linking times out after 5 seconds
-  OWNER_IVAR = :@celluloid_owner # reference to owning actor
-
-  # 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 :subject, :proxy, :tasks, :links, :mailbox, :thread, :name, :locals
-
-    class << self
-      extend Forwardable
-
-      def_delegators "Celluloid::Registry.root", :[], :[]=
-
-      def registered
-        Registry.root.names
-      end
-
-      def clear_registry
-        Registry.root.clear
-      end
-
-      # Obtain the current actor
-      def current
-        actor = Thread.current[:celluloid_actor]
-        raise NotActorError, "not in actor scope" unless actor
-        actor.proxy
-      end
-
-      # Obtain the name of the current actor
-      def 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
-        actors = []
-        Thread.list.each do |t|
-          next unless t.celluloid?
-          next if t.task
-          actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
-        end
-        actors
-      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
-        begin
-          actor.mailbox.shutdown
-        rescue DeadActorError
-        end
-      end
-
-      # Wait for an actor to terminate
-      def join(actor, timeout = nil)
-        actor.thread.join(timeout)
-        actor
-      end
-    end
-
-    # Wrap the given subject with an Actor
-    def initialize(subject, options = {})
-      @subject      = subject
-      @mailbox      = options[:mailbox] || Mailbox.new
-      @exit_handler = options[:exit_handler]
-      @exclusives   = options[:exclusive_methods]
-      @receiver_block_executions = options[:receiver_block_executions]
-      @task_class   = options[:task_class] || Celluloid.task_class
-
-      @tasks     = TaskSet.new
-      @links     = Links.new
-      @signals   = Signals.new
-      @receivers = Receivers.new
-      @timers    = Timers.new
-      @running   = true
-      @exclusive = false
-      @name      = nil
-      @locals    = {}
-
-      @thread = ThreadHandle.new do
-        setup_thread
-        run
-      end
-
-      @proxy = (options[:proxy_class] || ActorProxy).new(self)
-      @subject.instance_variable_set(OWNER_IVAR, self)
-    end
-
-    def setup_thread
-      Thread.current[:celluloid_actor]   = self
-      Thread.current[:celluloid_mailbox] = @mailbox
-    end
-
-    # Run the actor loop
-    def run
-      begin
-        while @running
-          if message = @mailbox.receive(timeout_interval)
-            handle_message message
-          else
-            # No message indicates a timeout
-            @timers.fire
-            @receivers.fire_timers
-          end
-        end
-      rescue MailboxShutdown
-        # If the mailbox detects shutdown, exit the actor
-      end
-
-      shutdown
-    rescue Exception => ex
-      handle_crash(ex)
-      raise unless ex.is_a? StandardError
-    end
-
-    # Terminate this actor
-    def terminate
-      @running = false
-    end
-
-    # Is this actor running in exclusive mode?
-    def exclusive?
-      @exclusive
-    end
-
-    # Execute a code block in exclusive mode.
-    def exclusive
-      if @exclusive
-        yield
-      else
-        begin
-          @exclusive = true
-          yield
-        ensure
-          @exclusive = false
-        end
-      end
-    end
-
-    # Perform a linking request with another actor
-    def linking_request(receiver, type)
-      exclusive do
-        start_time = Time.now
-        receiver.mailbox << LinkingRequest.new(Actor.current, type)
-        system_events = []
-
-        loop do
-          wait_interval = start_time + LINKING_TIMEOUT - Time.now
-          message = @mailbox.receive(wait_interval) do |msg|
-            msg.is_a?(LinkingResponse) &&
-            msg.actor.mailbox.address == receiver.mailbox.address &&
-            msg.type == type
-          end
-
-          case message
-          when LinkingResponse
-            # We're done!
-            system_events.each { |ev| handle_system_event(ev) }
-            return
-          when NilClass
-            raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
-          when SystemEvent
-            # Queue up pending system events to be processed after we've successfully linked
-            system_events << message
-          else raise 'wtf'
-          end
-        end
-      end
-    end
-
-    # Send a signal with the given name to all waiting methods
-    def signal(name, value = nil)
-      @signals.send name, value
-    end
-
-    # Wait for the given signal
-    def wait(name)
-      @signals.wait name
-    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
-
-    # How long to wait until the next timer fires
-    def timeout_interval
-      i1 = @timers.wait_interval
-      i2 = @receivers.wait_interval
-
-      if i1 and i2
-        i1 < i2 ? i1 : i2
-      elsif i1
-        i1
-      else
-        i2
-      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
-
-    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)
-      case message
-      when SystemEvent
-        handle_system_event message
-      when Call
-        task(:call, message.method) {
-          if @receiver_block_executions && meth = message.method
-            if meth == :__send__
-              meth = message.arguments.first
-            end
-            if @receiver_block_executions.include?(meth.to_sym)
-              message.execute_block_on_receiver
-            end
-          end
-          message.dispatch(@subject)
-        }
-      when BlockCall
-        task(:invoke_block) { message.dispatch }
-      when BlockResponse, Response
-        message.dispatch
-      else
-        @receivers.handle_message(message)
-      end
-      message
-    end
-
-    # Handle high-priority system event messages
-    def handle_system_event(event)
-      case event
-      when ExitEvent
-        task(:exit_handler, @exit_handler) { handle_exit_event event }
-      when LinkingRequest
-        event.process(links)
-      when NamingRequest
-        @name = event.name
-      when TerminationRequest
-        @running = false
-      when SignalConditionRequest
-        event.call
-      end
-    end
-
-    # Handle exit events received by this actor
-    def handle_exit_event(event)
-      @links.delete event.actor
-
-      # Run the exit handler if available
-      return @subject.send(@exit_handler, event.actor, event.reason) if @exit_handler
-
-      # Reraise exceptions from linked actors
-      # If no reason is given, actor terminated cleanly
-      raise event.reason if event.reason
-    end
-
-    # Handle any exceptions that occur within a running actor
-    def handle_crash(exception)
-      Logger.crash("#{@subject.class} crashed!", exception)
-      shutdown ExitEvent.new(@proxy, exception)
-    rescue => ex
-      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
-    end
-
-    # Handle cleaning up this actor after it exits
-    def shutdown(exit_event = ExitEvent.new(@proxy))
-      run_finalizer
-      cleanup exit_event
-    ensure
-      Thread.current[:celluloid_actor]   = nil
-      Thread.current[:celluloid_mailbox] = nil
-    end
-
-    # Run the user-defined finalizer, if one is set
-    def run_finalizer
-      # FIXME: remove before Celluloid 1.0
-      if @subject.respond_to?(:finalize) && @subject.class.finalizer != :finalize
-        Logger.warn("DEPRECATION WARNING: #{@subject.class}#finalize is deprecated and will be removed in Celluloid 1.0. " +
-          "Define finalizers with '#{@subject.class}.finalizer :callback.'")
-
-        task(:finalizer, :finalize) { @subject.finalize }
-      end
-
-      finalizer = @subject.class.finalizer
-      if finalizer && @subject.respond_to?(finalizer, true)
-        task(:finalizer, :finalize) { @subject.__send__(finalizer) }
-      end
-    rescue => ex
-      Logger.crash("#{@subject.class}#finalize crashed!", ex)
-    end
-
-    # Clean up after this actor
-    def cleanup(exit_event)
-      @mailbox.shutdown
-      @links.each do |actor|
-        begin
-          actor.mailbox << exit_event
-        rescue MailboxError
-          # We're exiting/crashing, they're dead. Give up :(
-        end
-      end
-
-      tasks.each { |task| task.terminate }
-    rescue => ex
-      Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
-    end
-
-    # Run a method inside a task unless it's exclusive
-    def task(task_type, method_name = nil, &block)
-      if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
-        exclusive { block.call }
-      else
-        @task_class.new(task_type, &block).resume
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/celluloid-0.14.0/lib/celluloid/autostart.rb

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