config_object 1.0.0

data/README.rdoc

@@ -0,0 +1,214 @@
+= ConfigObject
+
+The purpose of this gem is to have a standard way of configuring objects that is useable by other Ruby gems.
+
+== Features
+
+There are plenty of other gems that provide a configuration facility. This gem exists to provide a unique set of special features.
+
+* Support for complex configuration objects that can contain their own logic
+* Support for multiple configuration objects of the same class
+* Support for different settings for different environments
+* Configuration can be done from Ruby code or YAML files
+* DRY up your configuration with defaults
+* Configured values are frozen so they can't be accidentally modified
+* Configuration can be reloaded at any time and notify observing objects
+
+== Examples
+
+For the examples, we'll suppose we have some city data which is pretty static and doesn't change much.
+
+To use this library, you just need to declare a class that includes ConfigObject. Including this module will add an +id+ attribute and an +initialize+ method that sets attributes from a hash. For each key in the hash, the initializer will look for a setter method and call it with the value. If there is no setter method, it will simply set an instance variable with the same name.
+
+  class City
+    include ConfigObject
+    attr_reader :name, :county, :state, :population, :census_year, :hostname
+    
+    # Set the county information based on a hash. This feature can be used to create
+    # complex objects from simple configuration hashes.
+    def county= (attributes)
+      if attributes
+        @county = County.new(attributes)
+      else
+        @county = nil
+      end
+    end
+    
+    # You can use the objects as more than simple data stores because you can add whatever
+    # logic you like to the class
+    def size
+      if population > 1000000
+        :big
+      elsif population > 300000
+        :medium
+      else
+        :small
+      end
+    end
+  end
+  
+  # The initializer behavior of setting attributes from a hash is available in the module Attributes.
+  # If we just want that behavior, we can include it in any module.
+  class County
+    include ConfigObject::Attributes
+    attr_reader :name, :population
+  end
+
+You can use a YAML file to load multiple cities like so:
+
+  chicago:
+    name: Chicago
+    state: IL
+    population: 2896016
+    census_year: 2000
+    county:
+      name: Cook
+      population: 5294664
+  
+  st_louis:
+    name: St. Louis
+    state: MO
+    population: 348189
+    census_year: 2000
+    county:
+      name: St. Louis
+      population: 1016315
+
+  milwaukee:
+    name: Milwaukee
+    state: WI
+    population: 604477
+    census_year: 2008
+    county:
+      name: Milwaukee
+      population: 953328
+
+== Multiple Objects
+
+The above configuration will give us three cities with ids of "chicago", "st_louis", and "milwaukee". These object can be reference from the class:
+
+  City[:chicago]
+
+or
+
+  City['chicago']
+
+If we want all of them, we can call
+
+  City.all
+
+If we want to find by something other than the id using a filter hash:
+
+  City.find(:name => "Chicago")
+  City.all(:state => "IL")
+
+You can match values using a regular expression:
+
+  City.find(:name => /^St/)
+  City.all(:state => /(IL)|(WI)/)
+
+You can use a dot syntax to specify a chain of attributes to call:
+
+  City.all("county.name" => 'Milwaukee')
+
+If an attribute in the filter takes a single argument, it will be called with the match value:
+
+  City.all("county.population.>", 2000000)
+
+The result of finding by a hash are cached for future lookups so their is no performance penalty for calling them multiple times.
+
+== Configuring
+
+As show above, you can configure a class with a YAML file. You can also specify multiple YAML files, a directory containing YAML files, or specify your configuration from Ruby code. When you specify multiple files, the setting in the later files will be merged into the settings in the earlier files in the list.
+
+=== One YAML file
+
+  City.configuration_files = 'config/cities.yml'
+
+=== Multiple YAML files
+
+  City.configuration_files = 'config/cities.yml', 'config/production_cities.yml'
+
+=== Configure from code
+  City.configure({
+    :chicago => {:name => "Chicago", :population => 3000000},
+    :st_louis => {:name => "St. Louis", :population => 1000000}
+  })
+
+== Multiple Environments
+
+Often, your configuration will require different settings in different environments. There are a couple of ways to handle that.
+
+First, if you use multiple objects, like in our city example, you can specify multiple configuration files or blocks depending on the environment.
+
+For example, in a Rails application you could put your environment specific settings in separate files and call:
+
+  City.configuration_files = "config/cities.yml", "config/#{Rails.env}_cities.yml"
+
+=== development_cities.yml
+  
+  chicago:
+    host_name: chicago.local
+  
+  st_louis:
+    host_name: st-louis.local
+  
+  milwaukee:
+    host_name: milwaukee.local
+
+=== production_cities.yml
+
+  chicago:
+    host_name: chicago.example.com
+
+  st_louis:
+    host_name: st-louis.example.com
+
+  milwaukee:
+    host_name: milwaukee.example.com
+
+The other way to handle environment specific settings is if you only need one configuration object, use the environment name as the configuration id. For example, suppose we have a configuration class +HostConfig+ in a Rails application configured with this file:
+
+  development:
+    host: localhost
+    port: 5700
+    username: example
+    password: abc123
+  
+  production:
+    host: example.com
+    port: 5700
+    username: example
+    password: $SEddd1
+  
+To get the correct settings you could then reference:
+
+  HostConfig[Rails.env]
+
+== Default Values
+
+If you have some attributes that are mostly the same across all configuration objects, you can specify default values to DRY up you configuration. For instance we could rewrite our sample +HostConfig+ file as:
+
+  defaults:
+    port: 5700
+    username: example
+  
+  development:
+    host: localhost
+    password: abc123
+  
+  production:
+    host: example.com
+    password: $SEddd1
+
+Defaults can only be specified for root level hash. You can also specify defaults with the +set_defaults+ method.
+
+== Stable Values
+
+The attributes set on the configuration objects will be automatically frozen. This is to protect you from accidentally calling destructive methods on them (ie. <tt><<</tt> or +gsub!+ on String) and changing the original values. These sorts of bugs can be awfully hard to find especially in a Rails application where they may only appear when the code gets to production.
+
+== Reloading
+
+You can reload the configuration objects at any time with the +reload+ method.
+
+Objects can register themselves with the configuration class to be notified whenever the configuration is reloaded by calling +add_observer+ and specifying a callback. The callback method or block will be called whenever the configuration is changed so that persistent objects that use the configuration can reinitialize themselves with the new values.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'spec/rake/spectask'
+  desc 'Run unit tests'
+  Spec::Rake::SpecTask.new(:test) do |t|
+    t.spec_files = FileList.new('spec/**/*_spec.rb')
+  end
+rescue LoadError
+  task :test do
+    STDERR.puts "You must have rspec >= 1.2.9 to run the tests"
+  end
+end
+
+desc 'Generate documentation for config_object.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.options << '--title' << 'ConfigObject' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "config_object"
+    gem.summary = %Q{Simple and powerful configuration library}
+    gem.description = %Q{A configuration gem which is simple to use but full of awesome features.}
+    gem.email = "brian@embellishedvisions.com"
+    gem.homepage = "http://github.com/bdurand/config_object"
+    gem.authors = ["Brian Durand"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile"].to_a
+    gem.has_rdoc = true
+    gem.extra_rdoc_files = ["README.rdoc"]
+    
+    gem.add_development_dependency('rspec', '>= 1.2.9')
+    gem.add_development_dependency('jeweler')
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+end

data/lib/config_object.rb

@@ -0,0 +1,319 @@
+require 'yaml'
+require 'erb'
+require 'pathname'
+
+# Classes that include ConfigObject can then be loaded from configuration using the ClassMethods. The objects
+# themselves will have an +id+ method as well as an initializer that sets attributes from a hash (see Attributes
+# for details).
+module ConfigObject
+  
+  def self.included (base) #:nodoc:
+    base.extend(ClassMethods)
+    base.send :include, Attributes
+  end
+  
+  module ClassMethods
+    DEFAULTS = 'defaults'
+    
+    # Find a configuration object by it's identifier or by a conditions hash.
+    #
+    # Identifiers are always looked up by string so find(:production) is the same as find('production').
+    #
+    # Condition hashes are used to select an item based on the field values. A match is made when either
+    # the attribute value matches a hash value. Hash values may be regular expressions. Matches are cached
+    # so there is no overhead in looking up a value by conditions multiple times.
+    #
+    # See #all for examples.
+    def find (id_or_conditions)
+      if id_or_conditions.is_a?(Hash)
+        lookup(id_or_conditions).first
+      else
+        configs[id_or_conditions.to_s]
+      end
+    end
+    
+    alias_method :[], :find
+    
+    # Find all configuration objects that match the conditions hash.
+    #
+    # Condition hashes are used to select an item based on the field values. A match is made when either
+    # the attribute value matches a hash value. Hash values may be regular expressions. Matches are cached
+    # so there is no overhead in looking up a value by conditions multiple times.
+    #
+    # Examples (assumes the City class includes ConfigObject):
+    #
+    #   City.all(:name => "Springfield") # find all cities named Springfield
+    #   City.all("state.name" => "Illinois") # find all cities where the state object has a name of Illinois
+    #   City.all("population.>" => 1000000) # find all cities where population is greater than one million
+    #   City.all("transportation.include?" => "train") # find all cities where transportation includes "train"
+    #   City.all(:name => /^New/) # find all cities that start with "New"
+    def all (conditions = {})
+      if conditions.size == 0
+        configs.values
+      else
+        lookup(conditions)
+      end
+    end
+    
+    # Get an array of ids for all configuration objects.
+    def ids
+      configs.keys
+    end
+    
+    # Force the configuration objects to be reloaded from the configuration files.
+    # Any observers will be notified by invoking the callback provided.
+    def reload
+      @configs = nil
+      @cache = {}
+      notify_observers
+      nil
+    end
+    
+    # Set default values for the attributes for all configuration objects.
+    #
+    # Calling this method multiple times will merge the default values with those from
+    # previous calls.
+    def set_defaults (values)
+      @defaults ||= {}
+      @defaults.merge!(stringify_keys(values))
+      reload
+    end
+    
+    # Add an observer to the configuration class. Whenever the configuration is reloaded,
+    # observers will be notified by either invoking the callback method provided or by
+    # calling the block.
+    def add_observer (observer, callback = nil, &block)
+      @observers ||= {}
+      @observers[observer] = callback || block
+      observer
+    end
+    
+    # Remove an observer so it no longer receives notifications when the configuration is reloaded.
+    def remove_observer (observer)
+      @observers.delete(observer) if observer
+      observer
+    end
+    
+    # Configure objects with a hash. This can be used in lieu of configuration files
+    # if you need to configure objects through code like in a Rails initializer.
+    # The argument passed in must be a hash where the keys are the configuration
+    # object ids and the values are the configuration attribute values.
+    #
+    # If this method is called multiple times, the values for each configuration
+    # object will be merged with the values from previous calls.
+    #
+    # Defaults can be set by using the special id "defaults" as one of the keys.
+    def configure (config_options)
+      @configure_hash ||= {}
+      config_options.each_pair do |id, values|
+        id = id.to_s
+        if id == DEFAULTS
+          set_defaults(values)
+        else
+          existing_values = @configure_hash[id] || {}
+          @configure_hash[id] = existing_values.merge(values)
+        end
+      end
+      reload
+    end
+    
+    # Set the files used to load the configuration objects. Each file will be read in the
+    # order specified. Values in later files will be merged into values specified in earlier
+    # files. This allows later files to serve as overrides for the earlier files and is
+    # ideal for specifying envrionment dependent settings.
+    def configuration_files= (*files)
+      @configuration_files = files.flatten.collect{|f| f.is_a?(Pathname) ? f : Pathname.new(f)}
+      reload
+      @configuration_files
+    end
+
+    # Get the list of files used to load the configuration. If the list is changed, you
+    # should call reload to ensure the new files are read.
+    def configuration_files
+      @configuration_files ||= []
+    end
+    
+    # Clear all configuration settings. Mostly made available for testing purposes.
+    def clear
+      @configure_hash = nil
+      @configuration_files = nil
+      @defaults = nil
+      reload
+    end
+    
+    protected
+    
+    # Notify all observers that the configuration has changed
+    def notify_observers
+      @observers.each_pair do |observer, callback|
+        args = []
+        callback = observer.method(callback) unless callback.is_a?(Proc)
+        args << self if callback.arity == 1 || callback.arity == -2
+        callback.call(*args)
+      end if @observers
+    end
+    
+    # Determine if an object attribute matches the specified value.
+    def object_matches? (object, attribute, match_value) #:nodoc:
+      attribute = attribute.to_s.split('.') unless attribute.is_a?(Array)
+      method_name = attribute.first
+      if object.respond_to?(method_name)
+        arity = object.method(method_name).arity
+        # If this is the last attribute in a chain and the method requires a single argument, call the method with the match value.
+        if arity == 1 or arity == -2 and attribute.length == 1
+          return !!object.send(method_name, match_value)
+        end
+        value = object.send(method_name)
+      end
+      if value
+        if attribute.size > 1
+          return object_matches?(value, attribute[1, attribute.size], match_value)
+        else
+          if match_value.is_a?(Regexp)
+            return value.is_a?(String) && value.match(match_value)
+          else
+            return value == match_value
+          end
+        end
+      else
+        return match_value.nil?
+      end
+    end
+    
+    # Get the hash that contains all the configs mapping the ids to the objects.
+    def configs #:nodoc:
+      unless @configs
+        @cache = {}
+        hashes = {}
+        new_defaults = {}
+        configuration_files.each do |file|
+          file = Pathname.new(file) unless file.is_a?(Pathname)
+          load_yaml_file(file).each_pair do |id, values|
+            load_config_hash(hashes, new_defaults, id, values)
+          end
+        end
+        if @configure_hash
+          @configure_hash.each do |id, values|
+            load_config_hash(hashes, new_defaults, id, values)
+          end
+        end
+        @defaults ||= {}
+        @defaults = new_defaults.merge(@defaults)
+        @configs = {}
+        hashes.each_pair do |id, values|
+          @configs[id.to_s] = new(@defaults.merge(values.merge('id' => id)))
+        end
+      end
+      return @configs
+    end
+    
+    # Look up items based on the conditions specified as a hash. Lookups are cached so they can be safely
+    # invoked over and over without incurring a performance penalty.
+    def lookup (conditions) #:nodoc:
+      @cache ||= {}
+      values = @cache[conditions]
+      unless values
+        values = configs.values.select do |obj|
+          conditions.all? do |attribute, match_value|
+            object_matches?(obj, attribute, match_value)
+          end
+        end
+        @cache[conditions] = values
+      end
+      return values.dup
+    end
+    
+    private
+    
+    def load_config_hash (options, default_options, id, values) #:nodoc:
+      raise ArgumentError.new("Values defined for #{id} must be a hash") unless values.is_a?(Hash)
+      id = id.to_s
+      values = stringify_keys(values)
+      if id == DEFAULTS
+        default_options.merge!(values)
+      else
+        values = options[id].merge(values) if options[id]
+        options[id] = values
+      end
+    end
+    
+    def stringify_keys (hash) #:nodoc:
+      hash.inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
+      end
+    end
+    
+    # Load a YAML file into a hash. If the specified file is a directory,
+    # all *.yml or *.yaml files will be loaded as the values with the file
+    # base name used as the key. This process is recursive.
+    def load_yaml_file (file) #:nodoc:
+      if file.exist? and (file.directory? or [".yaml", ".yml"].include?(file.extname.downcase))
+        if file.directory?
+          vals = {}
+          file.children.each do |child|
+            key = child.basename.to_s.sub(/\.y(a?)ml$/i, '')
+            vals[key] = load_yaml_file(child)
+          end
+          return vals
+        else
+          yaml = file.read
+          if yaml.nil? or yaml.gsub(/\s/, '').size == 0
+            return {}
+          else
+            return YAML.load(ERB.new(yaml).result) || {}
+          end
+        end
+      else
+        return {}
+      end
+    end
+  end
+
+  # This module adds an initializer that sets attributes from a hash.
+  module Attributes
+    # Create a new configuration object with the specified attributes. Attributes are set by
+    # calling the setter method for each key if it exists. If there is no setter, an instance
+    # variable will be set. The value set will be duplicated and frozen if possible so that
+    # it can't be accidentally changed by calling a destructive method on it.
+    def initialize (attributes)
+      attributes.each_pair do |name, value|
+        setter = "#{name}=".to_sym
+        value = deep_freeze(value)
+        if respond_to?(setter)
+          send(setter, value)
+        else
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+  
+    protected
+  
+    # Freeze a duplicate of the value passed in so that consumers of the configuration object
+    # don't accidentally change it by calling destructive methods on the original copy.
+    # For hashes and arrays recusively freezes every element.
+    def deep_freeze (value)
+      if value.is_a?(Hash)
+        frozen = {}
+        value.each_pair{|k, v| frozen[k] = deep_freeze(v)}
+        value = frozen
+      elsif value.is_a?(Array)
+        value = value.collect{|v| deep_freeze(v)}
+      else
+        if value and !value.is_a?(Numeric)
+          value = value.dup rescue value
+        end
+      end
+      value.freeze unless value.frozen?
+      return value
+    rescue
+      return value
+    end
+  end
+
+  # Id is the only attribute defined for all config objects. It will be set when the configuration is loaded.
+  def id
+    @id
+  end
+end

data/spec/config_object_spec.rb

@@ -0,0 +1,344 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+module ConfigObject
+  class Tester
+    include ConfigObject
+
+    attr_reader :value, :object
+    attr_accessor :name
+    
+    def complex
+      @complex_called ||= 0
+      @complex_called += 1
+      @complex
+    end
+    
+    def complex_called
+      @complex_called ||= 0
+    end
+      
+    protected
+    
+    def value= (val)
+      @value = val.to_i
+    end
+    
+    def object= (attributes)
+      @object = attributes.is_a?(Hash) ? Attributed.new(attributes) : attributes
+    end
+  end
+  
+  class Tester2 < Tester
+  end
+  
+  class Attributed
+    include ConfigObject::Attributes
+    attr_reader :name, :value, :object
+    
+    def object= (attributes)
+      @object = attributes.is_a?(Hash) ? self.class.new(attributes) : attributes
+    end
+  end
+end
+
+describe ConfigObject do
+  
+  after :each do
+    ConfigObject::Tester.clear
+    ConfigObject::Tester2.clear
+  end
+  
+  it "should be able to be configured with a hash" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A"},
+      :item_b => {:name => "Item B"}
+    })
+    ConfigObject::Tester['item_a'].name.should == "Item A"
+    ConfigObject::Tester[:item_b].name.should == "Item B"
+    ConfigObject::Tester['item_c'].should == nil
+  end
+  
+  it "should load configurations from a file" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml")
+    ConfigObject::Tester['item_1'].name.should == "Item One"
+    ConfigObject::Tester[:item_2].name.should == "Item Two"
+    ConfigObject::Tester['item_3'].should == nil
+  end
+  
+  it "should load configurations from multiple files overriding values from the first files with those from the later files" do
+    ConfigObject::Tester.configuration_files = Pathname.new(File.join(File.dirname(__FILE__), "test_1.yml"))
+    ConfigObject::Tester.configuration_files << File.join(File.dirname(__FILE__), "test_2.yaml")
+    ConfigObject::Tester['item_1'].name.should == "Item One"
+    ConfigObject::Tester[:item_2].name.should == "Item Too"
+    ConfigObject::Tester[:item_2].value.should == 2
+    ConfigObject::Tester[:item_2].complex.should == "Thing"
+    ConfigObject::Tester['item_3'].name.should == "Item Three"
+  end
+  
+  it "should load configurations from directories using the file names as the keys" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml"), File.join(File.dirname(__FILE__), "test_files")
+    ConfigObject::Tester[:item_1].name.should == "Item One"
+    ConfigObject::Tester[:item_1].value.should == 8
+    ConfigObject::Tester[:item_2].name.should == "Item Two" # Not overriddend by item_2.txt
+    ConfigObject::Tester[:item_3].name.should == "Item 3 Directory"
+    ConfigObject::Tester[:item_3].object.value.should == 10
+    ConfigObject::Tester[:item_5].name.should == "Item Five"
+  end
+  
+  it "should load configurations from files only if they exist" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml"), "no_such_file.yaml"
+    ConfigObject::Tester['item_1'].name.should == "Item One"
+    ConfigObject::Tester[:item_2].name.should == "Item Two"
+    ConfigObject::Tester['item_3'].should == nil
+  end
+  
+  it "should evaluate ERB inside configuration files" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_2.yaml")
+    ConfigObject::Tester[:item_2].object.should == Date.today
+  end
+  
+  it "should load configuration from files and a hash with the hash taking precedence" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A"},
+      :item_1 => {:name => "Item Won"}
+    })
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml")
+    ConfigObject::Tester['item_a'].name.should == "Item A"
+    ConfigObject::Tester[:item_1].name.should == "Item Won"
+    ConfigObject::Tester[:item_2].name.should == "Item Two"
+  end
+  
+  it "should use default values set in a file for every configuration" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml")
+    ConfigObject::Tester[:item_1].value.should == 5
+    ConfigObject::Tester[:item_2].value.should == 1
+  end
+  
+  it "should let defaults be set manually" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml")
+    ConfigObject::Tester.set_defaults(:value => 6)
+    ConfigObject::Tester[:item_1].value.should == 5
+    ConfigObject::Tester[:item_2].value.should == 6
+  end
+  
+  it "should reload the configuration" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml")
+    ConfigObject::Tester[:item_1].name.should == "Item One"
+    ConfigObject::Tester[:item_3].should == nil
+
+    ConfigObject::Tester.configuration_files << File.join(File.dirname(__FILE__), "test_2.yaml")
+    ConfigObject::Tester[:item_3].should == nil
+    ConfigObject::Tester.reload
+    ConfigObject::Tester[:item_1].name.should == "Item One"
+    ConfigObject::Tester[:item_3].name.should == "Item Three"
+  end
+  
+  it "should reload automatically when the configuration files are set" do
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_1.yml")
+    ConfigObject::Tester[:item_1].name.should == "Item One"
+    ConfigObject::Tester[:item_3].should == nil
+
+    ConfigObject::Tester.configuration_files = File.join(File.dirname(__FILE__), "test_2.yaml")
+    ConfigObject::Tester[:item_1].should == nil
+    ConfigObject::Tester[:item_3].name.should == "Item Three"
+  end
+  
+  it "should reload automatically when a new configure is called" do
+    ConfigObject::Tester.configure({:item_a => {:name => "Item A"}})
+    ConfigObject::Tester[:item_a].name.should == "Item A"
+    ConfigObject::Tester[:item_b].should == nil
+
+    ConfigObject::Tester.configure({:item_b => {:name => "Item B"}})
+    ConfigObject::Tester[:item_a].name.should == "Item A"
+    ConfigObject::Tester[:item_b].name.should == "Item B"
+  end
+  
+  it "should reload automatically when the defaults are set" do
+    ConfigObject::Tester.configure({:item_a => {:name => "Item A"}})
+    ConfigObject::Tester[:item_a].name.should == "Item A"
+    ConfigObject::Tester[:item_a].value.should == nil
+
+    ConfigObject::Tester.set_defaults(:value => 14)
+    ConfigObject::Tester[:item_a].name.should == "Item A"
+    ConfigObject::Tester[:item_a].value.should == 14
+  end
+  
+  it "should notify observers with a callback method or block when the configuration is reloaded" do
+    ConfigObject::Tester.configure({:item_a => {:name => "Item A"}})
+    
+    observer_1 = Object.new
+    def observer_1.update_config (config); @updated = config; end
+    def observer_1.updated_config?; @updated; end
+    ConfigObject::Tester.add_observer(observer_1, :update_config)
+    
+    observer_2 = Object.new
+    observer_2_updated = nil
+    ConfigObject::Tester.add_observer(observer_2){|config| observer_2_updated = config}
+    
+    observer_1.updated_config?.should == nil
+    observer_2_updated.should == nil
+    ConfigObject::Tester.reload
+    observer_1.updated_config?.should == ConfigObject::Tester
+    observer_2_updated.should == ConfigObject::Tester
+  end
+  
+  it "should be able to remove observers from being notified" do
+    ConfigObject::Tester.configure({:item_a => {:name => "Item A"}})
+    
+    observer_1 = Object.new
+    observer_1_count = 0
+    ConfigObject::Tester.add_observer(observer_1){observer_1_count += 1}
+    
+    observer_2 = Object.new
+    observer_2_count = 0
+    ConfigObject::Tester.add_observer(observer_2){observer_2_count += 1}
+    
+    ConfigObject::Tester.reload
+    ConfigObject::Tester.remove_observer(observer_1)
+    ConfigObject::Tester.reload
+    observer_1_count.should == 1
+    observer_2_count.should == 2
+  end
+  
+  it "should get the ids of all configuration objects" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A"},
+      :item_b => {:name => "Item B"}
+    })
+    ConfigObject::Tester.ids.sort.should == ["item_a", "item_b"]
+  end
+  
+  it "should be able to find a configuration object by id" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A"},
+      :item_b => {:name => "Item B"}
+    })
+    ConfigObject::Tester.find("item_a").name.should == "Item A"
+    ConfigObject::Tester.find(:item_b).name.should == "Item B"
+  end
+  
+  it "should be able to find a configuration object by conditions" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A", :value => 10},
+      :item_b => {:name => "Item B"},
+      :item_c => {
+        :name => "Item C",
+        :value => 15,
+        :object => {:name => "Item C.1"},
+        :complex => [1, 2, 3]
+      }
+    })
+    ConfigObject::Tester.find("name" => "Item A").name.should == "Item A"
+    ConfigObject::Tester.find(:name => "Item B").name.should == "Item B"
+    ConfigObject::Tester.find(:name => /B/).name.should == "Item B"
+    ConfigObject::Tester.find(:value => 15).name.should == "Item C"
+    ConfigObject::Tester.find("object.name" => "Item C.1").name.should == "Item C"
+    ConfigObject::Tester.find("value.>" => 12).name.should == "Item C"
+    ConfigObject::Tester.find("complex.include?" => 1).name.should == "Item C"
+    ConfigObject::Tester.find("complex.include?" => 5).should == nil
+  end
+  
+  it "should be able to get all configuration objects" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A"},
+      :item_b => {:name => "Item B"}
+    })
+    ConfigObject::Tester.all.collect{|a| a.name}.should == ["Item A", "Item B"]
+  end
+  
+  it "should be able to get all configuration objects that match some conditions" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A", :value => 10},
+      :item_b => {:name => "Item B"},
+      :item_c => {
+        :name => "Item C",
+        :value => 15,
+        :object => {:name => "Item C.1"}
+      }
+    })
+    item_a = ConfigObject::Tester[:item_a]
+    item_b = ConfigObject::Tester[:item_b]
+    item_c = ConfigObject::Tester[:item_c]
+    ConfigObject::Tester.all("name" => "Item A").should == [item_a]
+    ConfigObject::Tester.all(:name => "Item B").should == [item_b]
+    ConfigObject::Tester.all(:name => /A|B/).sort{|a,b| a.name <=> b.name}.should == [item_a, item_b]
+    ConfigObject::Tester.all(:value => 15).should == [item_c]
+    ConfigObject::Tester.all("object.name" => "Item C.1").should == [item_c]
+  end
+  
+  it "should cache the result of finding objects by conditions" do
+    ConfigObject::Tester.configure({
+      :item_a => {:name => "Item A", :complex => 1},
+      :item_b => {:name => "Item B", :complex => 2}
+    })
+    item_a = ConfigObject::Tester[:item_a]
+    item_b = ConfigObject::Tester[:item_b]
+    item_a.complex_called.should == 0
+    items = ConfigObject::Tester.all(:complex => 1).should == [item_a]
+    item_a.complex_called.should == 1
+    items = ConfigObject::Tester.all(:complex => 1).should == [item_a]
+    item_a.complex_called.should == 1
+    items = ConfigObject::Tester.all(:complex => 2).should == [item_b]
+    item_a.complex_called.should == 2
+  end
+  
+  it "should call setter methods when initializing new objects" do
+    config = ConfigObject::Tester.new(:name => "Name", :value => "10")
+    config.name.should == "Name"
+    config.value.should == 10
+  end
+  
+  it "should set instance variables when no setter is defined when intializing new objects" do
+    config = ConfigObject::Tester.new(:complex => "test", :no_attr => "here")
+    config.complex.should == "test"
+    config.instance_variable_get(:@no_attr).should == "here"
+  end
+  
+  it "should duplicate and freeze the objects set in attributes" do
+    name = "Item A"
+    values = ["X", "Y"]
+    type = "array"
+    complex = {"values" => values, "type" => type}
+    ConfigObject::Tester.configure({:item_a => {:name => name, :complex => complex}})
+    item = ConfigObject::Tester[:item_a]
+    
+    item.name.should == name
+    item.name.object_id.should_not == name.object_id
+    item.complex.should == complex
+    item.complex.object_id.should_not == complex.object_id
+    item.complex["values"].object_id.should_not == values.object_id
+    item.complex["type"].object_id.should_not == type.object_id
+    
+    name.should_not be_frozen
+    complex.should_not be_frozen
+    values.should_not be_frozen
+    values.each{|v| v.should_not be_frozen}
+    type.should_not be_frozen
+
+    item.name.should be_frozen
+    item.complex.should be_frozen
+    item.complex["values"].should be_frozen
+    item.complex["values"].each{|v| v.should be_frozen}
+    item.complex["type"].should be_frozen
+  end
+  
+  it "should not blow up when setting non-duplicable or non-freezable attributes" do
+    array = [1, 2]
+    array.freeze
+    ConfigObject::Tester.configure({:item_a => {:name => nil, :value => 1, :object => true, :complex => array}})
+  end
+  
+  it "should have an id attribute that is set by the configuration" do
+    ConfigObject::Tester.configure(:item_a => {:name => "Item A"})
+    ConfigObject::Tester[:item_a].id.should == "item_a"
+  end
+  
+  it "should not share objects between classes" do
+    ConfigObject::Tester.configure(:item_a => {:name => "Item A"})
+    ConfigObject::Tester.ids.should == ["item_a"]
+    ConfigObject::Tester2.ids.should == []
+    ConfigObject::Tester2.configure(:item_b => {:name => "Item B"})
+    ConfigObject::Tester.ids.should == ["item_a"]
+    ConfigObject::Tester2.ids.should == ["item_b"]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'config_object'))

data/spec/test_1.yml

@@ -0,0 +1,13 @@
+item_1:
+  name: Item One
+  value: 5
+  
+item_2:
+  name: Item Two
+  complex: "Thing"
+  
+item_4:
+  name: Item Four
+
+defaults:
+  value: 1

data/spec/test_2.yaml

@@ -0,0 +1,7 @@
+item_2:
+  name: Item Too
+  value: 2
+  object: <%= Date.today.to_s %>
+  
+item_3:
+  name: Item Three

data/spec/test_files/item_1.yml

@@ -0,0 +1,7 @@
+value: 8
+object:
+  name: object one
+  value: 14
+  object:
+    name: object two
+    value: 15

data/spec/test_files/item_2.txt

@@ -0,0 +1 @@
+name: Item Two From Text File

data/spec/test_files/item_3/name.yml

@@ -0,0 +1 @@
+Item 3 Directory

data/spec/test_files/item_3/object.yml

@@ -0,0 +1,2 @@
+name: object three
+value: 10

data/spec/test_files/item_5.yaml

@@ -0,0 +1,2 @@
+name: Item Five
+value: 10

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: config_object
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A configuration gem which is simple to use but full of awesome features.
+email: brian@embellishedvisions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/config_object.rb
+- spec/config_object_spec.rb
+- spec/spec_helper.rb
+- spec/test_1.yml
+- spec/test_2.yaml
+- spec/test_files/item_1.yml
+- spec/test_files/item_2.txt
+- spec/test_files/item_3/name.yml
+- spec/test_files/item_3/object.yml
+- spec/test_files/item_5.yaml
+has_rdoc: true
+homepage: http://github.com/bdurand/config_object
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple and powerful configuration library
+test_files: 
+- spec/config_object_spec.rb
+- spec/spec_helper.rb