Cleared all interpreter warnings except circular references.

* Added parenthesis when using splat operator
* Used _ for unused variables
* Renamed variables when block echoed surrounding scope
* Configuration now autoloads lazily.
* Cleared all circular references.

Author: jdantonio

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

lib/concurrent/executor/executor.rb

@@ -1,5 +1,6 @@
-require 'concurrent/executor/executor_service'
+require 'concurrent/configuration'
 require 'concurrent/concern/deprecation'
+require 'concurrent/executor/executor_service'
 
 module Concurrent
 

lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -166,7 +166,7 @@ def ns_shutdown_execution
     def ns_kill_execution
       # TODO log out unprocessed tasks in queue
       # TODO try to shutdown first?
-      @pool.each &:kill
+      @pool.each(&:kill)
       @pool.clear
       @ready.clear
     end
@@ -297,32 +297,31 @@ def kill
       private
 
       def create_worker(queue, pool, idletime)
-        Thread.new(queue, pool, idletime) do |queue, pool, idletime|
+        Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
           last_message = Concurrent.monotonic_time
           catch(:stop) do
             loop do
 
-              case message = queue.pop
+              case message = my_queue.pop
               when :idle_test
-                if (Concurrent.monotonic_time - last_message) > idletime
-                  pool.remove_busy_worker(self)
+                if (Concurrent.monotonic_time - last_message) > my_idletime
+                  my_pool.remove_busy_worker(self)
                   throw :stop
                 else
-                  pool.worker_not_old_enough(self)
+                  my_pool.worker_not_old_enough(self)
                 end
 
               when :stop
-                pool.remove_busy_worker(self)
+                my_pool.remove_busy_worker(self)
                 throw :stop
 
               else
                 task, args = message
-                run_task pool, task, args
+                run_task my_pool, task, args
                 last_message = Concurrent.monotonic_time
 
-                pool.ready_worker(self)
+                my_pool.ready_worker(self)
               end
-
             end
           end
         end

lib/concurrent/scheduled_task.rb

@@ -1,9 +1,7 @@
 require 'concurrent/errors'
 require 'concurrent/ivar'
-require 'concurrent/configuration'
 require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/executor/executor'
-require 'concurrent/executor/timer_set'
 require 'concurrent/utility/monotonic_time'
 require 'concurrent/concern/deprecation'
 

lib/concurrent/utility/at_exit.rb

@@ -12,7 +12,7 @@ class AtExitImplementation < Synchronization::Object
 
     def initialize(*args)
       super()
-      synchronize { ns_initialize *args }
+      synchronize { ns_initialize(*args) }
     end
 
     # Add a handler to be run at `Kernel#at_exit`