Hide JavaDaemonThreadFactory and make YARD happy

Author: pitr-ch

lib/concurrent-ruby/concurrent/configuration.rb

@@ -115,7 +115,7 @@ def self.global_logger=(value)
   # 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
-  # exit by calling {AtExit.run} method.
+  # exit by calling `AtExit.run` method.
   #
   # @note this option should be needed only because of `at_exit` ordering
   #   issues which may arise when running some of the testing frameworks.
@@ -125,9 +125,9 @@ def self.global_logger=(value)
   # @note This method should *never* be called
   #   from within a gem. It should *only* be used from within the main
   #   application and even then it should be used only when necessary.
-  # @see AtExit
+  #
   def self.disable_at_exit_handlers!
-    AtExit.enabled = false
+    AT_EXIT.enabled = false
   end
 
   # Global thread pool optimized for short, fast *operations*.

lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb

@@ -125,10 +125,10 @@ def ns_auto_terminate?
     def ns_auto_terminate=(value)
       case value
       when true
-        AtExit.add(self) { terminate_at_exit }
+        AT_EXIT.add(self) { terminate_at_exit }
         @auto_terminate = true
       when false
-        AtExit.delete(self)
+        AT_EXIT.delete(self)
         @auto_terminate = false
       else
         raise ArgumentError

lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb

@@ -37,7 +37,7 @@ class CachedThreadPool < ThreadPoolExecutor
     #
     #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
     def initialize(opts = {})
-      defaults  = { idletime:    DEFAULT_THREAD_IDLETIMEOUT }
+      defaults  = { idletime: DEFAULT_THREAD_IDLETIMEOUT }
       overrides = { min_threads: 0,
                     max_threads: DEFAULT_MAX_POOL_SIZE,
                     max_queue:   DEFAULT_MAX_QUEUE_SIZE }
@@ -52,10 +52,9 @@ def ns_initialize(opts)
       super(opts)
       if Concurrent.on_jruby?
         self.auto_terminate = opts.fetch(:auto_terminate, true)
-        @max_queue = 0
-        @executor = java.util.concurrent.Executors.newCachedThreadPool(
-            Concurrent::DaemonThreadFactory.new(self.auto_terminate?)
-        )
+        @max_queue          = 0
+        @executor           = java.util.concurrent.Executors.newCachedThreadPool(
+            DaemonThreadFactory.new(self.auto_terminate?))
         @executor.setRejectedExecutionHandler(FALLBACK_POLICY_CLASSES[@fallback_policy].new)
         @executor.setKeepAliveTime(opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT), java.util.concurrent.TimeUnit::SECONDS)
       end

lib/concurrent-ruby/concurrent/executor/java_daemon_thread_factory.rb

@@ -116,10 +116,27 @@ def ns_initialize(opts)
             idletime,
             java.util.concurrent.TimeUnit::SECONDS,
             queue,
-            Concurrent::DaemonThreadFactory.new(self.auto_terminate?),
+            DaemonThreadFactory.new(self.auto_terminate?),
             FALLBACK_POLICY_CLASSES[@fallback_policy].new)
 
       end
     end
+
+    class DaemonThreadFactory
+      # hide include from YARD
+      send :include, java.util.concurrent.ThreadFactory
+
+      def initialize(daemonize = true)
+        @daemonize = daemonize
+      end
+
+      def newThread(runnable)
+        thread = java.util.concurrent.Executors.defaultThreadFactory().newThread(runnable)
+        thread.setDaemon(@daemonize)
+        return thread
+      end
+    end
+
+    private_constant :DaemonThreadFactory
   end
 end

lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb

@@ -5,7 +5,6 @@ module Concurrent
 
   if Concurrent.on_jruby?
     require 'concurrent/executor/java_thread_pool_executor'
-    require 'concurrent/executor/java_daemon_thread_factory'
   end
 
   ThreadPoolExecutorImplementation = case

lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb

@@ -91,7 +91,6 @@ def runner
 
   private_constant :AtExitImplementation
 
-  # @see AtExitImplementation
   # @!visibility private
-  AtExit = AtExitImplementation.new.install
+  AT_EXIT = AtExitImplementation.new.install
 end

lib/concurrent-ruby/concurrent/utility/at_exit.rb

@@ -24,7 +24,7 @@ module Concurrent
         expect(Concurrent.global_fast_executor).to receive(:kill).at_least(:once).with(no_args)
         expect(Concurrent.global_io_executor).to receive(:kill).at_least(:once).with(no_args)
         expect(Concurrent.global_timer_set).to receive(:kill).at_least(:once).with(no_args)
-        Concurrent::AtExit.run
+        Concurrent::AT_EXIT.run
       end
     end
    end