Add Java 7 deprecatin warning

Author: pitr-ch

README.md

@@ -39,6 +39,7 @@
 
 MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), 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 required for JRuby (Java 7 support is deprecated in version 0.9 and will be removed in 1.0).
 
 ## Features & Documentation
 

lib/concurrent/concern/deprecation.rb

@@ -10,18 +10,25 @@ module Deprecation
       include Concern::Logging
 
       def deprecated(message, strip = 2)
-        caller_line = caller(strip).first
-        klass       = if Class === self
+        caller_line = caller(strip).first if strip > 0
+        klass       = if Module === self
                         self
                       else
                         self.class
                       end
-        log WARN, klass.to_s, format("[DEPRECATED] %s\ncalled on: %s", message, caller_line)
+        message     = if strip > 0
+                        format("[DEPRECATED] %s\ncalled on: %s", message, caller_line)
+                      else
+                        format('[DEPRECATED] %s', message)
+                      end
+        log WARN, klass.to_s, message
       end
 
       def deprecated_method(old_name, new_name)
         deprecated "`#{old_name}` is deprecated and it'll removed in next release, use `#{new_name}` instead", 3
       end
+
+      extend self
     end
   end
 end

lib/concurrent/concern/logging.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'concurrent/configuration'
 
 module Concurrent
   module Concern

lib/concurrent/configuration.rb

@@ -11,37 +11,6 @@ module Concurrent
   extend Concern::Logging
   extend Concern::Deprecation
 
-  # Suppresses all output when used for logging.
-  NULL_LOGGER = lambda { |level, progname, message = nil, &block| }
-
-  # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(NULL_LOGGER)
-  private_constant :GLOBAL_LOGGER
-
-  # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
-  private_constant :GLOBAL_FAST_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
-  private_constant :GLOBAL_IO_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
-  private_constant :GLOBAL_TIMER_SET
-
-  # @!visibility private
-  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
-  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
-
-  def self.global_logger
-    GLOBAL_LOGGER.value
-  end
-
-  def self.global_logger=(value)
-    GLOBAL_LOGGER.value = value
-  end
-
   # @return [Logger] Logger with provided level and output.
   def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
     logger           = Logger.new(output)
@@ -62,17 +31,48 @@ def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
              progname,
              formatted_message
     end
-    logger
+
+    lambda do |level, progname, message = nil, &block|
+      logger.add level, message, progname, &block
+    end
   end
 
   # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
   def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    logger = create_stdlib_logger level, output
-    Concurrent.global_logger = lambda do |level, progname, message = nil, &block|
-      logger.add level, message, progname, &block
-    end
+    Concurrent.global_logger = create_stdlib_logger level, output
   end
 
+  # 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))
+  private_constant :GLOBAL_LOGGER
+
+  def self.global_logger
+    GLOBAL_LOGGER.value
+  end
+
+  def self.global_logger=(value)
+    GLOBAL_LOGGER.value = value
+  end
+
+  # @!visibility private
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
+  private_constant :GLOBAL_FAST_EXECUTOR
+
+  # @!visibility private
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
+  private_constant :GLOBAL_IO_EXECUTOR
+
+  # @!visibility private
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
+  private_constant :GLOBAL_TIMER_SET
+
+  # @!visibility private
+  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
+  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
+
   # Disables AtExit handlers including pool auto-termination handlers.
   # When disabled it will be the application programmer's responsibility
   # to ensure that the handlers are shutdown properly prior to application
@@ -275,4 +275,18 @@ def self.configuration
   def self.configure
     yield(configuration)
   end
+
+  # for dependency reasons this check cannot be in concurrent/synchronization
+  if Concurrent.on_jruby?
+    require 'java'
+
+    version_string = java.lang.System.getProperties['java.runtime.version']
+    version        = version_string.split('.', 3)[0..1].map(&:to_i)
+    if (version <=> [1, 8]) < 0
+      deprecated <<-TXT.gsub(/^\s*\|/, '').chop, 0
+          |Java 7 is deprecated, please use Java 8.
+          |Java 7 support is only best effort, it may not work. It will be removed in next release (1.0).
+      TXT
+    end
+  end
 end

lib/concurrent/synchronization/java_object.rb

@@ -4,7 +4,6 @@ module Concurrent
   module Synchronization
 
     if Concurrent.on_jruby?
-      require 'jruby'
 
       # @!visibility private
       # @!macro internal_implementation_note