concurrent-ruby 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: faedca437c0657830f5b0cf420bbc9fe8a7f9908
-  data.tar.gz: 26114b1a172fdff0a590694d0c417a9ae3e52b5e
+  metadata.gz: 1f2057bba5c491730f2195150ad50cf4d2602143
+  data.tar.gz: ae0f81c1ca1b860e59d751df021389fac61ad736
 SHA512:
-  metadata.gz: ded8d7abaf69a21931f850de692e0b8e34bbd3275ff294a3afe7f3697dd52e3a638a6359f0c5a8ab7b8d60beaecbf9bfc2469868e4a45629c22678975c42f8c8
-  data.tar.gz: 2d9b104c2c7eeb3352aa78dddf6a0c3a1b46752d973409a443cd6b53ed64a948378290a88fbb83a9d292ab12c649deac86a05c1fff5ad51f39169afba9e65673
+  metadata.gz: 2ad27004cc16860bbd15debd5a3ad1b0da3fb3ee2d568f9db428d4eef434ae5e2444548754775ce22dbc820636591e41ce0324a2475acf2e7eb8e9e4bb2e7927
+  data.tar.gz: f6e90a9735aa4ce2bade9754ea15bce067035644658980f24196c9e6cac5b3d9415cb3e0f42206192c58989c3cdebe5fc4b31b978fb4e546dd7fc34f0049da63

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## Current Release v1.0.4 (27 Dec 2016)
+
+concurrent-ruby:
+
+* Nothing
+
+concurrent-ruby-edge:
+
+* New promises' API renamed, lots of improvements, edge bumped to 0.3.0
+  * **Incompatible** with previous 0.2.3 version
+  * see https://github.com/ruby-concurrency/concurrent-ruby/pull/522
+
+## Release v1.0.3 (17 Dec 2016)
+
 * Trigger execution of flattened delayed futures
 * Avoid forking for processor_count if possible
 * Semaphore Mutex and JRuby parity
@@ -12,14 +26,14 @@
 * Fixes format-security error when compiling ruby_193_compatible.h
 * Concurrent::Atom#swap fixed: reraise the exceptions from block
 
-## Current Release v1.0.2 (2 May 2016)
+## Release v1.0.2 (2 May 2016)
 
 * Fix bug with `Concurrent::Map` MRI backend `#inspect` method
 * Fix bug with `Concurrent::Map` MRI backend using `Hash#value?`
 * Improved documentation and examples
 * Minor updates to Edge
 
-### Release v1.0.1 (27 February 2016)
+## Release v1.0.1 (27 February 2016)
 
 * Fix "uninitialized constant Concurrent::ReentrantReadWriteLock" error.
 * Better handling of `autoload` vs. `require`.
@@ -32,7 +46,7 @@
 * Improved documentation.
 * Updated README and CONTRIBUTING.
 
-### Release v1.0.0 (13 November 2015)
+## Release v1.0.0 (13 November 2015)
 
 * Rename `attr_volatile_with_cas` to `attr_atomic`
 * Add `clear_each` to `LockFreeStack`
@@ -80,7 +94,7 @@
 * Many improved tests
 * Some internal reorganization
 
-### Release v0.9.1 (09 August 2015)
+## Release v0.9.1 (09 August 2015)
 
 * Fixed a Rubiniux bug in synchronization object
 * Fixed all interpreter warnings (except circular references)
@@ -94,7 +108,7 @@
 * `ThreadLocalVar#bind` method is now public
 * Refactored many tests
 
-### Release v0.9.0 (10 July 2015)
+## Release v0.9.0 (10 July 2015)
 
 * Updated `AtomicReference`
   - `AtomicReference#try_update` now simply returns instead of raising exception
@@ -193,14 +207,14 @@
 * Removed brute-force killing of threads in tests
 * Fixed a thread pool bug when the operating system cannot allocate more threads
 
-### Release v0.8.0 (25 January 2015)
+## 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
 
-### Release v0.7.2 (24 January 2015)
+## 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
@@ -217,7 +231,7 @@
 * Tests now run on new Travis build environment
 * Multiple documentation updates
 
-### 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.
 
@@ -238,7 +252,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * Removed confusing warning when not using native extenstions
 * Improved documentation
 
-### Release v0.7.0 (13 August 2014)
+## Release v0.7.0 (13 August 2014)
 
 * Merge the [atomic](https://github.com/ruby-concurrency/atomic) gem
   - Pure Ruby `MutexAtomic` atomic reference class
@@ -271,14 +285,14 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * Removed deprecated `Actor` class
 * Better support for Rubinius
 
-### Release v0.6.1 (14 June 2014)
+## Release v0.6.1 (14 June 2014)
 
 * Many improvements to `Concurrent::Actress`
 * Bug fixes to `Concurrent::RubyThreadPoolExecutor`
 * Fixed several brittle tests
 * Moved documentation to http://ruby-concurrency.github.io/concurrent-ruby/frames.html
 
-### Release v0.6.0 (25 May 2014)
+## Release v0.6.0 (25 May 2014)
 
 * Added `Concurrent::Observable` to encapsulate our thread safe observer sets
 * Improvements to new `Channel`
@@ -317,7 +331,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * First implementation of [new, high-performance](https://github.com/ruby-concurrency/concurrent-ruby/pull/49) `Channel`
 * `Actor` is deprecated in favor of new experimental actor implementation [#73](https://github.com/ruby-concurrency/concurrent-ruby/pull/73). To avoid namespace collision it is living in `Actress` namespace until `Actor` is removed in next release.
 
-### Release v0.5.0
+## Release v0.5.0
 
 This is the most significant release of this gem since its inception. This release includes many improvements and optimizations. It also includes several bug fixes. The major areas of focus for this release were:
 

data/README.md

@@ -9,39 +9,28 @@
 [![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>
+Modern concurrency tools for Ruby. Inspired by
+[Erlang](http://www.erlang.org/doc/reference_manual/processes.html),
+[Clojure](http://clojure.org/concurrent_programming),
+[Scala](http://akka.io/),
+[Haskell](http://www.haskell.org/haskellwiki/Applications_and_libraries/Concurrency_and_parallelism#Concurrent_Haskell),
+[F#](http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx),
+[C#](http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx),
+[Java](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html),
+and classic concurrency patterns.
+
+<img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png" align="right" style="margin-left: 20px;" />
+
+The design goals of this gem are:
+
+* Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why
+* Remain free of external gem dependencies
+* 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
 
 ### Supported Ruby versions
 
@@ -127,13 +116,13 @@ These features are under active development and may change frequently. They are
 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):
+* [Promises Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promises.html):
   Unified implementation of futures and promises which combines features of previous `Future`,
   `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and `TimerTask` into a single framework. It extensively uses the
   new synchronization layer to make all the features **non-blocking** and **lock-free**, with the exception of obviously blocking
   operations like `#wait`, `#value`. It also offers better performance.
+* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
+  Implements the Actor Model, where concurrent actors exchange messages.
 * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/Channel.html):
   Communicating Sequential Processes ([CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)).
   Functionally equivalent to Go [channels](https://tour.golang.org/concurrency/2) with additional
@@ -141,15 +130,16 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
 * [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
 * [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
-* [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeStack.html)
+* [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LockFreeStack.html)
 
 #### Statuses:
 
 *Why are these not in core?*
 
+- **Promises Framework** - They are being finalized to be able to be moved to core. They'll deprecate old 
+  implementation.
 - **Actor** - Partial documentation and tests; depends on new future/promise framework; stability is good.
 - **Channel** - Brand new implementation; partial documentation and tests; stability is good.
-- **Future/Promise Framework** - API changes; partial documentation and tests; stability is good.
 - **LazyRegister** - Missing documentation and tests.
 - **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing.
 

data/lib/concurrent/atom.rb

@@ -37,6 +37,7 @@ require 'concurrent/synchronization'
 #     *coordinated*, *synchronous*, change of *many* stated. Used when multiple
 #     value must change together, in an all-or-nothing transaction.
 
+
 module Concurrent
 
   # Atoms provide a way to manage shared, synchronous, independent state.

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -129,5 +129,9 @@ module Concurrent
   #
   # @!macro atomic_fixnum_public_api
   class AtomicFixnum < AtomicFixnumImplementation
+    # @return [String] Short string representation.
+    def to_s
+      format '<#%s:0x%x value:%s>', self.class, object_id << 1, get
+    end
   end
 end

data/lib/concurrent/atomic/atomic_reference.rb

@@ -40,3 +40,10 @@ else
   class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
   end
 end
+
+class Concurrent::AtomicReference
+  # @return [String] Short string representation.
+  def to_s
+    format '<#%s:0x%x value:%s>', self.class, object_id << 1, get
+  end
+end

data/lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -29,8 +29,8 @@ module Concurrent
     #   array, so we don't leak memory
 
     # @!visibility private
-    FREE = []
-    LOCK = Mutex.new
+    FREE   = []
+    LOCK   = Mutex.new
     ARRAYS = {} # used as a hash set
     @@next = 0
     private_constant :FREE, :LOCK, :ARRAYS
@@ -72,9 +72,9 @@ module Concurrent
     def allocate_storage
       @index = LOCK.synchronize do
         FREE.pop || begin
-        result = @@next
-        @@next += 1
-        result
+          result = @@next
+          @@next += 1
+          result
         end
       end
       ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
@@ -83,13 +83,15 @@ module Concurrent
     # @!visibility private
     def self.threadlocal_finalizer(index)
       proc do
-        LOCK.synchronize do
-          FREE.push(index)
-          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-          # But that is natural! More threads means more storage is used per TLV
-          # So naturally more CPU time is required to free more storage
-          ARRAYS.each_value do |array|
-            array[index] = nil
+        Thread.new do # avoid error: can't be called from trap context
+          LOCK.synchronize do
+            FREE.push(index)
+            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
+            # But that is natural! More threads means more storage is used per TLV
+            # So naturally more CPU time is required to free more storage
+            ARRAYS.each_value do |array|
+              array[index] = nil
+            end
           end
         end
       end
@@ -98,10 +100,12 @@ module Concurrent
     # @!visibility private
     def self.thread_finalizer(array)
       proc do
-        LOCK.synchronize do
-          # The thread which used this thread-local array is now gone
-          # So don't hold onto a reference to the array (thus blocking GC)
-          ARRAYS.delete(array.object_id)
+        Thread.new do # avoid error: can't be called from trap context
+          LOCK.synchronize do
+            # The thread which used this thread-local array is now gone
+            # So don't hold onto a reference to the array (thus blocking GC)
+            ARRAYS.delete(array.object_id)
+          end
         end
       end
     end

data/lib/concurrent/atomic/thread_local_var.rb

@@ -11,7 +11,7 @@ module Concurrent
   #   Creates a thread local variable.
   #
   #   @param [Object] default the default value when otherwise unset
-  #   @param [Proc] block Optional block that gets called to obtain the
+  #   @param [Proc] default_block Optional block that gets called to obtain the
   #     default value for each thread
 
   # @!macro [new] thread_local_var_method_get
@@ -72,28 +72,28 @@ module Concurrent
   #   the current thread will ever see that change.
   #
   #   @!macro thread_safe_variable_comparison
-  #   
+  #
   #   @example
   #     v = ThreadLocalVar.new(14)
   #     v.value #=> 14
   #     v.value = 2
   #     v.value #=> 2
-  #   
+  #
   #   @example
   #     v = ThreadLocalVar.new(14)
-  #   
+  #
   #     t1 = Thread.new do
   #       v.value #=> 14
   #       v.value = 1
   #       v.value #=> 1
   #     end
-  #   
+  #
   #     t2 = Thread.new do
   #       v.value #=> 14
   #       v.value = 2
   #       v.value #=> 2
   #     end
-  #   
+  #
   #     v.value #=> 14
   #
   #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal

data/lib/concurrent/atomic_reference/jruby+truffle.rb

@@ -1 +1,2 @@
-require 'concurrent/atomic_reference/mutex_atomic'
+require 'atomic'
+require 'concurrent/atomic_reference/rbx'

data/lib/concurrent/collection/map/non_concurrent_map_backend.rb

@@ -95,6 +95,7 @@ module Concurrent
       end
 
       def each_pair
+        return enum_for :each_pair unless block_given?
         dupped_backend.each_pair do |k, v|
           yield k, v
         end

data/lib/concurrent/configuration.rb

@@ -10,11 +10,43 @@ require 'concurrent/utility/processor_counter'
 module Concurrent
   extend Concern::Logging
 
-  autoload :Options,            'concurrent/options'
-  autoload :TimerSet,           'concurrent/executor/timer_set'
+  autoload :Options, 'concurrent/options'
+  autoload :TimerSet, 'concurrent/executor/timer_set'
   autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
 
   # @return [Logger] Logger with provided level and output.
+  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
+    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
+    lambda do |severity, progname, message = nil, &block|
+      return false if severity < level
+
+      message           = block ? block.call : message
+      formatted_message = case message
+                          when String
+                            message
+                          when Exception
+                            format "%s (%s)\n%s",
+                                   message.message, message.class, (message.backtrace || []).join("\n")
+                          else
+                            message.inspect
+                          end
+
+      output.print format "[%s] %5s -- %s: %s\n",
+                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
+                          Logger::SEV_LABEL[severity],
+                          progname,
+                          formatted_message
+      true
+    end
+  end
+
+  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
+  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
+    Concurrent.global_logger = create_simple_logger level, output
+  end
+
+  # @return [Logger] Logger with provided level and output.
+  # @deprecated
   def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
     logger           = Logger.new(output)
     logger.level     = level
@@ -24,32 +56,35 @@ module Concurrent
                             msg
                           when Exception
                             format "%s (%s)\n%s",
-                              msg.message, msg.class, (msg.backtrace || []).join("\n")
+                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
                           else
                             msg.inspect
                           end
       format "[%s] %5s -- %s: %s\n",
-        datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-        severity,
-        progname,
-        formatted_message
+             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
+             severity,
+             progname,
+             formatted_message
     end
 
     lambda do |loglevel, progname, message = nil, &block|
-    logger.add loglevel, message, progname, &block
+      logger.add loglevel, message, progname, &block
     end
   end
 
   # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
+  # @deprecated
   def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
     Concurrent.global_logger = create_stdlib_logger level, output
   end
 
+  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
+
   # Suppresses all output when used for logging.
   NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
 
   # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_stdlib_logger(Logger::WARN))
+  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
   private_constant :GLOBAL_LOGGER
 
   def self.global_logger
@@ -131,23 +166,23 @@ module Concurrent
 
   def self.new_fast_executor(opts = {})
     FixedThreadPool.new(
-      [2, Concurrent.processor_count].max,
-      auto_terminate:  opts.fetch(:auto_terminate, true),
-      idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
-      fallback_policy: :abort # shouldn't matter -- 0 max queue
+        [2, Concurrent.processor_count].max,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :abort # shouldn't matter -- 0 max queue
     )
   end
 
   def self.new_io_executor(opts = {})
     ThreadPoolExecutor.new(
-      min_threads:     [2, Concurrent.processor_count].max,
-      max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-      # max_threads:     1000,
-      auto_terminate:  opts.fetch(:auto_terminate, true),
-      idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
-      fallback_policy: :abort # shouldn't matter -- 0 max queue
+        min_threads:     [2, Concurrent.processor_count].max,
+        max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
+        # max_threads:     1000,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :abort # shouldn't matter -- 0 max queue
     )
   end
 end

data/lib/concurrent/errors.rb

@@ -30,7 +30,18 @@ module Concurrent
 
   # Raised when an attempt is made to modify an immutable object
   # (such as an `IVar`) after its final state has been set.
-  MultipleAssignmentError = Class.new(Error)
+  class MultipleAssignmentError < Error
+    attr_reader :inspection_data
+
+    def initialize(message = nil, inspection_data = nil)
+      @inspection_data = inspection_data
+      super message
+    end
+
+    def inspect
+      format '%s %s>', super[0..-2], @inspection_data.inspect
+    end
+  end
 
   # Raised by an `Executor` when it is unable to process a given task,
   # possibly because of a reject policy or other internal error.
@@ -43,4 +54,16 @@ module Concurrent
   # Raised when an operation times out.
   TimeoutError = Class.new(Error)
 
+  # Aggregates multiple exceptions.
+  class MultipleErrors < Error
+    attr_reader :errors
+
+    def initialize(errors, message = "#{errors.size} errors")
+      @errors = errors
+      super [*message,
+             *errors.map { |e| [format('%s (%s)', e.message, e.class), *e.backtrace] }.flatten(1)
+            ].join("\n")
+    end
+  end
+
 end

data/lib/concurrent/synchronization/condition.rb

@@ -1,6 +1,5 @@
 module Concurrent
   module Synchronization
-    # TODO (pitr-ch 04-Dec-2016): should be in edge
     class Condition < LockableObject
       safe_initialization!
 

data/lib/concurrent/synchronization/lock.rb

@@ -1,6 +1,5 @@
 module Concurrent
   module Synchronization
-    # TODO (pitr-ch 04-Dec-2016): should be in edge
     class Lock < LockableObject
       # TODO use JavaReentrantLock on JRuby
 

data/lib/concurrent/synchronization/object.rb

@@ -70,8 +70,8 @@ module Concurrent
       # any instance variables with CamelCase names and isn't {.safe_initialization?}.
       def self.ensure_safe_initialization_when_final_fields_are_present
         Object.class_eval do
-          def self.new(*)
-            object = super
+          def self.new(*args, &block)
+            object = super(*args, &block)
           ensure
             has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
             if has_final_field && !safe_initialization?

data/lib/concurrent/synchronization/rbx_object.rb

@@ -30,6 +30,7 @@ module Concurrent
 
       def full_memory_barrier
         # Rubinius instance variables are not volatile so we need to insert barrier
+        # TODO (pitr 26-Nov-2015): check comments like ^
         Rubinius.memory_barrier
       end
     end

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '1.0.3'
-  EDGE_VERSION = '0.2.3'
+  VERSION      = '1.0.4'
+  EDGE_VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-17 00:00:00.000000000 Z
+date: 2016-12-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.