configurable 0.4.0 → 0.4.1

data/History

@@ -1,3 +1,10 @@
+== 0.4.1 / 2009-03-23
+
+* Simplified internal API for nesting (removed initialize_<key>)
+* Added :hidden option type to prevent declaration of an option
+* Refactored :map_default attribute to :set_default
+* Made OrderedHashPatch preserve order when serialized as YAML
+
 == 0.4.0 / 2009-03-05
 
 Reworked nesting.  Changes are not backward compatible.

data/README

@@ -131,5 +131,5 @@ Configurable is available as a gem on RubyForge[http://rubyforge.org/projects/ta
 Copyright (c) 2008-2009, Regents of the University of Colorado.
 Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
 Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
-Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]
+License:: {MIT-Style}[link:files/MIT-LICENSE.html]
 

data/lib/config_parser.rb

@@ -331,7 +331,8 @@ class ConfigParser
   #   psr.parse("--opt value")
   #   psr.config             # => {:opt => 'eulav'}
   #
-  # Define raises an error if key is already set by a different option.
+  # The :hidden type causes no configuration to be defined.  Raises an error if
+  # key is already set by a different option.
   def define(key, default_value=nil, attributes={})
     # check for conflicts and register
     if default_config.has_key?(key)
@@ -346,6 +347,7 @@ class ConfigParser
     when :switch then setup_switch(key, default_value, attributes)
     when :flag   then setup_flag(key, default_value, attributes)
     when :list   then setup_list(key, attributes)
+    when :hidden then return nil
     when nil     then setup_option(key, attributes)
     else
       if respond_to?("setup_#{attributes[:type]}")

data/lib/configurable.rb

@@ -122,11 +122,19 @@ require 'configurable/class_methods'
 #
 # ==== Non-reader/writer attributes
 #
-# Metadata for a config may be specified in attributes as well.  Attributes like
-# :desc, and :type are used by ConfigParser, for instance, to determine how to
-# represent the configuration on the command line.  Attributes are unstructured
-# so they can accomodate metadata for multiple contexts (ex a web or desktop 
-# interface), as needed.
+# Attributes provide metadata for how to use configurations in various contexts.
+# In general, attributes can be used to set any metadata an application
+# 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.
+# type::         Specifies the type of option ConfigParser generates for this
+#                Delegate (ex: :switch, :flag, :list, :hidden)
+# desc::         The description string used in the ConfigParser help
+# long::         The long option (default: key)
+# short::        The short option.
 #
 module Configurable
   autoload(:Utils, 'configurable/utils')

data/lib/configurable/class_methods.rb

@@ -255,12 +255,10 @@ module Configurable
     #                         (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}=")
-    # instance_initializer::  The method that initializes the instance.
-    #                         (default: "initialize_#{key}")
-    # reader::                The method used to read the instance configuration.
+    # reader::                The method used to read the instance config.
     #                         (default: "#{key}_config_reader")
-    # writer::                The method used to initialize or reconfigure the
-    #                         instance. (default: "#{key}_config_writer")
+    # 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
@@ -270,14 +268,13 @@ module Configurable
     # functionality:
     #
     # Attribute::             Function          
-    # instance_reader::       Returns the instance of the configurable class
+    # 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
-    # instance_initializer::  Receives the initial config and return an instance of
-    #                         configurable class
     # reader::                Returns instance.config
-    # writer::                Reconfigures instance using the input overrides,
-    #                         or uses instance_initializer and instance_writer to
-    #                         initialize and set the instance.
+    # 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
@@ -289,7 +286,6 @@ module Configurable
       attributes = {
         :instance_reader => true,
         :instance_writer => true,
-        :initializer => true
       }.merge(attributes)
       
       # define the nested configurable
@@ -310,7 +306,17 @@ module Configurable
       
       # define instance reader
       instance_reader = define_attribute_method(:instance_reader, attributes, key) do |attribute|
-        attr_reader(key)
+        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)
       end
       
@@ -320,25 +326,21 @@ module Configurable
         public(attribute)
       end
       
-      # define initializer
-      initializer = define_attribute_method(:initializer, attributes, "initialize_#{key}") do |attribute|
-        define_method(attribute) {|config| configurable_class.new.reconfigure(config) }
-        private(attribute)
-      end
-      
       # define the reader
       reader = define_attribute_method(:reader, attributes, "#{key}_config_reader") do |attribute|
-        define_method(attribute) { send(instance_reader).config }
+        define_method(attribute) do
+          send(instance_reader).config
+        end
         private(attribute)
       end
       
       # define the writer
       writer = define_attribute_method(:writer, attributes, "#{key}_config_writer") do |attribute|
         define_method(attribute) do |value|
-          if instance = send(instance_reader)
-            instance.reconfigure(value)
+          if value.kind_of?(configurable_class)
+            send(instance_writer, value)
           else
-            send(instance_writer, send(initializer, value))
+            send(instance_reader).reconfigure(value)
           end
         end
         private(attribute)
@@ -458,6 +460,33 @@ module Configurable
       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

data/lib/configurable/delegate_hash.rb

@@ -185,7 +185,7 @@ module Configurable
         # UNLESS map_default is set (indicating manual initialization)
         value = case
         when source.has_key?(key) then source.delete(key)
-        when delegate[:map_default, true] then delegate.default
+        when delegate[:set_default, true] then delegate.default
         else next
         end
         

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: configurable
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-05 00:00:00 -07:00
+date: 2009-03-23 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency