rconfig 0.3.3 → 0.4.0

data/lib/rconfig/core_ext/nil.rb

@@ -0,0 +1,5 @@
+class NilClass
+   def blank?
+     true
+   end
+end

data/lib/rconfig/core_ext/string.rb

@@ -0,0 +1,3 @@
+class String
+  alias_method :blank?, :empty?
+end

data/lib/rconfig/core_methods.rb

@@ -0,0 +1,276 @@
+##
+# Copyright (c) 2009 Rahmal Conda <rahmal@gmail.com>
+#
+module RConfig
+  module CoreMethods
+    include Constants
+
+    ##
+    # 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.
+    #
+    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})"
+
+
+      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
+
+
+    ##
+    # 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.
+    #   ]
+    #
+    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
+
+    ##
+    # Return the config file information for the given config name.
+    #
+    def config_files(name)
+      self.cache_files[name] ||= get_config_files(name)
+    end
+
+
+    ##
+    # 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.
+    def config_changed?(name)
+      logger.debug "config_changed?(#{name.inspect})"
+      name = name.to_s
+      !(self.cache_files[name] === get_config_files(name))
+    end
+
+
+    ##
+    # Get the merged config hash for the named file.
+    # Returns a cached indifferent access faker hash merged
+    # from all config files for a name.
+    #
+    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
+
+    ##
+    # 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.
+    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
+
+    ##
+    # If config files have changed, caches are flushed, on_load triggers are run.
+    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
+
+
+    ##
+    # 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[:test_mode] =>
+    #        RConfig.application[:test_mode] ||
+    #        RConfig.application.test_mode
+    #
+    # Ex.2  RConfig[:web_app_root] => ENV['WEB_APP_ROOT']
+    #
+    # NOTE: The application config file can be in any of
+    #       the supported formats (yml, xml, conf, etc.)
+    #
+    def [](key, file=:application)
+      self.config_for(file)[key] || ENV[key.to_s.upcase]
+    end
+
+    ##
+    # Get the value specified by the args, in the file specified by th name
+    #
+    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
+
+    ##
+    # Get a hash of merged config data.
+    # Will auto check every 5 minutes, for longer running apps, unless reload is disabled.
+    #
+    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
+
+    ##
+    # 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
+    #
+    def method_missing(method, * args)
+      value = with_file(method, * args)
+      logger.debug "#{self}.method_missing(#{method.inspect}, #{args.inspect}) => #{value.inspect}"
+      value
+    end
+
+  end
+end
+

data/lib/rconfig/exceptions.rb

@@ -1,13 +1,26 @@
-
-#--
+##
 # Copyright (c) 2009 Rahmal Conda <rahmal@gmail.com>
 #
 # RConfig Exceptions
-#++
+#
+module RConfig
+  # General error in config initialization or operation.
+  class ConfigError < StandardError; end
+
+  # Load path(s) are not set, don't exist, or Invalid in some manner
+  class InvalidLoadPathError < ConfigError; end
+
+  module Exceptions
+
+    # Raised when no valid load paths are available.
+    def raise_load_path_error
+      raise InvalidLoadPathError, "No load paths were provided, and none of the default paths were found."
+    end
 
-# General error in config initialization or operation.
-class ConfigError < StandardError; end
+    # Raised if logging is enabled, but no logger is specified}.
+    def raise_logger_error
+      raise ConfigError, "No logger was specified, and a defualt logger was not found. Set logger to `false` to disable logging."
+    end
 
-# Config path(s) are not set, don't exist, or Invalid in some manner
-class InvalidConfigPathError < ConfigError; end
- 
+  end
+end

data/lib/rconfig/load_paths.rb

@@ -0,0 +1,55 @@
+module RConfig
+  module LoadPaths
+    include Constants
+
+    ##
+    # Sets the list of directories to search for
+    # configuration files.
+    # The argument must be an array of strings representing
+    # the paths to the directories, or a string representing
+    # either a single path or a list of paths separated by
+    # either a colon (:) or a semi-colon (;).
+    def set_load_paths(paths)
+      self.load_paths = parse_load_paths(paths)
+      reload(true)  # Load Paths have changed so force a reload
+    end
+
+    ##
+    # Adds the specified path to the list of directories to search for
+    # configuration files.
+    # It only allows one path to be entered at a time.
+    def add_load_path(path)
+      if path = parse_load_paths(path).first # only accept first one.
+        self.load_paths << path
+        return reload(true)  # Load Paths have changed so force a reload
+      end
+      false
+    end
+
+    ##
+    # If the paths are made up of a delimited string, then parse out the
+    # individual paths. Verify that each path is valid.
+    def parse_load_paths(paths)
+      return [] unless paths
+      if paths.is_a? String
+        path_sep = (paths =~ /;/) ? ';' : ':'
+        paths = paths.split(/#{path_sep}+/)
+      end
+      raise ArgumentError, "Path(s) must be a String or an Array [#{paths.inspect}]" unless paths.is_a? Array
+      raise ArgumentError, "Must provide at least one load path: [#{paths.inspect}]" if paths.empty?
+      paths.each do |dir|
+        dir = CONFIG_ROOT if dir == 'CONFIG_ROOT'
+        raise RConfig::InvalidConfigPathError, "This directory is invalid: [#{dir.inspect}]" unless Dir.exists?(dir)
+      end
+      paths
+    end
+
+    ##
+    # Indicates whether or not config_paths have been set.
+    # Returns true if self.load_paths has at least one directory.
+    def load_paths_set?
+      not load_paths.blank?
+    end
+
+  end
+end

data/lib/rconfig/logger.rb

@@ -0,0 +1,86 @@
+module RConfig
+  class Logger #:nodoc:
+    attr_accessor :level, :log_format, :date_format
+    attr_reader   :output
+
+    FATAL     = 4
+    ERROR     = 3
+    WARN      = 2
+    INFO      = 1
+    DEBUG     = 0
+    
+    MAX_LEVEL = 4
+
+    def initialize(options={})
+      # Use provided output
+      if output = options[:output] && output.respond_to?(:puts)
+        @output = output
+        @needs_close = false
+      end
+
+      # Use log file
+      if output.nil? && options[:file] && File.exists?(optios[:file])
+        @output = File.open(options[:file].to_s, 'a')
+        @needs_close = true
+      end
+
+      # Default to stderr, if no outputter or file provider
+      @output ||= STDERR
+
+      # Use provided level or default to warn
+      @level = options[:level] ||
+        ((defined?(Rails) && %w[test development].include?(Rails.env)) ? DEBUG : WARN)
+
+      # Date format
+      @date_format = options[:date_format] || '%Y-%m-%d %H:%M:%S'
+      #@log_format  = options[:log_format] || "[%l] %d :: %M :: %t"
+    end
+
+    def close
+      output.close if @needs_close
+    end
+
+    def log(level, message)
+      if self.level <= level
+        indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
+        message.lines.each do |line|
+          log_str = "[#{indent}] #{Time.now.strftime(self.date_format)} :: #{line.strip}\n"
+          output.puts log_str
+        end
+      end
+    end
+
+    def fatal(message)
+      log(FATAL, message)
+    end
+
+    def error(message)
+      log(ERROR, message)
+    end
+
+    def warn(message)
+      log(WARN, message)
+    end
+
+    def info(message)
+      log(INFO, message)
+    end
+
+    def debug(message)
+      log(DEBUG, message)
+    end
+
+  end
+
+  class DisabledLogger
+    def log(level, message) end
+    def dont_log(message) end
+
+    alias_method :fatal, :dont_log
+    alias_method :error, :dont_log
+    alias_method :warn,  :dont_log
+    alias_method :info,  :dont_log
+    alias_method :debug, :dont_log
+  end
+end
+