Merge pull request #385 from ruby-concurrency/warnings

Cleared all interpreter warnings.

Author: jdantonio

.travis.yml

@@ -27,4 +27,4 @@ matrix:
     - rvm: jruby-head
     - rvm: 1.9.3
 
-script: bundle exec rake ci
+script: RUBYOPT=-w bundle exec rake ci

CHANGELOG.md

@@ -1,6 +1,15 @@
 ### Upcoming Release v0.9.1 (TBD)
 
+* Fixed a Rubiniux bug in synchronization object
+* Fixed all unterpreter warnings (except circular references)
+* Fixed requires when requiring Atom alone
+* Significantly improved `ThreadLocalVar` on non-JRuby platforms
+* Fixed error handling in Edge `Concurrent.zip`
 * `AtomicFixnum` methods `#increment` and `#decrement` now support optional delta
+* New AtomicFixnum#update` method
+* Minor optimizations in `ReadWriteLock`
+* New `ReentrantReadWriteLock` class
+* `ThreadLocalVar#bind` method is now public
 
 ## Current Release v0.9.0 (10 July 2015)
 

README.md

@@ -105,6 +105,7 @@ Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
 * [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
 
@@ -127,7 +128,8 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 * [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)
-* [Lock Free Linked Set](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.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:
 
@@ -139,8 +141,7 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 - **Channel** - Missing documentation; limted features; stability good.
 - **Exchanger** - Known race condition requiring a new implementation.
 - **LazyRegister** - Missing documentation and tests.
-- **AtomicMarkableReference** - Needs real world battle testing
-- **LockFreeLinkedSet** - Needs real world battle testing
+- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Needs real world battle testing
 
 ## Usage
 
@@ -184,8 +185,6 @@ 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
-require 'concurrent/exchanger'      # Concurrent::Exchanger
-require 'concurrent/lazy_register'  # Concurrent::LazyRegister
 ```
 
 If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.

appveyor.yml

@@ -9,7 +9,7 @@ install:
 build: off
 
 test_script:
-  - bundle exec rake ci
+  - RUBYOPT=-w bundle exec rake ci
 
 environment:
   matrix:

lib/concurrent/actor/core.rb

@@ -208,7 +208,7 @@ def ns_initialize(opts, &block)
       end
 
       def initialize_behaviours(opts)
-        @behaviour_definition = (Type! opts[:behaviour_definition] || @context.behaviour_definition, Array).each do |(behaviour, *args)|
+        @behaviour_definition = (Type! opts[:behaviour_definition] || @context.behaviour_definition, Array).each do |(behaviour, _)|
           Child! behaviour, Behaviour::Abstract
         end
         @behaviours           = {}

lib/concurrent/actor/utils/pool.rb

@@ -37,7 +37,7 @@ def initialize(size, &worker_initializer)
         end
 
         def on_message(message)
-          command, *rest = message
+          command, _ = message
           return if [:restarted, :reset, :resumed, :terminated].include? command # ignore events from supervised actors
 
           envelope_to_redirect = if envelope.future

lib/concurrent/collection/copy_on_notify_observer_set.rb

@@ -100,7 +100,7 @@ def duplicate_and_clear_observers
       end
 
       def duplicate_observers
-        synchronize { observers = @observers.dup }
+        synchronize { @observers.dup }
       end
 
       def notify_to(observers, *args)

lib/concurrent/configuration.rb

@@ -1,9 +1,13 @@
 require 'thread'
-require 'concurrent/atomics'
+require 'concurrent/delay'
 require 'concurrent/errors'
-require 'concurrent/executors'
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/deprecation'
 require 'concurrent/concern/logging'
+require 'concurrent/executor/timer_set'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 
@@ -32,8 +36,8 @@ def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
              formatted_message
     end
 
-    lambda do |level, progname, message = nil, &block|
-      logger.add level, message, progname, &block
+    lambda do |loglevel, progname, message = nil, &block|
+      logger.add loglevel, message, progname, &block
     end
   end
 

lib/concurrent/delay.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'concurrent/configuration'
 require 'concurrent/concern/obligation'
 require 'concurrent/executor/executor'
 require 'concurrent/executor/immediate_executor'

lib/concurrent/edge/future.rb

@@ -113,7 +113,7 @@ def post(*args, &job)
       # post job on executor
       # @return [true, false]
       def post_on(executor, *args, &job)
-        Concurrent.executor(executor).post *args, &job
+        Concurrent.executor(executor).post(*args, &job)
       end
 
       # TODO add first(futures, count=count)
@@ -307,7 +307,7 @@ def set(*args, &block)
       # @!visibility private
       def complete_with(state, raise_on_reassign = true)
         if @State.compare_and_set(PENDING, state)
-          (state)
+          #(state)
           # go to synchronized block only if there were waiting threads
           synchronize { ns_broadcast } if @Waiters.clear
           call_callbacks
@@ -323,7 +323,7 @@ def complete_with(state, raise_on_reassign = true)
       # @return [Array<AbstractPromise>]
       def blocks
         @Callbacks.each_with_object([]) do |callback, promises|
-          promises.push *callback.select { |v| v.is_a? AbstractPromise }
+          promises.push(*(callback.select { |v| v.is_a? AbstractPromise }))
         end
       end
 
@@ -464,7 +464,7 @@ def to_sym
       # @!visibility private
       class SuccessArray < Success
         def apply(block)
-          block.call *value
+          block.call(*value)
         end
       end
 
@@ -520,7 +520,7 @@ def reason
         end
 
         def apply(block)
-          block.call *reason
+          block.call(*reason)
         end
       end
 
@@ -776,14 +776,14 @@ def call_callback(method, state, *args)
       end
 
       def pr_async_callback_on_success(state, executor, callback)
-        pr_with_async(executor, state, callback) do |state, callback|
-          pr_callback_on_success state, callback
+        pr_with_async(executor, state, callback) do |st, cb|
+          pr_callback_on_success st, cb
         end
       end
 
       def pr_async_callback_on_failure(state, executor, callback)
-        pr_with_async(executor, state, callback) do |state, callback|
-          pr_callback_on_failure state, callback
+        pr_with_async(executor, state, callback) do |st, cb|
+          pr_callback_on_failure st, cb
         end
       end
 
@@ -804,8 +804,8 @@ def pr_callback_notify_blocked(state, promise)
       end
 
       def pr_async_callback_on_completion(state, executor, callback)
-        pr_with_async(executor, state, callback) do |state, callback|
-          pr_callback_on_completion state, callback
+        pr_with_async(executor, state, callback) do |st, cb|
+          pr_callback_on_completion st, cb
         end
       end
 
@@ -981,7 +981,7 @@ def initialize(future, blocked_by_futures, countdown)
         @Countdown = AtomicFixnum.new countdown
 
         super(future)
-        @BlockedBy.each { |future| future.add_callback :pr_callback_notify_blocked, self }
+        @BlockedBy.each { |f| f.add_callback :pr_callback_notify_blocked, self }
       end
 
       # @api private
@@ -1063,8 +1063,8 @@ def initialize(blocked_by_future, default_executor, executor, &task)
 
       def on_completable(done_future)
         if done_future.success?
-          Concurrent.post_on(@Executor, done_future, @Task) do |done_future, task|
-            evaluate_to lambda { done_future.apply task }
+          Concurrent.post_on(@Executor, done_future, @Task) do |future, task|
+            evaluate_to lambda { future.apply task }
           end
         else
           complete_with done_future.internal_state
@@ -1082,8 +1082,8 @@ def initialize(blocked_by_future, default_executor, executor, &task)
 
       def on_completable(done_future)
         if done_future.failed?
-          Concurrent.post_on(@Executor, done_future, @Task) do |done_future, task|
-            evaluate_to lambda { done_future.apply task }
+          Concurrent.post_on(@Executor, done_future, @Task) do |future, task|
+            evaluate_to lambda { future.apply task }
           end
         else
           complete_with done_future.internal_state
@@ -1097,7 +1097,7 @@ class ChainPromise < BlockedTaskPromise
 
       def on_completable(done_future)
         if Future === done_future
-          Concurrent.post_on(@Executor, done_future, @Task) { |future, task| evaluate_to *future.result, task }
+          Concurrent.post_on(@Executor, done_future, @Task) { |future, task| evaluate_to(*future.result, task) }
         else
           Concurrent.post_on(@Executor, @Task) { |task| evaluate_to task }
         end