concurrent-ruby 0.7.2-java → 0.8.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a22905c0d896596f7b3247122687f19e6f6967eb
+  data.tar.gz: 0c7b8b282b51f1a71c37df90da8eeb3aa7b614a9
+SHA512:
+  metadata.gz: 63abed1c068d3c25930a6a60637d4ad5dc40121f091440850ab03214a7cf8e13fee800fc258a0ce93482462134728884081f88a013656778a8344255f8ceb048
+  data.tar.gz: 05670a25a6e3e6cd9c091e4b50ff13f506723383abb5e263039b4e90c01b2a392d2b2651179ae90f39f55b6e4b1538e65a5ffa606385e9c7d9491e627e9a5c63

data/CHANGELOG.md

@@ -1,4 +1,11 @@
-### Next Release v0.7.2 (24 January 2015)
+### Next Release v0.8.0 (25 January 2015)
+
+* C extension for MRI have been extracted into the `concurrent-ruby-ext` companion gem.
+  Please see the README for more detail.
+* Better variable isolation in `Promise` and `Future` via an `:args` option
+* Continued to update intermittently failing tests
+
+## Current Release v0.7.2 (24 January 2015)
 
 * New `Semaphore` class based on [java.util.concurrent.Semaphore](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html)
 * New `Promise.all?` and `Promise.any?` class methods
@@ -15,7 +22,7 @@
 * Tests now run on new Travis build environment
 * Multiple documentation updates
 
-## Current Release v0.7.1 (4 December 2014)
+### Release v0.7.1 (4 December 2014)
 
 Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/issues/142) for more information on the next planned release.
 

data/README.md

@@ -37,10 +37,8 @@
 
 ### Supported Ruby versions
 
-MRI 1.9.3, 2.0, 2.1, JRuby (1.9 mode), and Rubinius 2.x are supported.
-Although native code is used for performance optimizations on some platforms, all functionality
-is available in pure Ruby. This gem should be fully compatible with any interpreter that is
-compliant with Ruby 1.9.3 or newer.
+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.
 
 ## Features & Documentation
 
@@ -62,6 +60,7 @@ This library contains a variety of concurrency abstractions at high and low leve
 * [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. 
+* [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html): Communicating Sequential Processes (CSP). 
 
 ### Java-inspired ThreadPools and other executors
 
@@ -98,28 +97,45 @@ Lower-level abstractions mainly used as building blocks.
 * [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)
 
-## Installing and Building
+## Usage
 
-This gem includes several platform-specific optimizations. To reduce the possibility of
-compilation errors, we provide pre-compiled gem packages for several platforms as well
-as a pure-Ruby build. Installing the gem should be no different than installing any other
-Rubygems-hosted gem. Rubygems will automatically detect your platform and install the
-appropriate pre-compiled build. You should never see Rubygems attempt to compile the gem
-on installation. Additionally, to ensure compatability with the largest possible number
-of Ruby interpreters, the C extensions will *never* load under any Ruby other than MRI,
-even when installed.
+All abstractions within this gem can be loaded simply by requiring it:
 
-The following gem builds will be built at every release:
+```ruby
+require 'concurrent'
+```
+
+To reduce the amount of code loaded at runtime, subsets of this gem can be required:
 
-* concurrent-ruby-x.y.z.gem (pure Ruby)
-* concurrent-ruby-x.y.z-java.gem (JRuby)
-* concurrent-ruby-x.y.z-x86-linux.gem (Linux 32-bit)
-* concurrent-ruby-x.y.z-x86_64-linux.gem (Linux 64-bit)
-* concurrent-ruby-x.y.z-x86-mingw32.gem (Windows 32-bit)
-* concurrent-ruby-x.y.z-x64-mingw32.gem (Windows 64-bit)
-* concurrent-ruby-x.y.z-x86-solaris-2.11.gem (Solaris)
+```ruby
+require 'concurrent'                # everything
+
+# groups
+
+require 'concurrent/actor'          # Concurrent::Actor and supporting code
+require 'concurrent/atomics'        # atomic and thread synchronization classes
+require 'concurrent/channels'       # Concurrent::Channel and supporting code
+require 'concurrent/executors'      # Thread pools and other executors
+require 'concurrent/utilities'      # utility methods such as processor count and timers
+
+# individual abstractions
+
+require 'concurrent/agent'          # Concurrent::Agent
+require 'concurrent/async'          # Concurrent::Async
+require 'concurrent/atomic'         # Concurrent::Atomic (formerly the `atomic` gem)
+require 'concurrent/dataflow'       # Concurrent::dataflow
+require 'concurrent/delay'          # Concurrent::Delay
+require 'concurrent/exchanger'      # Concurrent::Exchanger
+require 'concurrent/future'         # Concurrent::Future
+require 'concurrent/ivar'           # Concurrent::IVar
+require 'concurrent/mvar'           # Concurrent::MVar
+require 'concurrent/promise'        # Concurrent::Promise
+require 'concurrent/scheduled_task' # Concurrent::ScheduledTask
+require 'concurrent/timer_task'     # Concurrent::TimerTask
+require 'concurrent/tvar'           # Concurrent::TVar
+```
 
-### Installing
+## Installation
 
 ```shell
 gem install concurrent-ruby
@@ -133,31 +149,64 @@ gem 'concurrent-ruby'
 
 and run `bundle install` from your shell.
 
-### Building
+### C Extensions for MRI
 
-Because we provide pre-compiled gem builds, users should never need to build the gem manually.
-The build process for this gem is completely automated using open source tools. All of
-the automation components are available in the [ruby-concurrency/rake-compiler-dev-box](https://github.com/ruby-concurrency/rake-compiler-dev-box)
-GitHub repository.
+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. The extension gem lists `concurrent-ruby` as a dependency so it is not necessary to install both.
+Simply install the extension gen:
 
-This gem will compile native C code under MRI and native Java code under JRuby. It is
-also possible to build a pure-Ruby version. All builds have identical functionality.
-The only difference is performance. Additionally, pure-Ruby classes are always available,
-even when using the native optimizations. Please see the [documentation](http://ruby-concurrency.github.io/concurrent-ruby/)
-for more details.
+```ruby
+gem install concurrent-ruby-ext
+```
 
-To build and package the gem using MRI or JRuby, install the necessary build dependencies and run:
+or add the following line to Gemfile:
 
-```shell
-bundle exec rake compile
-bundle exec rake build
+```ruby
+gem 'concurrent-ruby-ext'
+```
+
+and run `bundle install` from your shell.
+
+In code it is only necessary to
+
+```ruby
+require 'concurrent'
 ```
 
-To build and package a pure-Ruby gem, on *any* platform and interpreter
-(including MRI and JRuby), run:
+The `concurrent-ruby` gem will automatically detect the presence of the `concurrent-ruby-ext` gem
+and load the appropriate C extensions.
 
-```shell
-BUILD_PURE_RUBY='true' bundle exec rake build
+#### 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*
+rake build:native       # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg directory
+rake compile:extension  # Compile extension
+
+*JRuby only*
+rake build              # Build JRuby-specific core gem (alias for `build:core`)
+rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory
+
+*All except JRuby*
+rake build              # Build core and extension gems
+rake build:core         # Build concurrent-ruby-<version>.gem into the pkg directory
+rake build:ext          # Build concurrent-ruby-ext-<version>.gem into the pkg directory
+
+*All*
+rake clean              # Remove any temporary products
+rake clobber            # Remove any generated file
+rake compile            # Compile all the extensions
 ```
 
 ## Maintainers
@@ -167,6 +216,7 @@ BUILD_PURE_RUBY='true' bundle exec rake build
 * [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
 

data/lib/concurrent/atomic.rb

@@ -12,6 +12,7 @@ RUBY
 end
 #####################################################################
 
+require_relative '../extension_helper'
 require 'concurrent/atomic_reference/concurrent_update_error'
 require 'concurrent/atomic_reference/mutex_atomic'
 
@@ -77,7 +78,7 @@ elsif defined? Concurrent::RbxAtomic
   class Concurrent::Atomic < Concurrent::RbxAtomic
   end
 
-elsif Concurrent.allow_c_native_class?('CAtomic')
+elsif defined? Concurrent::CAtomic
 
   # @!macro atomic_reference
   class Concurrent::Atomic < Concurrent::CAtomic

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,5 +1,4 @@
 require_relative '../../extension_helper'
-Concurrent.safe_require_c_extensions
 
 module Concurrent
 
@@ -162,7 +161,7 @@ module Concurrent
     class AtomicBoolean < JavaAtomicBoolean
     end
 
-  elsif Concurrent.allow_c_native_class?('CAtomicBoolean')
+  elsif defined?(CAtomicBoolean)
 
     # @!macro atomic_boolean
     class CAtomicBoolean

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,5 +1,4 @@
 require_relative '../../extension_helper'
-Concurrent.safe_require_c_extensions
 
 module Concurrent
 
@@ -166,7 +165,7 @@ module Concurrent
     class AtomicFixnum < JavaAtomicFixnum
     end
 
-  elsif Concurrent.allow_c_native_class?('CAtomicFixnum')
+  elsif defined?(CAtomicFixnum)
 
     # @!macro atomic_fixnum
     class CAtomicFixnum

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,5 +1,4 @@
 require_relative '../../extension_helper'
-Concurrent.safe_require_java_extensions
 
 if defined?(Concurrent::JavaAtomic)
   require 'concurrent/atomic_reference/direct_update'

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,37 +1,29 @@
-require_relative '../../extension_helper'
+if defined? Concurrent::CAtomic
+  require_relative '../../extension_helper'
+  require 'concurrent/atomic_reference/direct_update'
+  require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
-if Concurrent.allow_c_extensions?
-  begin
-    require 'concurrent_ruby_ext'
-  rescue LoadError
-    # may be a Windows cross-compiled native gem
-    require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
-  end
-end
-
-require 'concurrent/atomic_reference/direct_update'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-module Concurrent
+  module Concurrent
 
-  # @!macro atomic_reference
-  class CAtomic
-    include Concurrent::AtomicDirectUpdate
-    include Concurrent::AtomicNumericCompareAndSetWrapper
+    # @!macro atomic_reference
+    class CAtomic
+      include Concurrent::AtomicDirectUpdate
+      include Concurrent::AtomicNumericCompareAndSetWrapper
 
-    # @!method initialize
-    #   @!macro atomic_reference_method_initialize
+      # @!method initialize
+      #   @!macro atomic_reference_method_initialize
 
-    # @!method get
-    #   @!macro atomic_reference_method_get
+      # @!method get
+      #   @!macro atomic_reference_method_get
 
-    # @!method set
-    #   @!macro atomic_reference_method_set
+      # @!method set
+      #   @!macro atomic_reference_method_set
 
-    # @!method get_and_set
-    #   @!macro atomic_reference_method_get_and_set
+      # @!method get_and_set
+      #   @!macro atomic_reference_method_get_and_set
 
-    # @!method _compare_and_set
-    #   @!macro atomic_reference_method_compare_and_set
+      # @!method _compare_and_set
+      #   @!macro atomic_reference_method_compare_and_set
+    end
   end
 end

data/lib/concurrent/future.rb

@@ -23,6 +23,8 @@ module Concurrent
     #   global task pool (for short-running tasks)
     # @option opts [object] :executor when provided will run all operations on
     #   this executor rather than the global thread pool (overrides :operation)
+    # @option opts [object, Array] :args zero or more arguments to be passed the task block on execution
+    #
     # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
     # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
@@ -35,6 +37,7 @@ module Concurrent
       @state = :unscheduled
       @task = block
       @executor = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_operation_pool
+      @args = OptionsParser::get_arguments_from(opts)
     end
 
     # Execute an `:unscheduled` `Future`. Immediately sets the state to `:pending` and
@@ -52,11 +55,9 @@ module Concurrent
     # @example Instance and execute in one line
     #   future = Concurrent::Future.new{ sleep(1); 42 }.execute
     #   future.state #=> :pending
-    #
-    # @since 0.5.0
     def execute
       if compare_and_set_state(:pending, :unscheduled)
-        @executor.post{ work }
+        @executor.post(@args){ work }
         self
       end
     end
@@ -72,6 +73,8 @@ module Concurrent
     #   global task pool (for short-running tasks)
     # @option opts [object] :executor when provided will run all operations on
     #   this executor rather than the global thread pool (overrides :operation)
+    # @option opts [object, Array] :args zero or more arguments to be passed the task block on execution
+    #
     # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
     # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
@@ -84,8 +87,6 @@ module Concurrent
     # @example
     #   future = Concurrent::Future.execute{ sleep(1); 42 }
     #   future.state #=> :pending
-    #
-    # @since 0.5.0
     def self.execute(opts = {}, &block)
       Future.new(opts, &block).execute
     end
@@ -96,7 +97,7 @@ module Concurrent
 
     # @!visibility private
     def work # :nodoc:
-      success, val, reason = SafeTaskExecutor.new(@task).execute
+      success, val, reason = SafeTaskExecutor.new(@task).execute(*@args)
       complete(success, val, reason)
     end
   end

data/lib/concurrent/options_parser.rb

@@ -23,6 +23,10 @@ module Concurrent
       end
     end
 
+    def get_arguments_from(opts = {})
+      [*opts.fetch(:args, [])]
+    end
+
     # Get the requested `Executor` based on the values set in the options hash.
     #
     # @param [Hash] opts the options defining the requested executor

data/lib/concurrent/promise.rb

@@ -172,22 +172,25 @@ module Concurrent
 
     # Initialize a new Promise with the provided options.
     #
-    # @param [Hash] opts the options used to define the behavior at update and deref
+    # @!macro [attach] promise_init_options
     #
-    # @option opts [Promise] :parent the parent `Promise` when building a chain/tree
-    # @option opts [Proc] :on_fulfill fulfillment handler
-    # @option opts [Proc] :on_reject rejection handler
+    #   @param [Hash] opts the options used to define the behavior at update and deref
     #
-    # @option opts [Boolean] :operation (false) when `true` will execute the future on the global
-    #   operation pool (for long-running operations), when `false` will execute the future on the
-    #   global task pool (for short-running tasks)
-    # @option opts [object] :executor when provided will run all operations on
-    #   this executor rather than the global thread pool (overrides :operation)
+    #   @option opts [Promise] :parent the parent `Promise` when building a chain/tree
+    #   @option opts [Proc] :on_fulfill fulfillment handler
+    #   @option opts [Proc] :on_reject rejection handler
     #
-    # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
-    # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
-    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
-    #   returning the value returned from the proc
+    #   @option opts [Boolean] :operation (false) when `true` will execute the future on the global
+    #     operation pool (for long-running operations), when `false` will execute the future on the
+    #     global task pool (for short-running tasks)
+    #   @option opts [object] :executor when provided will run all operations on
+    #     this executor rather than the global thread pool (overrides :operation)
+    #   @option opts [object, Array] :args zero or more arguments to be passed the task block on execution
+    #
+    #   @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
+    #   @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
+    #   @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
+    #     returning the value returned from the proc
     #
     # @see http://wiki.commonjs.org/wiki/Promises/A
     # @see http://promises-aplus.github.io/promises-spec/
@@ -195,6 +198,8 @@ module Concurrent
       opts.delete_if { |k, v| v.nil? }
 
       @executor = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_operation_pool
+      @args = OptionsParser::get_arguments_from(opts)
+
       @parent = opts.fetch(:parent) { nil }
       @on_fulfill = opts.fetch(:on_fulfill) { Proc.new { |result| result } }
       @on_reject = opts.fetch(:on_reject) { Proc.new { |reason| raise reason } }
@@ -219,7 +224,6 @@ module Concurrent
     end
 
     # @return [Promise]
-    # @since 0.5.0
     def execute
       if root?
         if compare_and_set_state(:pending, :unscheduled)
@@ -232,7 +236,18 @@ module Concurrent
       self
     end
 
-    # @since 0.5.0
+    # Create a new `Promise` object with the given block, execute it, and return the
+    # `:pending` object.
+    #
+    # @!macro promise_init_options
+    #
+    # @return [Promise] the newly created `Promise` in the `:pending` state
+    #
+    # @raise [ArgumentError] if no block is given
+    #
+    # @example
+    #   promise = Concurrent::Promise.execute{ sleep(1); 42 }
+    #   promise.state #=> :pending
     def self.execute(opts = {}, &block)
       new(opts, &block).execute
     end
@@ -389,6 +404,7 @@ module Concurrent
       composite
     end
 
+    # @!visibility private
     def set_pending
       mutex.synchronize do
         @state = :pending
@@ -413,6 +429,7 @@ module Concurrent
       nil
     end
 
+    # @!visibility private
     def notify_child(child)
       if_state(:fulfilled) { child.on_fulfill(apply_deref_options(@value)) }
       if_state(:rejected) { child.on_reject(@reason) }
@@ -421,7 +438,7 @@ module Concurrent
     # @!visibility private
     def realize(task)
       @executor.post do
-        success, value, reason = SafeTaskExecutor.new(task).execute
+        success, value, reason = SafeTaskExecutor.new(task).execute(*@args)
 
         children_to_notify = mutex.synchronize do
           set_state!(success, value, reason)
@@ -432,11 +449,13 @@ module Concurrent
       end
     end
 
+    # @!visibility private
     def set_state!(success, value, reason)
       set_state(success, value, reason)
       event.set
     end
 
+    # @!visibility private
     def synchronized_set_state!(success, value, reason)
       mutex.lock
       set_state!(success, value, reason)

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end

data/lib/extension_helper.rb

@@ -1,28 +1,37 @@
 module Concurrent
 
+  @@c_ext_loaded ||= false
+  @@java_ext_loaded ||= false
+
   # @!visibility private
   def self.allow_c_extensions?
     defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
   end
 
   # @!visibility private
-  def self.allow_c_native_class?(clazz)
-    allow_c_extensions? && Concurrent.const_defined?(clazz)
-  rescue
-    false
+  def self.jruby?
+    RUBY_PLATFORM == 'java'
   end
 
-  # @!visibility private
-  def self.safe_require_c_extensions
-    require 'concurrent_ruby_ext' if allow_c_extensions?
-  rescue LoadError
-    #warn 'Attempted to load C extensions on unsupported platform. Continuing with pure-Ruby.'
-  end
-
-  # @!visibility private
-  def self.safe_require_java_extensions
-    require 'concurrent_ruby_ext' if RUBY_PLATFORM == 'java'
-  rescue LoadError
-    #warn 'Attempted to load Java extensions on unsupported platform. Continuing with pure-Ruby.'
+  if allow_c_extensions? && !@@c_ext_loaded
+    begin
+      require 'concurrent/extension'
+      @@c_ext_loaded = true
+    rescue LoadError
+      # may be a Windows cross-compiled native gem
+      begin
+        require "concurrent/#{RUBY_VERSION[0..2]}/extension"
+        @@c_ext_loaded = true
+      rescue LoadError
+        warn 'Performance on MRI may be improved with the concurrent-ruby-ext gem. Please see http://concurrent-ruby.com'
+      end
+    end
+  elsif jruby? && !@@java_ext_loaded
+    begin
+      require 'concurrent_ruby_ext'
+      @@java_ext_loaded = true
+    rescue LoadError
+      warn 'Performance on JRuby may be improved by installing the pre-compiled Java extensions. Please see http://concurrent-ruby.com'
+    end
   end
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.2
-  prerelease:
+  version: 0.8.0
 platform: java
 authors:
 - Jerry D'Antonio
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-01-24 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -22,51 +21,12 @@ extra_rdoc_files:
 - LICENSE.txt
 - CHANGELOG.md
 files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
 - lib/concurrent.rb
-- lib/concurrent_ruby.rb
-- lib/concurrent_ruby_ext.so
-- lib/extension_helper.rb
 - lib/concurrent/actor.rb
-- lib/concurrent/actress.rb
-- lib/concurrent/agent.rb
-- lib/concurrent/async.rb
-- lib/concurrent/atomic.rb
-- lib/concurrent/atomics.rb
-- lib/concurrent/channels.rb
-- lib/concurrent/collections.rb
-- lib/concurrent/configuration.rb
-- lib/concurrent/dataflow.rb
-- lib/concurrent/delay.rb
-- lib/concurrent/dereferenceable.rb
-- lib/concurrent/errors.rb
-- lib/concurrent/exchanger.rb
-- lib/concurrent/executors.rb
-- lib/concurrent/future.rb
-- lib/concurrent/ivar.rb
-- lib/concurrent/lazy_register.rb
-- lib/concurrent/logging.rb
-- lib/concurrent/mvar.rb
-- lib/concurrent/obligation.rb
-- lib/concurrent/observable.rb
-- lib/concurrent/options_parser.rb
-- lib/concurrent/promise.rb
-- lib/concurrent/scheduled_task.rb
-- lib/concurrent/timer_task.rb
-- lib/concurrent/tvar.rb
-- lib/concurrent/utilities.rb
-- lib/concurrent/version.rb
 - lib/concurrent/actor/behaviour.rb
-- lib/concurrent/actor/context.rb
-- lib/concurrent/actor/core.rb
-- lib/concurrent/actor/default_dead_letter_handler.rb
-- lib/concurrent/actor/envelope.rb
-- lib/concurrent/actor/errors.rb
-- lib/concurrent/actor/internal_delegations.rb
-- lib/concurrent/actor/public_delegations.rb
-- lib/concurrent/actor/reference.rb
-- lib/concurrent/actor/root.rb
-- lib/concurrent/actor/type_check.rb
-- lib/concurrent/actor/utils.rb
 - lib/concurrent/actor/behaviour/abstract.rb
 - lib/concurrent/actor/behaviour/awaits.rb
 - lib/concurrent/actor/behaviour/buffer.rb
@@ -80,10 +40,25 @@ files:
 - lib/concurrent/actor/behaviour/supervising.rb
 - lib/concurrent/actor/behaviour/terminates_children.rb
 - lib/concurrent/actor/behaviour/termination.rb
+- lib/concurrent/actor/context.rb
+- lib/concurrent/actor/core.rb
+- lib/concurrent/actor/default_dead_letter_handler.rb
+- lib/concurrent/actor/envelope.rb
+- lib/concurrent/actor/errors.rb
+- lib/concurrent/actor/internal_delegations.rb
+- lib/concurrent/actor/public_delegations.rb
+- lib/concurrent/actor/reference.rb
+- lib/concurrent/actor/root.rb
+- lib/concurrent/actor/type_check.rb
+- lib/concurrent/actor/utils.rb
 - lib/concurrent/actor/utils/ad_hoc.rb
 - lib/concurrent/actor/utils/balancer.rb
 - lib/concurrent/actor/utils/broadcast.rb
 - lib/concurrent/actor/utils/pool.rb
+- lib/concurrent/actress.rb
+- lib/concurrent/agent.rb
+- lib/concurrent/async.rb
+- lib/concurrent/atomic.rb
 - lib/concurrent/atomic/atomic_boolean.rb
 - lib/concurrent/atomic/atomic_fixnum.rb
 - lib/concurrent/atomic/condition.rb
@@ -102,13 +77,22 @@ files:
 - lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
 - lib/concurrent/atomic_reference/rbx.rb
 - lib/concurrent/atomic_reference/ruby.rb
+- lib/concurrent/atomics.rb
 - lib/concurrent/channel/buffered_channel.rb
 - lib/concurrent/channel/channel.rb
 - lib/concurrent/channel/unbuffered_channel.rb
 - lib/concurrent/channel/waitable_list.rb
+- lib/concurrent/channels.rb
 - lib/concurrent/collection/blocking_ring_buffer.rb
 - lib/concurrent/collection/priority_queue.rb
 - lib/concurrent/collection/ring_buffer.rb
+- lib/concurrent/collections.rb
+- lib/concurrent/configuration.rb
+- lib/concurrent/dataflow.rb
+- lib/concurrent/delay.rb
+- lib/concurrent/dereferenceable.rb
+- lib/concurrent/errors.rb
+- lib/concurrent/exchanger.rb
 - lib/concurrent/executor/cached_thread_pool.rb
 - lib/concurrent/executor/executor.rb
 - lib/concurrent/executor/fixed_thread_pool.rb
@@ -129,16 +113,31 @@ files:
 - lib/concurrent/executor/single_thread_executor.rb
 - lib/concurrent/executor/thread_pool_executor.rb
 - lib/concurrent/executor/timer_set.rb
+- lib/concurrent/executors.rb
+- lib/concurrent/future.rb
+- lib/concurrent/ivar.rb
+- lib/concurrent/lazy_register.rb
+- lib/concurrent/logging.rb
+- lib/concurrent/mvar.rb
+- lib/concurrent/obligation.rb
+- lib/concurrent/observable.rb
+- lib/concurrent/options_parser.rb
+- lib/concurrent/promise.rb
+- lib/concurrent/scheduled_task.rb
+- lib/concurrent/timer_task.rb
+- lib/concurrent/tvar.rb
+- lib/concurrent/utilities.rb
 - lib/concurrent/utility/processor_count.rb
 - lib/concurrent/utility/timeout.rb
 - lib/concurrent/utility/timer.rb
-- README.md
-- LICENSE.txt
-- CHANGELOG.md
+- lib/concurrent/version.rb
+- lib/concurrent_ruby.rb
 - lib/concurrent_ruby_ext.jar
+- lib/extension_helper.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
 - MIT
+metadata: {}
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -148,20 +147,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      hash: 2
-      segments:
-      - 0
-  none: false
 requirements: []
 rubyforge_project:
-rubygems_version: 1.8.25
+rubygems_version: 2.4.5
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell, F#, C#, Java, and classic concurrency patterns.
 test_files: []