logstash-codec-json 2.0.2 → 2.0.3

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

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

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

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

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