Extract ReInclude

Author: pitr-ch

lib/concurrent/promises.rb

@@ -3,41 +3,13 @@
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/collection/lock_free_stack'
 require 'concurrent/errors'
+require 'concurrent/re_include'
 
 module Concurrent
 
   # {include:file:doc/promises-main.md}
   module Promises
 
-    # TODO (pitr-ch 23-Dec-2016): move out
-    # @!visibility private
-    module ReInclude
-      def included(base)
-        included_into << [:include, base]
-        super(base)
-      end
-
-      def extended(base)
-        included_into << [:extend, base]
-        super(base)
-      end
-
-      def include(*modules)
-        super(*modules)
-        modules.reverse.each do |module_being_included|
-          included_into.each do |method, mod|
-            mod.send method, module_being_included
-          end
-        end
-      end
-
-      private
-
-      def included_into
-        @included_into ||= []
-      end
-    end
-
     # @!macro [new] promises.param.default_executor
     #   @param [Executor, :io, :fast] default_executor Instance of an executor or a name of the
     #     global executor. Default executor propagates to chained futures unless overridden with

lib/concurrent/re_include.rb

@@ -0,0 +1,58 @@
+module Concurrent
+
+  # Methods form module A included to a module B, which is already included into class C,
+  # will not be visible in the C class. If this module is extended to B then A's methods
+  # are correctly made visible to C.
+  #
+  # @example
+  #   module A
+  #     def a
+  #       :a
+  #     end
+  #   end
+  #
+  #   module B1
+  #   end
+  #
+  #   class C1
+  #     include B1
+  #   end
+  #
+  #   module B2
+  #     extend Concurrent::ReInclude
+  #   end
+  #
+  #   class C2
+  #     include B2
+  #   end
+  #
+  #   B1.send :include, A
+  #   B2.send :include, A
+  #
+  #   C1.new.respond_to? :a # => false
+  #   C2.new.respond_to? :a # => true
+  module ReInclude
+    # @!visibility private
+    def included(base)
+      (@re_include_to_bases ||= []) << [:include, base]
+      super(base)
+    end
+
+    # @!visibility private
+    def extended(base)
+      (@re_include_to_bases ||= []) << [:extend, base]
+      super(base)
+    end
+
+    # @!visibility private
+    def include(*modules)
+      result = super(*modules)
+      modules.reverse.each do |module_being_included|
+        (@re_include_to_bases ||= []).each do |method, mod|
+          mod.send method, module_being_included
+        end
+      end
+      result
+    end
+  end
+end