configtoolkit 1.1.0 → 1.2.0

data/History.txt

@@ -1,3 +1,7 @@
+=== 1.2.0 / 2008-05-20
+Add BaseConfig.load_group, which allows a hash of configs to be loaded with
+one call.  Corrected a bug in how array parameters are printed.
+
 === 1.1.0 / 2008-05-14
 Finish the README.txt; this is the first production release!
 

data/README.txt

@@ -211,6 +211,46 @@ This will produce the following apple.yaml:
   num_cpus: 32
   behind_firewall: false
 
+To load a group of named configurations at once from this machines.yaml file:
+  db_cluster:
+    db1:
+      name: cherry
+      architecture: powerpc
+      os: Linux
+      num_cpus: 24
+      contains_sensitive_data: yes
+      addresses:
+        - http://cherrydb.designingpatterns.com
+        - http://db1.designingpatterns.com
+    db2:
+      name: strawberry
+      architecture: powerpc
+      os: Linux
+      num_cpus: 24
+      contains_sensitive_data: yes
+      addresses:
+        - http://strawberrydb.designingpatterns.com
+        - http://db2.designingpatterns.com
+    db3:
+      name: blueberry
+      architecture: powerpc
+      os: Linux
+      num_cpus: 24
+      contains_sensitive_data: yes
+      addresses:
+        - http://blueberrydb.designingpatterns.com
+        - http://db3.designingpatterns.com
+
+do:
+  require 'rubygems'
+  require 'configtoolkit'
+  require 'configtoolkit/yamlreader'
+
+  configs = MachineConfig.load_group(ConfigToolkit::YAMLReader.new("machines.yaml"), "db_cluster")
+  configs.each do |name, config|
+    print "The #{name} configuration:\n#{config}\n"
+  end
+
 == REQUIREMENTS:
 
 Hoe is required, but only for running the tests.

data/Rakefile

@@ -7,7 +7,7 @@ require 'hoe'
 
 $stderr = STDERR
 
-Hoe.new('configtoolkit', "1.1.0") do |p|
+Hoe.new('configtoolkit', "1.2.0") do |p|
   p.remote_rdoc_dir = ''
   p.developer('DesigningPatterns', 'technical.inquiries@designingpatterns.com')
 end

data/lib/configtoolkit/baseconfig.rb

@@ -287,8 +287,7 @@ class BaseConfig
   # webserver, then the containing_object_name would be
   # 'production.webserver'.
   #
-  attr_accessor :containing_object_name
-  protected :containing_object_name= # This is NOT part of the public interface
+  attr_reader :containing_object_name
 
   # 
   # ====Description:
@@ -651,8 +650,7 @@ class BaseConfig
         nested_containing_object_name = "#{@containing_object_name}.#{param_name}"
       end
 
-      child_config.containing_object_name = nested_containing_object_name
-      child_config.load_impl(raw_value)
+      child_config.load_impl(raw_value, nested_containing_object_name)
       return child_config
     elsif((value_class < ConstrainedArray) && (raw_value.class == Array))
       #
@@ -735,8 +733,11 @@ class BaseConfig
   # ====Parameters:
   # [containing_object_hash]
   #      The Hash containing the configuration's parameters
+  # [containing_object_name]
+  #      The containing object name
   # 
-  def load_impl(containing_object_hash)
+  def load_impl(containing_object_hash, containing_object_name)
+    @containing_object_name = containing_object_name
     @params_with_values.clear()
 
     if(containing_object_hash != nil)
@@ -766,20 +767,21 @@ class BaseConfig
 
   # 
   # ====Description:
-  # This method loads self from reader (with containing object
-  # containing_object_name).
+  # This method loads the configuration hash from reader for containing object
+  # containing_object_name.  This method is not really part of BaseConfig's
+  # public API but, unfortunately, cannot be made private (since it is
+  # called from an instance method; there are no "protected" class methods,
+  # unfortunately).
   # 
   # ====Parameters:
-  # [reader]
-  #      The reader from which to load the parameter values.  This method
-  #      will call the read method of reader, which will return
-  #      a Hash containing, in the most nested containing object entry,
-  #      the configuration parameter values for self.
-  # [containing_object_name = ""]
-  #      The containing object name
+  # See the parameter list for load.
   # 
-  def load(reader, containing_object_name = "")
-    param_hash = reader.read
+  # ====Returns:
+  # The configuration hash for containing_object_name (or nil, if none
+  # is found)
+  # 
+  def self.load_containing_object_hash(reader, containing_object_name)
+    param_hash = reader.read()
 
     if(param_hash.class != Hash)
       message =  "#{reader.class}#read returned #{param_hash.class} "
@@ -801,15 +803,14 @@ class BaseConfig
     # is empty).  On the other hand, if an object is found but it is not
     # really an object (a Hash), then raise an exception.
     #
-    @containing_object_name = containing_object_name
     containing_object_hash = param_hash
-    @containing_object_name.split(".").each do |object_name|
+    containing_object_name.split(".").each do |object_name|
       containing_object_hash = containing_object_hash.fetch(object_name, nil)
 
       if(containing_object_hash == nil)
         break
       elsif(containing_object_hash.class != Hash)
-        message =  "error: #{self.class}#load found "
+        message =  "error: #{self}.load_containing_object_hash found "
         message << "#{containing_object_hash.class} "
         message << "rather than Hash when reading the "
         message << "#{object_name} containing object"
@@ -817,7 +818,32 @@ class BaseConfig
       end
     end
 
-    load_impl(containing_object_hash)
+    return containing_object_hash
+  end
+  private_class_method :load_containing_object_hash
+
+  # 
+  # ====Description:
+  # This method loads self from reader (with containing object
+  # containing_object_name).
+  # 
+  # ====Parameters:
+  # [reader]
+  #      The reader from which to load the parameter values.  This method
+  #      will call the read method of reader, which will return
+  #      a Hash containing, in the most nested containing object entry,
+  #      the configuration parameter values for self.
+  # [containing_object_name = ""]
+  #      The containing object name
+  # 
+  def load(reader, containing_object_name = "")
+    #
+    # Not being able to call private class methods from one of the
+    # class' instance methods is a language bug.
+    #
+    containing_object_hash = self.class.send(:load_containing_object_hash, reader, containing_object_name)
+
+    load_impl(containing_object_hash, containing_object_name)
   end
 
   # 
@@ -837,6 +863,52 @@ class BaseConfig
     instance.load(reader, containing_object_name)
     return instance
   end
+
+  # 
+  # ====Description:
+  # This class method loads arbitrarily many configs from
+  # reader.  This should be used when containing_object_name's
+  # elements all are hashes, each of which is a different instance of
+  # this class' configuration.  This call returns a Hash containing
+  # elements mapping configuration name to configuration
+  # instance.
+  # 
+  # ====Parameters:
+  # See the parameter list for load.
+  # 
+  # ====Returns:
+  # A Hash of names (Strings) mapping to loaded configuration instances
+  # 
+  def self.load_group(reader, containing_object_name = "")
+    containing_object_hash = load_containing_object_hash(reader, containing_object_name)
+
+    config_group = {}
+    if(containing_object_hash != nil)
+      containing_object_hash.each do |key, value|
+        value_containing_object_name = "#{containing_object_name}.#{key}"
+
+        if(!value.is_a?(Hash))
+          message =  "error: #{self}.load_group found "
+          message << "#{value.class} "
+          message << "rather than Hash when reading the "
+          message << "#{value_containing_object_name} containing object"
+          raise Error, message
+        end
+
+        instance = new()
+
+        #
+        # Have to use send in order to call protected method.
+        # I think that not being able to call protected instance methods
+        # from class methods is a bug.
+        #
+        instance.send(:load_impl, value, value_containing_object_name)
+        config_group[key] = instance
+      end
+    end
+
+    return config_group
+  end
   
   # 
   # ====Description:
@@ -862,7 +934,7 @@ class BaseConfig
         str << "{\n"
         value.write_impl(str, nesting_indent)
         str << indent << "}"
-      elsif(value.class < Array)
+      elsif(value.is_a?(Array))
         #
         # Writing an array requires calling write_value_impl for each element,
         # just at one further indentation level.

data/test/machines.yaml

@@ -8,6 +8,17 @@ addresses:
   - http://default.designingpatterns.com
   - http://apple.designingpatterns.com
 
+qa:
+  name: pear
+  architecture: x86_64
+  os: FreeBSD
+  num_cpus: 8
+  behind_firewall: true
+  contains_sensitive_data: true
+  addresses:
+    - http://release.designingpatterns.com
+    - http://pear.designingpatterns.com
+
 production:
   name: orange
   architecture: ultrasparc
@@ -28,6 +39,69 @@ test:
     - http://test.designingpatterns.com
     - http://bananna.designingpatterns.com
 
+#
+# db1, db2, and db3 are duplicated at the top-level and
+# within db_cluster, in order to properly test load_group.
+#
+db1:
+  name: cherry
+  architecture: powerpc
+  os: Linux
+  num_cpus: 24
+  contains_sensitive_data: yes
+  addresses:
+    - http://cherrydb.designingpatterns.com
+    - http://db1.designingpatterns.com
+
+db2:
+  name: strawberry
+  architecture: powerpc
+  os: Linux
+  num_cpus: 24
+  contains_sensitive_data: yes
+  addresses:
+    - http://strawberrydb.designingpatterns.com
+    - http://db2.designingpatterns.com
+
+db3:
+  name: blueberry
+  architecture: powerpc
+  os: Linux
+  num_cpus: 24
+  contains_sensitive_data: yes
+  addresses:
+    - http://blueberrydb.designingpatterns.com
+    - http://db3.designingpatterns.com
+
+db_cluster1:
+  db1:
+    name: cherry
+    architecture: powerpc
+    os: Linux
+    num_cpus: 24
+    contains_sensitive_data: yes
+    addresses:
+      - http://cherrydb.designingpatterns.com
+      - http://db1.designingpatterns.com
+  db2:
+    name: strawberry
+    architecture: powerpc
+    os: Linux
+    num_cpus: 24
+    contains_sensitive_data: yes
+    addresses:
+      - http://strawberrydb.designingpatterns.com
+      - http://db2.designingpatterns.com
+  db3:
+    name: blueberry
+    architecture: powerpc
+    os: Linux
+    num_cpus: 24
+    contains_sensitive_data: yes
+    addresses:
+      - http://blueberrydb.designingpatterns.com
+      - http://db3.designingpatterns.com
+
 bad_containing_object: 3
 
 missing_num_cpus:
@@ -98,3 +172,9 @@ bad_contains_sensitive_data_behind_firewall_combo:
   addresses:
     - http://test.designingpatterns.com
     - http://bananna.designingpatterns.com
+
+bad_group:
+  bad_element:
+    - 3
+    - 4
+    - 5

data/test/test_baseconfig.rb

@@ -107,13 +107,13 @@ class BaseConfigTest < Test::Unit::TestCase
       assert_equal(param_value, config.send(param_name))
     end
 
-    puts config
-  end
+    #
+    # Ensure that the programatically set config is equal to one
+    # sourcing the same information via load.
+    #
+    assert_equal(MachineConfig.load(ConfigToolkit::YAMLReader.new(MACHINES_CONFIG_FILE_NAME), "qa"), config)
 
-  def verify_param_values(config, expected_config_param_values)
-    expected_config_param_values.each do |param_name, param_value|
-      assert_equal(param_value, config.send(param_name))
-    end
+    puts config
   end
 
   def verify_correct_dump(config_file_name, containing_object_name)
@@ -182,13 +182,25 @@ class BaseConfigTest < Test::Unit::TestCase
 
   def verify_correct_load(config_file_name,
                           containing_object_name,
-                          expected_param_values)
+                          expected_config)
     reader = ConfigToolkit::YAMLReader.new(config_file_name)
     config = MachineConfig.load(reader, containing_object_name)
-    verify_param_values(config, expected_param_values)
+    assert_equal(expected_config, config)
     puts config
   end
 
+  def verify_correct_load_group(config_file_name,
+                                containing_object_name,
+                                expected_configs)
+    reader = ConfigToolkit::YAMLReader.new(config_file_name)
+    configs = MachineConfig.load_group(reader, containing_object_name)
+    assert_equal(expected_configs, configs)
+
+    configs.each do |name, config|
+      assert_equal("#{containing_object_name}.#{name}", config.containing_object_name)
+    end
+  end
+
   def verify_load_error(config_file_name, containing_object_name, message)
     reader = ConfigToolkit::YAMLReader.new(config_file_name)
     
@@ -203,52 +215,68 @@ class BaseConfigTest < Test::Unit::TestCase
     assert(rescued_exception)
   end
 
+  def verify_load_group_error(config_file_name, containing_object_name, message)
+    reader = ConfigToolkit::YAMLReader.new(config_file_name)
+    
+    rescued_exception = false
+    begin
+      config = MachineConfig.load_group(reader, containing_object_name)
+    rescue ConfigToolkit::Error => e
+      assert_equal(message, e.message)
+      rescued_exception = true
+    end
+
+    assert(rescued_exception)
+  end
+
   #
   # Test whether a canned config file can be load correctly (whether
   # the config instances ends up having the expected values).
   #
   def test_load
-    verify_correct_load(MACHINES_CONFIG_FILE_NAME, "", {
-                          :name => "apple",
-                          :architecture => "powerpc",
-                          :os => "AIX",
-                          :num_cpus => 32,
-                          :behind_firewall => false,
-                          :contains_sensitive_data => false,
-                          :addresses =>
-                          [
-                           URI("http://default.designingpatterns.com"),
-                           URI("http://apple.designingpatterns.com")
-                          ]
-                        })
-
-    verify_correct_load(MACHINES_CONFIG_FILE_NAME, "production", {
-                          :name => "orange",
-                          :architecture => "ultrasparc",
-                          :os => "Solaris",
-                          :num_cpus => 64,
-                          :behind_firewall => true,
-                          :contains_sensitive_data => true,
-                          :addresses => 
-                          [
-                           URI("http://production.designingpatterns.com"),
-                           URI("http://orange.designingpatterns.com")
-                          ]
-                        })
-
-    verify_correct_load(MACHINES_CONFIG_FILE_NAME, "test", {
-                          :name => "bananna",
-                          :architecture => "itanium",
-                          :os => "Linux",
-                          :num_cpus => 16,
-                          :behind_firewall => true,
-                          :contains_sensitive_data => false,
-                          :addresses =>
-                          [
-                           URI("http://test.designingpatterns.com"),
-                           URI("http://bananna.designingpatterns.com")
-                          ]
-                        })
+    config = MachineConfig.new()
+    config.name = "apple"
+    config.architecture = "powerpc"
+    config.os = "AIX"
+    config.num_cpus = 32
+    config.behind_firewall = false
+    config.contains_sensitive_data = false
+    config.addresses = [
+                        URI("http://default.designingpatterns.com"),
+                        URI("http://apple.designingpatterns.com")
+                       ]
+    verify_correct_load(MACHINES_CONFIG_FILE_NAME, "", config)
+
+    config = MachineConfig.new()
+    config.name = "orange"
+    config.architecture = "ultrasparc"
+    config.os = "Solaris"
+    config.num_cpus = 64
+    config.behind_firewall = true
+    config.contains_sensitive_data = true
+    config.addresses = [
+                        URI("http://production.designingpatterns.com"),
+                        URI("http://orange.designingpatterns.com")
+                       ]
+    verify_correct_load(MACHINES_CONFIG_FILE_NAME, "production", config)
+
+    config = MachineConfig.new()
+    config.name = "bananna"
+    config.architecture = "itanium"
+    config.os = "Linux"
+    config.num_cpus = 16
+    config.behind_firewall = true
+    config.contains_sensitive_data = false
+    config.addresses = [
+                        URI("http://test.designingpatterns.com"),
+                        URI("http://bananna.designingpatterns.com")
+                       ]
+    verify_correct_load(MACHINES_CONFIG_FILE_NAME, "test", config)
+
+    verify_correct_load_group(MACHINES_CONFIG_FILE_NAME, "db_cluster1",
+                              "db1" => MachineConfig.load(ConfigToolkit::YAMLReader.new(MACHINES_CONFIG_FILE_NAME), "db1"),
+                              "db2" => MachineConfig.load(ConfigToolkit::YAMLReader.new(MACHINES_CONFIG_FILE_NAME), "db2"),
+                              "db3" => MachineConfig.load(ConfigToolkit::YAMLReader.new(MACHINES_CONFIG_FILE_NAME), "db3"))
   end
 
   def test_load_errors
@@ -258,7 +286,7 @@ class BaseConfigTest < Test::Unit::TestCase
 
     verify_load_error(MACHINES_CONFIG_FILE_NAME,
                       "bad_containing_object",
-                      "error: BaseConfigTest::MachineConfig#load found Fixnum rather than Hash when reading the bad_containing_object containing object")
+                      "error: BaseConfigTest::MachineConfig.load_containing_object_hash found Fixnum rather than Hash when reading the bad_containing_object containing object")
 
     verify_load_error(MACHINES_CONFIG_FILE_NAME,
                       "missing_num_cpus",
@@ -288,5 +316,8 @@ class BaseConfigTest < Test::Unit::TestCase
                       "bad_contains_sensitive_data_behind_firewall_combo",
                       "BaseConfigTest::MachineConfig#validate_all_values load error for bad_contains_sensitive_data_behind_firewall_combo: a machine cannot contain sensitive data and not be behind the firewall")
 
+    verify_load_group_error(MACHINES_CONFIG_FILE_NAME,
+                            "bad_group",
+                            "error: BaseConfigTest::MachineConfig.load_group found Array rather than Hash when reading the bad_group.bad_element containing object")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: configtoolkit
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - DesigningPatterns
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-15 00:00:00 -04:00
+date: 2008-05-21 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency