RubyGems - logstash-codec-json - Versions diffs - 2.0.3 → 2.0.4 - Mend

logstash-codec-json 2.0.3 → 2.0.4

Files changed (1927) hide show

data/vendor/gems/concurrent-ruby-0.9.1-java/LICENSE.txt DELETED Viewed

@@ -1,21 +0,0 @@
-Copyright (c) Jerry D'Antonio -- released under the MIT license.
-http://www.opensource.org/licenses/mit-license.php
-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/vendor/gems/concurrent-ruby-0.9.1-java/README.md DELETED Viewed

@@ -1,295 +0,0 @@
-# Concurrent Ruby
-[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.svg)](http://badge.fury.io/rb/concurrent-ruby)
-[![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby)
-[![Build status](https://ci.appveyor.com/api/projects/status/iq8aboyuu3etad4w?svg=true)](https://ci.appveyor.com/project/rubyconcurrency/concurrent-ruby)
-[![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.svg)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby)
-[![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.svg)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby)
-[![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.svg)](https://gemnasium.com/ruby-concurrency/concurrent-ruby)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT)
-[![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-devs%20%26%20users-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
-<table>
-  <tr>
-    <td align="left" valign="top">
-      <p>
-        Modern concurrency tools for Ruby. Inspired by
-        <a href="http://www.erlang.org/doc/reference_manual/processes.html">Erlang</a>,
-        <a href="http://clojure.org/concurrent_programming">Clojure</a>,
-        <a href="http://akka.io/">Scala</a>,
-        <a href="http://www.haskell.org/haskellwiki/Applications_and_libraries/Concurrency_and_parallelism#Concurrent_Haskell">Haskell</a>,
-        <a href="http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx">F#</a>,
-        <a href="http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx">C#</a>,
-        <a href="http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html">Java</a>,
-        and classic concurrency patterns.
-      </p>
-      <p>
-        The design goals of this gem are:
-        <ul>
-          <li>Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why</li>
-          <li>Remain free of external gem dependencies</li>
-          <li>Stay true to the spirit of the languages providing inspiration</li>
-          <li>But implement in a way that makes sense for Ruby</li>
-          <li>Keep the semantics as idiomatic Ruby as possible</li>
-          <li>Support features that make sense in Ruby</li>
-          <li>Exclude features that don't make sense in Ruby</li>
-          <li>Be small, lean, and loosely coupled</li>
-        </ul>
-      </p>
-    </td>
-    <td align="right" valign="top">
-      <img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png"/>
-    </td>
-  </tr>
-</table>
-### Supported Ruby versions
-MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
-This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
-Java 8 is required for JRuby (Java 7 support is deprecated in version 0.9 and will be removed in 1.0).
-## Features & Documentation
-We have a roadmap guiding our work toward the [v1.0.0 release](https://github.com/ruby-concurrency/concurrent-ruby/issues/257).
-The primary site for documentation is the automatically generated [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
-We also have a [mailing list](http://groups.google.com/group/concurrent-ruby) and [IRC (gitter)](https://gitter.im/ruby-concurrency/concurrent-ruby).
-This library contains a variety of concurrency abstractions at high and low levels. One of the high-level abstractions is likely to meet most common needs.
-#### General-purpose Concurrency Abstractions
-* [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
-* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
-* [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
-  * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#dataflow-class_method): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
-* [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
-* [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
-* [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals.
-#### Thread-safe Value Objects
-* `Maybe` A thread-safe, immutable object representing an optional value, based on
-  [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
-* `Delay` Lazy evaluation of a block yielding an immutable result. Based on Clojure's
-   [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
-#### Thread-safe Structures
-Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
-* `ImmutableStruct` Immutable struct where values are set at construction and cannot be changed later.
-* `MutableStruct` Synchronized, mutable struct where values can be safely changed at any time.
-* `SettableStruct` Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
-#### Java-inspired ThreadPools and Other Executors
-* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
-#### Thread Synchronization Classes and Algorithms
-* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
-* [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
-* [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
-* [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
-#### Thread-safe Variables
-* [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
-* [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
-* [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html)
-* [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
-* [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
-* [Thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
-* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
-* [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html)
-* [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html)
-### Edge Features
-These are available in the `concurrent-ruby-edge` companion gem, installed with `gem install concurrent-ruby-edge`.
-These features are under active development and may change frequently. They are expected not to
-keep backward compatibility (there may also lack tests and documentation). Semantic versions will
-be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to `concurrent-ruby` when final.
-* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
-  Implements the Actor Model, where concurrent actors exchange messages.
-* [new Future Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/FutureShortcuts.html) - new
-  unified implementation of Futures and Promises which combines Features of previous `Future`,
-  `Promise`, `IVar`, `Event`, `Probe`, `dataflow`, `Delay`, `TimerTask` into single framework. It uses extensively
-  new synchronization layer to make all the features **non-blocking** and **lock-free** with exception of obviously blocking
-  operations like `#wait`, `#value`. It also offers better performance.
-* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
-* [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html):
-  Communicating Sequential Processes (CSP).
-* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
-* [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
-* [Atomic Markable Reference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
-* [LockFreeLinked Set](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
-* [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeStack.html)
-#### Statuses:
-*Why are these not in core?*
-- **Actor** - Partial documentation and tests; stability is good.
-- **Future/Promise Framework** - API changes; partial documentation and tests; stability good.
-- **Agent** - Incomplete behaviour compared to Clojure's models; stability good.
-- **Channel** - Missing documentation; limted features; stability good.
-- **Exchanger** - Known race condition requiring a new implementation.
-- **LazyRegister** - Missing documentation and tests.
-- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Needs real world battle testing
-## Usage
-All abstractions within this gem can be loaded simply by requiring it:
-```ruby
-require 'concurrent'
-```
-To reduce the amount of code loaded at runtime, subsets of this gem can be required:
-```ruby
-require 'concurrent'                # everything
-# groups
-require 'concurrent/atomics'        # atomic and thread synchronization classes
-require 'concurrent/executors'      # Thread pools and other executors
-# individual abstractions
-require 'concurrent/async'            # Concurrent::Async
-require 'concurrent/atom'             # Concurrent::Atom
-require 'concurrent/dataflow'         # Concurrent::dataflow
-require 'concurrent/delay'            # Concurrent::Delay
-require 'concurrent/future'           # Concurrent::Future
-require 'concurrent/immutable_struct' # Concurrent::ImmutableStruct
-require 'concurrent/ivar'             # Concurrent::IVar
-require 'concurrent/maybe'            # Concurrent::Maybe
-require 'concurrent/mutable_struct'   # Concurrent::MutableStruct
-require 'concurrent/mvar'             # Concurrent::MVar
-require 'concurrent/promise'          # Concurrent::Promise
-require 'concurrent/scheduled_task'   # Concurrent::ScheduledTask
-require 'concurrent/settable_struct'  # Concurrent::SettableStruct
-require 'concurrent/timer_task'       # Concurrent::TimerTask
-require 'concurrent/tvar'             # Concurrent::TVar
-# experimental - available in `concurrent-ruby-edge` companion gem
-require 'concurrent/actor'          # Concurrent::Actor and supporting code
-require 'concurrent/edge/future'    # new Future Framework
-require 'concurrent/agent'          # Concurrent::Agent
-require 'concurrent/channel '       # Concurrent::Channel and supporting code
-```
-If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
-## Installation
-```shell
-gem install concurrent-ruby
-```
-or add the following line to Gemfile:
-```ruby
-gem 'concurrent-ruby'
-```
-and run `bundle install` from your shell.
-### C Extensions for MRI
-Potential performance improvements may be achieved under MRI by installing optional C extensions.
-To minimize installation errors the C extensions are available in the `concurrent-ruby-ext` extension
-gem. `concurrent-ruby` and `concurrent-ruby-ext` are always released together with same version.
-Simply install the extension gem too:
-```ruby
-gem install concurrent-ruby-ext
-```
-or add the following line to Gemfile:
-```ruby
-gem 'concurrent-ruby-ext'
-```
-and run `bundle install` from your shell.
-In code it is only necessary to
-```ruby
-require 'concurrent'
-```
-The `concurrent-ruby` gem will automatically detect the presence of the `concurrent-ruby-ext` gem
-and load the appropriate C extensions.
-#### Note For gem developers
-No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users.
-The best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
-### Building
-All published versions of this gem (core, extension, and several platform-specific packages) are compiled,
-packaged, tested, and published using an open, [automated process](https://github.com/ruby-concurrency/rake-compiler-dev-box).
-This process can also be used to create pre-compiled binaries of the extension gem for virtally
-any platform. *Documentation is forthcoming...*
-```
-*MRI only*
-bundle exec rake build:native       # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg dir
-bundle exec rake compile:extension  # Compile extension
-*JRuby only*
-bundle exec rake build              # Build JRuby-specific core gem (alias for `build:core`)
-bundle exec rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory
-*All except JRuby*
-bundle exec rake build:core         # Build concurrent-ruby-<version>.gem into the pkg directory
-bundle exec rake build:ext          # Build concurrent-ruby-ext-<version>.gem into the pkg directory
-*When Docker IS installed*
-bundle exec rake build:windows      # Build the windows binary <version> gems per rake-compiler-dock
-bundle exec rake build              # Build core, extension, and edge gems, including Windows binaries
-*When Docker is NOT installed*
-bundle exec rake build              # Build core, extension, and edge gems (excluding Windows binaries)
-*All*
-bundle exec rake clean              # Remove any temporary products
-bundle exec rake clobber            # Remove any generated file
-bundle exec rake compile            # Compile all the extensions
-```
-## Maintainers
-* [Jerry D'Antonio](https://github.com/jdantonio) (creator)
-* [Michele Della Torre](https://github.com/mighe)
-* [Chris Seaton](https://github.com/chrisseaton)
-* [Lucas Allan](https://github.com/lucasallan)
-* [Petr Chalupa](https://github.com/pitr-ch)
-* [Paweł Obrok](https://github.com/obrok)
-## Contributing
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-## License and Copyright
-*Concurrent Ruby* is free software released under the [MIT License](http://www.opensource.org/licenses/MIT).
-The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo)
-was designed by [David Jones](https://twitter.com/zombyboy).
-It is Copyright &copy; 2014 [Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.

data/vendor/gems/concurrent-ruby-0.9.1-java/lib/concurrent.rb DELETED Viewed

@@ -1,121 +0,0 @@
-require 'concurrent/version'
-require 'concurrent/synchronization'
-require 'concurrent/configuration'
-require 'concurrent/atomics'
-require 'concurrent/errors'
-require 'concurrent/executors'
-require 'concurrent/utilities'
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/atom'
-require 'concurrent/async'
-require 'concurrent/dataflow'
-require 'concurrent/delay'
-require 'concurrent/future'
-require 'concurrent/immutable_struct'
-require 'concurrent/ivar'
-require 'concurrent/maybe'
-require 'concurrent/mutable_struct'
-require 'concurrent/mvar'
-require 'concurrent/promise'
-require 'concurrent/scheduled_task'
-require 'concurrent/settable_struct'
-require 'concurrent/timer_task'
-require 'concurrent/tvar'
-# @!macro [new] internal_implementation_note
-#
-#   @note **Private Implementation:** This abstraction is a private, internal
-#     implementation detail. It should never be used directly.
-# @!macro [new] monotonic_clock_warning
-#
-#   @note Time calculations one all platforms and languages are sensitive to
-#     changes to the system clock. To alleviate the potential problems
-#     associated with changing the system clock while an application is running,
-#     most modern operating systems provide a monotonic clock that operates
-#     independently of the system clock. A monotonic clock cannot be used to
-#     determine human-friendly clock times. A monotonic clock is used exclusively
-#     for calculating time intervals. Not all Ruby platforms provide access to an
-#     operating system monotonic clock. On these platforms a pure-Ruby monotonic
-#     clock will be used as a fallback. An operating system monotonic clock is both
-#     faster and more reliable than the pure-Ruby implementation. The pure-Ruby
-#     implementation should be fast and reliable enough for most non-realtime
-#     operations. At this time the common Ruby platforms that provide access to an
-#     operating system monotonic clock are MRI 2.1 and above and JRuby (all versions).
-#
-#   @see http://linux.die.net/man/3/clock_gettime Linux clock_gettime(3)
-# @!macro [new] copy_options
-#
-#   ## Copy Options
-#
-#   Object references in Ruby are mutable. This can lead to serious
-#   problems when the {#value} of an object is a mutable reference. Which
-#   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
-#   "primative" data type. Each instance can be configured with a few
-#   options that can help protect the program from potentially dangerous
-#   operations. Each of these options can be optionally set when the oject
-#   instance is created:
-#
-#   * `:dup_on_deref` When true the object will call the `#dup` method on
-#     the `value` object every time the `#value` methid is called
-#     (default: false)
-#   * `:freeze_on_deref` When true the object will call the `#freeze`
-#     method on the `value` object every time the `#value` method is called
-#     (default: false)
-#   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
-#     every time   the `#value` method is called. The `Proc` will be given
-#     the current `value` as its only argument and the result returned by
-#     the block will be the return   value of the `#value` call. When `nil`
-#     this option will be ignored (default: nil)
-#
-#   When multiple deref options are set the order of operations is strictly defined.
-#   The order of deref operations is:
-#   * `:copy_on_deref`
-#   * `:dup_on_deref`
-#   * `:freeze_on_deref`
-#
-#   Because of this ordering there is no need to `#freeze` an object created by a
-#   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
-#   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
-#   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
-#   or Haskell) as we are likely to get in Ruby.
-# @!macro [attach] deref_options
-#
-#   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
-#     returning the data from {#value}
-#   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
-#     returning the data from {#value}
-#   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
-#     method, call the given proc passing the internal value as the sole
-#     argument then return the new value returned from the proc.
-# @!macro [attach] executor_and_deref_options
-#
-#   @param [Hash] opts the options used to define the behavior at update and deref
-#     and to specify the executor on which to perform actions
-#   @option opts [Executor] :executor when set use the given `Executor` instance.
-#     Three special values are also supported: `:task` returns the global task pool,
-#     `:operation` returns the global operation pool, and `:immediate` returns a new
-#     `ImmediateExecutor` object.
-#   @!macro deref_options
-# Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
-# F#, C#, Java, and classic concurrency patterns.
-#
-# The design goals of this gem are:
-#
-# * Stay true to the spirit of the languages providing inspiration
-# * But implement in a way that makes sense for Ruby
-# * Keep the semantics as idiomatic Ruby as possible
-# * Support features that make sense in Ruby
-# * Exclude features that don't make sense in Ruby
-# * Be small, lean, and loosely coupled
-module Concurrent
-end

data/vendor/gems/concurrent-ruby-0.9.1-java/lib/concurrent/async.rb DELETED Viewed

@@ -1,298 +0,0 @@
-require 'thread'
-require 'concurrent/configuration'
-require 'concurrent/delay'
-require 'concurrent/errors'
-require 'concurrent/ivar'
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/executor/serialized_execution'
-require 'concurrent/concern/deprecation'
-module Concurrent
-  # A mixin module that provides simple asynchronous behavior to any standard
-  # class/object or object.
-  #
-  # ```cucumber
-  # Feature:
-  #   As a stateful, plain old Ruby class/object
-  #   I want safe, asynchronous behavior
-  #   So my long-running methods don't block the main thread
-  # ```
-  #
-  # Stateful, mutable objects must be managed carefully when used asynchronously.
-  # But Ruby is an object-oriented language so designing with objects and classes
-  # plays to Ruby's strengths and is often more natural to many Ruby programmers.
-  # The `Async` module is a way to mix simple yet powerful asynchronous capabilities
-  # into any plain old Ruby object or class. These capabilities provide a reasonable
-  # level of thread safe guarantees when used correctly.
-  #
-  # When this module is mixed into a class or object it provides to new methods:
-  # `async` and `await`. These methods are thread safe with respect to the enclosing
-  # object. The former method allows methods to be called asynchronously by posting
-  # to the global thread pool. The latter allows a method to be called synchronously
-  # on the current thread but does so safely with respect to any pending asynchronous
-  # method calls. Both methods return an `IVar` which can be inspected for
-  # the result of the method call. Calling a method with `async` will return a
-  # `:pending` `IVar` whereas `await` will return a `:complete` `IVar`.
-  #
-  # Very loosely based on the `async` and `await` keywords in C#.
-  #
-  # ### An Important Note About Thread Safe Guarantees
-  #
-  # > Thread safe guarantees can only be made when asynchronous method calls
-  # > are not mixed with synchronous method calls. Use only synchronous calls
-  # > when the object is used exclusively on a single thread. Use only
-  # > `async` and `await` when the object is shared between threads. Once you
-  # > call a method using `async`, you should no longer call any methods
-  # > directly on the object. Use `async` and `await` exclusively from then on.
-  # > With careful programming it is possible to switch back and forth but it's
-  # > also very easy to create race conditions and break your application.
-  # > Basically, it's "async all the way down."
-  #
-  # @example
-  #
-  #   class Echo
-  #     include Concurrent::Async
-  #
-  #     def echo(msg)
-  #       sleep(rand)
-  #       print "#{msg}\n"
-  #       nil
-  #     end
-  #   end
-  #
-  #   horn = Echo.new
-  #   horn.echo('zero')      # synchronous, not thread-safe
-  #
-  #   horn.async.echo('one') # asynchronous, non-blocking, thread-safe
-  #   horn.await.echo('two') # synchronous, blocking, thread-safe
-  #
-  # @see Concurrent::IVar
-  module Async
-    # @!method self.new(*args, &block)
-    #
-    #   Instanciate a new object and ensure proper initialization of the
-    #   synchronization mechanisms.
-    #
-    #   @param [Array<Object>] args Zero or more arguments to be passed to the
-    #     object's initializer.
-    #   @param [Proc] bloc Optional block to pass to the object's initializer.
-    #   @return [Object] A properly initialized object of the asynchronous class.
-    # Check for the presence of a method on an object and determine if a given
-    # set of arguments matches the required arity.
-    #
-    # @param [Object] obj the object to check against
-    # @param [Symbol] method the method to check the object for
-    # @param [Array] args zero or more arguments for the arity check
-    #
-    # @raise [NameError] the object does not respond to `method` method
-    # @raise [ArgumentError] the given `args` do not match the arity of `method`
-    #
-    # @note This check is imperfect because of the way Ruby reports the arity of
-    #   methods with a variable number of arguments. It is possible to determine
-    #   if too few arguments are given but impossible to determine if too many
-    #   arguments are given. This check may also fail to recognize dynamic behavior
-    #   of the object, such as methods simulated with `method_missing`.
-    #
-    # @see http://www.ruby-doc.org/core-2.1.1/Method.html#method-i-arity Method#arity
-    # @see http://ruby-doc.org/core-2.1.0/Object.html#method-i-respond_to-3F Object#respond_to?
-    # @see http://www.ruby-doc.org/core-2.1.0/BasicObject.html#method-i-method_missing BasicObject#method_missing
-    #
-    # @!visibility private
-    def self.validate_argc(obj, method, *args)
-      argc = args.length
-      arity = obj.method(method).arity
-      if arity >= 0 && argc != arity
-        raise ArgumentError.new("wrong number of arguments (#{argc} for #{arity})")
-      elsif arity < 0 && (arity = (arity + 1).abs) > argc
-        raise ArgumentError.new("wrong number of arguments (#{argc} for #{arity}..*)")
-      end
-    end
-    # @!visibility private
-    def self.included(base)
-      base.singleton_class.send(:alias_method, :original_new, :new)
-      base.extend(ClassMethods)
-      super(base)
-    end
-    # @!visibility private
-    module ClassMethods
-      def new(*args, &block)
-        obj = original_new(*args, &block)
-        obj.send(:init_synchronization)
-        obj
-      end
-    end
-    private_constant :ClassMethods
-    # Delegates asynchronous, thread-safe method calls to the wrapped object.
-    #
-    # @!visibility private
-    class AsyncDelegator
-      # Create a new delegator object wrapping the given delegate,
-      # protecting it with the given serializer, and executing it on the
-      # given executor. Block if necessary.
-      #
-      # @param [Object] delegate the object to wrap and delegate method calls to
-      # @param [Concurrent::Delay] executor a `Delay` wrapping the executor on which to execute delegated method calls
-      # @param [Concurrent::SerializedExecution] serializer the serializer to use when delegating method calls
-      # @param [Boolean] blocking will block awaiting result when `true`
-      def initialize(delegate, executor, serializer, blocking = false)
-        @delegate = delegate
-        @executor = executor
-        @serializer = serializer
-        @blocking = blocking
-      end
-      # Delegates method calls to the wrapped object. For performance,
-      # dynamically defines the given method on the delegator so that
-      # all future calls to `method` will not be directed here.
-      #
-      # @param [Symbol] method the method being called
-      # @param [Array] args zero or more arguments to the method
-      #
-      # @return [IVar] the result of the method call
-      #
-      # @raise [NameError] the object does not respond to `method` method
-      # @raise [ArgumentError] the given `args` do not match the arity of `method`
-      def method_missing(method, *args, &block)
-        super unless @delegate.respond_to?(method)
-        Async::validate_argc(@delegate, method, *args)
-        self.define_singleton_method(method) do |*args2|
-          Async::validate_argc(@delegate, method, *args2)
-          ivar = Concurrent::IVar.new
-          @serializer.post(@executor.value) do
-            begin
-              ivar.set(@delegate.send(method, *args2, &block))
-            rescue => reason
-              ivar.fail(reason)
-            end
-          end
-          ivar.value if @blocking
-          ivar
-        end
-        self.send(method, *args)
-      end
-    end
-    private_constant :AsyncDelegator
-    # Causes the chained method call to be performed asynchronously on the
-    # global thread pool. The method called by this method will return a
-    # future object in the `:pending` state and the method call will have
-    # been scheduled on the global thread pool. The final disposition of the
-    # method call can be obtained by inspecting the returned future.
-    #
-    # Before scheduling the method on the global thread pool a best-effort
-    # attempt will be made to validate that the method exists on the object
-    # and that the given arguments match the arity of the requested function.
-    # Due to the dynamic nature of Ruby and limitations of its reflection
-    # library, some edge cases will be missed. For more information see
-    # the documentation for the `validate_argc` method.
-    #
-    # @!macro [attach] async_thread_safety_warning
-    #   @note The method call is guaranteed to be thread safe with respect to
-    #     all other method calls against the same object that are called with
-    #     either `async` or `await`. The mutable nature of Ruby references
-    #     (and object orientation in general) prevent any other thread safety
-    #     guarantees. Do NOT mix non-protected method calls with protected
-    #     method call. Use *only* protected method calls when sharing the object
-    #     between threads.
-    #
-    # @return [Concurrent::IVar] the pending result of the asynchronous operation
-    #
-    # @raise [NameError] the object does not respond to `method` method
-    # @raise [ArgumentError] the given `args` do not match the arity of `method`
-    #
-    # @see Concurrent::IVar
-    def async
-      @__async_delegator__.value
-    end
-    # Causes the chained method call to be performed synchronously on the
-    # current thread. The method called by this method will return an
-    # `IVar` object in either the `:fulfilled` or `rejected` state and the
-    # method call will have completed. The final disposition of the
-    # method call can be obtained by inspecting the returned `IVar`.
-    #
-    # Before scheduling the method on the global thread pool a best-effort
-    # attempt will be made to validate that the method exists on the object
-    # and that the given arguments match the arity of the requested function.
-    # Due to the dynamic nature of Ruby and limitations of its reflection
-    # library, some edge cases will be missed. For more information see
-    # the documentation for the `validate_argc` method.
-    #
-    # @!macro async_thread_safety_warning
-    #
-    # @return [Concurrent::IVar] the completed result of the synchronous operation
-    #
-    # @raise [NameError] the object does not respond to `method` method
-    # @raise [ArgumentError] the given `args` do not match the arity of `method`
-    #
-    # @see Concurrent::IVar
-    def await
-      @__await_delegator__.value
-    end
-    # Set a new executor.
-    #
-    # @raise [ArgumentError] executor has already been set.
-    def executor=(executor)
-      @__async_executor__.reconfigure { executor } or
-        raise ArgumentError.new('executor has already been set')
-    end
-    # Initialize the internal serializer and other stnchronization mechanisms.
-    #
-    # @note This method *must* be called immediately upon object construction.
-    #   This is the only way thread-safe initialization can be guaranteed.
-    #
-    # @raise [Concurrent::InitializationError] when called more than once
-    #
-    # @!visibility private
-    # @deprecated
-    def init_mutex
-      deprecated 'mutex synchronization now happens automatically'
-      init_synchronization
-    rescue InitializationError
-      # suppress
-    end
-    private
-    # Initialize the internal serializer and other stnchronization mechanisms.
-    #
-    # @note This method *must* be called immediately upon object construction.
-    #   This is the only way thread-safe initialization can be guaranteed.
-    #
-    # @raise [Concurrent::InitializationError] when called more than once
-    #
-    # @!visibility private
-    def init_synchronization
-      return self if @__async_initialized__
-      @__async_initialized__ = true
-      serializer = Concurrent::SerializedExecution.new
-      @__async_executor__ = Delay.new {
-        Concurrent.global_io_executor
-      }
-      @__await_delegator__ = Delay.new {
-        AsyncDelegator.new(self, Delay.new{ Concurrent::ImmediateExecutor.new }, serializer, true)
-      }
-      @__async_delegator__ = Delay.new {
-        AsyncDelegator.new(self, @__async_executor__, serializer, false)
-      }
-      self
-    end
-  end
-end