concurrent-ruby 1.1.0.pre2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9eff851dc1c1194d74471f51e804151e6523be1af22c681393518897d8723e7
-  data.tar.gz: 97aea57e3c31de3e0a927b07b5bbae7a5b2859537fe959f08d045fadc86d818a
+  metadata.gz: 8d042c846e692138ba0eea6efbabb53794abbaae207477dc5e549abac9fab266
+  data.tar.gz: 34678c0ec6d519d5beac0b12a8c6116d4eb1ff29dd620ba03df851d086b04adc
 SHA512:
-  metadata.gz: ee74332b245d576afd75179edf7d37e2d815e0f24afe157e9b76189c7275e60a8edc348646d659c5d631e73fa5382a57a94ec82c6b4bb909a993f86b45677192
-  data.tar.gz: d21e2f11e2c3f9090cbb4e7dada48cd64d3eb3a9c7588417b6e52975ebe0a0f8fafc612695c46cd58f94389c7597800c038a57f89fa70db936493b007890d1e7
+  metadata.gz: 9b75559855ce216316a81bb68a9fcb1e74dceed4baa8e816d2e02cd12af50745e88f9afba7470681a8f47297a297fe9fd79e82ace4b5f63410197469eab45523
+  data.tar.gz: 79e63eb2ef9ab15e9fd5d1d777ae027e68b399ec885d85bc8156f9edad741ecf4eb20fc063357068018ef932c18e7263466ef64cee7592bf50b39433e83b94a7

data/CHANGELOG.md

@@ -1,9 +1,30 @@
 ## Current
 
+## Release v1.1.1, edge v0.4.1 (1 Nov 2018)
+
+* (#768) add support for 1.9.3 back 
+
+## Release v1.1.0, edge v0.4.0 (31 OCt 2018) (yanked)
+
+* (#768) yanked because of issues with removed 1.9.3 support 
+
+## Release v1.1.0.pre2, edge v0.4.0.pre2 (18 Sep 2018)
+
+concurrent-ruby:
+
+* fixed documentation and README links
+* fix Set for TruffleRuby and Rubinius
+* use properly supported TruffleRuby APIs
+
+concurrent-ruby-edge:
+
+* add Promises.zip_futures_over_on
+
 ## Release v1.1.0.pre1, edge v0.4.0.pre1 (15 Aug 2018)
 
 concurrent-ruby:
 
+* requires at least Ruby 2.0
 * [Promises](http://ruby-concurrency.github.io/concurrent-ruby/1.1.0/Concurrent/Promises.html)
   are moved from `concurrent-ruby-edge` to `concurrent-ruby`
 * Add support for TruffleRuby

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-require_relative 'lib/concurrent/version'
+require File.join(File.dirname(__FILE__ ), 'lib/concurrent/version')
 
 no_path = ENV['NO_PATH']
 options = no_path ? {} : { path: '.' }
@@ -19,7 +19,7 @@ end
 group :documentation, optional: true do
   gem 'yard', '~> 0.9.0', :require => false
   gem 'redcarpet', '~> 3.0', platforms: :mri # understands github markdown
-  gem 'md-ruby-eval', '~> 0.2'
+  gem 'md-ruby-eval', '~> 0.3'
 end
 
 group :testing do

data/README.md

@@ -227,8 +227,12 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 
 ## Supported Ruby versions
 
-MRI 2.0 and above, JRuby 9000, TruffleRuby are supported. 
-This gem should be fully compatible with any interpreter that is compliant with Ruby 2.0 or newer.
+* MRI 2.0 and above
+* JRuby 9000
+* TruffleRuby are supported.
+* Any Ruby interpreter that is compliant with Ruby 2.0 or newer.
+
+Actually we still support mri 1.9.3 and jruby 1.7.27 but we are looking at ways how to drop the support.
 Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
 
 The legacy support for Rubinius is kept but it is no longer maintained, if you would like to help 

data/Rakefile

@@ -2,6 +2,7 @@
 
 require_relative 'lib/concurrent/version'
 require_relative 'lib/concurrent/utility/engine'
+require_relative 'lib/concurrent/utility/193'
 
 core_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby.gemspec')
 ext_gemspec  = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-ext.gemspec')
@@ -9,7 +10,29 @@ edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.
 
 require 'rake/javaextensiontask'
 
-Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
+JRUBY_JAR_PATH = '/usr/local/opt/rbenv/versions/jruby-9.1.17.0/lib/jruby.jar'
+
+class ConcurrentRubyJavaExtensionTask < Rake::JavaExtensionTask
+  def java_classpath_arg(*args)
+    jruby_cpath = nil
+    if RUBY_PLATFORM =~ /java/
+      begin
+        cpath       = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
+        cpath       += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
+        jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
+      rescue => e
+      end
+    end
+    unless jruby_cpath
+      jruby_cpath = JRUBY_JAR_PATH
+      raise "#{jruby_cpath} does not exist" unless File.exist? jruby_cpath
+    end
+    jruby_cpath += File::PATH_SEPARATOR + args.join(File::PATH_SEPARATOR) unless args.empty?
+    jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
+  end
+end
+
+ConcurrentRubyJavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
   ext.ext_dir = 'ext/concurrent-ruby'
   ext.lib_dir = 'lib/concurrent'
 end
@@ -70,9 +93,9 @@ begin
     desc '* test packaged and installed gems instead of local files'
     task :installed do
       Dir.chdir(__dir__) do
-        sh 'gem install pkg/concurrent-ruby-1.1.0.pre1.gem'
-        sh 'gem install pkg/concurrent-ruby-ext-1.1.0.pre1.gem' if Concurrent.on_cruby?
-        sh 'gem install pkg/concurrent-ruby-edge-0.4.0.pre1.gem'
+        sh "gem install pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
+        sh "gem install pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if Concurrent.on_cruby?
+        sh "gem install pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem"
         ENV['NO_PATH'] = 'true'
         sh 'bundle update'
         sh 'bundle exec rake spec:ci'
@@ -132,6 +155,7 @@ begin
             "{Concurrent::#{$1} #{$1}}"
           end
         end
+        FileUtils.mkpath 'tmp'
         File.write 'tmp/README.md', content
       end
     end
@@ -199,18 +223,29 @@ namespace :release do
   # Depends on environment of @pitr-ch
 
   mri_version   = '2.5.1'
-  jruby_version = 'jruby-9.1.17.0'
+  jruby_version = 'jruby-9.1.17.1'
 
   task :checks => "yard:#{current_yard_version_name}:uptodate" do
     Dir.chdir(__dir__) do
-      begin
-        STDOUT.puts "Is this a final release build? (Do git checks?) (y/n)"
-        input = STDIN.gets.strip.downcase
-      end until %w(y n).include?(input)
-      if input == 'y'
-        sh 'test -z "$(git status --porcelain)"'
-        sh 'git fetch'
-        sh 'test $(git show-ref --verify --hash refs/heads/master) = $(git show-ref --verify --hash refs/remotes/github/master)'
+      sh 'test -z "$(git status --porcelain)"' do |ok, res|
+        unless ok
+          begin
+            STDOUT.puts 'Command failed. Continue? (y/n)'
+            input = STDIN.gets.strip.downcase
+          end until %w(y n).include?(input)
+          exit 1 if input == 'n'
+        end
+      end
+      sh 'git fetch'
+      sh 'test $(git show-ref --verify --hash refs/heads/master) = ' +
+             '$(git show-ref --verify --hash refs/remotes/origin/master)' do |ok, res|
+        unless ok
+          begin
+            STDOUT.puts 'Command failed. Continue? (y/n)'
+            input = STDIN.gets.strip.downcase
+          end until %w(y n).include?(input)
+          exit 1 if input == 'n'
+        end
       end
     end
   end
@@ -243,10 +278,10 @@ namespace :release do
   namespace :publish do
     task :ask do
       begin
-        STDOUT.puts "Do you want to publish? (y/n)"
+        STDOUT.puts 'Do you want to publish? (y/n)'
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
-      raise 'reconsidered' if input == 'n'
+      exit 1 if input == 'n'
     end
 
     desc '** tag HEAD with current version and push to github'
@@ -254,7 +289,7 @@ namespace :release do
       Dir.chdir(__dir__) do
         sh "git tag v#{Concurrent::VERSION}"
         sh "git tag edge-v#{Concurrent::EDGE_VERSION}"
-        sh "git push github v#{Concurrent::VERSION} edge-v#{Concurrent::EDGE_VERSION}"
+        sh "git push origin v#{Concurrent::VERSION} edge-v#{Concurrent::EDGE_VERSION}"
       end
     end
 

data/ext/concurrent-ruby/com/concurrent_ruby/ext/SynchronizationLibrary.java

@@ -284,21 +284,23 @@ public class SynchronizationLibrary implements Library {
         }
 
         @JRubyMethod(name = "sleep_interruptibly", visibility = Visibility.PUBLIC, module = true)
-        public static IRubyObject sleepInterruptibly(ThreadContext context, IRubyObject receiver, Block block) {
+        public static IRubyObject sleepInterruptibly(final ThreadContext context, IRubyObject receiver, final Block block) {
             try {
-                return context.getThread().executeTask(context, block,
-                        new RubyThread.Task<Block, IRubyObject>() {
-                            public IRubyObject run(ThreadContext context, Block block1) throws InterruptedException {
-                                return block1.call(context);
-                            }
-
-                            public void wakeup(RubyThread thread, Block block1) {
-                                thread.getNativeThread().interrupt();
-                            }
-                        });
+                context.getThread().executeBlockingTask(new RubyThread.BlockingTask() {
+                    @Override
+                    public void run() throws InterruptedException {
+                        block.call(context);
+                    }
+
+                    @Override
+                    public void wakeup() {
+                        context.getThread().getNativeThread().interrupt();
+                    }
+                });
             } catch (InterruptedException e) {
                 throw context.runtime.newThreadError("interrupted in Concurrent::Synchronization::JRuby.sleep_interruptibly");
             }
+            return context.nil;
         }
     }
 }

data/lib/concurrent.rb

@@ -1,3 +1,5 @@
+require 'concurrent/utility/193'
+
 require 'concurrent/version'
 require 'concurrent/constants'
 require 'concurrent/errors'

data/lib/concurrent/atomic/atomic_reference.rb

@@ -2,6 +2,14 @@ require 'concurrent/synchronization'
 require 'concurrent/utility/engine'
 require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
+# Shim for TruffleRuby::AtomicReference
+if Concurrent.on_truffleruby? && !defined?(TruffleRuby::AtomicReference)
+  # @!visibility private
+  module TruffleRuby
+    AtomicReference = Truffle::AtomicReference
+  end
+end
+
 module Concurrent
 
   # Define update methods that use direct paths
@@ -155,8 +163,10 @@ module Concurrent
                                     end
                                     JavaAtomicReference
                                   when Concurrent.on_truffleruby?
-                                    class TruffleRubyAtomicReference < Truffle::AtomicReference
+                                    class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
                                       include AtomicDirectUpdate
+                                      alias_method :value, :get
+                                      alias_method :value=, :set
                                       alias_method :compare_and_swap, :compare_and_set
                                       alias_method :swap, :get_and_set
                                     end

data/lib/concurrent/atomic/java_count_down_latch.rb

@@ -16,14 +16,16 @@ if Concurrent.on_jruby?
 
       # @!macro count_down_latch_method_wait
       def wait(timeout = nil)
+        result = nil
         if timeout.nil?
           Synchronization::JRuby.sleep_interruptibly { @latch.await }
-          true
+          result = true
         else
           Synchronization::JRuby.sleep_interruptibly do
-            @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+            result = @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
           end
         end
+        result
       end
 
       # @!macro count_down_latch_method_count_down

data/lib/concurrent/atomic/mutex_atomic_boolean.rb

@@ -50,6 +50,8 @@ module Concurrent
       @value = !!initial
     end
 
+    private
+
     # @!visibility private
     def ns_make_value(value)
       old = @value

data/lib/concurrent/exchanger.rb

@@ -141,8 +141,8 @@ module Concurrent
 
       def initialize(item)
         super()
-        @Item = item
-        @Latch = Concurrent::CountDownLatch.new
+        @Item      = item
+        @Latch     = Concurrent::CountDownLatch.new
         self.value = nil
       end
 
@@ -252,8 +252,8 @@ module Concurrent
       #     - Wake the sleeping occupier
       #     - Return the occupier's item
 
-      value = NULL if value.nil?                        # The sentinel allows nil to be a valid value
-      me = Node.new(value)                              # create my node in case I need to occupy
+      value  = NULL if value.nil? # The sentinel allows nil to be a valid value
+      me     = Node.new(value) # create my node in case I need to occupy
       end_at = Concurrent.monotonic_time + timeout.to_f # The time to give up
 
       result = loop do
@@ -304,13 +304,17 @@ module Concurrent
       #
       # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
       def do_exchange(value, timeout)
+        result = nil
         if timeout.nil?
-          Synchronization::JRuby.sleep_interruptibly { @exchanger.exchange(value) }
+          Synchronization::JRuby.sleep_interruptibly do
+            result = @exchanger.exchange(value)
+          end
         else
           Synchronization::JRuby.sleep_interruptibly do
-            @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+            result = @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
           end
         end
+        result
       rescue java.util.concurrent.TimeoutException
         CANCEL
       end

data/lib/concurrent/map.rb

@@ -31,46 +31,89 @@ module Concurrent
   # -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
   # does. For most uses it should do fine though, and we recommend you consider
   # `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
-  #
-  # > require 'concurrent'
-  # >
-  # > map = Concurrent::Map.new
   class Map < Collection::MapImplementation
 
-    # @!macro 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.
+    # @!macro map.atomic_method
+    #   This method is atomic.
+
+    # @!macro map.atomic_method_with_block
+    #   This method is atomic.
+    #   @note Atomic methods taking a block do not allow the `self` instance
+    #     to be used within the block. Doing so will cause a deadlock.
+
+    # @!method compute_if_absent(key)
+    #   Compute and store new value for key if the key is absent.
+    #   @param [Object] key
+    #   @yield new value
+    #   @yieldreturn [Object] new value
+    #   @return [Object] new value or current value
+    #   @!macro map.atomic_method_with_block
+
+    # @!method compute_if_present(key)
+    #   Compute and store new value for key if the key is present.
+    #   @param [Object] key
+    #   @yield new value
+    #   @yieldparam old_value [Object]
+    #   @yieldreturn [Object, nil] new value, when nil the key is removed
+    #   @return [Object, nil] new value or nil
+    #   @!macro map.atomic_method_with_block
+
+    # @!method compute(key)
+    #   Compute and store new value for key.
+    #   @param [Object] key
+    #   @yield compute new value from old one
+    #   @yieldparam old_value [Object, nil] old_value, or nil when key is absent
+    #   @yieldreturn [Object, nil] new value, when nil the key is removed
+    #   @return [Object, nil] new value or nil
+    #   @!macro map.atomic_method_with_block
+
+    # @!method merge_pair(key, value)
+    #   If the key is absent, the value is stored, otherwise new value is
+    #   computed with a block.
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @yield compute new value from old one
+    #   @yieldparam old_value [Object] old value
+    #   @yieldreturn [Object, nil] new value, when nil the key is removed
+    #   @return [Object, nil] new value or nil
+    #   @!macro map.atomic_method_with_block
+
+    # @!method replace_pair(key, old_value, new_value)
+    #   Replaces old_value with new_value if key exists and current value
+    #   matches old_value
+    #   @param [Object] key
+    #   @param [Object] old_value
+    #   @param [Object] new_value
+    #   @return [true, false] true if replaced
+    #   @!macro map.atomic_method
+
+    # @!method replace_if_exists(key, new_value)
+    #   Replaces current value with new_value if key exists
+    #   @param [Object] key
+    #   @param [Object] new_value
+    #   @return [Object, nil] old value or nil
+    #   @!macro map.atomic_method
+
+    # @!method get_and_set(key, value)
+    #   Get the current value under key and set new value.
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @return [Object, nil] old value or nil when the key was absent
+    #   @!macro map.atomic_method
+
+    # @!method delete(key)
+    #   Delete key and its value.
+    #   @param [Object] key
+    #   @return [Object, nil] old value or nil when the key was absent
+    #   @!macro map.atomic_method
+
+    # @!method delete_pair(key, value)
+    #   Delete pair and its value if current value equals the provided value.
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @return [true, false] true if deleted
+    #   @!macro map.atomic_method
 
-    # @!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)
@@ -83,6 +126,9 @@ module Concurrent
       @default_proc = block
     end
 
+    # Get a value with key
+    # @param [Object] key
+    # @return [Object] the value
     def [](key)
       if value = super # non-falsy value is an existing mapping, return it right away
         value
@@ -98,17 +144,27 @@ module Concurrent
     end
 
     alias_method :get, :[]
+    # TODO (pitr-ch 30-Oct-2018): doc
     alias_method :put, :[]=
 
+    # Get a value with key, or default_value when key is absent,
+    # or fail when no default_value is given.
+    # @param [Object] key
+    # @param [Object] default_value
+    # @yield default value for a key
+    # @yieldparam key [Object]
+    # @yieldreturn [Object] default value
+    # @return [Object] the value or default value
+    # @raise [KeyError] when key is missing and no default_value is provided
     # @!macro 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.
+    #   @note 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
@@ -121,23 +177,39 @@ module Concurrent
       end
     end
 
-    # @!macro map_method_not_atomic
+    # Fetch value with key, or store default value when key is absent,
+    # or fail when no default_value is given. This is a two step operation,
+    # therefore not atomic. The store can overwrite other concurrently
+    # stored value.
+    # @param [Object] key
+    # @param [Object] default_value
+    # @yield default value for a key
+    # @yieldparam key [Object]
+    # @yieldreturn [Object] default value
+    # @return [Object] the value or default value
+    # @!macro map.atomic_method_with_block
     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
+    # Insert value into map with key if key is absent in one atomic step.
+    # @param [Object] key
+    # @param [Object] value
+    # @return [Object, nil] the value or nil when key was present
     def put_if_absent(key, value)
       computed = false
-      result = compute_if_absent(key) do
+      result   = compute_if_absent(key) do
         computed = true
         value
       end
       computed ? nil : result
     end unless method_defined?(:put_if_absent)
 
+    # Is the value stored in the map. Iterates over all values.
+    # @param [Object] value
+    # @return [true, false]
     def value?(value)
       each_value do |v|
         return true if value.equal?(v)
@@ -145,26 +217,46 @@ module Concurrent
       false
     end
 
+    # All keys
+    # @return [::Array<Object>] keys
     def keys
       arr = []
-      each_pair {|k, v| arr << k}
+      each_pair { |k, v| arr << k }
       arr
     end unless method_defined?(:keys)
 
+    # All values
+    # @return [::Array<Object>] values
     def values
       arr = []
-      each_pair {|k, v| arr << v}
+      each_pair { |k, v| arr << v }
       arr
     end unless method_defined?(:values)
 
+    # Iterates over each key.
+    # @yield for each key in the map
+    # @yieldparam key [Object]
+    # @return [self]
+    # @!macro map.atomic_method_with_block
     def each_key
-      each_pair {|k, v| yield k}
+      each_pair { |k, v| yield k }
     end unless method_defined?(:each_key)
 
+    # Iterates over each value.
+    # @yield for each value in the map
+    # @yieldparam value [Object]
+    # @return [self]
+    # @!macro map.atomic_method_with_block
     def each_value
-      each_pair {|k, v| yield v}
+      each_pair { |k, v| yield v }
     end unless method_defined?(:each_value)
 
+    # Iterates over each key value pair.
+    # @yield for each key value pair in the map
+    # @yieldparam key [Object]
+    # @yieldparam value [Object]
+    # @return [self]
+    # @!macro map.atomic_method_with_block
     def each_pair
       return enum_for :each_pair unless block_given?
       super
@@ -172,30 +264,39 @@ module Concurrent
 
     alias_method :each, :each_pair unless method_defined?(:each)
 
+    # Find key of a value.
+    # @param [Object] value
+    # @return [Object, nil] key or nil when not found
     def key(value)
-      each_pair {|k, v| return k if v == value}
+      each_pair { |k, v| return k if v == value }
       nil
     end unless method_defined?(:key)
     alias_method :index, :key if RUBY_VERSION < '1.9'
 
+    # Is map empty?
+    # @return [true, false]
     def empty?
-      each_pair {|k, v| return false}
+      each_pair { |k, v| return false }
       true
     end unless method_defined?(:empty?)
 
+    # The size of map.
+    # @return [Integer] size
     def size
       count = 0
-      each_pair {|k, v| count += 1}
+      each_pair { |k, v| count += 1 }
       count
     end unless method_defined?(:size)
 
+    # @!visibility private
     def marshal_dump
       raise TypeError, "can't dump hash with default proc" if @default_proc
       h = {}
-      each_pair {|k, v| h[k] = v}
+      each_pair { |k, v| h[k] = v }
       h
     end
 
+    # @!visibility private
     def marshal_load(hash)
       initialize
       populate_from(hash)
@@ -209,6 +310,7 @@ module Concurrent
     end
 
     private
+
     def raise_fetch_no_key
       raise KeyError, 'key not found'
     end
@@ -219,7 +321,7 @@ module Concurrent
     end
 
     def populate_from(hash)
-      hash.each_pair {|k, v| self[k] = v}
+      hash.each_pair { |k, v| self[k] = v }
       self
     end
 

data/lib/concurrent/thread_safe/util/data_structures.rb

@@ -1,5 +1,14 @@
 require 'concurrent/thread_safe/util'
 
+# Shim for TruffleRuby.synchronized
+if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
+  module TruffleRuby
+    def self.synchronized(object, &block)
+      Truffle::System.synchronized(object, &block)
+    end
+  end
+end
+
 module Concurrent
   module ThreadSafe
     module Util
@@ -44,8 +53,7 @@ module Concurrent
         klass.superclass.instance_methods(false).each do |method|
           klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{method}(*args, &block)    
-              # TODO (pitr-ch 01-Jul-2018): don't use internal TruffleRuby APIs  
-              Truffle::System.synchronized(self) { super(*args, &block) }
+              TruffleRuby.synchronized(self) { super(*args, &block) }
             end
           RUBY
         end

data/lib/concurrent/utility/193.rb

@@ -0,0 +1,17 @@
+require_relative 'engine'
+
+if Concurrent.ruby_version :<, 2, 0, 0
+  # @!visibility private
+  module Kernel
+    def __dir__
+      File.dirname __FILE__
+    end
+  end
+
+  # @!visibility private
+  class LoadError < ScriptError
+    def path
+      message.split(' -- ').last
+    end
+  end
+end

data/lib/concurrent/utility/engine.rb

@@ -8,7 +8,7 @@ module Concurrent
       end
 
       def on_jruby_9000?
-        on_jruby? && ruby_version(:>=, 9, 0, 0, JRUBY_VERSION)
+        on_jruby? && ruby_version(JRUBY_VERSION, :>=, 9, 0, 0)
       end
 
       def on_cruby?
@@ -39,7 +39,7 @@ module Concurrent
         defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
       end
 
-      def ruby_version(comparison, major, minor, patch, version = RUBY_VERSION)
+      def ruby_version(version = RUBY_VERSION, comparison, major, minor, patch)
         result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
         comparisons = { :== => [0],
                         :>= => [1, 0],

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '1.1.0.pre2'
-  EDGE_VERSION = '0.4.0.pre2'
+  VERSION      = '1.1.1'
+  EDGE_VERSION = '0.4.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.0.pre2
+  version: 1.1.1
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-18 00:00:00.000000000 Z
+date: 2018-11-05 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -157,6 +157,7 @@ files:
 - lib/concurrent/timer_task.rb
 - lib/concurrent/tuple.rb
 - lib/concurrent/tvar.rb
+- lib/concurrent/utility/193.rb
 - lib/concurrent/utility/at_exit.rb
 - lib/concurrent/utility/engine.rb
 - lib/concurrent/utility/monotonic_time.rb
@@ -176,12 +177,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.3