option_list 0.2.0 → 1.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MGE1NTkyMWExYjVhYmY1MzJjZmQyOWM2ODVlNmMwNWNmNjVhM2QxYg==
+    NDA0MjBiNDdkNWRhMzgzMzBkYWJiMjhiOGUxNTA3YmE5ZjI3Y2Q4OA==
   data.tar.gz: !binary |-
-    NjAyN2M4NWQ2OGRiZGRjNWY5MTU5MGE4NjMwYjUzNzYwZjNhMDI3MQ==
+    MmIzZGRjZDc0YWRlYTgxNWUyY2VjMWI2MTBmNjg3NGIzZjFlMmMzMg==
 SHA512:
   metadata.gz: !binary |-
-    MzljNzk3MzI0NjM5ZTM5NmZiZDY4YjlmMWUzNThiODc5ZjJmZmE5NjliMTk0
-    NGQ3ZThjNThiNTE0ZTExNGVkYmRlMGZkNzYyNDcxZjcwOWZiMTAxMjIzYmI5
-    YmI1OWZjNjM4MjFjNDJkMTVjM2EwNzc3NDExNDc3OWZjMTJiMTk=
+    MWE0ZjhiZmU0ZmMxYmUzY2VjMDFiZjM5MDU4MjQwODg2NjUwODExNzk0NWVh
+    NGU2ZmQ1OGU3NzRkOGQ1ZTY2ZDI2ODg2NWU3OGQ1YWU1N2E2ZGZlYTQzZWRm
+    NTUyYTdmM2VjYTVlOTcwYTFhODdjNTc4NzBhYjk5MDQyZWQ1MTU=
   data.tar.gz: !binary |-
-    M2E4MmM2NjdjNjQ4MDA0ZmRjNDcyZGE1YTVmZjU0NmY4NTA4MDcxZDJkOGYy
-    YWI5ODBiNTMzNTU4ZjIxZTQzMjI1YjNmNTkwNjc0ZDAwNWQ5ODJhOGFlNzFi
-    YjRmMTkyYThhYTdmNDYwNThhM2ZiNDhjYWNiNTA3ODg3MzI4MjM=
+    NmRiN2NmMjM3OGFkYjcwMThjNjc5MzU1MjM3ODlkODIzNGE4YzZhMTliYzhh
+    YWNkZTNhNjE4MDgwZTc2NzE0Y2QzNzkzOWIwYTJiOWQzMmU0NGEzOTI1MTFl
+    ZTUxZTAwOTAzZTc0YjBmMTYyNTEyOGMxODI4NTFmYjI5ZWE2ZmI=

data/license.txt

@@ -0,0 +1,21 @@
+=== The MIT License (MIT).
+
+Copyright (c) 2013 Peter Camilleri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/option_list.rb

@@ -1,27 +1,5 @@
 require 'set'
 
-#=== The MIT License (MIT).
-#
-#Copyright (c) 2013 Peter Camilleri
-#
-#Permission is hereby granted, free of charge, to any person obtaining a copy
-#of this software and associated documentation files (the "Software"), to deal
-#in the Software without restriction, including without limitation the rights
-#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-#copies of the Software, and to permit persons to whom the Software is
-#furnished to do so, subject to the following conditions:
-#
-#The above copyright notice and this permission notice shall be included in
-#all copies or substantial portions of the Software.
-#
-#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-#THE SOFTWARE.
-#
 #=== The file option_list.rb and the class \OptionList.
 #This file contains the code for the \OptionList class that implements smart
 #and easy options for functions. It has the virtue of defining function
@@ -49,34 +27,60 @@ require 'set'
 #that the library (gem) user does not have to work hard or be lost or confused.
 #Only time will tell to what extent these lofty goals have been achieved. 
 #Hopefully, with good feedback, this and other code libraries will improve.
+#=== Version 1.0.1
+#This version represents a major overhaul of the \OptionList class. In 
+#particular, the selected option data and the dynamic methods used to access
+#that data are no longer contained in the option list object but instead in
+#a singleton subclass of Hash that is returned by the select method. There 
+#are several advantages to this, but the main one is that since \OptionList
+#objects now only contain specification and default values, they are much more
+#thread safe than before. While there is nothing multi-threaded about the
+#\OptionList class itself, it is reasonable to assume that a function option
+#handler could very easily end up embedded in such an environment. In fact, my
+#first major test of the class ran into this exact issue.
 class OptionList
-  #An internal marker for value entries.
-  VALUE_ENTRY = 'A value entry.'
 
-  #Create an option list from an array of option specs. These specs consist of
-  #a number of array specifications and hash specifications.
+  #The option list code version.
+  def self.version
+    '1.0.1'
+  end
+  
+  #The option list code version. This is a redirect to the class method.
+  def version
+    self.class.version
+  end
+
+  #Create an option list from an array of option specifications. These 
+  #specifications consist of a number of array specifications and hash 
+  #specifications. These are described below:
   #==== Array Specification
-  #In the array form of specification, the first element of the array is the
-  #category of the option, and the subsequent entries are the allowed values
-  #for that category. The first of these values is the default value for the 
-  #category. This may be nil to have no default value. The symbols used in each
-  #category must be unique. Duplicates will fail with an ArgumentError.
+  #Array specifications are used in cases where an option category may be one
+  #of a fixed number of distinct symbol values or optionally nil to represent 
+  #no selection.
+  #In this form of specification, the first element of the array is the
+  #category of the option, and the second and following entries are the 
+  #allowed values for that category. The second element has a special role. It
+  #is the default value for the category. Only this value may be nil to have 
+  #no default value. The symbols used in each category must be unique.
   #==== Hash Specification
-  #In the hash form of specification, the key is the category and the value 
-  #is the default value. There is no list of allowed values in this case. 
+  #Hash specifications are used to specify options that do not have a fixed set
+  #of possible values. In this form of specification, the hash key symbol is 
+  #the category and the hash value is the default value for the category. It 
+  #may be nil or any other type or value. Allowed values are not listed.
   #==== Example:
   # @opt_list = OptionList.new([:history, :history, :nohistory], {:page_len => 42})
   #==== Parameters:
-  #* option_specs - The comma separated option specs, made into an array by the
-  #  splat operator.
+  #* option_specs - The comma separated option specifications, made into an 
+  #  array by the splat operator.
   #* select_block - An optional block of code that is called when selections
   #  have been made. This allows for custom validations to be applied at that
   #  point. This block should accept one argument, a reference to the option
-  #  list object that is calling it for validation.
+  #  list value object that is calling it for validation.
   #==== Dynamic Methods:
-  #As option specs are added, new methods are created to allow for easy access
-  #to the option information. If the above example were processed, the following
-  #methods would be added:
+  #As option specifications are added, new methods are created in the value 
+  #object to allow for easy access to the option information. If the above 
+  #example were processed, the following methods would be added to the value
+  #returned by the select method:
   #* history - would return the value of the :history category.
   #* history? - would return true if the :history option where active.
   #* nohistory? - would return true if the :nohistory option were active.
@@ -84,23 +88,10 @@ class OptionList
   #==== Exceptions:
   #* ArgumentError for a number of invalid argument conditions.
   def initialize(*option_specs, &select_block)
+    fAE "Missing option specifications." if option_specs.empty?
     @categories = Hash.new
     @default    = Hash.new
-    @selected   = Hash.new
-    do_add_specs(option_specs)
-    @select_block = select_block
-  end
-  
-  #Add additonal option specifications to the option list. See the method new
-  #for more information on those specifications.
-  def add_specs(*option_specs)
-    do_add_specs(option_specs)
-  end
-  
-  private  #Private methods follow.
-
-  #Iterate over the array of specs, adding them to the option list.
-  def do_add_specs(option_specs)
+    
     option_specs.each do |spec|
       if spec.is_a?(Hash)
         hash_spec(spec)
@@ -110,53 +101,12 @@ class OptionList
         fAE "Found #{spec.class} instead of Hash or Array."
       end
     end
+    
+    @select_block = select_block
   end
-  
-  #Process an array spec that lists all the valid values for an option. See
-  #the new method for more information on these specs.
-  def array_spec(spec)
-    cat = spec.delete_at(0)
-    fAE "Found #{cat.class}, expected Symbol." unless cat.is_a?(Symbol)   
-    fAE "Duplicate category: #{cat}" if @default.has_key?(cat)
-    fAE "Invalid number of entries for #{cat}." unless spec.length > 1
-    define_singleton_method(cat) { @selected[cat] }
-
-    spec.each_with_index do |opt, index|
-      if opt != nil
-        fAE "Found #{opt.class}, expected Symbol." unless opt.is_a?(Symbol)   
-        fAE "Duplicate option: #{opt}" if @categories.has_key?(opt)
-        
-        @categories[opt] = cat
-        qry = (opt.to_s + '?').to_sym
-        define_singleton_method(qry) { @selected[cat] == opt }
-        @selected[cat] = @default[cat] = opt if index == 0
-      elsif index == 0
-        @selected[cat] = @default[cat] = nil
-      else
-        fAE "The value nil is only allowed as the default option."
-      end
-    end
-  end
-  
-  #Process a hash spec that lists only the default value for an option. See
-  #the new method for more information on these specs.
-  def hash_spec(spec)
-    fAE "Hash contains no specs." unless spec.length > 0
 
-    spec.each do |cat, value|
-      fAE "Found #{cat.class}, expected Symbol." unless cat.is_a?(Symbol)    
-      fAE "Duplicate category: #{cat}" if @default.has_key?(cat)
-      
-      define_singleton_method(cat) { @selected[cat] }
-      @categories[cat] = VALUE_ENTRY
-      @selected[cat] = @default[cat] = value    
-    end  
-  end
-  
-  public #Back to public methods.
-  
-  #From the possible options, select the actual, in force, options for use in
-  #the code. These options may take several forms:
+  #From the possible options, select the actual, in force, options and return
+  #an access object for use in the code. These options may take several forms:
   #=== Types of option data:
   #* A symbol - For categories with a specified symbol list, simply list one
   #  of the allowed symbols.
@@ -166,12 +116,12 @@ class OptionList
   #* Mixed - Symbols and hashes can be mixed in an array (see below on how this
   #  is done) Note: Option order does not matter.
   #Some examples:
-  # foo(:sedan, :turbo)
-  # foo({:style=>:sedan})
-  # foo({:page_len=>60})
-  # foo(:sedan, :turbo, {:page_len=>60})
-  # foo({:style=>:sedan, :page_len=>60})
-  # foo({:style=>:sedan}, {:page_len=>60})
+  # o = foo(:sedan, :turbo)
+  # o = foo({:style=>:sedan})
+  # o = foo({:page_len=>60})
+  # o = foo(:sedan, :turbo, {:page_len=>60})
+  # o = foo({:style=>:sedan, :page_len=>60})
+  # o = foo({:style=>:sedan}, {:page_len=>60})
   #=== Passing in option data:
   #The caller of this method may pass these options in a number of ways:
   #==== Array (via a splat)
@@ -201,75 +151,113 @@ class OptionList
   #* selections - An array of the options passed into the client function, usually
   #  with the splat operator. Note that if select is called with no arguments,
   #  all of the default values will be selected.
+  #==== Returns:
+  #An option value object wich is a singleton subclass of the Hash class.
   #==== Exceptions:
   #* ArgumentError for a number of invalid argument conditions.
   #==== Notes:
-  #After processing the selections, the selection block is called if one was
-  #defined in by the constructor.
+  #After processing the selections, the selection validation block is called 
+  #if one was defined for the constructor.
   def select(selections=[])
-    @selected = @default.clone
-    add_selections(selections)
-    @select_block.call(self) unless @select_block.nil?
-  end
-
-  #Add/override additional selections to the option_list. See the select method
-  #for more information about those selection values.
-  def add_selections(selections=[])
+    selected = @default.clone
     selections = [selections] unless selections.is_a?(Array)
     dup = Set.new
 
     selections.each do |opt|
       if opt.is_a?(Symbol)
-        symbolic_selection(opt, dup)
+        symbolic_selection(opt, selected, dup)
       elsif opt.is_a?(Hash)
-        hash_selections(opt, dup)
+        hash_selections(opt, selected, dup)
       else
         fAE "Found #{opt.class} instead of Hash or Symbol."
       end
     end
+    
+    @select_block.call(selected) unless @select_block.nil?
+    selected
   end
   
-  #Call the selection block if one was defined in by the constructor. This 
-  #method must be used if selections are added with add_selections.
-  def validate
-    @select_block.call(self) unless @select_block.nil?
+  private  #Private stuff follows.
+
+  #Return a internal category marker constant for value entries.
+  def value_entry
+    'A value entry.'
   end
   
-  private  #Some more privacy, please!
+  #Process an array spec that lists all the valid values for an option. See
+  #the new method for more information on these specs.
+  def array_spec(spec)
+    cat = spec.delete_at(0)
+    fAE "Found #{cat.class}, expected Symbol." unless cat.is_a?(Symbol)   
+    fAE "Duplicate category: #{cat}" if @default.has_key?(cat)
+    fAE "Invalid number of entries for #{cat}." unless spec.length > 1
+    @default.define_singleton_method(cat) { self[cat] }
+
+    spec.each_with_index do |opt, index|
+      if opt != nil
+        fAE "Found #{opt.class}, expected Symbol." unless opt.is_a?(Symbol)   
+        fAE "Duplicate option: #{opt}" if @categories.has_key?(opt)
+        
+        @categories[opt] = cat
+        qry = (opt.to_s + '?').to_sym
+        @default.define_singleton_method(qry) { self[cat] == opt }
+        @default[cat] = opt if index == 0
+      elsif index == 0
+        @default[cat] = nil
+      else
+        fAE "The value nil is only allowed as the default option."
+      end
+    end
+  end
+  
+  #Process a hash spec that lists only the default value for an option. See
+  #the new method for more information on these specs.
+  def hash_spec(spec)
+    fAE "Hash contains no specs." unless spec.length > 0
+
+    spec.each do |cat, value|
+      fAE "Found #{cat.class}, expected Symbol." unless cat.is_a?(Symbol)    
+      fAE "Duplicate category: #{cat}" if @default.has_key?(cat)
+      
+      @default.define_singleton_method(cat) { self[cat] }
+      @categories[cat] = value_entry
+      @default[cat] = value    
+    end  
+  end
   
   #Process a symbolic option selection.
   #==== Parameters:
   #* option - a symbol to process.
+  #* selected - a hash of selected data.
   #* dup - a set of categories that have been set. Used to detect duplicates.
-  def symbolic_selection(option, dup)
+  def symbolic_selection(option, selected, dup)
     fAE "Unknown option: #{option}." unless @categories.has_key?(option)
     cat = @categories[option]
     fAE "Category #{cat} has multiple values." if dup.include?(cat)
     dup.add(cat)
-    @selected[cat] = option
+    selected[cat] = option
   end
   
   #Process a hash of option selection values.
   #==== Parameters:
   #* options - a hash of options to process.
+  #* selected - a hash of selected data.
   #* dup - a set of categories that have been set. Used to detect duplicates.
-  def hash_selections(options, dup)
+  def hash_selections(options, selected, dup)
     options.each do |cat, value|
       fAE "Not a category: #{cat}." unless @default.has_key?(cat)
       fAE "Category #{cat} has multiple values." if dup.include?(cat)
            
-      unless (@categories[cat] == VALUE_ENTRY) || value.nil?
+      unless (@categories[cat] == value_entry) || value.nil?
         fAE "Found #{opt.class}, expected Symbol." unless value.is_a?(Symbol)
         fAE "Invalid option: #{value}." unless @categories[value] == cat
       end
       
       dup.add(cat)
-      @selected[cat] = value
+      selected[cat] = value
     end
   end
 
-  public
-  
   #Fail with an argument error.
   def fAE(msg)
     fail(ArgumentError, msg, caller)

data/option_list_test.rb

@@ -4,30 +4,32 @@
 require_relative 'option_list'
 require          'minitest/autorun'
 
+class OptionTest
+  def initialize(opt)
+    @opt = opt
+  end
+  
+  def test(*args)
+    o = @opt.select(args)
+  end
+end
+
 class OptionListTester < MiniTest::Unit::TestCase
-  $do_this_only_one_time = true
+  $do_this_only_one_time = ""
   
   def initialize(*all)
-    if $do_this_only_one_time
-      puts "Testing file: option_list.rb" 
-      $do_this_only_one_time = false
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
     end
     
     super(*all)
   end
 
-  def setup
-    @ol1 = OptionList.new([:history, :history, :nohistory], {:pg_len => 42})
-    @ol2 = OptionList.new([:history, nil, :history, :nohistory]) 
-    @ol3 = OptionList.new([:history, nil, :history, :nohistory],
-                          {:fuel1=>:matter, :fuel2=>:antimatter}) do |opt|
-      opt.fAE "The :history option must be set." if opt.history.nil?
-      opt.fAE "Improper fuel mix." unless opt.fuel1 == :matter && opt.fuel2 == :antimatter
-    end
-  end
-
   def test_that_it_rejects_bad_specs
     #Reject empty argument lists.
+    assert_raises(ArgumentError) { @x = OptionList.new }    
     assert_raises(ArgumentError) { @x = OptionList.new([])}
     assert_raises(ArgumentError) { @x = OptionList.new({})}
     
@@ -62,204 +64,151 @@ class OptionListTester < MiniTest::Unit::TestCase
   end
   
   def test_that_the_methods_were_added
-    assert_respond_to(@ol1, :history)
-    assert_respond_to(@ol1, :history? )
-    assert_respond_to(@ol1, :nohistory? )
-    assert_respond_to(@ol1, :pg_len)
-    
-    assert_respond_to(@ol2, :history)
-    assert_respond_to(@ol2, :history? )
-    assert_respond_to(@ol2, :nohistory? )
-    assert_raises(NoMethodError) { @ol2.send((nil.to_s+'?').to_sym) }
-  end
+    ol1 = OptionList.new([:history, :history, :nohistory], {:pg_len => 42})
+    o = ol1.select
   
-  def test_that_it_rejects_bad_added_specs
-    #reject a bad addition...
-    assert_raises(ArgumentError) {@ol1.add_specs({:history=>'fun'})}
-    #but don't mess up.
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)
+    assert_respond_to(o, :history)
+    assert_respond_to(o, :history? )
+    assert_respond_to(o, :nohistory? )
+    assert_respond_to(o, :pg_len)
 
-    #reject a bad addition...
-    assert_raises(ArgumentError) {@ol1.add_specs({:pg_len=>66})}
-    #but don't mess up.
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)
+    ol2 = OptionList.new([:history, nil, :history, :nohistory]) 
+    o = ol2.select
+    
+    assert_respond_to(o, :history)
+    assert_respond_to(o, :history? )
+    assert_respond_to(o, :nohistory? )
+    assert_raises(NoMethodError) { o.send((nil.to_s+'?').to_sym) }
   end
 
   def test_that_it_rejects_bad_selections
+    ol1 = OptionList.new([:history, :history, :nohistory], {:pg_len => 42})
+  
     #Reject if options are not an array or a hash.
-    assert_raises(ArgumentError) { @ol1.select(45) }
+    assert_raises(ArgumentError) { ol1.select(45) }
     
     #Reject if the option is not a symbol.
-    assert_raises(ArgumentError) { @ol1.select([34]) }
+    assert_raises(ArgumentError) { ol1.select([34]) }
     
     #Reject if the category is not a symbol.
-    assert_raises(ArgumentError) { @ol1.select({'page_len'=>77}) }
+    assert_raises(ArgumentError) { ol1.select({'page_len'=>77}) }
     
     #Reject if the symbol is not one defined.
-    assert_raises(ArgumentError) { @ol1.select([:foobar]) }
-    assert_raises(ArgumentError) { @ol1.select({:history=>:foobar}) }
+    assert_raises(ArgumentError) { ol1.select([:foobar]) }
+    assert_raises(ArgumentError) { ol1.select({:history=>:foobar}) }
     
     #Reject on duplicate symbol from the same category.
-    assert_raises(ArgumentError) { @ol1.select([:history, :history]) }
-    assert_raises(ArgumentError) { @ol1.select([:history, :nohistory]) }   
-    assert_raises(ArgumentError) { @ol1.select([:history, {:history=>:nohistory}]) }
-    assert_raises(ArgumentError) { @ol1.select([{:history=>:history}, {:history=>:nohistory}]) }
+    assert_raises(ArgumentError) { ol1.select([:history, :history]) }
+    assert_raises(ArgumentError) { ol1.select([:history, :nohistory]) }   
+    assert_raises(ArgumentError) { ol1.select([:history, {:history=>:nohistory}]) }
+    assert_raises(ArgumentError) { ol1.select([{:history=>:history}, {:history=>:nohistory}]) }
     
     #Reject on an undefined category.
-    assert_raises(ArgumentError) { @ol1.select({:zoo => 999})}
+    assert_raises(ArgumentError) { ol1.select({:zoo => 999})}
   end
   
   def test_that_it_handles_good_options
     #ol1 test series.
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    
-    @ol1.select
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    
-    @ol1.select([])
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    
-    @ol1.select([:history])
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    
-    @ol1.select([:nohistory])
-    assert(@ol1.nohistory?)
-    refute(@ol1.history?)
-    assert_equal(@ol1.history, :nohistory)
-    assert_equal(@ol1.pg_len, 42)    
+    ol1 = OptionList.new([:history, :history, :nohistory], {:pg_len => 42})
+    
+    o = ol1.select
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 42)    
+    
+    o = ol1.select([])
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 42)    
+    
+    o = ol1.select([:history])
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 42)    
+    
+    o = ol1.select([:nohistory])
+    refute(o.history?)
+    assert(o.nohistory?)
+    assert_equal(o.history, :nohistory)
+    assert_equal(o.pg_len, 42)    
 
-    @ol1.select({:history=>:history})
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    
-    @ol1.select({:history=>:nohistory})
-    assert(@ol1.nohistory?)
-    refute(@ol1.history?)
-    assert_equal(@ol1.history, :nohistory)
-    assert_equal(@ol1.pg_len, 42)    
+    o = ol1.select({:history=>:history})
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 42)    
+    
+    o = ol1.select({:history=>:nohistory})
+    refute(o.history?)
+    assert(o.nohistory?)
+    assert_equal(o.history, :nohistory)
+    assert_equal(o.pg_len, 42)    
 
-    @ol1.select({:pg_len=>55})
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 55)
-    
-    @ol1.select({:history=>:history, :pg_len=>55})
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 55)
+    o = ol1.select({:pg_len=>55})
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 55)
+    
+    o = ol1.select({:history=>:history, :pg_len=>55})
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 55)
 
-    @ol1.select({:history=>:nohistory, :pg_len=>55})
-    assert(@ol1.nohistory?)
-    refute(@ol1.history?)
-    assert_equal(@ol1.history, :nohistory)
-    assert_equal(@ol1.pg_len, 55)
+    o = ol1.select({:history=>:nohistory, :pg_len=>55})
+    refute(o.history?)
+    assert(o.nohistory?)
+    assert_equal(o.history, :nohistory)
+    assert_equal(o.pg_len, 55)
 
-    @ol1.select([:history, {:pg_len=>55}])
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 55)
+    o = ol1.select([:history, {:pg_len=>55}])
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
+    assert_equal(o.pg_len, 55)
+
+    o = ol1.select([:nohistory, {:pg_len=>55}])
+    refute(o.history?)
+    assert(o.nohistory?)
+    assert_equal(o.history, :nohistory)
+    assert_equal(o.pg_len, 55)
 
-    @ol1.select([:nohistory, {:pg_len=>55}])
-    assert(@ol1.nohistory?)
-    refute(@ol1.history?)
-    assert_equal(@ol1.history, :nohistory)
-    assert_equal(@ol1.pg_len, 55)
     
-    @ol1.add_specs([:temp, nil, :hot, :nice, :cold])
-    @ol1.select   #Restore to default values.
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    refute(@ol1.hot?)
-    refute(@ol1.nice?)
-    refute(@ol1.cold?)
-    assert_equal(@ol1.temp, nil)    
-    @ol1.select(:hot)
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    assert(@ol1.hot?)
-    refute(@ol1.nice?)
-    refute(@ol1.cold?)
-    assert_equal(@ol1.temp, :hot)
+    #ol2 test series.
+    ol2 = OptionList.new([:history, nil, :history, :nohistory]) 
     
-    #Adding selections.
-    @ol1.select   #Restore to default values.
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    refute(@ol1.hot?)
-    refute(@ol1.nice?)
-    refute(@ol1.cold?)
-    assert_equal(@ol1.temp, nil)
-    @ol1.add_selections({:temp=>:hot})
-    assert(@ol1.history?)
-    refute(@ol1.nohistory?)
-    assert_equal(@ol1.history, :history)
-    assert_equal(@ol1.pg_len, 42)    
-    assert(@ol1.hot?)
-    refute(@ol1.nice?)
-    refute(@ol1.cold?)
-    assert_equal(@ol1.temp, :hot)
-    @ol1.add_selections([:cold, :nohistory])
-    assert(@ol1.nohistory?)
-    refute(@ol1.history?)
-    assert_equal(@ol1.history, :nohistory)
-    refute(@ol1.hot?)
-    refute(@ol1.nice?)
-    assert(@ol1.cold?)
-    assert_equal(@ol1.temp, :cold)
+    o = ol2.select([:history])
+    assert(o.history?)
+    refute(o.nohistory?)
+    assert_equal(o.history, :history)
 
+    o = ol2.select([:nohistory])
+    assert(o.nohistory?)
+    refute(o.history?)
+    assert_equal(o.history, :nohistory)
 
-    #ol2 test series.
-    refute(@ol2.history?)
-    refute(@ol2.nohistory?)
-    assert(@ol2.history.nil?)
-    
-    @ol2.select([:history])
-    assert(@ol2.history?)
-    refute(@ol2.nohistory?)
-    assert_equal(@ol2.history, :history)
-    
-    @ol2.select([:nohistory])
-    assert(@ol2.nohistory?)
-    refute(@ol2.history?)
-    assert_equal(@ol2.history, :nohistory)
-    
-    @ol2.select([])
-    refute(@ol2.history?)
-    refute(@ol2.nohistory?)
-    assert(@ol2.history.nil?)
+    o = ol2.select([])
+    refute(o.history?)
+    refute(o.nohistory?)
+    assert(o.history.nil?)
   end
   
   def test_that_the_select_block_works
-    assert_raises(ArgumentError) { @ol3.select() }    
-    assert_raises(ArgumentError) { @ol3.select({:history=>:nohistory, :fuel2=>:matter}) }    
+    ol3 = OptionList.new([:history, nil, :history, :nohistory],
+                          fuel1: :matter, fuel2: :antimatter) do |opt|
+      fail "The :history option must be set." if opt.history.nil?
+      fail "Improper fuel mix." unless opt.fuel1 == :matter && opt.fuel2 == :antimatter
+    end
+    
+    t = OptionTest.new(ol3)
+    
+    assert_raises(RuntimeError) { t.test() }
+    assert_raises(RuntimeError) { t.test(:nohistory, fuel2: :income_tax) }
+    #Really though, this should work! Both anti-matter and income tax
+    #destroy anything that that they come into contact with.
   end
 end

data/rakefile.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  #rdoc.main = "option_list.rb"
+  rdoc.rdoc_files = ['option_list.rb', 'option_list_test.rb', 'license.txt']
+  rdoc.options << '--visibility' << 'private'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = ['option_list_test.rb']
+  t.verbose = false
+end

metadata

@@ -1,24 +1,54 @@
 --- !ruby/object:Gem::Specification
 name: option_list
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.3
 platform: ruby
 authors:
 - Peter Camilleri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-22 00:00:00.000000000 Z
-dependencies: []
-description: A unified handler for flexible function option parameters. Please see
-  the homepage for docs.
+date: 2013-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'A unified handler for flexible function option parameters. '
 email: peter.c.camilleri@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- license.txt
 files:
 - option_list.rb
 - option_list_test.rb
+- rakefile.rb
+- license.txt
 homepage: http://teuthida-technologies.com/?p=1506
 licenses:
 - MIT
@@ -37,8 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-requirements:
-- No special requirements.
+requirements: []
 rubyforge_project: 
 rubygems_version: 2.1.4
 signing_key: