module ActiveSupport::Dependencies

def associate_with(file_name)
  depend_on(file_name, true)
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
  autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
  return 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)
  # No name => anonymous module.
  return false if desc.is_a?(Module) && desc.anonymous?
  name = to_constant_name desc
  return false unless qualified_const_defined? name
  return autoloaded_constants.include?(name)
end

def clear
  log_call
  loaded.clear
  remove_unloadable_constants!
end

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

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

def hook!
  Object.class_eval { include Loadable }
  Module.class_eval { include ModuleConstMissing }
  Exception.class_eval { include Blamable }
  true
end

def load?
  mechanism == :load
end

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| /(.*)::[^:]+\Z/ =~ const_path ? $1 : :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?
  return result
end

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
  raise NameError, "#{from_mod} is not missing constant #{const_name}!" if local_const_defined?(from_mod, const_name)
  qualified_name = qualified_name_for from_mod, const_name
  path_suffix = qualified_name.underscore
  file_path = search_for_file(path_suffix)
  if file_path && ! loaded.include?(File.expand_path(file_path).sub(/\.rb\z/, '')) # We found a matching file to load
    require_or_load file_path
    raise LoadError, "Expected #{file_path} to define #{qualified_name}" unless local_const_defined?(from_mod, const_name)
    return from_mod.const_get(const_name)
  elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
    return mod
  elsif (parent = from_mod.parent) && parent != from_mod &&
        ! from_mod.parents.any? { |p| local_const_defined?(p, const_name) }
    # 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
      return parent.const_missing(const_name)
    rescue NameError => e
      raise unless e.missing_name? qualified_name_for(parent, const_name)
    end
  end
  raise NameError,
        "uninitialized constant #{qualified_name}",
        caller.reject {|l| l.starts_with? __FILE__ }
end

def load_once_path?(path)
  # to_s works around a ruby1.9 issue where #starts_with?(Pathname) will always return false
  autoload_once_paths.any? { |base| path.starts_with? base.to_s }
end

def loadable_constants_for_path(path, bases = autoload_paths)
  path = $1 if path =~ /\A(.*)\.rb\Z/
  expanded_path = File.expand_path(path)
  paths = []
  bases.each do |root|
    expanded_root = File.expand_path(root)
    next unless %r{\A#{Regexp.escape(expanded_root)}(/|\\)} =~ expanded_path
    nesting = expanded_path[(expanded_root.size)..-1]
    nesting = nesting[1..-1] if nesting && nesting[0] == ?/
    next if nesting.blank?
    paths << nesting.camelize
  end
  paths.uniq!
  paths
end

def local_const_defined?(mod, const)
  mod.const_defined?(const)
end

def local_const_defined?(mod, const) #:nodoc:
  mod.const_defined?(const, false)
end

def log(msg)
  logger.debug "Dependencies: #{msg}" if log_activity?
end

def log_activity?
  logger && log_activity
end

def log_call(*args)
  if log_activity?
    arg_str = args.collect { |arg| arg.inspect } * ', '
    /in `([a-z_\?\!]+)'/ =~ caller(1).first
    selector = $1 || '<unknown>'
    log "called #{selector}(#{arg_str})"
  end
end

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

def new_constants_in(*descs)
  log_call(*descs)
  constant_watch_stack.watch_namespaces(descs)
  aborting = true
  begin
    yield # Now yield to the code that is to define new constants.
    aborting = false
  ensure
    new_constants = constant_watch_stack.new_constants
    log "New constants: #{new_constants * ', '}"
    return new_constants unless aborting
    log "Error during loading, removing partially loaded constants "
    new_constants.each {|c| remove_constant(c) }.clear
  end
  return []
end

def qualified_const_defined?(path)
  Object.qualified_const_defined?(path.sub(/^::/, ''))
end

def qualified_const_defined?(path)
  Object.qualified_const_defined?(path.sub(/^::/, ''), 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 reference(klass)
  Reference.store klass
end

def remove_constant(const) #:nodoc:
  return false unless qualified_const_defined? const
  # Normalize ::Foo, Foo, Object::Foo, and ::Object::Foo to Object::Foo
  names = const.to_s.sub(/^::(Object)?/, 'Object::').split("::")
  to_remove = names.pop
  parent = Inflector.constantize(names * '::')
  log "removing constant #{const}"
  constantized = constantize(const)
  constantized.before_remove_const if constantized.respond_to?(:before_remove_const)
  parent.instance_eval { remove_const to_remove }
  return true
end

def remove_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)
  log_call file_name, const_path
  file_name = $1 if file_name =~ /^(.*)\.rb$/
  expanded = File.expand_path(file_name)
  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
  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?
      if !warnings_on_first_load or history.include?(expanded)
        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
  end
  # Record history *after* loading so first load gets warnings.
  history << expanded
  return result
end

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

def search_for_file(path_suffix)
  path_suffix = path_suffix.sub(/(\.rb)?$/, ".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
      desc.name.presence ||
        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)
  true
end

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