Released v1.0.1

Author: jdantonio

CHANGELOG.md

@@ -1,4 +1,17 @@
-## Current Release v1.0.0 (13 November 2015)
+## Current Release v1.0.1 (27 February 2016)
+
+* Fix "uninitialized constant Concurrent::ReentrantReadWriteLock" error.
+* Better handling of `autoload` vs. `require`.
+* Improved API for Edge `Future` zipping.
+* Fix reference leak in Edge `Future` constructor .
+* Fix bug which prevented thread pools from surviving a `fork`.
+* Fix bug in which `TimerTask` did not correctly specify all its dependencies.
+* Improved support for JRuby+Truffle
+* Improved error messages.
+* Improved documentation.
+* Updated README and CONTRIBUTING.
+
+### Release v1.0.0 (13 November 2015)
 
 * Rename `attr_volatile_with_cas` to `attr_atomic`
 * Add `clear_each` to `LockFreeStack`

CONTRIBUTING.md

@@ -50,6 +50,18 @@ Implement your feature or bug fix.
 
 Make sure that `bundle exec rake` completes without errors.
 
+#### Follow the Guidelines
+
+There are a few very strong guidelines which we follow when adding features. Submissions which fail to follow these guidelines will likely be rejected or will require modification before acceptance.
+
+* **No downstream dependencies:** Concurrent Ruby is a foundational library used by major projects like [Rails](http://rubyonrails.org/). Our downstream dependencies become everyone's dependencies. Because we cannot guarantee that downstream projects meet our development standards, it's best for everyone if we simply aviod dependencies.
+* **Do not monkey patch Ruby:** Changing Ruby for our convenience affects every gem in every project that uses Concurrent Ruby. Monkey patching Ruby may change the behavior of other libraries in unexpected ways and destabilize projects which depend on us.
+* **Do not polute the global namespace:** Putting all our code within the `Concurrent` module guarantees that there will be no namespace collisions with other gems or the projects which depend on us.
+* **No global varaibles:** Global state should be kept to an absolute minimum. When it's necessary, add it to the global gem configuration.
+* **Minimize per-object configuration:** Ruby makes programmers happy. One of Ruby's charms is its simplicity. Concurrent Ruby aims to mirror this simplicity. Advanced configuration options are encouraged when they provide value, but every abstraction should have reasonable defaults that meet the needs of most users.
+* **Provide explicit behavior and guarantees:** Our APIs should be concrete and clearly define what they do (and don't do). Users of Concurrent Ruby should never be surprised by unexpected behavior or be given guarantees we cannot keep.
+* **Eat our own dog food:** Concurrent Ruby provides a rich set of low-level (internal and public) classes which provide strong guarantees and are optimized for performance across platforms. All our high-level abstractions should make use of these tools.
+
 #### Write Documentation
 
 Document any external behavior in the [README](README.md).

README.md

@@ -45,9 +45,9 @@
 
 ### Supported Ruby versions
 
-MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
+MRI 1.9.3, 2.0 and above, JRuby 1.7x in 1.9 mode, JRuby 9000, 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 preferred for JRuby but every Java version on which JRuby 9000 runs will be supported.
+Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
 
 ## Thread Safety
 
@@ -59,14 +59,10 @@ It is critical to remember, however, that Ruby is a language of mutable referenc
 
 ## 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 a class. Loosely based on Erlang's [gen_server](http://www.erlang.org/doc/man/gen_server.html).

Rakefile

@@ -42,7 +42,13 @@ Dir.glob('tasks/**/*.rake').each do |rakefile|
 end
 
 def has_docker?
-  system("docker version > /dev/null 2>&1 || boot2docker version > /dev/null 2>&1")
+  if Concurrent.on_linux?
+    system("docker version > /dev/null 2>&1")
+  elsif Concurrent.on_osx?
+    system("docker version > /dev/null 2>&1 || boot2docker version > /dev/null 2>&1")
+  else
+    false
+  end
 end
 
 if Concurrent.on_jruby?

lib/concurrent/map.rb

@@ -41,8 +41,43 @@ module Collection
   # > require 'concurrent'
   # >
   # > map = Concurrent::Map.new
-
   class Map < Collection::MapImplementation
+
+    # @!macro [new] map_method_is_atomic
+    #   This method is atomic. Atomic methods of `Map` which accept a block
+    #   do not allow the `self` instance to be used within the block. Doing
+    #   so will cause a deadlock.
+
+    # @!method put_if_absent
+    #   @!macro map_method_is_atomic
+
+    # @!method compute_if_absent
+    #   @!macro map_method_is_atomic
+
+    # @!method compute_if_present
+    #   @!macro map_method_is_atomic
+
+    # @!method compute
+    #   @!macro map_method_is_atomic
+
+    # @!method merge_pair
+    #   @!macro map_method_is_atomic
+
+    # @!method replace_pair
+    #   @!macro map_method_is_atomic
+
+    # @!method replace_if_exists
+    #   @!macro map_method_is_atomic
+
+    # @!method get_and_set
+    #   @!macro map_method_is_atomic
+
+    # @!method delete
+    #   @!macro map_method_is_atomic
+
+    # @!method delete_pair
+    #   @!macro map_method_is_atomic
+
     def initialize(options = nil, &block)
       if options.kind_of?(::Hash)
         validate_options_hash!(options)
@@ -71,6 +106,15 @@ def [](key)
     alias_method :get, :[]
     alias_method :put, :[]=
 
+    # @!macro [attach] map_method_not_atomic
+    #   The "fetch-then-act" methods of `Map` are not atomic. `Map` is intended
+    #   to be use as a concurrency primitive with strong happens-before
+    #   guarantees. It is not intended to be used as a high-level abstraction
+    #   supporting complex operations. All read and write operations are
+    #   thread safe, but no guarantees are made regarding race conditions
+    #   between the fetch operation and yielding to the block. Additionally,
+    #   this method does not support recursion. This is due to internal
+    #   constraints that are very unlikely to change in the near future.
     def fetch(key, default_value = NULL)
       if NULL != (value = get_or_default(key, NULL))
         value
@@ -83,12 +127,14 @@ def fetch(key, default_value = NULL)
       end
     end
 
+    # @!macro map_method_not_atomic
     def fetch_or_store(key, default_value = NULL)
       fetch(key) do
         put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
       end
     end
 
+    # @!macro map_method_is_atomic
     def put_if_absent(key, value)
       computed = false
       result = compute_if_absent(key) do

lib/concurrent/utility/engine.rb

@@ -27,6 +27,14 @@ def on_windows?
         !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
       end
 
+      def on_osx?
+        !(RbConfig::CONFIG['host_os'] =~ /darwin|mac os/).nil?
+      end
+
+      def on_linux?
+        !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
+      end
+
       def ruby_engine
         defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
       end

lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '1.0.0'
-  EDGE_VERSION = '0.2.0'
+  VERSION      = '1.0.1'
+  EDGE_VERSION = '0.2.1'
 end