module RConfig::CoreMethods

Public Instance Methods

[](key, file=:application) click to toggle source

This method provides shorthand to retrieve configuration data that is global in scope, and used on an application or environment-wide level. The default location that it checks is the application file. The application config file is a special config file that should be used for config data that is broad in scope and used throughout the application. Since RConfig gives special regard to the application config file, thought should be given to whatever config information is placed there.

Most config data will be specific to particular part of the application (i.e. database, web service), and should therefore be placed in its own specific config file, such as database.yml, or services.xml

This method also acts as a wrapper for ENV. If no value is returned from the application config, it will also check ENV for a value matching the specified key.

Ex.1 RConfig =>

RConfig.application[:test_mode] ||
RConfig.application.test_mode

Ex.2 RConfig => ENV

NOTE: The application config file can be in any of

the supported formats (yml, xml, conf, etc.)
# File lib/rconfig/core_methods.rb, line 224
def [](key, file=:application)
  with_file(file, key) || ENV[key.to_s.upcase]
end
check_for_changes(name=nil) click to toggle source

If name is specified, checks that file for changes and reloads it if there are. Otherwise, checks all files in the cache, reloading the changed files.

# File lib/rconfig/core_methods.rb, line 164
def check_for_changes(name=nil)
  changed = []
  if name == nil
    self.cache_hash.keys.dup.each do |name|
      if reload_on_change(name)
        changed << name
      end
    end
  else
    name = name.to_s
    if reload_on_change(name)
      changed << name
    end
  end
  logger.debug "check_for_changes(#{name.inspect}) => #{changed.inspect}"
  changed
end
config_changed?(name) click to toggle source

Returns whether or not the config for the given config name has changed since it was last loaded.

Returns true if any files for config have changes since last load.

# File lib/rconfig/core_methods.rb, line 131
def config_changed?(name)
  logger.debug "config_changed?(#{name.inspect})"
  name = name.to_s
  !(self.cache_files[name] === get_config_files(name))
end
config_files(name) click to toggle source

Return the config file information for the given config name.

# File lib/rconfig/core_methods.rb, line 120
def config_files(name)
  self.cache_files[name] ||= get_config_files(name)
end
config_for(name) click to toggle source

Get a hash of merged config data. Will auto check every 5 minutes, for longer running apps, unless reload is disabled.

# File lib/rconfig/core_methods.rb, line 252
def config_for(name)
  name = name.to_s
  check_for_changes(name) if auto_check?(name)
  data = get_config_data(name)
  logger.debug "config_for(#{name.inspect}) => #{data.inspect}"
  data
end
get_config_data(name) click to toggle source

Get the merged config hash for the named file. Returns a cached indifferent access faker hash merged from all config files for a name.

# File lib/rconfig/core_methods.rb, line 143
def get_config_data(name)
  logger.debug "get_config_data(#{name.inspect})"

  name = name.to_s
  unless result = self.cache_hash[name]
    result = self.cache_hash[name] =
        make_indifferent(
            merge_hashes(
                load_config_files(name)
            )
        )
    logger.debug "get_config_data(#{name.inspect}): reloaded"
  end

  result
end
get_config_files(name) click to toggle source

Returns a list of all relevant config files as specified by suffixes list. Each element is an Array, containing:

[ 
  "server",              # The base name of the 
  "server_production",   # The suffixed name
  "/path/to/server.yml", # The absolute path to the file 
  <Wed Apr 09 08:53:14>  # The last modified time of the file or nil, if it doesn't exist.
]
# File lib/rconfig/core_methods.rb, line 95
def get_config_files(name)
  files = []

  self.load_paths.reverse.each do |directory|
    # splatting *suffix allows us to deal with multipart suffixes
    name_no_overlay, suffixes = suffixes_for(name)
    suffixes.map { |suffix| [name_no_overlay, *suffix].compact.join('_') }.each do |name_with_suffix|
      self.file_types.each do |ext|
        filename = filename_for_name(name_with_suffix, directory, ext)
        if File.exists?(filename)
          modified_time = File.stat(filename).mtime
          files << [name, name_with_suffix, filename, ext, modified_time]
        end
      end
    end
  end

  logger.debug "get_config_files(#{name}) => #{files.select { |x| x[3] }.inspect}"

  files
end
load_config_files(name, force=false) click to toggle source

Get each config file's yaml hash for the given config name, to be merged later. Files will only be loaded if they have not been loaded before or the files have changed within the last five minutes, or force is explicitly set to true.

# File lib/rconfig/core_methods.rb, line 14
def load_config_files(name, force=false)
  name = name.to_s

  # Return last config file hash list loaded,
  # if reload is disabled and files have already been loaded.
  return self.cache_config_files[name] if self.reload_disabled? && self.cache_config_files[name]

  logger.info "Loading config files for: #{name}"
  logger.debug "load_config_files(#{name.inspect})"

  # Get current time for checking last loaded status.
  now = Time.now

  # Get array of all the existing files file the config name.
  config_files = self.get_config_files(name)

  # Get all the data from all yaml files into as configs
  configs = config_files.collect do |f|
    name, name_with_suffix, filename, ext, modified_time = * f

    # Get the cached file info the specific file, if
    # it's been loaded before.
    config_data, last_modified, last_loaded = self.cache[filename]

    logger.debug "f = #{f.inspect}\n" +
      "cache #{name_with_suffix} filename      = #{filename.inspect}\n" +
      "cache #{name_with_suffix} config_data   = #{config_data.inspect}\n" +
      "cache #{name_with_suffix} last_modified = #{last_modified.inspect}\n" +
      "cache #{name_with_suffix} last_loaded   = #{last_loaded.inspect}\n"

    # Load the file if its never been loaded or its been more than
    # so many minutes since last load attempt. (default: 5 minutes)
    if config_data.blank? || (now - last_loaded > self.reload_interval)
      if force || config_data.blank? || modified_time != last_modified

        logger.debug "modified_time #{name.inspect} #{filename.inspect} " +
          "changed #{modified_time != last_modified} : #{modified_time.inspect} #{last_modified.inspect}"

        logger.debug "RConfig: loading #{filename.inspect}"

        config_data = read(filename, name, ext)  # Get contents from config file

        logger.debug "RConfig: loaded #{filename.inspect} => #{config_data.inspect}"

        (self.config_loaded ||= {})[name] = config_files  # add files to the loaded files cache

        self.cache[filename] = [config_data, modified_time, now]  # Save cached config file contents, and modified_time.

        logger.debug "cache[#{filename.inspect}] = #{self.cache[filename].inspect}"

        self.cache_hash[name] = nil # Flush merged hash cache.

        self.cache_files[name] = config_files  # Config files changed or disappeared.

      end # if config_data == nil || (now - last_loaded > self.reload_interval)
    end # if force || config_data == nil || modified_time != last_modified

    config_data
  end # config_files.collect
  configs.compact!

  logger.debug "load_config_files(#{name.inspect}) => #{configs.inspect}"

  # Keep last loaded config files around in case self.reload_dsabled.
  self.cache_config_files[name] = configs #unless configs.empty?

  configs
end
method_missing(method, * args) click to toggle source

Short-hand access to config file by its name.

Example:

RConfig.provider(:foo) => RConfig.with_file(:provider).foo
RConfig.provider.foo   => RConfig.with_file(:provider).foo
# File lib/rconfig/core_methods.rb, line 268
def method_missing(method, * args)
  value = with_file(method, * args)
  logger.debug "#{self}.method_missing(#{method.inspect}, #{args.inspect}) => #{value.inspect}"
  value
end
reload_on_change(name) click to toggle source

If config files have changed, caches are flushed, on_load triggers are run.

# File lib/rconfig/core_methods.rb, line 184
def reload_on_change(name)
  logger.debug "reload_on_change(#{name.inspect}), reload_disabled=#{self.reload_disabled?}"
  if changed = config_changed?(name) && reload?
    if self.cache_hash[name]
      flush_cache(name)  # flush cached config values.
      fire_on_load(name) # force on_load triggers.
    end
  end
  changed
end
with_file(name, *args) click to toggle source

Get the value specified by the args, in the file specified by th name

# File lib/rconfig/core_methods.rb, line 231
def with_file(name, *args)
  logger.debug "with_file(#{name.inspect}, #{args.inspect})"
  result = args.inject(config_for(name)) { |v, i|
    logger.debug "v = #{v.inspect}, i = #{i.inspect}"
    case v
      when Hash
        v[i.to_s]
      when Array
        i.is_a?(Integer) ? v[i] : nil
      else
        nil
    end
  }
  logger.debug "with_file(#{name.inspect}, #{args.inspect}) => #{result.inspect}"
  result
end