configurable 0.5.0 → 0.6.0

data/lib/configurable/utils.rb

@@ -1,16 +1,12 @@
 module Configurable
   
-  # Utility methods to dump and load configurations, particularly nested
-  # configurations.
+  # Utility methods to dump and load Configurable class configurations.
   module Utils
     module_function
     
-    default_dump_block = lambda do |key, delegate|
-      default = delegate.default(false)
-      
+    default_dump_block = lambda do |key, config|
       # note: this causes order to be lost...
-      default = default.to_hash if delegate.is_nest?
-      YAML.dump({key => default})[5..-1]
+      YAML.dump({key => config.default})[5..-1]
     end
     
     # A block performing the default YAML dump.
@@ -23,9 +19,9 @@ module Configurable
     # A block performing the default load.
     DEFAULT_LOAD = default_load_block
     
-    # Dumps delegates to target as yaml.  Delegates are output in order, and
-    # symbol keys are be stringified if delegates has been extended with
-    # IndifferentAccess (this produces a nicer config file).
+    # Dumps configurations to target as yaml.  Configs are output in order,
+    # and symbol keys are be stringified if configurations has been extended
+    # with IndifferentAccess (this produces a nicer config file).
     #
     #   class DumpExample
     #     include Configurable
@@ -40,7 +36,7 @@ module Configurable
     #   # str: value
     #   # }
     #
-    # Dump may be provided with a block to format each (key, delegate) pair;
+    # Dump may be provided with a block to format each (key, Config) pair;
     # the block results are pushed directly to target, so newlines must be
     # specified manually.
     # 
@@ -57,27 +53,27 @@ module Configurable
     #   #
     #   # }
     #
-    def dump(delegates, target="")
-      return dump(delegates, target, &DEFAULT_DUMP) unless block_given?
+    def dump(configs, target="")
+      return dump(configs, target, &DEFAULT_DUMP) unless block_given?
       
-      stringify = delegates.kind_of?(IndifferentAccess)
-      delegates.each_pair do |key, delegate|
+      stringify = configs.kind_of?(IndifferentAccess)
+      configs.each_pair do |key, config|
         key = key.to_s if stringify && key.kind_of?(Symbol)
-        target << yield(key, delegate)
+        target << yield(key, config)
       end
       
       target
     end
     
-    # Dumps the delegates to the specified file.  If recurse is true, nested
-    # configurations are each dumped to their own file, based on the nesting
+    # Dumps the configurations to the specified file.  If recurse is true,
+    # nested configs are each dumped to their own file, based on the nesting
     # key.  For instance if you nested a in b:
     #
     #   a_configs = {
-    #     'key' => Delegate.new(:r, :w, 'a default')}
+    #     'key' => Config.new(:r, :w, 'a default')}
     #   b_configs = {
-    #     'key' => Delegate.new(:r, :w, 'b default')}
-    #     'a' => Delegate.new(:r, :w, DelegateHash.new(a_configs))}}
+    #     'key' => Config.new(:r, :w, 'b default')}
+    #     'a' => Config.new(:r, :w, ConfigHash.new(a_configs))}}
     #
     #   Utils.dump_file(b_configs, 'b.yml')
     #   File.read('b.yml')         # => "key: b default"
@@ -93,28 +89,25 @@ module Configurable
     # preview dumps are always returned by dump_file.
     #
     # ==== Note
-    # For load_file to correctly load a recursive dump, all delegate hashes
-    # must use String keys.  Symbol keys are allowed if the delegate hashes use
+    # For load_file to correctly load a recursive dump, all config hashes
+    # must use String keys.  Symbol keys are allowed if the config hashes use
     # IndifferentAccess; all other keys will not load properly.  By default 
     # Configurable is set up to satisfy these conditions.
     #
     # 1.8 Bug: Currently dump_file with recurse=false will cause order to be
     # lost in nested configs. See http://bahuvrihi.lighthouseapp.com/projects/21202-configurable/tickets/8
-    def dump_file(delegates, path, recurse=false, preview=false, &block)
-      return dump_file(delegates, path, recurse, preview, &DEFAULT_DUMP) unless block_given?
+    def dump_file(configs, path, recurse=false, preview=false, &block)
+      return dump_file(configs, path, recurse, preview, &DEFAULT_DUMP) unless block_given?
       
       current = ""
       dumps = [[path, current]]
       
-      dump(delegates, current) do |key, delegate|
-        if recurse && delegate.is_nest?
-          nested_delegates = delegate.default(false).delegates
-          nested_dumps = dump_file(nested_delegates, recursive_path(key, path), true, true, &block)
-          
-          dumps.concat(nested_dumps)
+      dump(configs, current) do |key, config|
+        if recurse && config.kind_of?(NestConfig)
+          dumps.concat(dump_file(config.nest_class.configurations, recursive_path(key, path), true, true, &block))
           ""
         else
-          yield(key, delegate)
+          yield(key, config)
         end
       end
       

data/lib/configurable/validation.rb

@@ -8,7 +8,7 @@ module Configurable
   
   # Validation generates blocks for common validations and transformations of 
   # configurations set through Configurable.  In general these blocks load
-  # string inputs as YAML and valdiate the results; non-string inputs are
+  # string inputs as YAML and validate the results; non-string inputs are
   # simply validated.
   #
   #   integer = Validation.integer
@@ -56,7 +56,7 @@ module Configurable
 
     # Registers the default attributes with the specified block
     # in Configurable::DEFAULT_ATTRIBUTES.
-    def register(block, attributes)
+    def register(attributes={}, &block)
       DEFAULT_ATTRIBUTES[block] = attributes
       block
     end
@@ -207,7 +207,7 @@ module Configurable
     
     # default attributes {:type => :string, :example => "string"}
     STRING = string_validation_block
-    register STRING, :type => :string, :example => "string"
+    register :type => :string, :example => "string", &STRING
     
     # Same as string but allows nil.  Note the special
     # behavior of the nil string '~' -- rather than
@@ -242,7 +242,7 @@ module Configurable
     
     # default attributes {:type => :symbol, :example => ":sym"}
     SYMBOL = yaml(Symbol)
-    register SYMBOL, :type => :symbol, :example => ":sym"
+    register :type => :symbol, :example => ":sym", &SYMBOL
     
     # Same as symbol but allows nil:
     #
@@ -253,6 +253,46 @@ module Configurable
     SYMBOL_OR_NIL = yaml(Symbol, nil)
     register_as SYMBOL, SYMBOL_OR_NIL
     
+    # Returns a block that checks the input is a symbol.
+    # String inputs are directly converted to a symbol.
+    #
+    #   strbol.class              # => Proc
+    #   strbol.call(:sym)         # => :sym
+    #   strbol.call(':sym')       # => :":sym"
+    #   strbol.call('str')        # => :sym
+    #   strbol.call(nil)          # => ValidationError
+    #
+    def strbol(); STRBOL; end
+
+    # default attributes {:type => :symbol, :example => ":sym"}
+    STRBOL = lambda do |input|
+      if input.kind_of?(String)
+        input = input.to_sym
+      end
+      
+      validate(input, [Symbol])
+    end
+    register :type => :symbol, :example => ":sym", &STRBOL
+
+    # Same as strbol but allows nil.  Tilde is considered a string
+    # equivalent of nil (this behavior is consistent with the YAML
+    # methods but obviously inconsistent with the strbol behavior).
+    #
+    #   strbol_or_nil.call('~')   # => nil
+    #   strbol_or_nil.call(nil)   # => nil
+    def strbol_or_nil(); STRBOL_OR_NIL; end
+
+    STRBOL_OR_NIL = lambda do |input|
+      input = case input
+      when "~"    then nil
+      when String then input.to_sym
+      else input
+      end
+      
+      validate(input, [Symbol, nil])
+    end
+    register_as STRBOL, STRBOL_OR_NIL
+    
     # Returns a block that checks the input is true, false or nil.
     # String inputs are loaded as yaml first.
     #
@@ -272,21 +312,21 @@ module Configurable
     
     # default attributes {:type => :boolean, :example => "true, yes"}
     BOOLEAN = yaml(true, false, nil)
-    register BOOLEAN, :type => :boolean, :example => "true, yes"
+    register :type => :boolean, :example => "true, yes", &BOOLEAN
 
     # Same as boolean.
     def switch(); SWITCH; end
     
     # default attributes {:type => :switch}
     SWITCH = yaml(true, false, nil)
-    register SWITCH, :type => :switch
+    register :type => :switch, &SWITCH
     
     # Same as boolean.
     def flag(); FLAG; end
     
     # default attributes {:type => :flag}
     FLAG = yaml(true, false, nil)
-    register FLAG, :type => :flag
+    register :type => :flag, &FLAG
 
     # Returns a block that checks the input is an array.
     # String inputs are loaded as yaml first.
@@ -301,7 +341,7 @@ module Configurable
     
     # default attributes {:type => :array, :example => "[a, b, c]"}
     ARRAY = yaml(Array)
-    register ARRAY, :type => :array, :example => "[a, b, c]"
+    register :type => :array, :example => "[a, b, c]", &ARRAY
 
     # Same as array but allows nil:
     #
@@ -343,7 +383,7 @@ module Configurable
     
     # default attributes {:type => :list, :split => ','}
     LIST = list_block
-    register LIST, :type => :list, :split => ','
+    register :type => :list, :split => ',', &LIST
     
     # Returns a block that checks the input is a hash.
     # String inputs are loaded as yaml first.
@@ -358,7 +398,7 @@ module Configurable
     
     # default attributes {:type => :hash, :example => "{one: 1, two: 2}"}
     HASH = yaml(Hash)
-    register HASH, :type => :hash, :example => "{one: 1, two: 2}"
+    register :type => :hash, :example => "{one: 1, two: 2}", &HASH
 
     # Same as hash but allows nil:
     #
@@ -383,7 +423,7 @@ module Configurable
     
     # default attributes {:type => :integer, :example => "2"}
     INTEGER = yaml(Integer)
-    register INTEGER, :type => :integer, :example => "2"
+    register :type => :integer, :example => "2", &INTEGER
     
     # Same as integer but allows nil:
     #
@@ -409,7 +449,7 @@ module Configurable
     
     # default attributes {:type => :float, :example => "2.2, 2.0e+2"}
     FLOAT = yaml(Float)
-    register FLOAT, :type => :float, :example => "2.2, 2.0e+2"
+    register :type => :float, :example => "2.2, 2.0e+2", &FLOAT
     
     # Same as float but allows nil:
     #
@@ -436,7 +476,7 @@ module Configurable
     
     # default attributes {:type => :numeric, :example => "2, 2.2, 2.0e+2"}
     NUMERIC = yaml(Numeric)
-    register NUMERIC, :type => :numeric, :example => "2, 2.2, 2.0e+2"
+    register :type => :numeric, :example => "2, 2.2, 2.0e+2", &NUMERIC
     
     # Same as numeric but allows nil:
     #
@@ -477,7 +517,7 @@ module Configurable
     
     # default attributes {:type => :regexp, :example => "/regexp/i"}
     REGEXP = regexp_block
-    register REGEXP, :type => :regexp, :example => "/regexp/i"
+    register :type => :regexp, :example => "/regexp/i", &REGEXP
 
     # Same as regexp but allows nil. Note the special behavior of the nil
     # string '~' -- rather than being converted to a regexp, it is processed
@@ -524,7 +564,7 @@ module Configurable
     
     # default attributes {:type => :range, :example => "min..max"}
     RANGE = range_block
-    register RANGE, :type => :range, :example => "min..max"
+    register :type => :range, :example => "min..max", &RANGE
     
     # Same as range but allows nil:
     #
@@ -579,7 +619,7 @@ module Configurable
     
     # default attributes {:type => :time, :example => "2008-08-08 08:00:00"}
     TIME = time_block
-    register TIME, :type => :time, :example => "2008-08-08 08:00:00"
+    register :type => :time, :example => "2008-08-08 08:00:00", &TIME
     
     # Same as time but allows nil:
     #
@@ -614,15 +654,14 @@ module Configurable
     #  {:type => :select, :options => options}
     #
     def select(*options, &validation)
-      block = lambda do |input|
+      register(
+        :type => :select, 
+        :options => options,
+        :validation => attributes(validation)
+      ) do |input|
         input = validation.call(input) if validation
         validate(input, options)
       end
-      
-      register(block, 
-        :type => :select, 
-        :options => options,
-        :validation => attributes(validation))
     end
     
     # Returns a block that checks the input is an array, and that each member
@@ -645,17 +684,16 @@ module Configurable
     #  {:type => :list_select, :options => options, :split => ','}
     #
     def list_select(*options, &validation)
-      block = lambda do |input|
+      register( 
+        :type => :list_select, 
+        :options => options, 
+        :split => ',',
+        :validation => attributes(validation)
+      ) do |input|
         args = validate(input, [Array])
         args.collect! {|arg| validation.call(arg) } if validation
         args.each {|arg| validate(arg, options) }
       end
-      
-      register(block, 
-        :type => :list_select, 
-        :options => options, 
-        :split => ',',
-        :validation => attributes(validation))
     end
     
     # Returns a block validating the input is an IO, a string, or an integer.
@@ -693,9 +731,9 @@ module Configurable
       end
     end
     
-    # default attributes {:type => :io, :duplicate_default => false, :example => "/path/to/file"}
+    # default attributes {:type => :io, :dup => false, :example => "/path/to/file"}
     IO_OR_STRING = check(IO, String, Integer)
-    register IO_OR_STRING, :type => :io, :duplicate_default => false, :example => "/path/to/file"
+    register :type => :io, :dup => false, :example => "/path/to/file", &IO_OR_STRING
     
     # Same as io but allows nil:
     #

data/lib/configurable/version.rb

@@ -0,0 +1,7 @@
+module Configurable
+  MAJOR = 0
+  MINOR = 6
+  TINY = 0
+  
+  VERSION="#{MAJOR}.#{MINOR}.#{TINY}"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: configurable
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 -06:00
+date: 2009-12-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.0
+        version: 1.0.0
     version: 
 description: 
 email: simon.a.chiang@gmail.com
@@ -42,17 +42,22 @@ files:
 - lib/config_parser/utils.rb
 - lib/configurable.rb
 - lib/configurable/class_methods.rb
-- lib/configurable/delegate.rb
-- lib/configurable/delegate_hash.rb
+- lib/configurable/config.rb
+- lib/configurable/config_hash.rb
 - lib/configurable/indifferent_access.rb
 - lib/configurable/module_methods.rb
-- lib/configurable/validation.rb
+- lib/configurable/nest_config.rb
+- lib/configurable/ordered_hash_patch.rb
 - lib/configurable/utils.rb
+- lib/configurable/validation.rb
+- lib/configurable/version.rb
 - MIT-LICENSE
 - README
 - History
 has_rdoc: true
 homepage: http://tap.rubyforge.org/configurable
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
@@ -78,9 +83,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: tap
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: configurable
 test_files: []
 

data/lib/configurable/delegate.rb

@@ -1,103 +0,0 @@
-module Configurable
-  
-  # Delegates are used by DelegateHash to determine how to map read/write
-  # operations to a receiver.
-  class Delegate
-    class << self
-  
-      # Determines if the value is duplicable.  Non-duplicable 
-      # values include nil, true, false, Symbol, Numeric, and 
-      # any object that does not respond to dup.
-      def duplicable_value?(value)
-        case value
-        when nil, true, false, Symbol, Numeric, Method then false
-        else value.respond_to?(:dup)
-        end
-      end
-    end
-
-    # The reader method, by default key
-    attr_reader :reader
-
-    # The writer method, by default key=
-    attr_reader :writer
-
-    # An hash of metadata for self, used to present the delegate in different
-    # contexts (ex on the command line, in a web form, or a desktop app).
-    # Note that attributes should be set through []= and not through this
-    # reader.
-    attr_reader :attributes
-
-    # Initializes a new Delegate with the specified key and default value.
-    def initialize(reader, writer="#{reader}=", default=nil, attributes={})
-      @attributes = attributes
-      
-      self.default = default
-      self.reader = reader
-      self.writer = writer
-    end
-    
-    # Sets the value of an attribute.
-    def []=(key, value)
-      attributes[key] = value
-      reset_duplicable if key == :duplicate_default
-    end
-    
-    # Returns the value for the specified attribute, or
-    # default, if the attribute is unspecified.
-    def [](key, default=nil)
-      attributes.has_key?(key) ? attributes[key] : default
-    end
-
-    # Sets the default value for self.
-    def default=(value)
-      @default = value
-      reset_duplicable
-    end
-
-    # Returns the default value, or a duplicate of the default value if specified.
-    # The default value will not be duplicated unless duplicable (see 
-    # Delegate.duplicable_value?).  Duplication can also be turned off by
-    # specifying self[:duplicate_default] = false.
-    def default(duplicate=true)
-      duplicate && @duplicable ? @default.dup : @default
-    end
-
-    # Sets the reader for self.
-    def reader=(value)
-      raise ArgumentError, "reader may not be nil" if value == nil
-      @reader = value.to_sym
-    end
-
-    # Sets the writer for self.
-    def writer=(value)
-      raise ArgumentError, "writer may not be nil" if value == nil
-      @writer = value.to_sym
-    end
-    
-    # Returns true if the default value is a kind of DelegateHash.
-    def is_nest?
-      @default.kind_of?(DelegateHash)
-    end
-
-    # True if another is a kind of Delegate with the same
-    # reader, writer, and default value.  Attributes are
-    # not considered.
-    def ==(another)
-      another.kind_of?(Delegate) &&
-      self.reader == another.reader &&
-      self.writer == another.writer &&
-      self.default(false) == another.default(false)
-    end
-    
-    private
-    
-    # resets marker indiciating whether or not a default value is duplicable
-    def reset_duplicable # :nodoc:
-      @duplicable = case attributes[:duplicate_default]
-      when true, nil then Delegate.duplicable_value?(@default)
-      else false
-      end
-    end
-  end
-end