Load the config files as specified via +files+.

 @param files [Array<String>] The path(s) for config files.
 @return [Config] The config hash. (+self+)
3567
def load_site_configs(*files)
      # Allows both:
      #   load_site_configs('foo', 'bar')
      #   load_site_configs(['foo', bar'])
      # but not:
      #   load_site_configs(['foo'], 'bar')
      files = files[0] if files.length == 1 && files[0].is_a?(Array)

      load_files(*files)
    end
71443
@SuppressWarnings("unused")
    private Map<String, String> hashFiles(String... fileNames) {
        Map<String, String> hashes = new HashMap<String, String>();
        for (int i = 0; i < fileNames.length; i++) {
            String hash = hashURL(fileNames[i]);
            hashes.put(fileNames[i], hash);
        }
        return hashes;
    }
1013998
def load_stylesheets
      # Load standard stylesheet
      style = ::File.expand_path("../../../config/style.css", __FILE__)
      @stylesheets << style
      @stylesheets << stylesheet if ::File.exists?(stylesheet)
    end
35090
def load_extensions
    self.class.validate_path @extensions_path
    Dir[File.join(@extensions_path, '**', '*.rb').to_s].each { |f| load(f) }
  end
88853
def load_files(file_finder)
      if file_finder.options.fetch(:files).empty?
        file_finder.list(*options[:extensions])
      else
        file_finder.options.fetch(:files) { [] }
      end
    end
859874
def load_config(filepath)
      return {} if filepath.nil? || !File.exist?(filepath)

      config_file = File.open(filepath).read

      # Replace environment variables
      config_file = parse_environment_variables(config_file)

      YAML.safe_load(config_file)
    end
1213689
def load_enviroment(file = nil)
        file ||= "."

        if File.directory?(file) && File.exists?(File.expand_path("#{file}/config/environment.rb"))
          require 'rails'
          require File.expand_path("#{file}/config/environment.rb")
          if defined?(::Rails) && ::Rails.respond_to?(:application)
            # Rails 3
            ::Rails.application.eager_load!
          elsif defined?(::Rails::Initializer)
            # Rails 2.3
            $rails_rake_task = false
            ::Rails::Initializer.run :load_application_classes
          end
        elsif File.file?(file)
          require File.expand_path(file)
        end
      end
761893
def parse_files
      @parse_files ||= begin
        files = expand_dirs_to_files(@path)
        files = file_sort(files)

        if @options['only'].present?
          files = file_accept(files, @options['only'])
        end

        # By default, tmp, vender, spec, test, features are ignored.
        %w[vendor spec test features tmp].each do |dir|
          files = file_ignore(files, File.join(@path, dir)) unless @options[dir]
        end

        # Exclude files based on exclude regexes if the option is set.
        @options['exclude'].each do |pattern|
          files = file_ignore(files, pattern)
        end

        %w[Capfile Gemfile Gemfile.lock].each do |file|
          files.unshift File.join(@path, file)
        end

        files.compact
      end
    end
848906
def load_files(files):
    """"""

    for py_file in files:
        LOG.debug("exec %s", py_file)
        execfile(py_file, globals(), locals())
800157
def config_files(override)
      files = []
      if override.stringify_keys.key?('config')
        files = override.stringify_keys.delete('config')
        override.delete('config')
      else
        files << source(override) + File::SEPARATOR + DEFAULT_FILENAME
      end
      files = [files] unless files.is_a? Array
      files
    end
1336984
def load_layout(files, initial = {})
      layout = initial
      Squib::logger.info { "  using layout(s): #{files}" }
      Array(files).each do |file|
        thefile = file
        thefile = builtin(file) unless File.exists?(file)
        if File.exists? thefile
          # note: YAML.load_file returns false on empty file
          yml = layout.merge(YAML.load_file(thefile) || {})
          yml.each do |key, value|
            layout[key] = recurse_extends(yml, key, {})
          end
        else
          Squib::logger.error { "Layout file not found: #{file}. Skipping..." }
        end
      end
      return layout
    end
904960
def load_application_files
      if %w(development test).include?(env.to_s)
        config['autoload_paths'].each(&method(:autoreload_constants))
        autoreload_yml
      end
      config['autoload_paths'].each(&method(:require_dependencies))
    end
32466
def load_filter_file(file, hash)
      # collect the class => attribute => filter entries
      logger.debug { "Loading the migration filter configuration #{file}..." }
      begin
        config = YAML::load_file(file)
      rescue
        raise MigrationError.new("Could not read filter file #{file}: " + $!)
      end
      config.each do |path_s, flt|
        next if flt.nil_or_empty?
        klass, path = create_attribute_path(path_s)
        if path.empty? then
          raise MigrationError.new("Migration filter configuration path does not include a property: #{path_s}")
        elsif path.size > 1 then
          raise MigrationError.new("Migration filter configuration path with more than one property is not supported: #{path_s}")
        end
        pa = klass.standard_attribute(path.first.to_sym)
        flt_hash = hash[klass] ||= {}
        flt_hash[pa] = flt
      end
    end
1373658
def load
      @config = YAML.load_file(config_path)
      @status.set(errors: Status::INFO_FILE_LOADED)
      if @config == false
        @status.set(errors: Status::ERR_NOT_LOADING_EMPTY_FILE)
      end
    rescue
      @status.set(errors: Status::ERR_CANT_LOAD)
    end
659940
def load_default_config_files
      [ENV['FLO_CONFIG_FILE'], File.join(Dir.pwd, '.flo'), File.join(Dir.home, '.flo')].compact.each do |file|
        if File.exist?(file)
          self.load_config_file(file)
        end
      end
    end
277925
def load_file_exclusions
      return unless config_hash["Exclude Files"]
      config_options[:excluded_files] = []
      config_hash["Exclude Files"].each do |short_file|
        config_options[:excluded_files] << File.join(starting_path, short_file)
      end
    end
822015
def read_config_file(file)
      next_config = safe_load_file(file)
      check_config_is_hash!(next_config, file)
      Bunto.logger.info "Configuration file:", file
      next_config
    rescue SystemCallError
      if @default_config_file ||= nil
        Bunto.logger.warn "Configuration file:", "none"
        {}
      else
        Bunto.logger.error "Fatal:", "The configuration file '#{file}'
          could not be found."
        raise LoadError, "The Configuration file '#{file}' could not be found."
      end
    end