module ActiveSupport::Dependencies

def self.load_interlock
  Dependencies.interlock.loading { yield }
end

def self.run_interlock
  Dependencies.interlock.running { yield }
end

def self.unload_interlock
  Dependencies.interlock.unloading { yield }
end

def autoload_module!(into, const_name, qualified_name, path_suffix)
  return nil unless base_path = autoloadable_module?(path_suffix)
  mod = Module.new
  into.const_set const_name, mod
  log("constant #{qualified_name} autoloaded (module autovivified from #{File.join(base_path, path_suffix)})")
  autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
  autoloaded_constants.uniq!
  mod
end

def autoloadable_module?(path_suffix)
  autoload_paths.each do |load_path|
    return load_path if File.directory? File.join(load_path, path_suffix)
  end
  nil
end

def autoloaded?(desc)
  return false if desc.is_a?(Module) && real_mod_name(desc).nil?
  name = to_constant_name desc
  return false unless qualified_const_defined?(name)
  autoloaded_constants.include?(name)
end

def clear
  Dependencies.unload_interlock do
    loaded.clear
    loading.clear
    remove_unloadable_constants!
  end
end

def constantize(name)
  Reference.get(name)
end

def depend_on(file_name, message = "No such file to load -- %s.rb")
  path = search_for_file(file_name)
  require_or_load(path || file_name)
rescue LoadError => load_error
  if file_name = load_error.message[/ -- (.*?)(\.rb)?$/, 1]
    load_error.message.replace(message % file_name)
    load_error.copy_blame!(load_error)
  end
  raise
end

def hook!
  Loadable.include_into(Object)
  ModuleConstMissing.include_into(Module)
  Exception.include(Blamable)
end

def load?
  mechanism == :load
end

def load_file(path, const_paths = loadable_constants_for_path(path))
  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!
  result
end

def load_missing_constant(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)
  path_suffix = qualified_name.underscore
  file_path = search_for_file(path_suffix)
  if file_path
    expanded = File.expand_path(file_path)
    expanded.sub!(/\.rb\z/, "")
    if loading.include?(expanded)
      raise "Circular dependency detected while autoloading constant #{qualified_name}"
    else
      require_or_load(expanded, qualified_name)
      if from_mod.const_defined?(const_name, false)
        log("constant #{qualified_name} autoloaded from #{expanded}.rb")
        return from_mod.const_get(const_name)
      else
        raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it"
      end
    end
  elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
    return mod
  elsif (parent = from_mod.module_parent) && parent != from_mod &&
        ! from_mod.module_parents.any? { |p| p.const_defined?(const_name, false) }
    # If our parents do not have a constant named +const_name+ then we are free
    # to attempt to load upwards. If they do have such a constant, then this
    # const_missing must be due to from_mod::const_name, which should not
    # return constants from from_mod's parents.
    begin
      # Since Ruby does not pass the nesting at the point the unknown
      # constant triggered the callback we cannot fully emulate constant
      # name lookup and need to make a trade-off: we are going to assume
      # that the nesting in the body of Foo::Bar is [Foo::Bar, Foo] even
      # though it might not be. Counterexamples are
      #
      #   class Foo::Bar
      #     Module.nesting # => [Foo::Bar]
      #   end
      #
      # or
      #
      #   module M::N
      #     module S::T
      #       Module.nesting # => [S::T, M::N]
      #     end
      #   end
      #
      # for example.
      return parent.const_missing(const_name)
    rescue NameError => e
      raise unless e.missing_name? qualified_name_for(parent, const_name)
    end
  end
  name_error = NameError.new("uninitialized constant #{qualified_name}", const_name)
  name_error.set_backtrace(caller.reject { |l| l.starts_with? __FILE__ })
  raise name_error
end

def load_once_path?(path)
  # to_s works around a ruby issue where String#starts_with?(Pathname)
  # will raise a TypeError: no implicit conversion of Pathname into String
  autoload_once_paths.any? { |base| path.starts_with? base.to_s }
end

def loadable_constants_for_path(path, bases = autoload_paths)
  path = path.chomp(".rb")
  expanded_path = File.expand_path(path)
  paths = []
  bases.each do |root|
    expanded_root = File.expand_path(root)
    next unless expanded_path.start_with?(expanded_root)
    root_size = expanded_root.size
    next if expanded_path[root_size] != ?/
    nesting = expanded_path[(root_size + 1)..-1]
    paths << nesting.camelize unless nesting.blank?
  end
  paths.uniq!
  paths
end

def log(message)
  logger.debug("autoloading: #{message}") if logger && verbose
end

def mark_for_unload(const_desc)
  name = to_constant_name const_desc
  if explicitly_unloadable_constants.include? name
    false
  else
    explicitly_unloadable_constants << name
    true
  end
end

def new_constants_in(*descs)
  constant_watch_stack.watch_namespaces(descs)
  success = false
  begin
    yield # Now yield to the code that is to define new constants.
    success = true
  ensure
    new_constants = constant_watch_stack.new_constants
    return new_constants if success
    # Remove partially loaded constants.
    new_constants.each { |c| remove_constant(c) }
  end
end

def qualified_const_defined?(path)
  Object.const_defined?(path, false)
end

def qualified_name_for(mod, name)
  mod_name = to_constant_name mod
  mod_name == "Object" ? name.to_s : "#{mod_name}::#{name}"
end

def real_mod_name(mod)
  UNBOUND_METHOD_MODULE_NAME.bind(mod).call
end

def reference(klass)
  Reference.store klass
end

def remove_constant(const) #:nodoc:
  # Normalize ::Foo, ::Object::Foo, Object::Foo, Object::Object::Foo, etc. as Foo.
  normalized = const.to_s.sub(/\A::/, "")
  normalized.sub!(/\A(Object::)+/, "")
  constants = normalized.split("::")
  to_remove = constants.pop
  # Remove the file path from the loaded list.
  file_path = search_for_file(const.underscore)
  if file_path
    expanded = File.expand_path(file_path)
    expanded.sub!(/\.rb\z/, "")
    loaded.delete(expanded)
  end
  if constants.empty?
    parent = Object
  else
    # This method is robust to non-reachable constants.
    #
    # Non-reachable constants may be passed if some of the parents were
    # autoloaded and already removed. It is easier to do a sanity check
    # here than require the caller to be clever. We check the parent
    # rather than the very const argument because we do not want to
    # trigger Kernel#autoloads, see the comment below.
    parent_name = constants.join("::")
    return unless qualified_const_defined?(parent_name)
    parent = constantize(parent_name)
  end
  # In an autoloaded user.rb like this
  #
  #   autoload :Foo, 'foo'
  #
  #   class User < ActiveRecord::Base
  #   end
  #
  # we correctly register "Foo" as being autoloaded. But if the app does
  # not use the "Foo" constant we need to be careful not to trigger
  # loading "foo.rb" ourselves. While #const_defined? and #const_get? do
  # require the file, #autoload? and #remove_const don't.
  #
  # We are going to remove the constant nonetheless ---which exists as
  # far as Ruby is concerned--- because if the user removes the macro
  # call from a class or module that were not autoloaded, as in the
  # 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
      # 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
    # The constant is no longer reachable, just skip it.
  end
end

def remove_unloadable_constants!
  log("removing unloadable constants")
  autoloaded_constants.each { |const| remove_constant const }
  autoloaded_constants.clear
  Reference.clear!
  explicitly_unloadable_constants.each { |const| remove_constant const }
end

def require_or_load(file_name, const_path = nil)
  file_name = file_name.chomp(".rb")
  expanded = File.expand_path(file_name)
  return if loaded.include?(expanded)
  Dependencies.load_interlock do
    # Maybe it got loaded while we were waiting for our lock:
    return if loaded.include?(expanded)
    # Record that we've seen this file *before* loading it to avoid an
    # infinite loop with mutual dependencies.
    loaded << expanded
    loading << expanded
    begin
      if load?
        # 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?
        if !warnings_on_first_load || history.include?(expanded)
          result = load_file(*load_args)
        else
          enable_warnings { result = load_file(*load_args) }
        end
      else
        result = require file_name
      end
    rescue Exception
      loaded.delete expanded
      raise
    ensure
      loading.pop
    end
    # Record history *after* loading so first load gets warnings.
    history << expanded
    result
  end
end

def safe_constantize(name)
  Reference.safe_get(name)
end

def search_for_file(path_suffix)
  path_suffix += ".rb" unless path_suffix.ends_with?(".rb")
  autoload_paths.each do |root|
    path = File.join(root, path_suffix)
    return path if File.file? path
  end
  nil # Gee, I sure wish we had first_match ;-)
end

def to_constant_name(desc) #:nodoc:
  case desc
  when String then desc.sub(/^::/, "")
  when Symbol then desc.to_s
  when Module
    real_mod_name(desc) ||
      raise(ArgumentError, "Anonymous modules have no name to be referenced by")
  else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
  end
end

def unhook!
  ModuleConstMissing.exclude_from(Module)
  Loadable.exclude_from(Object)
end

def will_unload?(const_desc)
  autoloaded?(const_desc) ||
    explicitly_unloadable_constants.include?(to_constant_name(const_desc))
end