rconfig 0.3.3 → 0.4.0

data/lib/rconfig/properties_file.rb

@@ -0,0 +1,138 @@
+##
+# Copyright (c) 2009 Rahmal Conda <rahmal@gmail.com>
+#
+# This class parses key/value based properties files used for configuration.
+# It is used by rconfig to import configuration files of the aforementioned
+# format. Unlike yaml, and xml files it can only support three levels. First,
+# it can have root level properties:
+#
+#            server_url=host.domain.com
+#            server_port=8080
+#
+# Secondly, it can have properties grouped into catagories. The group names
+# must be specified within brackets like [ ... ]
+#
+#            [server]
+#            url=host.domain.com
+#            port=8080
+#
+# Finally, groups can also be qualified with namespaces, similar to git 
+# config files. Group names are same as before, but with namespace in
+# within the brackets like [ <group> "<name>" ]
+#
+#            [host "dev"]
+#            domain=dev.server.com
+#
+#            [host "prod"]
+#            domain=www.server.com
+#
+# These can be retrieved using dot-notation or variable to do it dynamically.
+#
+#            RConfig.props.host.dev.domain
+#                      - or -
+#            RConfig.props.host[env].domain  (where env is 'dev' or 'prod')
+#
+module RConfig
+  class PropertiesFile
+    include Singleton # Don't instantiate this class
+
+    COMMENT = /^\#/
+    KEYVAL  = /\s*=\s*/
+    QUOTES  = /^['"](.*)['"]$/
+    GROUP   = /^\[(.+)\]$/
+    NAMEGRP = /^\[(.+) \"(.+)\"\]$/
+    KEY_REF = /(.+)?\%\{(.+)\}(.+)?/
+
+    ##
+    # Parse config file and import data into hash to be stored in config.
+    #
+    def self.parse(config_file)
+      raise ArgumentError, 'Invalid config file name.' unless config_file
+
+      config = {}
+
+      # The config is top down.. anything after a [group] gets added as part
+      # of that group until a new [group] is found.  
+      group, topgrp = nil
+      config_file.split("\n").each do |line|   # for each line in the config file
+        line.strip!
+        unless COMMENT.match(line) # skip comments (lines that state with '#')
+          if KEYVAL.match(line)    # if this line is a config property
+            key, val = line.split(KEYVAL, 2) # parse key and value from line
+            key = key.chomp.strip
+            val = val.chomp.strip
+            if val
+              if val =~ QUOTES # if the value is in quotes
+                value = $1     # strip out value from quotes
+              else
+                value = val    # otherwise, leave as-is
+              end
+            else
+              value = ''       # if value was nil, set it to empty string
+            end
+
+            if topgrp                                # If there was a top-level named group, then there must be a group.
+              config[topgrp][group][key] = value     # so add the prop to the named group
+            elsif group                              # if this property is part of a group
+              config[group][key] = value             # then add it to the group
+            else                                     # otherwise... 
+              config[key] = value                    # add the prop to top-level config
+            end
+
+          elsif match = NAMEGRP.match(line) # This line is a named group (i.e. [env "test"], [env "qa"], [env "production"])
+            topgrp, group = match.to_a[1..-1] # There can be multiple groups within a single top-level group
+            config[topgrp] ||= {} # add group to top-level group
+            config[topgrp][group] ||= {} # add name of group as subgroup (properties are added to subgroup)
+
+          elsif match = GROUP.match(line) # if this line is a config group
+            group = match.to_a[1] # parse the group name from line
+            topgrp = nil # we got a new group with no namespace, so reset topgrp
+            config[group] ||= {} # add group to top-level config
+          end
+        end
+      end
+
+      # Pre-populate the values that refer to other properties
+      # Example:
+      #   root_path = /path/to/root
+      #   image_path = %{root_path}/images
+      config = parse_references(config)
+
+      config # return config hash
+    end # def parse
+  
+    ##
+    # Recursively checks all the values in the hash for references to other properties,
+    # and replaces the references with the actual values.  The syntax for referring to 
+    # another property in the config file is the ley of the property wrapped in curly
+    # braces, preceded by a percent sign.  If the property is in a group, then the full 
+    # namespace must be used.
+    #
+    # Example:
+    #   root_path = /path/to/root             # In this property file snippet 
+    #   image_path = %{root_path}/images      # image path refers to root path
+    #
+    #
+    def self.parse_references hash, config=nil
+      config ||= hash.dup
+
+      hash.each do |key, val|
+        case val
+        when Hash
+          hash[key] = parse_references(val, config)
+        when String
+          pre, ref, post = KEY_REF.match(val).to_a[1..-1]
+          hash[key] = if ref
+              ref = ref.split('.').inject(config){|c,i| c && c[i] }
+              [pre, ref, post].join              
+            else
+              val
+            end         
+        end
+      end
+
+      hash
+    end # def parse_references
+
+  end # class PropertiesFileParser
+end # module RConfig

data/lib/rconfig/reload.rb

@@ -0,0 +1,75 @@
+module RConfig
+  module Reload
+
+    ##
+    # Flag indicating whether or not reload should be executed.
+    def reload?
+      self.enable_reload
+    end
+
+    def reload_disabled?
+      not reload?
+    end
+
+    ##
+    # Sets the flag indicating whether or not reload should be executed.
+    def enable_reload=(reload)
+      raise ArgumentError, 'Argument must be true or false.' unless [true, false].include?(reload)
+      self.enable_reload = reload
+    end
+
+    ##
+    # Sets the number of seconds between reloading of config files
+    # and automatic reload checks. Defaults to 5 minutes. Setting
+    #
+    def reload_interval=(interval)
+      raise ArgumentError, 'Argument must be Integer.' unless interval.kind_of?(Integer)
+      self.enable_reload = false if interval == 0  # Sett
+      self.reload_interval = interval
+    end
+
+    ##
+    # Flushes cached config data, so that it can be reloaded from disk.
+    # It is recommended that this should be used with caution, and any
+    # need to reload in a production setting should minimized or
+    # completely avoided if possible.
+    def reload(force=false)
+      raise ArgumentError, 'Argument must be true or false.' unless [true, false].include?(force)
+      if force || reload?
+        flush_cache
+        return true
+      end
+      false
+    end
+
+    ##
+    # Executes given block, without reloading any config. Meant to
+    # run configuration-sensitive code that may otherwise trigger a
+    # reload of any/all config files. If reload is disabled then it
+    # makes no difference  if this wrapper is used or not.
+    # Returns result of the block
+    def without_reload(&block)
+      return unless block_given?
+      result = nil
+      enable_reload_cache = self.enable_reload
+      begin
+        self.enable_reload
+        result = yield
+      ensure
+        self.enable_reload = enable_reload_cache
+        check_config_changed if reload?
+      end
+      result
+    end
+
+    def auto_check?(name)
+      now = Time.now
+      if (!self.last_auto_check[name]) || (now - self.last_auto_check[name]) > self.reload_interval
+        self.last_auto_check[name] = now
+        return true
+      end
+      return false
+    end
+    
+  end
+end

data/lib/rconfig/settings.rb

@@ -0,0 +1,93 @@
+module RConfig
+  module Settings
+    extend Utils
+    include Constants
+
+    ### Configuration Settings ====>
+
+    # Load paths for configuration files. Add folders to this load path
+    # to load up other resources for administration. External gems can
+    # include their paths in this load path to provide active_admin UIs
+    setting :load_paths,          default_load_paths
+
+    # Custom cascade used when cascading configurations to override default
+    # config files. Can be used to add locale or branch specific configs.
+    setting :overlay,             false
+
+    # The type of configuration files to load Supported file types are yaml,
+    # xml, and property files (.property).
+    setting :file_types,          CONFIG_FILE_TYPES
+
+    # The logger rconfig will log to.
+    setting :logger,              RConfig::Logger.new
+
+    # Indicates whether or not periodic reloads should be performed.
+    setting :enable_reload,       false
+
+    # How often periodic reloads should be performed in seconds.
+    # The number of seconds between reloading of config files
+    # and automatic reload checks. Defaults to 5 minutes.
+    setting :reload_interval,     300  # 5 min
+
+    ### Initialize Configuration Cache ====>
+
+    # Primary configuration cache for RConfig.
+    # Hash of yaml file names and their respective contents,
+    # last modified time, and the last time it was loaded.
+    # self.cache[filename] = [yaml_contents, mod_time, time_loaded]
+    setting :cache,               {}
+
+    # File cache used to store loaded configuration files.
+    # Hash of config file base names and their existing filenames
+    # including the suffixes.
+    # self.cache_files['ldap'] = ['ldap.yml', 'ldap_local.yml', 'ldap_<hostname>.yml']
+    setting :cache_files,         {}
+
+    # Cache key-value lookup
+    # Hash of config base name and the contents of all its respective
+    # files merged into hashes. This hash holds the data that is
+    # accessed when RConfig is called. This gets re-created each time
+    # the config files are loaded.
+    # self.cache_hash['ldap'] = config_hash
+    setting :cache_hash,          {}
+
+    # This hash holds the same info as self.cache_hash, but it is only
+    # loaded once. If reload is disabled, data will from this hash
+    # will always be passed back when RConfig is called.
+    setting :cache_config_files,  {}
+
+    # Hash of suffixes for a given cascading configuration name.
+    # The suffixes are used to load cascading configurations for
+    # a specified name.
+    # Example:
+    #   self.suffixes[:name] #=> %w[ name_development name_staging name_production name_GB ]
+    setting :suffixes,            {}
+
+    # Hash of callbacks, mapped to a given config file. Each collection of procs are
+    # executed when the config file they are mapped to has been reloaded.
+    setting :callbacks,           {}
+
+    # Hash of config base name and the last time it was checked for
+    # update.
+    # self.last_auto_check['ldap'] = Time.now
+    setting :last_auto_check,     {}
+
+    # Helper variable for white-box testing and debugging.
+    # A hash of each file that has been loaded.
+    setting :config_loaded
+
+    # Magically unique value. Used to provide a key to retrieve a default value
+    # specified in a config file. The symbol is wrapped in an array so that it will
+    # not be treated like a normal key and changed to a string.
+    #
+    # Example:
+    #          currency:
+    #            us: dollar
+    #            gb: pound
+    #            default: dollar
+    #
+    #          RConfig.currency.ca => 'dollar'
+    setting :default_key,         [:default_key].freeze
+
+  end
+end

data/lib/rconfig/utils.rb

@@ -0,0 +1,175 @@
+module RConfig
+  module Utils
+    include Constants
+
+    # Used to customize configuration of RConfig. Run 'rails generate rconfig:install' to create
+    # a fresh initializer with all configuration values.
+    def setup
+      yield self
+      raise_load_path_error if load_paths.empty?
+      self.logger ||= DisabledLogger.new
+    end
+
+    # Creates a class variable a sets it to the default value specified.
+    def setting(name, default=nil)
+      RConfig.class_eval <<-EOC, __FILE__, __LINE__ + 1
+        def self.#{name}
+          @@#{name}
+        end
+        def self.#{name}=(val)
+          @@#{name} = val
+        end
+      EOC
+
+      RConfig.send(:"#{name}=", default)
+    end
+
+    # Checks environment for default configuration load paths.  Adds them to load paths if found.
+    def default_load_paths
+      paths = []
+
+      # Check for Rails config path
+      paths << "#{::Rails.root}/config" if rails?
+
+      # Check for defined constants
+      paths << CONFIG_ROOT if defined?(CONFIG_ROOT) && Dir.exists?(CONFIG_ROOT)
+      paths << CONFIG_PATH if defined?(CONFIG_PATH) && Dir.exists?(CONFIG_PATH)
+
+      # Check for config directory in app root
+      config_dir = File.join(app_root, 'config')
+      paths << config_dir if Dir.exists?(config_dir)
+
+      paths
+    end
+
+    ##
+    #  Returns true if the current application is a rails app.
+    def rails?
+      !!defined?(::Rails)
+    end
+
+    ##
+    #
+    def app_root
+      File.expand_path(File.dirname(__FILE__))
+    end
+
+    ##
+    # Helper method for white-box testing and debugging.
+    # Sets the flag indicating whether or not to log
+    # errors and application run-time information.
+    def log_level=(level)
+      return unless logger
+      logger.level = level unless level.nil?
+    end
+
+    def log_level
+      logger.try(:level)
+    end
+
+    ##
+    # Creates a dottable hash for all Hash objects, recursively.
+    def create_dottable_hash(hash)
+      make_indifferent(hash)
+    end
+
+    ##
+    # Reads and parses the config data from the specified file.
+    def read(file, name, ext)
+      contents = File.read(file)           # Read the contents from the file.
+      contents = ERB.new(contents).result  # Evaluate any ruby code using ERB.
+      parse(contents, name, ext)           # Parse the contents based on the file type
+    end
+
+    ##
+    # Parses contents of the config file based on file type.
+    # XML files expect the root element to be the same as the
+    # file name.
+    #
+    def parse(contents, name, ext)
+      hash = case ext
+        when *YML_FILE_TYPES
+          YAML::load(contents)
+        when *XML_FILE_TYPES
+          parse_xml(contents, name)
+        when *CNF_FILE_TYPES
+          RConfig::PropertiesFile.parse(contents)
+        else
+          raise ConfigError, "Unknown File type: #{ext}"
+        end
+      hash.freeze
+    end
+
+    ##
+    # Parses xml file and processes any references in the property values.
+    def parse_xml(contents, name)
+      hash = Hash.from_xml(contents)
+      hash = hash[name] if hash.size == 1 && hash.key?(name)  # xml document could have root tag matching the file name.
+      RConfig::PropertiesFile.parse_references(hash)
+    end
+
+    ##
+    # Returns a merge of hashes.
+    #
+    def merge_hashes(hashes)
+      hashes.inject({}) { |n, h| n.weave(h, true) }
+    end
+
+    ##
+    # Recursively makes hashes into frozen IndifferentAccess Config Hash
+    # Arrays are also traversed and frozen.
+    #
+    def make_indifferent(hash)
+      case hash
+        when Hash
+          unless hash.frozen?
+            hash.each do |k, v|
+              hash[k] = make_indifferent(v)
+            end
+            hash = RConfig::Config.new.merge!(hash).freeze
+          end
+          logger.debug "make_indefferent: x = #{hash.inspect}:#{hash.class}"
+        when Array
+          unless hash.frozen?
+            hash.collect! do |v|
+              make_indifferent(v)
+            end
+            hash.freeze
+          end
+          # Freeze Strings.
+        when String
+          hash.freeze
+        end
+      hash
+    end
+
+    ##
+    # If a config file name is specified, flushes cached config values
+    # for specified config file. Otherwise, flushes all cached config data.
+    # The latter should be avoided in production environments, if possible.
+    def flush_cache(name=nil)
+      if name
+        name = name.to_s
+        self.cache_hash[name] &&= nil
+      else
+        logger.warn "RConfig: Flushing config data cache."
+        self.suffixes        = {}
+        self.cache           = {}
+        self.cache_files     = {}
+        self.cache_hash      = {}
+        self.last_auto_check = {}
+        self
+      end
+    end
+
+    ##
+    # Get complete file name, including file path for the given config name
+    # and directory.
+    def filename_for_name(name, directory=self.load_paths.first, ext=:yml)
+      File.join(directory, "#{name}.#{ext}")
+    end
+
+
+
+  end
+end