configmanager 0.0.2 → 0.0.3

data/lib/configmanager.rb

@@ -1,27 +1,28 @@
-#
-# 16 Jul 2012
-#
-
-require "options_arg"
-
-require "configmanager/configuration"
-require "configmanager/loaders"
-
-# General purpose configuration manager.
-# Loads properties from YAML files and makes them available through a same hash like interface.
-# Supports ${} and $() style references. All references are evaluated only when a property's value is requested.
-module ConfigManager
-
-  # Loads properties from the specified file.
-  #
-  # @param [String] file_path the file to load properties from.
-  # @param [Object] loader any object that can respond to the 'load_properties(file_path, configuration)' method and return a hash.
-  # @param [ConfigManager::Configuration] configuration the configuration to load the properties into.
-  #
-  # @return [ConfigManager::Configuration] the configuration object wrapping the properties loaded from the file.
-  def self.load_from_file(file_path, loader = YAMLPropertiesLoader, configuration = ConfigManager::Configuration.new())
-    loader.load_properties(file_path, configuration)
-    configuration
-  end
-
+#
+# 16 Jul 2012
+#
+
+require "rubygems"
+require "options_arg"
+
+require "configmanager/configuration"
+require "configmanager/loaders"
+
+# General purpose configuration manager.
+# Loads properties from YAML files and makes them available through a same hash like interface.
+# Supports ${} and $() style references. All references are evaluated only when a property's value is requested.
+module ConfigManager
+
+  # Loads properties from the specified file.
+  #
+  # @param [String] file_path the file to load properties from.
+  # @param [Object] loader any object that can respond to the 'load_properties(file_path, configuration)' method and return a hash.
+  # @param [ConfigManager::Configuration] configuration the configuration to load the properties into.
+  #
+  # @return [ConfigManager::Configuration] the configuration object wrapping the properties loaded from the file.
+  def self.load_from_file(file_path, loader = YAMLPropertiesLoader, configuration = ConfigManager::Configuration.new())
+    loader.load_properties(file_path, configuration)
+    configuration
+  end
+
 end

data/lib/configmanager/combined_configuration.rb

@@ -1,65 +1,65 @@
-#
-# 20 Jul 2012
-#
-
-require "configmanager/configuration"
-require "configmanager/exceptions"
-
-module ConfigManager
-
-  # A configuration class that can merge multiple configuration trees into a single configuration tree.
-  # Each addition, overwrites any properties that already existed.
-  class CombinedConfiguration < ConfigManager::Configuration
-
-    # Creates a new empty combined configuration.
-    #
-    # @param [Hash] options configuration options. Supported keys are:
-    #   :interpolator - an object that can respond to the 'interpolate' method. Default is the DefaultInterpolator.
-    #   :use_interpolator - global flag to specify if the interpolator should be used for this configuration. Default is true.
-    def initialize(options = {})
-      super
-
-      @configurations = {}
-    end
-
-    # Adds a configuration to be merged into this configuration. All existing properties are overwritten.
-    #
-    # @param [String] name a unique name for this configuration, it can be retrieved later with this name.
-    # @param [ConfigManager::Configuration] configuration the configuration to be merged.
-    #
-    # @return [NilClass]
-    def add_configuration(name, configuration)
-      raise ConfigManager::KeyError.new("Cannot add - Configuration '#{name}' already exists!") if @configurations.has_key?(name)
-      @configurations[name] = configuration
-      merge_configuration(configuration)
-
-      nil
-    end
-
-    # Get the configuration identified by the specified name. Raises an exception if the configuration does not exist.
-    # Modifying the returned configuration does not update this combined configuration.
-    #
-    # @param [String] name the configuration to get.
-    #
-    # @return [ConfigManager::Configuration] the configuration.
-    def get_configuration(name)
-      raise ConfigManager::PropertyNotFoundError("Cannot get - Configuration '#{name}' does not exist!") unless @configurations.has_key?(name)
-      @configurations[name]
-    end
-
-    private
-
-    # Merges the specified configuration with this configuration. Existing nodes are overwritten!
-    #
-    # @param [ConfigManager::Configuration] configuration the configuration to merge.
-    #
-    # @return [NilClass]
-    def merge_configuration(configuration)
-      values = configuration.get_property("")
-      at = ""
-      add_properties(values, at, :overwrite => true)
-    end
-
-  end
-
-end
+#
+# 20 Jul 2012
+#
+
+require "configmanager/configuration"
+require "configmanager/exceptions"
+
+module ConfigManager
+
+  # A configuration class that can merge multiple configuration trees into a single configuration tree.
+  # Each addition, overwrites any properties that already existed.
+  class CombinedConfiguration < ConfigManager::Configuration
+
+    # Creates a new empty combined configuration.
+    #
+    # @param [Hash] options configuration options. Supported keys are:
+    #   :interpolator - an object that can respond to the 'interpolate' method. Default is the DefaultInterpolator.
+    #   :use_interpolator - global flag to specify if the interpolator should be used for this configuration. Default is true.
+    def initialize(options = {})
+      super
+
+      @configurations = {}
+    end
+
+    # Adds a configuration to be merged into this configuration. All existing properties are overwritten.
+    #
+    # @param [String] name a unique name for this configuration, it can be retrieved later with this name.
+    # @param [ConfigManager::Configuration] configuration the configuration to be merged.
+    #
+    # @return [NilClass]
+    def add_configuration(name, configuration)
+      raise ConfigManager::KeyError.new("Cannot add - Configuration '#{name}' already exists!") if @configurations.has_key?(name)
+      @configurations[name] = configuration
+      merge_configuration(configuration)
+
+      nil
+    end
+
+    # Get the configuration identified by the specified name. Raises an exception if the configuration does not exist.
+    # Modifying the returned configuration does not update this combined configuration.
+    #
+    # @param [String] name the configuration to get.
+    #
+    # @return [ConfigManager::Configuration] the configuration.
+    def get_configuration(name)
+      raise ConfigManager::PropertyNotFoundError("Cannot get - Configuration '#{name}' does not exist!") unless @configurations.has_key?(name)
+      @configurations[name]
+    end
+
+    private
+
+    # Merges the specified configuration with this configuration. Existing nodes are overwritten!
+    #
+    # @param [ConfigManager::Configuration] configuration the configuration to merge.
+    #
+    # @return [NilClass]
+    def merge_configuration(configuration)
+      values = configuration.get_property("")
+      at = ""
+      add_properties(values, at, :overwrite => true)
+    end
+
+  end
+
+end

data/lib/configmanager/configuration.rb

@@ -1,165 +1,168 @@
-#
-# 20 Jul 2012
-#
-
-require "configmanager/exceptions"
-require "configmanager/interpolators"
-
-module ConfigManager
-
-# Represents a collection of properties stored as a hash.
-  class Configuration
-
-    # Creates a new empty configuration.
-    #
-    # @param [Hash] options configuration options. Supported keys are:
-    #   :interpolator - an object that can respond to the 'interpolate' method. Default is the DefaultInterpolator.
-    #   :use_interpolator - global flag to specify if the interpolator should be used for this configuration. Default is true.
-    def initialize(options = {})
-      @root = {}
-      @use_interpolator = get_option(options, :use_interpolator, false, true)
-      @interpolator = get_option(options, :interpolator, false, ConfigManager::DefaultInterpolator)
-    end
-
-    # Adds a hash of properties to this configuration.
-    #
-    # @param [Hash] values the values to add to this configuration.
-    # @param [String] at the node under which to add these properties. Default is the root node.
-    # @param [Hash] options configuration options. Supported key are
-    #   :overwrite - true to overwrite existing properties, false to raise an exception if a property exists. Default is false.
-    #
-    # @return [NilClass]
-    def add_properties(values, at = "", options = {})
-      # Add each item in the hash - Nested hashes call this method recursively.
-      at_array = at.split(".")
-      values.each_pair do |key, value|
-        full_key = (at_array + [key]).join(".")
-        value.kind_of?(Hash) ? add_properties(value, full_key, options) : add_property(full_key, value, options)
-      end
-
-      nil
-    end
-
-    # Adds a property to this configuration. The key is a '.' separated string that fully qualifies this property.
-    # So the property a.b identifies the property 'b' inside the group 'a'. Similarly a.b.c identifies the property
-    # 'c' inside the group 'b' which is inside the group 'a'.
-    #
-    # @param [String] key the unique key to identify this property.
-    # @param [Object] value the value of this property.
-    # @param [Hash] options configuration options. Supported keys are:
-    #   :overwrite - true to overwrite existing properties, false to raise an exception if a property exists. Default is false.
-    #   :at - an optional node's name under which to add this property. Default is the root node.
-    #
-    # @return [NilClass]
-    def add_property(key, value, options = {})
-      # Default options.
-      at = get_option(options, :at, false, "")
-      overwrite = get_option(options, :overwrite, false, false)
-      # Create and add the property.
-      key_array = key.split(".")
-      at_array = at.split(".")
-      leaf = key_array[-1]
-      at_array = at_array + key_array[0..-2]
-      at_node = get_node(at_array, create = true)
-      # Got the node, now add the property, unless it already exists.
-      raise ConfigManager::KeyError.new("Cannot add - '#{at_array.join(".")}.#{leaf}' already exists!") if at_node.has_key?(leaf) and not overwrite
-      at_node[leaf] = value
-
-      nil
-    end
-
-    # Get the value of the specified property. The key is a '.' separated string that fully qualifies this property.
-    # So the property a.b identifies the property 'b' inside the group 'a'. Similarly a.b.c identifies the property
-    # 'c' inside the group 'b' which is inside the group 'a'.
-    #
-    # If enabled, the property's value is interpolated.
-    # Finally the list of post-processors are invoked and the value is returned.
-    #
-    # @param [String] key the property to get.
-    # @param [Hash] options configuration options. Supported keys are:
-    #   :use_interpolator - flag to indicate if the interpolator should be used. Uses the value specified when creating this configuration by default.
-    #   :interpolator - the interpolator to use. Uses the value specified when creating this configuration by default.
-    #   :post_processors - an array of callable procs. Each one is invoked with the output of the previous one. The first one is invoked with the fully interpolated value.
-    #   :replacements - a hash containing replacement values for references. References are looked up in this before being looked up in this configuration.
-    #   :tolerate_missing_references: a flag to indicate if missing references should raise an exception.
-    #
-    # Note : Interpolator implementations may support additional options too.
-    #
-    # @return [Object] the property's value.
-    def get_property(key, options = {})
-      use_interpolator = get_option(options, :use_interpolator, false, @use_interpolator)
-      interpolator = get_option(options, :interpolator, false, @interpolator)
-      post_processors = pop_option(options, :post_processors, false, [])
-      # Get the required property's raw value.
-      key_array = key.split(".")
-      create = false
-      raw_value = get_node(key_array, create)
-      # Interpolate.
-      raw_value = interpolator.interpolate(key, raw_value, self, options) if use_interpolator
-      # Post-process.
-      final_value = raw_value
-      post_processors.each { |processor| final_value = processor.call(final_value) }
-      # All done.
-      final_value
-    end
-
-    # Check to see if the specified property is defined for this configuration. This method will throw an exception if
-    # the key is invalid.
-    #
-    # @param [String] key the property to check.
-    #
-    # @return [TrueClass, FalseClass] true if the property exists, false otherwise.
-    def has_property?(key)
-      key_array = key.split(".")
-      create = false
-      get_node(key_array, create)
-      return true
-    rescue ConfigManager::PropertyNotFoundError
-      return false
-    end
-
-    private
-
-    # Gets the node identified by the specified key. If the 'create' flag is true, missing nodes will be created.
-    #
-    # @param [Array] key_array the array representing the full key.
-    # @param [TrueClass, FalseClass] create true to create missing nodes, false otherwise.
-    #
-    # @return [Hash] the node identified by this key.
-    def get_node(key_array, create = false)
-      return @root if key_array.empty?
-
-      key_str = key_array.join(".")
-      processed_parts = []
-      current_node = @root
-      # Walk the property tree. What's left at the end, is the required node.
-      key_array.each do |part|
-        # If the current node is not a hash, it means the key is invalid.
-        unless current_node.kind_of?(Hash)
-          raise ConfigManager::KeyError.new("Invalid key '#{key_str}' - Reached leaf at '#{processed_parts.join(".")}'!")
-        end
-
-        # If the current node is a hash, then check if the next part of the key is present.
-        # If it present, make that the current node.
-        # If it isn't present and the create flag is true, create an empty node and make it the current node.
-        # If the create flag is false, raise an exception.
-        processed_parts << part
-        if current_node.has_key?(part)
-          current_node = current_node[part]
-        elsif create
-          current_node = current_node[part] = {}
-        else
-          raise ConfigManager::PropertyNotFoundError.new("Key '#{processed_parts.join(".")}' does not exist!")
-        end
-      end
-      # The required node.
-      current_node
-    end
-
-    alias_method :[], :get_property
-    alias_method :[]=, :add_property
-    alias_method :set_property, :add_property
-
-  end
-
-end
+#
+# 20 Jul 2012
+#
+
+require "configmanager/exceptions"
+require "configmanager/interpolators"
+
+module ConfigManager
+
+  # Represents a collection of properties stored as a hash.
+  class Configuration
+
+    # Creates a new empty configuration.
+    #
+    # @param [Hash] options configuration options. Supported keys are:
+    #   :interpolator - an object that can respond to the 'interpolate' method. Default is the DefaultInterpolator.
+    #   :use_interpolator - global flag to specify if the interpolator should be used for this configuration. Default is true.
+    #   :tolerate_missing_reference - global flag to specify if missing references should raise an exception.
+    def initialize(options = {})
+      @root = {}
+      @use_interpolator = get_option(options, :use_interpolator, false, true)
+      @interpolator = get_option(options, :interpolator, false, ConfigManager::DefaultInterpolator)
+      @tolerate_missing_references = get_option(options, :tolerate_missing_references, false, false)
+    end
+
+    # Adds a hash of properties to this configuration.
+    #
+    # @param [Hash] values the values to add to this configuration.
+    # @param [String] at the node under which to add these properties. Default is the root node.
+    # @param [Hash] options configuration options. Supported key are
+    #   :overwrite - true to overwrite existing properties, false to raise an exception if a property exists. Default is false.
+    #
+    # @return [NilClass]
+    def add_properties(values, at = "", options = {})
+      # Add each item in the hash - Nested hashes call this method recursively.
+      at_array = at.split(".")
+      values.each_pair do |key, value|
+        full_key = (at_array + [key]).join(".")
+        value.kind_of?(Hash) ? add_properties(value, full_key, options) : add_property(full_key, value, options)
+      end
+
+      nil
+    end
+
+    # Adds a property to this configuration. The key is a '.' separated string that fully qualifies this property.
+    # So the property a.b identifies the property 'b' inside the group 'a'. Similarly a.b.c identifies the property
+    # 'c' inside the group 'b' which is inside the group 'a'.
+    #
+    # @param [String] key the unique key to identify this property.
+    # @param [Object] value the value of this property.
+    # @param [Hash] options configuration options. Supported keys are:
+    #   :overwrite - true to overwrite existing properties, false to raise an exception if a property exists. Default is false.
+    #   :at - an optional node's name under which to add this property. Default is the root node.
+    #
+    # @return [NilClass]
+    def add_property(key, value, options = {})
+      # Default options.
+      at = get_option(options, :at, false, "")
+      overwrite = get_option(options, :overwrite, false, false)
+      # Create and add the property.
+      key_array = key.split(".")
+      at_array = at.split(".")
+      leaf = key_array[-1]
+      at_array = at_array + key_array[0..-2]
+      at_node = get_node(at_array, create = true)
+      # Got the node, now add the property, unless it already exists.
+      raise ConfigManager::KeyError.new("Cannot add - '#{at_array.join(".")}.#{leaf}' already exists!") if at_node.has_key?(leaf) and not overwrite
+      at_node[leaf] = value
+
+      nil
+    end
+
+    # Get the value of the specified property. The key is a '.' separated string that fully qualifies this property.
+    # So the property a.b identifies the property 'b' inside the group 'a'. Similarly a.b.c identifies the property
+    # 'c' inside the group 'b' which is inside the group 'a'.
+    #
+    # If enabled, the property's value is interpolated.
+    # Finally the list of post-processors are invoked and the value is returned.
+    #
+    # @param [String] key the property to get.
+    # @param [Hash] options configuration options. Supported keys are:
+    #   :use_interpolator - flag to indicate if the interpolator should be used. Uses the value specified when creating this configuration by default.
+    #   :interpolator - the interpolator to use. Uses the value specified when creating this configuration by default.
+    #   :post_processors - an array of callable procs. Each one is invoked with the output of the previous one. The first one is invoked with the fully interpolated value.
+    #   :replacements - a hash containing replacement values for references. References are looked up in this before being looked up in this configuration.
+    #   :tolerate_missing_references: a flag to indicate if missing references should raise an exception.
+    #
+    # Note : Interpolator implementations may support additional options too.
+    #
+    # @return [Object] the property's value.
+    def get_property(key, options = {})
+      use_interpolator = get_option(options, :use_interpolator, false, @use_interpolator)
+      interpolator = get_option(options, :interpolator, false, @interpolator)
+      tolerate_missing_references = set_option(options, :tolerate_missing_references, @tolerate_missing_references, false)
+      post_processors = pop_option(options, :post_processors, false, [])
+      # Get the required property's raw value.
+      key_array = key.split(".")
+      create = false
+      raw_value = get_node(key_array, create)
+      # Interpolate.
+      raw_value = interpolator.interpolate(key, raw_value, self, options) if use_interpolator
+      # Post-process.
+      final_value = raw_value
+      post_processors.each { |processor| final_value = processor.call(final_value) }
+      # All done.
+      final_value
+    end
+
+    # Check to see if the specified property is defined for this configuration. This method will throw an exception if
+    # the key is invalid.
+    #
+    # @param [String] key the property to check.
+    #
+    # @return [TrueClass, FalseClass] true if the property exists, false otherwise.
+    def has_property?(key)
+      key_array = key.split(".")
+      create = false
+      get_node(key_array, create)
+      return true
+    rescue ConfigManager::PropertyNotFoundError
+      return false
+    end
+
+    private
+
+    # Gets the node identified by the specified key. If the 'create' flag is true, missing nodes will be created.
+    #
+    # @param [Array] key_array the array representing the full key.
+    # @param [TrueClass, FalseClass] create true to create missing nodes, false otherwise.
+    #
+    # @return [Hash] the node identified by this key.
+    def get_node(key_array, create = false)
+      return @root if key_array.empty?
+
+      key_str = key_array.join(".")
+      processed_parts = []
+      current_node = @root
+      # Walk the property tree. What's left at the end, is the required node.
+      key_array.each do |part|
+        # If the current node is not a hash, it means the key is invalid.
+        unless current_node.kind_of?(Hash)
+          raise ConfigManager::KeyError.new("Invalid key '#{key_str}' - Reached leaf at '#{processed_parts.join(".")}'!")
+        end
+
+        # If the current node is a hash, then check if the next part of the key is present.
+        # If it present, make that the current node.
+        # If it isn't present and the create flag is true, create an empty node and make it the current node.
+        # If the create flag is false, raise an exception.
+        processed_parts << part
+        if current_node.has_key?(part)
+          current_node = current_node[part]
+        elsif create
+          current_node = current_node[part] = {}
+        else
+          raise ConfigManager::PropertyNotFoundError.new("Key '#{processed_parts.join(".")}' does not exist!")
+        end
+      end
+      # The required node.
+      current_node
+    end
+
+    alias_method :[], :get_property
+    alias_method :[]=, :add_property
+    alias_method :set_property, :add_property
+
+  end
+
+end