configurable 0.5.0 → 0.6.0

data/lib/config_parser/option.rb

@@ -66,7 +66,7 @@ class ConfigParser
         end
         block ? block.call(value) : value
       else
-        raise "value specified for flag" if value
+        raise "value specified for flag: #{switch}" if value
         block ? block.call : nil
       end
     end
@@ -75,7 +75,7 @@ class ConfigParser
     def to_s
       lines = Lazydoc::Utils.wrap(desc.to_s, 43)
       
-      header =  "    #{short_str} #{long_str} #{arg_name}"
+      header =  "    #{short_str}#{long_str} #{arg_name}"
       header = header.length > 36 ? header.ljust(80) : (LINE_FORMAT % [header, lines.shift])
       
       if lines.empty?
@@ -90,7 +90,14 @@ class ConfigParser
     
     # helper returning short formatted for to_s
     def short_str # :nodoc:
-      short ? short + ',' : '   '
+      case
+      when short && long
+        "#{short}, "
+      when short
+        "#{short}"
+      else 
+        '    '
+      end
     end
     
     # helper returning long formatted for to_s

data/lib/config_parser/switch.rb

@@ -29,7 +29,7 @@ class ConfigParser
     # or calls the block with true in all other cases.  Raises an
     # error if a value is specified.
     def parse(switch, value, argv)
-      raise "value specified for switch" if value
+      raise "value specified for switch: #{switch}" if value
       value = (switch == negative_long ? false : true)
       block ? block.call(value) : value
     end

data/lib/config_parser/utils.rb

@@ -12,25 +12,25 @@ class ConfigParser
     # the match:
     #
     #   $1:: the switch
-    #   $3:: the value
+    #   $2:: the value
     #
-    LONG_OPTION = /^(--[A-z].*?)(=(.*))?$/
+    LONG_OPTION = /^(--[A-z].*?)(?:=(.*))?$/
 
     # Matches a nested short option, with or without a value
     # (ex: '-o', '-n:o', '-o=value').  After the match:
     #
     #   $1:: the switch
-    #   $4:: the value
+    #   $2:: the value
     #
-    SHORT_OPTION = /^(-[A-z](:[A-z])*)(=(.*))?$/
+    SHORT_OPTION = /^(-[A-z](?::[A-z])*)(?:=(.*))?$/
 
     # Matches the alternate syntax for short options
     # (ex: '-n:ovalue', '-ovalue').  After the match:
     #
     #   $1:: the switch
-    #   $3:: the value
+    #   $2:: the value
     #
-    ALT_SHORT_OPTION = /^(-[A-z](:[A-z])*)(.+)$/
+    ALT_SHORT_OPTION = /^(-[A-z](?::[A-z])*)(.+)$/
     
     # Turns the input string into a short-format option.  Raises
     # an error if the option does not match SHORT_OPTION.  Nils
@@ -44,7 +44,7 @@ class ConfigParser
   
       str = str.to_s
       str = "-#{str}" unless str[0] == ?-
-      unless str =~ SHORT_OPTION && $3 == nil
+      unless str =~ SHORT_OPTION && $2 == nil
         raise ArgumentError, "invalid short option: #{str}"
       end
       str
@@ -64,7 +64,7 @@ class ConfigParser
       str = str.to_s
       str = "--#{str}" unless str =~ /^--/
       str.gsub!(/_/, '-')
-      unless str =~ LONG_OPTION && $3 == nil
+      unless str =~ LONG_OPTION && $2 == nil
         raise ArgumentError, "invalid long option: #{str}"
       end
       str
@@ -82,15 +82,48 @@ class ConfigParser
       "--#{switch.join(':')}"
     end
     
+    # Infers the default long using key and adds it to attributes.  Returns
+    # attributes.
+    #
+    #   infer_long(:key, {})                      # => {:long => '--key'}
+    #
+    def infer_long(key, attributes)
+      unless attributes.has_key?(:long)
+        attributes[:long] = "--#{key}"
+      end
+      
+      attributes
+    end
+    
+    # Infers the default argname from attributes[:long] and sets it in
+    # attributes.  Returns attributes.
+    #
+    #   infer_arg_name(:key, {:long => '--opt'})  # => {:long => '--opt', :arg_name => 'OPT'}
+    #   infer_arg_name(:key, {})                  # => {:arg_name => 'KEY'}
+    #
+    def infer_arg_name(key, attributes)
+      if attributes.has_key?(:arg_name)
+        return attributes
+      end
+      
+      if long = attributes[:long]
+        long.to_s =~ /^(?:--)?(.*)$/
+        attributes[:arg_name] = $1.upcase
+      else
+        attributes[:arg_name] = key.to_s.upcase
+      end
+      
+      attributes
+    end
+    
     # Attributes:
     #
     #   :long      the long key ("--key") 
     #   :arg_name  the argument name ("KEY") 
     #
     def setup_option(key, attributes={})
-      attributes[:long] ||= "--#{key}"
-      attributes[:long].to_s =~ /^(--)?(.*)$/ 
-      attributes[:arg_name] ||= $2.upcase
+      infer_long(key, attributes)
+      infer_arg_name(key, attributes)
       
       lambda {|value| config[key] = value }
     end
@@ -100,7 +133,7 @@ class ConfigParser
     #   :long      the long key ("--key") 
     #
     def setup_flag(key, default=true, attributes={})
-      attributes[:long] ||= "--#{key}"
+      infer_long(key, attributes)
       
       lambda {config[key] = !default }
     end
@@ -110,9 +143,11 @@ class ConfigParser
     #   :long      the long key ("--[no-]key") 
     #
     def setup_switch(key, default=true, attributes={})
-      attributes[:long] ||= "--#{key}"
-      attributes[:long].to_s =~ /^(--)?(\[no-\])?(.*)$/ 
-      attributes[:long] = "--[no-]#{$3}" unless $2
+      infer_long(key, attributes)
+      
+      if attributes[:long].to_s =~ /^(?:--)?(\[no-\])?(.*)$/ 
+        attributes[:long] = "--[no-]#{$2}" unless $1
+      end
       
       lambda {|value| config[key] = value }
     end
@@ -124,9 +159,8 @@ class ConfigParser
     #   :split     the split character
     #
     def setup_list(key, attributes={})
-      attributes[:long] ||= "--#{key}"
-      attributes[:long].to_s =~ /^(--)?(.*)$/ 
-      attributes[:arg_name] ||= $2.upcase
+      infer_long(key, attributes)
+      infer_arg_name(key, attributes)
       
       split = attributes[:split]
       n = attributes[:n]

data/lib/configurable.rb

@@ -1,3 +1,4 @@
+require 'configurable/version'
 require 'configurable/module_methods'
 
 # Configurable enables the specification of configurations within a class 
@@ -5,57 +6,56 @@ require 'configurable/module_methods'
 #
 #   class ConfigClass
 #     include Configurable
-# 
 #     config :one, 'one'
 #     config :two, 'two'
 #     config :three, 'three'
-#
 #   end
 #
 #   c = ConfigClass.new
-#   c.config.class         # => Configurable::DelegateHash
-#   c.config               # => {:one => 'one', :two => 'two', :three => 'three'}
+#   c.config.class            # => Configurable::ConfigHash
+#   c.config                  # => {:one => 'one', :two => 'two', :three => 'three'}
 #
 # Instances have a <tt>config</tt> object that acts like a forwarding hash; 
 # configuration keys delegate to accessors while undeclared key-value pairs
 # are stored internally:
 #
 #   c.config[:one] = 'ONE'
-#   c.one                  # => 'ONE'
+#   c.one                     # => 'ONE'
 #
 #   c.one = 1           
-#   c.config               # => {:one => 1, :two => 'two', :three => 'three'}
+#   c.config                  # => {:one => 1, :two => 'two', :three => 'three'}
 #
 #   c.config[:undeclared] = 'value'
-#   c.config.store         # => {:undeclared => 'value'}
+#   c.config.store            # => {:undeclared => 'value'}
 #
 # The writer for a configuration can be defined by providing a block to config.  
 # The Validation module provides a number of common validation/transform 
 # blocks accessible through the class method 'c':
 #
-#   class SubClass < ConfigClass
+#   class ValidationClass
+#     include Configurable
 #     config(:one, 'one') {|v| v.upcase }
 #     config :two, 2, &c.integer
 #   end
 #
-#   s = SubClass.new
-#   s.config               # => {:one => 'ONE', :two => 2, :three => 'three'}
+#   c = ValidationClass.new
+#   c.config                  # => {:one => 'ONE', :two => 2}
 #
-#   s.one = 'aNothER'             
-#   s.one                  # => 'ANOTHER'
+#   c.one = 'aNothER'             
+#   c.one                     # => 'ANOTHER'
 #
-#   s.two = -2
-#   s.two                  # => -2
-#   s.two = "3"
-#   s.two                  # => 3
-#   s.two = nil            # !> ValidationError
-#   s.two = 'str'          # !> ValidationError
+#   c.two = -2
+#   c.two                     # => -2
+#   c.two = "3"
+#   c.two                     # => 3
+#   c.two = nil               # !> ValidationError
+#   c.two = 'str'             # !> ValidationError
 # 
 # Note that config blocks are defined in class-context and will have access
 # to variables outside the block (as you would expect).  For instance, these
 # are analagous declarations:
 #
-#   class ClassConfig
+#   class ExampleClass
 #     config :key, 'value' do |input|
 #       input.upcase
 #     end
@@ -73,13 +73,51 @@ require 'configurable/module_methods'
 # Blocks provided to config_attr will have instance context and must set 
 # the instance variable themselves.
 #
-#   class ConfigClass
+#   class LiteralClass
 #     config_attr :key, 'value' do |input|
 #       @key = input.upcase
 #     end
 #   end
 #
-# Configurations are inherited and may be overridden in subclasses.
+# Configurations are inherited and may be overridden in subclasses.  They may
+# also be included from a module:
+#
+#   module A
+#     include Configurable
+#     config :a, 'a'
+#     config :b, 'b'
+#   end
+#
+#   class B
+#     include A
+#   end
+#
+#   class C < B
+#     config :b, 'B'
+#     config :c, 'C'
+#   end
+#
+#   B.new.config.to_hash      # => {:a => 'a', :b => 'b'}
+#   C.new.config.to_hash      # => {:a => 'a', :b => 'B', :c => 'C'} 
+#
+# Lastly, configurable classes may be nested through the nest method.  Nesting
+# creates a configurable class with the configs defined in the nest block;
+# nested configs may be accessed by chaining method calls, or through nested
+# calls to config.
+#
+#   class NestingClass
+#     include Configurable
+#     config :one, 'one'
+#     nest :two do
+#       config :three, 'three'
+#     end
+#   end
+#
+#   c = NestingClass.new
+#   c.config.to_hash          # => {:one => 'one', :two => {:three => 'three'}}
+#
+#   c.two.three = 'THREE'
+#   c.config[:two][:three]    # => 'THREE'
 #
 # === Attributes
 #
@@ -127,19 +165,35 @@ require 'configurable/module_methods'
 # needs.  A few attributes are used internally by Configurable.
 #
 # Attribute::    Use::
-# set_default::  When set to false, the delegate will not map a default value
-#                during bind.  Specify when you manually initialize a config
-#                variable.
+# init::         When set to false, the config will not initialize itself. 
+#                Specify when you manually initialize a config.
 # type::         Specifies the type of option ConfigParser generates for this
-#                Delegate (ex: :switch, :flag, :list, :hidden)
+#                Config (ex: :switch, :flag, :list, :hidden)
 # desc::         The description string used in the ConfigParser help
 # long::         The long option (default: key)
 # short::        The short option.
 #
+# Validation blocks have default attributes already assigned to them (ex type).
+# In cases where a user-defined block gets used multiple times, it may be useful
+# to register default attributes for that block.  To do so, use this pattern:
+#
+#   class AttributesClass
+#     include Configurable
+#     block = c.register(:type => :upcase) {|v| v.upcase }
+#
+#     config :a, 'A', &block
+#     config :b, 'B', &block
+#   end
+#   
+#   AttributesClass.configurations[:a][:type]   # => :upcase
+#   AttributesClass.configurations[:b][:type]   # => :upcase
+#
 module Configurable
   autoload(:Utils, 'configurable/utils')
 
-  # A DelegateHash bound to self
+  # A ConfigHash bound to self.  Accessing configurations through config
+  # is much slower (although sometimes more convenient) than through the
+  # config accessors.
   attr_reader :config
   
   # Initializes config, if necessary, and then calls super.  If initialize
@@ -150,8 +204,8 @@ module Configurable
     super
   end
 
-  # Reconfigures self with the given overrides. Only the 
-  # specified configs are modified.
+  # Reconfigures self with the given overrides. Only the specified configs
+  # are modified.
   #
   # Returns self.
   def reconfigure(overrides={})
@@ -159,12 +213,11 @@ module Configurable
     self
   end
 
-  # Reinitializes configurations in the copy such that
-  # the new object has it's own set of configurations,
-  # separate from the original object.
+  # Reinitializes configurations in the copy such that the new object has
+  # it's own set of configurations, separate from the original object.
   def initialize_copy(orig)
     super
-    initialize_config(orig.config.dup)
+    @config = ConfigHash.new(self, orig.config.store.dup, false)
   end
 
   protected
@@ -207,10 +260,49 @@ module Configurable
     end
   end
 
-  # Initializes config. Default config values 
-  # are overridden as specified by overrides.
+  # Initializes config. Default config values are overridden as specified.
   def initialize_config(overrides={})
-    @config = overrides.kind_of?(DelegateHash) ? overrides : DelegateHash.new(self.class.configurations, overrides)
-    @config.bind(self)
+    @config = ConfigHash.new(self, overrides, false)
+    
+    # cache as configs (equivalent to self.class.configurations)
+    # as an optimization
+    configs = @config.configs
+    
+    # hash overrides by delegate so they may be set
+    # in the correct order below
+    initial_values = {}
+    overrides.each_key do |key|
+      if config = configs[key]
+        
+        # check that the config may be initialized
+        unless config.init?
+          key = configs.keys.find {|k| configs[k] == config }
+          raise "initialization values are not allowed for: #{key.inspect}"
+        end
+        
+        # check that multiple overrides are not specified for a
+        # single config, as may happen with indifferent access
+        # (ex 'key' and :key)
+        if initial_values.has_key?(config)
+          key = configs.keys.find {|k| configs[k] == config }
+          raise "multiple values map to config: #{key.inspect}"
+        end
+        
+        # since overrides are used as the ConfigHash store,
+        # the overriding values must be removed, not read
+        initial_values[config] = overrides.delete(key)
+      end
+    end
+    
+    # now initialize configs in order
+    configs.each_pair do |key, config|
+      next unless config.init?
+
+      if initial_values.has_key?(config)
+        config.set(self, initial_values[config])
+      else
+        config.init(self)
+      end
+    end
   end
 end

data/lib/configurable/class_methods.rb

@@ -1,5 +1,4 @@
-require 'lazydoc'
-require 'configurable/delegate_hash'
+require 'configurable/config_hash'
 require 'configurable/indifferent_access'
 require 'configurable/validation'
 
@@ -7,33 +6,33 @@ autoload(:ConfigParser, 'config_parser')
 
 module Configurable
   
-  # ClassMethods extends classes that include Configurable and
-  # provides methods for declaring configurations.
+  # ClassMethods extends classes that include Configurable and provides methods
+  # for declaring configurations.
   module ClassMethods
-    include Lazydoc::Attributes
-
-    # A hash of (key, Delegate) pairs defining the class configurations.
-    attr_reader :configurations
-
-    def inherited(child) # :nodoc:
-      unless child.instance_variable_defined?(:@source_file)
-        caller[0] =~ Lazydoc::CALLER_REGEXP
-        child.instance_variable_set(:@source_file, File.expand_path($1)) 
+    CONFIGURATIONS_CLASS = Hash
+    
+    # A hash of (key, Config) pairs tracking configs defined on self.  See
+    # configurations for all configs declared across all ancestors.
+    attr_reader :config_registry
+    
+    def self.initialize(base)  # :nodoc:
+      unless base.instance_variable_defined?(:@config_registry)
+        base.instance_variable_set(:@config_registry, CONFIGURATIONS_CLASS.new)
       end
-
-      # deep duplicate configurations
-      unless child.instance_variable_defined?(:@configurations)
-        duplicate = child.instance_variable_set(:@configurations, configurations.dup)
-        duplicate.each_pair {|key, config| duplicate[key] = config.dup }
-        duplicate.extend(IndifferentAccess) if configurations.kind_of?(IndifferentAccess)
+      
+      unless base.instance_variable_defined?(:@use_indifferent_access)
+        base.instance_variable_set(:@use_indifferent_access, true)
+      end
+      
+      unless base.instance_variable_defined?(:@configurations)
+        base.instance_variable_set(:@configurations, nil)
       end
-      super
     end
     
     # Parses configurations from argv in a non-destructive manner by generating
     # a ConfigParser using the configurations for self.  Returns an array like
     # [args, config] where the args are the arguments that remain after parsing,
-    # and config is a hash of the parsed configs. The parser will is yielded to
+    # and config is a hash of the parsed configs. The parser is yielded to
     # the block, if given, to register additonal options.  
     #
     # See ConfigParser#parse for more information.
@@ -50,16 +49,55 @@ module Configurable
       [args, parser.config]
     end
     
-    protected
+    # A hash of (key, Config) pairs representing all configurations defined
+    # on this class or inherited from ancestors.  The configurations hash is
+    # generated on each call to ensure it accurately reflects any configs
+    # added on ancestors. This slows down initialization and config access
+    # through instance.config.
+    #
+    # Call cache_configurations after all configs have been declared in order
+    # to prevent regeneration of configurations and to significantly improve
+    # performance.
+    def configurations
+      return @configurations if @configurations
+      
+      configurations = CONFIGURATIONS_CLASS.new
+      configurations.extend(IndifferentAccess) if @use_indifferent_access
+      
+      ancestors.reverse.each do |ancestor|
+        next unless ancestor.kind_of?(ClassMethods)
+        ancestor.config_registry.each_pair do |key, value|
+          if value.nil?
+            configurations.delete(key)
+          else
+            configurations[key] = value
+          end
+        end
+      end
+      
+      configurations
+    end
+    
+    # Caches the configurations hash so as to improve peformance.  Call
+    # with on set to false to turn off caching.
+    def cache_configurations(on=true)
+      @configurations = nil
+      @configurations = self.configurations if on
+    end
     
+    protected
+
     # Sets configurations to symbolize keys for AGET ([]) and ASET([]=)
     # operations, or not.  By default, configurations will use
     # indifferent access.
     def use_indifferent_access(input=true)
-      if input
+      @use_indifferent_access = input
+      return unless @configurations
+      
+      if @use_indifferent_access
         @configurations.extend(IndifferentAccess)
       else
-        @configurations = configurations.dup
+        @configurations = @configurations.dup
       end
     end
 
@@ -129,17 +167,20 @@ module Configurable
     # Several attributes may be specified to modify how a config is constructed.
     # Attribute keys should be specified as symbols.
     #
-    # Attribute::             Description            
+    # Attribute::             Description  
+    # init::                  When set to false the config will not initialize
+    #                         during initialize_config. (default: true)
     # reader::                The method used to read the configuration.
     #                         (default: key)
     # writer::                The method used to write the configuration
     #                         (default: "#{key}=")
     #
-    # Neither attribute may be set to nil, but they may be set to non-default
-    # values.  In that case, config_attr will register the method names as
-    # provided, but it will not define the methods themselves. Specifying true
-    # uses and defines the default methods.  Specifying false uses the default
-    # method name, but does not define the method itself.
+    # Neither reader nor writer may be set to nil, but they may be set to
+    # non-default values.  In that case, config_attr will register the method
+    # names as provided, but it will not define the methods themselves.
+    # Specifying true defines the default methods.  Specifying false makes
+    # the config expect the default method name, but does not define the method
+    # itself.
     #
     # Any additional attributes are registered with the configuration.
     def config_attr(key, value=nil, attributes={}, &block)
@@ -161,7 +202,10 @@ module Configurable
         public(attribute)
       end
       
-      configurations[key] = Delegate.new(reader, writer, value, attributes)
+      # define the configuration
+      init = attributes.has_key?(:init) ? attributes.delete(:init) : true
+      dup = attributes.has_key?(:dup) ? attributes.delete(:dup) : nil
+      config_registry[key] = Config.new(reader, writer, value, attributes, init, dup)
     end
     
     # Adds nested configurations to self.  Nest creates a new configurable
@@ -237,51 +281,28 @@ module Configurable
     #
     # === Attributes
     #
-    # Nest provides a number of attributes that can modify how a nest is
-    # constructed.  Attribute keys should be specified as symbols.
+    # Nest uses the same attributes as config_attr, with a couple additions:
     #
     # Attribute::             Description            
     # const_name::            Determines the constant name of the configurable
     #                         class within the nesting class.  May be nil.
     #                         (default: key.to_s.capitalize)
-    # instance_reader::       The method accessing the nested instance. (default: key)
-    # instance_writer::       The method to set the nested instance. (default: "#{key}=")
-    # reader::                The method used to read the instance config.
-    #                         (default: "#{key}_config_reader")
-    # writer::                The method used to reconfigure the instance. 
-    #                         (default: "#{key}_config_writer")
-    #
-    # Except for const_name, these attributes are used to define methods
-    # required for nesting to work properly.  None of the method attributes may
-    # be set to nil, but they may be set to non-default values.  In that case,
-    # nest will register the method names as provided, but it will not define
-    # the methods themselves.  The user must define methods with the following
-    # functionality:
-    #
-    # Attribute::             Function          
-    # instance_reader::       Returns the instance of the configurable class 
-    #                         (initializing if necessary, by default nest initializes
-    #                         using configurable_class.new)
-    # instance_writer::       Inputs and sets the instance of the configurable class
-    # reader::                Returns instance.config
-    # writer::                Reconfigures instance using the input overrides, or
-    #                         sets instance if provided.
-    #
-    # Methods can be public or otherwise.  Specifying true uses and defines the
-    # default methods.  Specifying false uses the default method name, but does
-    # not define the method itself.
+    # type::                  By default set to :nest.
     #
-    # Any additional attributes are registered with the configuration.
     def nest(key, configurable_class=nil, attributes={}, &block)
       attributes = merge_attributes(block, attributes)
       attributes = {
-        :instance_reader => true,
-        :instance_writer => true,
+        :reader => true,
+        :writer => true,
+        :type => :nest
       }.merge(attributes)
       
       # define the nested configurable
       if configurable_class
-        raise "a block is not allowed when a configurable class is specified" if block_given?
+        if block_given?
+          configurable_class = Class.new(configurable_class)
+          configurable_class.class_eval(&block)
+        end
       else
         configurable_class = Class.new { include Configurable }
         configurable_class.class_eval(&block) if block_given?
@@ -301,55 +322,90 @@ module Configurable
           const_set(const_name, configurable_class)
         end
       end
+      const_name = nil
       
-      # define instance reader
-      instance_reader = define_attribute_method(:instance_reader, attributes, key) do |attribute|
-        instance_variable = "@#{key}".to_sym
-        
-        # gets or initializes the instance
-        define_method(attribute) do
-          if instance_variable_defined?(instance_variable)
-            instance_variable_get(instance_variable)
-          else
-            instance_variable_set(instance_variable, configurable_class.new)
-          end
-        end
-        
-        public(key)
+      # define the reader.
+      reader = define_attribute_method(:reader, attributes, key) do |attribute|
+        attr_reader attribute
+        public(attribute)
       end
       
-      # define instance writer
-      instance_writer = define_attribute_method(:instance_writer, attributes, "#{key}=") do |attribute|
-        attr_writer(key)
+      # define the writer.  the default the writer validates the
+      # instance is the correct class then sets the instance variable
+      instance_variable = "@#{key}".to_sym
+      writer = define_attribute_method(:writer, attributes, "#{key}=") do |attribute|
+        define_method(attribute) do |value|
+          Validation.validate(value, [configurable_class])
+          instance_variable_set(instance_variable, value)
+        end
         public(attribute)
       end
       
-      # define the reader
-      reader = define_attribute_method(:reader, attributes, "#{key}_config_reader") do |attribute|
-        define_method(attribute) do
-          send(instance_reader).config
-        end
-        private(attribute)
+      # define the configuration
+      init = attributes.has_key?(:init) ? attributes.delete(:init) : true
+      config_registry[key] = NestConfig.new(configurable_class, reader, writer, attributes, init)
+      check_infinite_nest(configurable_class)
+    end  
+    
+    # Removes a configuration much like remove_method removes a method.  The
+    # reader and writer for the config are likewise removed.  Nested configs
+    # can be removed using this method.
+    #
+    # Setting :reader or :writer to false in the options prevents those methods
+    # from being removed.
+    #
+    def remove_config(key, options={})
+      unless config_registry.has_key?(key)
+        raise NameError.new("#{key.inspect} is not a config on #{self}")
       end
       
-      # define the writer
-      writer = define_attribute_method(:writer, attributes, "#{key}_config_writer") do |attribute|
-        define_method(attribute) do |value|
-          if value.kind_of?(configurable_class)
-            send(instance_writer, value)
-          else
-            send(instance_reader).reconfigure(value)
-          end
-        end
-        private(attribute)
+      options = {
+        :reader => true,
+        :writer => true
+      }.merge(options)
+      
+      config = config_registry.delete(key)
+      cache_configurations(@configurations != nil)
+      
+      undef_method(config.reader) if options[:reader]
+      undef_method(config.writer) if options[:writer]
+    end
+    
+    # Undefines a configuration much like undef_method undefines a method.  The
+    # reader and writer for the config are likewise undefined.  Nested configs
+    # can be undefined using this method.
+    #
+    # Setting :reader or :writer to false in the options prevents those methods
+    # from being undefined.
+    #
+    # ==== Implementation Note
+    #
+    # Configurations are undefined by setting the key to nil in the registry.
+    # Deleting the config is not sufficient because the registry needs to
+    # convey to self and subclasses to not inherit the config from ancestors.
+    #
+    # This is unlike remove_config where the config is simply deleted from
+    # the config_registry.
+    #
+    def undef_config(key, options={})
+      # temporarily cache as an optimization
+      configs = configurations
+      unless configs.has_key?(key)
+        raise NameError.new("#{key.inspect} is not a config on #{self}")
       end
       
-      # define the configuration
-      nested_config = DelegateHash.new(configurable_class.configurations)
-      configurations[key] = Delegate.new(reader, writer, nested_config, attributes)
+      options = {
+        :reader => true,
+        :writer => true
+      }.merge(options)
       
-      check_infinite_nest(configurable_class.configurations)
-    end  
+      config = configs[key]
+      config_registry[key] = nil
+      cache_configurations(@configurations != nil)
+      
+      undef_method(config.reader) if options[:reader]
+      undef_method(config.writer) if options[:writer]
+    end
     
     # Alias for Validation
     def c
@@ -358,6 +414,11 @@ module Configurable
 
     private
     
+    def inherited(base) # :nodoc:
+     ClassMethods.initialize(base)
+     super
+    end
+    
     # a helper to define methods that may be overridden in attributes.
     # yields the default to the block if the default is supposed to
     # be defined.  returns the symbolized method name.
@@ -384,12 +445,6 @@ module Configurable
       attribute.to_sym
     end
     
-    # a helper to initialize configurations for the first time,
-    # mainly implemented as a hook for OrderedHashPatch
-    def initialize_configurations # :nodoc:
-      @configurations ||= {}
-    end
-    
     # a helper method to merge the default attributes for the block with
     # the input attributes.  also registers a Trailer description.
     def merge_attributes(block, attributes) # :nodoc:
@@ -404,95 +459,19 @@ module Configurable
     end
     
     # helper to recursively check for an infinite nest
-    def check_infinite_nest(delegates) # :nodoc:
-      raise "infinite nest detected" if delegates == self.configurations
+    def check_infinite_nest(klass) # :nodoc:
+      raise "infinite nest detected" if klass == self
       
-      delegates.each_pair do |key, delegate|
-        if delegate.is_nest?
-          check_infinite_nest(delegate.default(false).delegates)
+      klass.configurations.each_value do |delegate|
+        if delegate.kind_of?(NestConfig)
+          check_infinite_nest(delegate.nest_class)
         end
       end
     end
   end
 end
 
-module Configurable
-  
-  # Beginning with ruby 1.9, Hash tracks the order of insertion and methods
-  # like each_pair return pairs in order.  Configurable leverages this feature
-  # to keep configurations in order for the command line documentation produced
-  # by ConfigParser.
-  #
-  # Pre-1.9 ruby implementations require a patched Hash that tracks insertion
-  # order.  This very thin subclass of hash does that for ASET insertions and
-  # each_pair.  OrderedHashPatches are used as the configurations object in 
-  # Configurable classes for pre-1.9 ruby implementations and for nothing else.
-  class OrderedHashPatch < Hash
-    def initialize
-      super
-      @insertion_order = []
-    end
-    
-    # ASET insertion, tracking insertion order.
-    def []=(key, value)
-      @insertion_order << key unless @insertion_order.include?(key)
-      super
-    end
-    
-    # Keys, sorted into insertion order
-    def keys
-      super.sort_by do |key|
-        @insertion_order.index(key) || length
-      end
-    end
-    
-    # Yields each key-value pair to the block in insertion order.
-    def each_pair
-      keys.each do |key|
-        yield(key, fetch(key))
-      end
-    end
-    
-    # Ensures the insertion order of duplicates is separate from parents.
-    def initialize_copy(orig)
-      super
-      @insertion_order = orig.instance_variable_get(:@insertion_order).dup
-    end
-    
-    # Overridden to load an array of [key, value] pairs in order (see to_yaml).
-    # The default behavior for loading from a hash of key-value pairs is
-    # preserved, but the insertion order will not be preserved.
-    def yaml_initialize( tag, val )
-      @insertion_order ||= []
-     
-      if Array === val
-        val.each do |k, v|
-          self[k] = v
-        end
-      else
-        super
-      end
-    end
-    
-    # Overridden to preserve insertion order by serializing self as an array
-    # of [key, value] pairs.
-    def to_yaml( opts = {} )
-      YAML::quick_emit( object_id, opts ) do |out|
-        out.seq( taguri, to_yaml_style ) do |seq|
-          each_pair do |key, value|
-            seq.add( [key, value] )
-          end
-        end
-      end
-    end
-  end
-  
-  module ClassMethods
-    undef_method :initialize_configurations
-    
-    # applies OrderedHashPatch
-    def initialize_configurations # :nodoc:
-      @configurations ||= OrderedHashPatch.new
-    end
-  end
-end if RUBY_VERSION < '1.9'
+# Apply the ordered hash patch if necessary
+if RUBY_VERSION < '1.9'
+  require 'configurable/ordered_hash_patch'
+end