configurable 0.7.0 → 1.0.0

data/lib/configurable/class_methods.rb

@@ -1,359 +1,202 @@
+require 'lazydoc'
 require 'configurable/config_hash'
-require 'configurable/indifferent_access'
-require 'configurable/validation'
-
-autoload(:ConfigParser, 'config_parser')
+require 'configurable/conversions'
 
 module Configurable
   
+  # Hash of default config types (bool, integer, float, string).
+  DEFAULT_CONFIG_TYPES = {
+    :bool    => ConfigTypes::BooleanType,
+    :integer => ConfigTypes::IntegerType,
+    :float   => ConfigTypes::FloatType,
+    :string  => ConfigTypes::StringType,
+    :nest    => ConfigTypes::NestType,
+    :obj     => ConfigTypes::ObjectType
+  }
+  
   # ClassMethods extends classes that include Configurable and provides methods
   # for declaring configurations.
   module ClassMethods
-    CONFIGURATIONS_CLASS = Hash
+    include ConfigClasses
+    include ConfigTypes
     
-    # A hash of (key, Config) pairs tracking configs defined on self.  See
-    # configurations for all configs declared across all ancestors.
+    # A hash of (key, Config) pairs tracking configs defined on self.  See the
+    # configs method for all configs declared across all ancestors.
     attr_reader :config_registry
     
-    def self.initialize(base)  # :nodoc:
+    # A hash of (key, ConfigType) pairs tracking config_types defined on self.
+    # See the config_types method for all config_types declared across all
+    # ancestors.
+    attr_reader :config_type_registry
+    
+    def self.initialize(base) # :nodoc:
+      base.reset_configs
       unless base.instance_variable_defined?(:@config_registry)
-        base.instance_variable_set(:@config_registry, CONFIGURATIONS_CLASS.new)
+        base.instance_variable_set(:@config_registry, {})
       end
       
-      unless base.instance_variable_defined?(:@use_indifferent_access)
-        base.instance_variable_set(:@use_indifferent_access, true)
+      base.reset_config_types
+      unless base.instance_variable_defined?(:@config_type_registry)
+        base.instance_variable_set(:@config_type_registry, {})
       end
       
-      unless base.instance_variable_defined?(:@configurations)
-        base.instance_variable_set(:@configurations, nil)
+      unless base.instance_variable_defined?(:@config_type_context)
+        base.instance_variable_set(:@config_type_context, base)
       end
     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 is yielded to
-    # the block, if given, to register additonal options.  
-    #
-    # See ConfigParser#parse for more information.
-    def parse(argv=ARGV, options={}) # :yields: parser
-      parse!(argv.dup, options)
-    end
-    
-    # Same as parse, but removes parsed args from argv.
-    def parse!(argv=ARGV, options={})
-      parser = ConfigParser.new
-      parser.add(configurations)
-      
-      args = parser.parse!(argv, options)
-      [args, parser.config]
-    end
-    
-    # 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
+    # A hash of (key, Config) pairs representing all configs defined on this
+    # class or inherited from ancestors.  The configs hash is memoized for
+    # performance.  Call reset_configs if configs needs to be recalculated for
+    # any reason.
+    #
+    # Configs is extended with the Conversions module.
+    def configs
+      @configs ||= begin
+        configs = {}
       
-      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
+        ancestors.reverse.each do |ancestor|
+          next unless ancestor.kind_of?(ClassMethods)
+          ancestor.config_registry.each_pair do |key, value|
+            if value.nil?
+              configs.delete(key)
+            else
+              configs[key] = value
+            end
           end
         end
+        
+        configs.extend Conversions
+        configs
       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
+    # Resets configs such that they will be recalculated.
+    def reset_configs
+      @configs = nil
     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)
-      @use_indifferent_access = input
-      return unless @configurations
+    # A hash of (key, ConfigType) pairs representing all config_types defined
+    # on this class or inherited from ancestors.  The config_types hash is
+    # memoized for performance.  Call reset_config_types if config_types needs
+    # to be recalculated for any reason.
+    def config_types
+      @config_types ||= begin
+        config_types = {}
+        
+        registries = []
+        each_registry do |ancestor, registry|
+          registries.unshift(registry)
+        end
+        
+        registries.each do |registry|
+          registry.each_pair do |key, value|
+            if value.nil?
+              config_types.delete(key)
+            else
+              config_types[key] = value
+            end
+          end
+        end
       
-      if @use_indifferent_access
-        @configurations.extend(IndifferentAccess)
-      else
-        @configurations = @configurations.dup
+        config_types
       end
     end
-
-    # Declares a class configuration and generates the associated accessors. 
-    # If a block is given, the <tt>key=</tt> method will set <tt>@key</tt> 
-    # to the return of the block, which executes in class-context.  
-    #
-    #   class SampleClass
-    #     include Configurable
-    #
-    #     config :str, 'value'
-    #     config(:upcase, 'value') {|input| input.upcase } 
-    #   end
-    #
-    #   # An equivalent class to illustrate class-context
-    #   class EquivalentClass
-    #     attr_accessor :str
-    #     attr_reader :upcase
-    #
-    #     UPCASE_BLOCK = lambda {|input| input.upcase }
-    #
-    #     def upcase=(input)
-    #       @upcase = UPCASE_BLOCK.call(input)
-    #     end
-    #   end
-    #
-    def config(key, value=nil, attributes={}, &block)
-      attributes = merge_attributes(block, attributes)
-      
-      if block_given?
-        instance_variable = "@#{key}".to_sym
-        config_attr(key, value, attributes) do |input|
-          instance_variable_set(instance_variable, yield(input))
-        end
-      else
-        config_attr(key, value, attributes)
-      end
+    
+    # Resets config_types such that they will be recalculated.
+    def reset_config_types
+      @config_types = nil
     end
-
-    # Declares a class configuration and generates the associated accessors. 
-    # If a block is given, the <tt>key=</tt> method will perform the block
-    # with instance-context.
-    #
-    #   class SampleClass
-    #     include Configurable
-    #
-    #     def initialize
-    #       initialize_config
-    #     end
-    #
-    #     config_attr :str, 'value'
-    #     config_attr(:upcase, 'value') {|input| @upcase = input.upcase } 
-    #   end
-    #
-    #   # An equivalent class to illustrate instance-context
-    #   class EquivalentClass
-    #     attr_accessor :str
-    #     attr_reader :upcase
-    #
-    #     def upcase=(input)
-    #       @upcase = input.upcase
-    #     end
-    #   end
-    #
-    # === Attributes
-    #
-    # Several attributes may be specified to modify how a config is constructed.
-    # Attribute keys should be specified as symbols.
-    #
-    # 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 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)
-      attributes = merge_attributes(block, attributes)
+    
+    protected
+    
+    attr_accessor :config_type_context
+    
+    # Defines and registers an instance of config_class with the specified key
+    # and attrs. Unless attrs specifies a :reader or :writer, the
+    # corresponding attr accessors will be defined for the config name (which
+    # by default is the key). 
+    def define_config(key, attrs={}, config_class=ScalarConfig)
+      reader = attrs[:reader]
+      writer = attrs[:writer]
       
-      # define the reader
-      reader = define_attribute_method(:reader, attributes, key) do |attribute|
-        attr_reader(attribute) 
-        public(attribute)
-      end
+      config = config_class.new(key, attrs)
       
-      # define the writer
-      if block_given? && attributes[:writer] != true
-        raise ArgumentError, "a block may not be specified without writer == true"
+      unless reader
+        attr_reader(config.name)
+        public(config.name)
       end
       
-      writer = define_attribute_method(:writer, attributes, "#{key}=") do |attribute|
-        block_given? ? define_method(attribute, &block) : attr_writer(key)
-        public(attribute)
+      unless writer
+        attr_writer(config.name)
+        public("#{config.name}=")
       end
       
-      # 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)
+      config_registry[config.key] = config
+      reset_configs
+      config
     end
     
-    # Adds nested configurations to self.  Nest creates a new configurable
-    # class using the block, and provides accessors to an instance of the
-    # new class.  Everything is set up so you can access configs through
-    # the instance or through config.
-    #
-    #   class A
-    #     include Configurable
-    #
-    #     config :key, 'one'
-    #     nest :nest do
-    #       config :key, 'two'
-    #     end
-    #   end
-    #
-    #   a = A.new
-    #   a.key                     # => 'one'
-    #   a.config[:key]            # => 'one'
-    #
-    #   a.nest.key                # => 'two'
-    #   a.config[:nest][:key]     # => 'two'
-    # 
-    #   a.nest.key = 'TWO'
-    #   a.config[:nest][:key]     # => 'TWO'
-    #
-    #   a.config[:nest][:key] = 2
-    #   a.nest.key                # => 2
-    #
-    #   a.config.to_hash          # => {:key => 'one', :nest => {:key => 2}}
-    #   a.nest.config.to_hash     # => {:key => 2}
-    #   a.nest.class              # => A::Nest
-    #
-    # An existing configurable class may be provided instead of using the block
-    # to define a new configurable class.  Recursive nesting is supported.
-    #
-    #   class B
-    #     include Configurable
-    #
-    #     config :key, 1, &c.integer
-    #     nest :nest do 
-    #       config :key, 2, &c.integer
-    #       nest :nest do
-    #         config :key, 3, &c.integer
-    #       end
-    #     end
-    #   end
-    #
-    #   class C
-    #     include Configurable
-    #     nest :a, A
-    #     nest :b, B
-    #   end
-    #
-    #   c = C.new
-    #   c.b.key = 7
-    #   c.b.nest.key = "8"
-    #   c.config[:b][:nest][:nest][:key] = "9"
-    #
-    #   c.config.to_hash
-    #   # => {
-    #   # :a => {
-    #   #   :key => 'one',
-    #   #   :nest => {:key => 'two'}
-    #   # },
-    #   # :b => {
-    #   #   :key => 7,
-    #   #   :nest => {
-    #   #     :key => 8,
-    #   #     :nest => {:key => 9}
-    #   #   }
-    #   # }}
-    #
-    # === Attributes
-    #
-    # 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)
-    # type::                  By default set to :nest.
-    #
-    def nest(key, configurable_class=nil, attributes={}, &block)
-      attributes = merge_attributes(block, attributes)
-      attributes = {
-        :reader => true,
-        :writer => true,
-        :type => :nest
-      }.merge(attributes)
+    # Defines a config after guessing or setting some standard values into
+    # attrs. Specifically:
+    #
+    # * :default is the default
+    # * :caster is the caster block (if provided)
+    # * :desc is set using Lazydoc (unless already set)
+    # * :list is set to true for array defaults (unless already set)
+    #
+    # In addition config also guesses the type of a config (if not manually
+    # specified by :type) and merges in any attributes for the corresponding
+    # config_type.  The class of the config is guessed from the attrs, based
+    # on the :list and :options attributes using this logic:
+    #
+    #   :list  :otions   config_class
+    #   ---------------------------
+    #   false  false     Config
+    #   true   false     List
+    #   false  true      Select
+    #   true   true      ListSelect
+    #
+    # == Usage Note
+    #
+    # Config is meant to be a convenience method.  It gets most things right
+    # but if the attrs logic is too convoluted (and at times it is) then
+    # define configs manually with the define_config method.
+    def config(key, default=nil, attrs={}, &block)
+      orig_attrs = attrs.dup
       
-      # define the nested configurable
-      if configurable_class
-        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?
+      if nest_class = guess_nest_class(default, block)
+        default = nest_class.new
       end
       
-      # set the new constant
-      const_name = if attributes.has_key?(:const_name) 
-        attributes.delete(:const_name) 
-      else
-        key.to_s.capitalize
+      if default.kind_of?(Configurable)
+        attrs[:configurable] = default
+        default = default.config.to_hash
       end
       
-      if const_name
-        # this prevents a warning in cases where the nesting
-        # class defines the configurable_class
-        unless const_defined?(const_name) && const_get(const_name) == configurable_class
-          const_set(const_name, configurable_class)
-        end
-      end
-      const_name = nil
+      attrs[:default]  = default
+      attrs[:type]     = guess_config_type(attrs).new(attrs)
+      attrs[:metadata] = guess_config_metadata(Lazydoc.register_caller).merge!(orig_attrs)
+      config_class     = guess_config_class(attrs)
       
-      # define the reader.
-      reader = define_attribute_method(:reader, attributes, key) do |attribute|
-        attr_reader attribute
-        public(attribute)
-      end
+      config = define_config(key, attrs, config_class)
       
-      # 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)
+      if nest_class
+        const_name = attrs[:const_name] || guess_nest_const_name(config)
+        unless const_defined?(const_name)
+          const_set(const_name, nest_class)
         end
-        public(attribute)
       end
-      
-      # 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  
+
+      config
+    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.
+    # Removes a config 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}")
@@ -365,18 +208,20 @@ module Configurable
       }.merge(options)
       
       config = config_registry.delete(key)
-      cache_configurations(@configurations != nil)
+      reset_configs
       
-      undef_method(config.reader) if options[:reader]
-      undef_method(config.writer) if options[:writer]
+      remove_method(config.reader) if options[:reader]
+      remove_method(config.writer) if options[:writer]
+      
+      config
     end
     
-    # Undefines a configuration much like undef_method undefines a method.  The
+    # Undefines a config 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.
+    # Setting :reader or :writer to false in the options prevents those
+    # methods from being undefined.
     #
     # ==== Implementation Note
     #
@@ -384,12 +229,9 @@ module Configurable
     # 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.
-    #
+    # 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
@@ -401,77 +243,212 @@ module Configurable
       
       config = configs[key]
       config_registry[key] = nil
-      cache_configurations(@configurations != nil)
+      reset_configs
       
       undef_method(config.reader) if options[:reader]
       undef_method(config.writer) if options[:writer]
+      
+      config
     end
     
-    # Alias for Validation
-    def c
-      Validation
+    def define_config_type(name, config_type)
+      config_type_registry[name] = config_type
+      reset_config_types
+      config_type
     end
-
+    
+    def config_type(name, *matchers, &caster)
+      config_type = StringType.subclass(*matchers).cast(&caster)
+      const_name  = guess_config_type_const_name(name)
+      
+      unless const_defined?(const_name)
+        const_set(const_name, config_type)
+      end
+      
+      define_config_type(name, config_type)
+    end
+    
+    # Removes a config_type much like remove_method removes a method.
+    def remove_config_type(name)
+      unless config_type_registry.has_key?(name)
+        raise NameError.new("#{name.inspect} is not a config_type on #{self}")
+      end
+      
+      config_type = config_type_registry.delete(name)
+      reset_config_types
+      config_type
+    end
+    
+    # Undefines a config_type much like undef_method undefines a method.
+    #
+    # ==== Implementation Note
+    #
+    # ConfigClasses are undefined by setting the key to nil in the registry.
+    # Deleting the config_type is not sufficient because the registry needs to
+    # convey to self and subclasses to not inherit the config_type from
+    # ancestors.
+    #
+    # This is unlike remove_config_type where the config_type is simply
+    # deleted from the config_type_registry.
+    def undef_config_type(name)
+      unless config_types.has_key?(name)
+        raise NameError.new("#{name.inspect} is not a config_type on #{self}")
+      end
+      
+      config_type = config_type_registry[name]
+      config_type_registry[name] = nil
+      reset_config_types
+      config_type
+    end
+    
     private
     
     def inherited(base) # :nodoc:
-     ClassMethods.initialize(base)
-     super
+      ClassMethods.initialize(base)
+      super
+    end
+
+    def guess_nest_class(base, block) # :nodoc:
+      unless base.kind_of?(Hash) || block
+        return nil
+      end
+
+      nest_class = Class.new { include Configurable }
+      nest_class.config_type_context = self
+
+      if base.kind_of?(Hash)
+        base.each_pair do |key, value|
+          nest_class.send(:config, key, value)
+        end
+      end
+
+      if block
+        nest_class.class_eval(&block)
+      end
+
+      check_infinite_nest(nest_class)
+      nest_class
+    end
+
+    # helper to recursively check for an infinite nest
+    def check_infinite_nest(klass) # :nodoc:
+      raise "infinite nest detected" if klass == self
+
+      klass.configs.each_value do |config|
+        if config.type.kind_of?(NestType)
+          check_infinite_nest(config.type.configurable.class)
+        end
+      end
     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.
-    def define_attribute_method(name, attributes, default) # :nodoc:
-      attribute = attributes.delete(name)
+    def each_registry # :nodoc:
+      # yield the registry for self first to take account of times when
+      # config_type_context.ancestors does not include self (otherwise
+      # config types defined on self are missed)
+      yield self, config_type_registry
       
-      case attribute
-      when true
-        # true means use the default and define the method
-        attribute = default
-        yield(attribute)
-        
-      when false
-        # false means use the default, but let the user define the method
-        attribute = default
-        
-      when nil
-        # nil is not allowed
-        raise "#{name.inspect} attribute cannot be nil"
+      config_type_context.ancestors.each do |ancestor|
+        case
+        when ancestor == self
+          next
+          
+        when ancestor.kind_of?(ClassMethods)
+          yield ancestor, ancestor.config_type_registry
+          
+        when ancestor == Configurable
+          yield ancestor, Configurable::DEFAULT_CONFIG_TYPES
+          break
+          
+        else next
+        end
       end
-      # ... all other values specify what the method should be,
-      # and lets the user define the method.
-
-      attribute.to_sym
     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:
-      defaults = DEFAULT_ATTRIBUTES[nil].dup
-      defaults.merge!(DEFAULT_ATTRIBUTES[block]) if block
-      defaults.merge!(attributes)
+    def guess_config_type_by_name(name) # :nodoc:
+      return name if name.nil?
       
-      # register with Lazydoc
-      defaults[:desc] ||= Lazydoc.register_caller(Lazydoc::Trailer, 2)
+      each_registry do |ancestor, registry|
+        if registry.has_key?(name)
+          return registry[name]
+        end
+      end
       
-      defaults
+      raise "no such config type: #{type.inspect}"
     end
     
-    # helper to recursively check for an infinite nest
-    def check_infinite_nest(klass) # :nodoc:
-      raise "infinite nest detected" if klass == self
+    def guess_config_type_by_value(value) # :nodoc:
+      each_registry do |ancestor, registry|
+        guesses = registry.values.select {|config_type| config_type.matches?(value) }
+        
+        case guesses.length
+        when 0 then next
+        when 1 then return guesses.at(0)
+        else raise "multiple guesses for config type: #{guesses.inspect} (in: #{ancestor} default: #{default.inspect})"
+        end
+      end
       
-      klass.configurations.each_value do |delegate|
-        if delegate.kind_of?(NestConfig)
-          check_infinite_nest(delegate.nest_class)
+      ObjectType
+    end
+    
+    def guess_config_type(attrs) # :nodoc:
+      if attrs.has_key?(:type)
+        guess_config_type_by_name attrs[:type]
+      else
+        value = attrs[:default]
+        value = value.at(0) if value.kind_of?(Array)
+        guess_config_type_by_value value
+      end
+    end
+    
+    def guess_config_class(attrs) # :nodoc:
+      if attrs.has_key?(:class)
+        attrs[:class] 
+      else
+        case attrs[:default]
+        when Array then ListConfig
+        when Hash  then NestConfig
+        else ScalarConfig
         end
       end
     end
+    
+    def guess_config_metadata(comment) # :nodoc:
+      Hash.new do |hash, key|
+        comment.resolve
+        
+        if trailer = comment.trailer
+          flags, desc = trailer.split(':', 2)
+          
+          if desc.nil?
+            flags, desc = '', flags
+          elsif flags.strip.empty?
+            hash[:hidden] = true
+          else
+            hash[:long]     = nil
+            hash[:short]    = nil
+            hash[:arg_name] = nil
+          end
+          
+          argv = flags.split(',').collect! {|arg| arg.strip }
+          argv << desc.strip
+        
+          comment_attrs = ConfigParser::Utils.parse_attrs(argv)
+          comment_attrs.each_pair do |attr_key, attr_value|
+            hash[attr_key] = attr_value
+          end
+        end
+        
+        hash[:help] = comment.content
+        hash.has_key?(key) ? hash[key] : nil
+      end
+    end
+    
+    def guess_nest_const_name(config) # :nodoc:
+      config.name.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+    
+    def guess_config_type_const_name(name) # :nodoc:
+      "#{name}Type".gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
   end
-end
-
-# Apply the ordered hash patch if necessary
-if RUBY_VERSION < '1.9'
-  require 'configurable/ordered_hash_patch'
 end