dependencies.rb in activesupport-5.0.0.beta4

- old
+ new

@@ -86,19 +86,10 @@
     # An array of constant names that need to be unloaded on every request. Used
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants
     self.explicitly_unloadable_constants = []
 
-    # The logger is used for generating information on the action run-time
-    # (including benchmarking) if available. Can be set to nil for no logging.
-    # Compatible with both Ruby's own Logger and Log4r loggers.
-    mattr_accessor :logger
-
-    # Set to +true+ to enable logging of const_missing and file loads.
-    mattr_accessor :log_activity
-    self.log_activity = false
-
     # The WatchStack keeps a stack of the modules being watched as files are
     # loaded. If a file in the process of being loaded (parent.rb) triggers the
     # load of another file (child.rb) the stack will ensure that child.rb
     # handles the new constants.
     #
@@ -141,11 +132,11 @@
 
           mod = Inflector.constantize(namespace) if Dependencies.qualified_const_defined?(namespace)
           next unless mod.is_a?(Module)
 
           # Get a list of the constants that were added
-          new_constants = mod.local_constants - original_constants
+          new_constants = mod.constants(false) - original_constants
 
           # @stack[namespace] returns an Array of the constants that are being evaluated
           # for that namespace. For instance, if parent.rb requires child.rb, the first
           # element of @stack[Object] will be an Array of the constants that were present
           # before parent.rb was required. The second element will be an Array of the
@@ -169,11 +160,11 @@
       # constants.
       def watch_namespaces(namespaces)
         @watching << namespaces.map do |namespace|
           module_name = Dependencies.to_constant_name(namespace)
           original_constants = Dependencies.qualified_const_defined?(module_name) ?
-            Inflector.constantize(module_name).local_constants : []
+            Inflector.constantize(module_name).constants(false) : []
 
           @stack[module_name] << original_constants
           module_name
         end
       end
@@ -350,20 +341,18 @@
       end
       raise
     end
 
     def clear
-      log_call
       Dependencies.unload_interlock do
         loaded.clear
         loading.clear
         remove_unloadable_constants!
       end
     end
 
     def require_or_load(file_name, const_path = nil)
-      log_call file_name, const_path
       file_name = $` if file_name =~ /\.rb\z/
       expanded = File.expand_path(file_name)
       return if loaded.include?(expanded)
 
       Dependencies.load_interlock do
@@ -375,12 +364,10 @@
         loaded << expanded
         loading << expanded
 
         begin
           if load?
-            log "loading #{file_name}"
-
             # Enable warnings if this file has not been loaded before and
             # warnings_on_first_load is set.
             load_args = ["#{file_name}.rb"]
             load_args << const_path unless const_path.nil?
 
@@ -388,11 +375,10 @@
               result = load_file(*load_args)
             else
               enable_warnings { result = load_file(*load_args) }
             end
           else
-            log "requiring #{file_name}"
             result = require file_name
           end
         rescue Exception
           loaded.delete expanded
           raise
@@ -481,22 +467,20 @@
     #
     # If the second parameter is left off, then Dependencies will construct a
     # set of names that the file at +path+ may define. See
     # +loadable_constants_for_path+ for more details.
     def load_file(path, const_paths = loadable_constants_for_path(path))
-      log_call path, const_paths
       const_paths = [const_paths].compact unless const_paths.is_a? Array
       parent_paths = const_paths.collect { |const_path| const_path[/.*(?=::)/] || ::Object }
 
       result = nil
       newly_defined_paths = new_constants_in(*parent_paths) do
         result = Kernel.load path
       end
 
       autoloaded_constants.concat newly_defined_paths unless load_once_path?(path)
       autoloaded_constants.uniq!
-      log "loading #{path} defined #{newly_defined_paths * ', '}" unless newly_defined_paths.empty?
       result
     end
 
     # Returns the constant path for the provided parent and constant name.
     def qualified_name_for(mod, name)
@@ -506,12 +490,10 @@
 
     # Load the constant named +const_name+ which is missing from +from_mod+. If
     # it is not possible to load the constant into from_mod, try its parent
     # module using +const_missing+.
     def load_missing_constant(from_mod, const_name)
-      log_call from_mod, const_name
-
       unless qualified_const_defined?(from_mod.name) && Inflector.constantize(from_mod.name).equal?(from_mod)
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
       qualified_name = qualified_name_for from_mod, const_name
@@ -671,29 +653,24 @@
     #
     # If the provided block does not run to completion, and instead raises an
     # exception, any new constants are regarded as being only partially defined
     # and will be removed immediately.
     def new_constants_in(*descs)
-      log_call(*descs)
-
       constant_watch_stack.watch_namespaces(descs)
-      aborting = true
+      success = false
 
       begin
         yield # Now yield to the code that is to define new constants.
-        aborting = false
+        success = true
       ensure
         new_constants = constant_watch_stack.new_constants
 
-        log "New constants: #{new_constants * ', '}"
-        return new_constants unless aborting
+        return new_constants if success
 
-        log "Error during loading, removing partially loaded constants "
-        new_constants.each { |c| remove_constant(c) }.clear
+        # Remove partially loaded constants.
+        new_constants.each { |c| remove_constant(c) }
       end
-
-      []
     end
 
     # Convert the provided const desc to a qualified constant name (as a string).
     # A module, class, symbol, or string may be provided.
     def to_constant_name(desc) #:nodoc:
@@ -736,12 +713,10 @@
         parent_name = constants.join('::')
         return unless qualified_const_defined?(parent_name)
         parent = constantize(parent_name)
       end
 
-      log "removing constant #{const}"
-
       # In an autoloaded user.rb like this
       #
       #   autoload :Foo, 'foo'
       #
       #   class User < ActiveRecord::Base
@@ -758,40 +733,22 @@
       # example above with Object, accessing to that constant must err.
       unless parent.autoload?(to_remove)
         begin
           constantized = parent.const_get(to_remove, false)
         rescue NameError
-          log "the constant #{const} is not reachable anymore, skipping"
+          # The constant is no longer reachable, just skip it.
           return
         else
           constantized.before_remove_const if constantized.respond_to?(:before_remove_const)
         end
       end
 
       begin
         parent.instance_eval { remove_const to_remove }
       rescue NameError
-        log "the constant #{const} is not reachable anymore, skipping"
+        # The constant is no longer reachable, just skip it.
       end
     end
-
-    protected
-      def log_call(*args)
-        if log_activity?
-          arg_str = args.collect(&:inspect) * ', '
-          /in `([a-z_\?\!]+)'/ =~ caller(1).first
-          selector = $1 || '<unknown>'
-          log "called #{selector}(#{arg_str})"
-        end
-      end
-
-      def log(msg)
-        logger.debug "Dependencies: #{msg}" if log_activity?
-      end
-
-      def log_activity?
-        logger && log_activity
-      end
   end
 end
 
 ActiveSupport::Dependencies.hook!