option_list 1.1.0 → 1.1.5

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OWQxY2I0ZTM2NjM1OTBiZDU2MWNmZDk4MjcyMDQ1ZGUzYWQzNDcyMA==
-  data.tar.gz: !binary |-
-    NDUyZWQxNmQ5MzMwZTkzZThhZTFjNzhjMTNmN2Y4ZmY1NDU2N2RmNQ==
+SHA256:
+  metadata.gz: 3fc80941391b0ec0003d6410fbacab0e5f54726d7ead3e0a30b85b2a1302f865
+  data.tar.gz: 8c13ce0b7069b663805c86f267996794d4a53261c2cf7cce9922284eed3dadaf
 SHA512:
-  metadata.gz: !binary |-
-    ZGNhMjA2NjExMzNjNDAzNzdjNmZmODJkODg1NmQwZDYzOTg2MTkxNTFiMDUx
-    MmU1NGFkMTMzZGE1MjI1MzU3MWE2M2U3MzEwMDEwYWYyNDI0YmIzYjk4MGQx
-    NDM3NjEwNTEwYzkxY2YxNjY5MWJmZjc0NDY3NmU3MmMyZmE4NGU=
-  data.tar.gz: !binary |-
-    ZDViOTVkN2U5NjMyZDNlYjliZDdlODk2NTM2MzFiZTJmMDExOThjNzhhOTMw
-    MTM1Yjk5ZTEwNjBiYTE2NmQzNzRkYWI4OWIyM2JhNGIwMGY2NzRiNGE2Zjli
-    MGJmMjMyYjliNDAzNmVmYmY2MGM1MzBmMzg1ODE1NGEwMDgzZTM=
+  metadata.gz: 19e4ce85288187faa5326495572e6b33df72b30792c174e8922aabbcb9e10cd329f8f88e612a704a052f349bd066ae0196f3522b500ddde7bb7bb375000e1c9f
+  data.tar.gz: bac17c293cd014626a1e03f069f89315be0615aea23c3c2943846d3698c0cafda9bf138e8da37e7b555a234e029a80983f9bc52e70e2901ca4012f7171c7e48b

data/.gitignore

@@ -0,0 +1,20 @@
+*.bat
+*.zip
+*.tmp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at peter.c.camilleri@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in option_list.gemspec
+gemspec

data/README.md

@@ -0,0 +1,95 @@
+# OptionList
+
+This gem addresses the fact that parameter validation is long and
+tedious and something needs to be done about that. This gem implements
+the idea that parameters be described separately and validated in a
+single line of client method code.
+
+Most of what this gem does has been subsumed by the Ruby Language itself,
+starting with version 1.9 and further with versions 2.0 and beyond.
+
+Finally, I'd like to add a personal note about this code. This was my first
+attempt at creating a gem. As such there is very much a newbie vibe to the
+code. I hope you can chalk this up to just a part of the learning process.
+None the less, if there are improvements that you (the reader) could suggest,
+I'd really appreciate hearing about them.
+
+Thanks in advance, Peter.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'option_list'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install option_list
+
+The options_list gem is at: ( https://rubygems.org/gems/options_list )
+
+## Usage
+
+The use of option_list occurs in three phases: Describing the Parameters,
+Passing in Parameters and Validating/Accessing the Parameters. This can be
+seen in the following example:
+```ruby
+module ReadLine
+  #Create the parameter specification (simplified for brevity)
+  @spec = OptionList.new([:buffer, :history, :no_history], {:depth => 50}) do |options|
+    fail "Depth must be an integer" unless options.depth.is_a(Integer)
+    fail "Depth must be positive" if options.depth < 1
+  end
+
+  class << self
+    attr_reader :spec
+  end
+
+  def read_line(prompt, *options)
+    @options = ReadLine.spec.select(options)
+    #Further code deleted for brevity.
+    #Somewhere along the line it records the last line.
+    buffer_line(current_line)
+    current_line
+  end
+
+  def buffer_line(line)
+    @line_buffer << line if @options.history?
+    @line_buffer.delete_at(0) if @line_buffer.length > @options.depth
+  end
+end
+```
+The option_list gem is described in the The option_list User's Guide
+which covers version 1.1.1 which has no material change from 1.1.3
+
+## Contributing
+
+#### Plan A
+
+1. Fork it ( https://github.com/PeterCamilleri/option_list/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+#### Plan B
+
+Go to the GitHub repository and raise an issue calling attention to some
+aspect that could use some TLC or a suggestion or an idea.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](./LICENSE.txt).
+
+## Code of Conduct
+
+Everyone interacting in the fully_freeze project’s codebases, issue trackers,
+chat rooms and mailing lists is expected to follow the
+[code of conduct](./CODE_OF_CONDUCT.md).
+

data/lib/option_list.rb

@@ -4,158 +4,59 @@ require 'set'
 #This file contains the code for the \OptionList class that implements smart
 #and easy options for functions. It has the virtue of defining function
 #options clearly in a single place instead of spread out in complex code.
-#A classic but unclear sequence in many functions is the use of boolean values
-#to control or switch on or off some option. For example consider the well 
-#known readline function:
-# cmd = readline(">", false)
-#See the boolean at the end? It says "false". What is "false"? Who knows? You 
-#need to dig deeper or guess or just cut and paste without understanding. What
-#if, instead, the code looked like:
-# cmd = readline(">", :nohistory)
-#The boolean has been replaced by something a lot clearer. The problem with
-#such clarity is that it involves a lot more effort than the lazy boolean. The
-#\OptionList class aims to solve that issue by making useful, flexible options
-#just about as easy to use as the lazy way.
-#==== Warning: This code is most opinionated! ;-)
-#The philosophy and opinion expressed through this code is that errors should
-#be detected as close to the point of error as possible and that an error is
-#preferable to running with potentially incorrect results. As a result, it
-#will be noted that the programmer does not hesitate to use the fAE, a wrapper
-#of the "fail" keyword, liberally throughout the code to achieve this end.
-#Complimentary to this is the idea that the library (gem) writer should do as
-#much of the "heavy lifting" as possible, with clear, detailed documentation so
-#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.
+#==== User's Guide
+#Most of the documentation for this gem has been moved to
+#{Option List User's Guide}[http://teuthida-technologies.com/guides/OL_UG_Version_1_1_1.pdf]
+#====Version 1.1.1
+#Embraced reek and git and created the user's guide to pair down rdoc mark up
+#to be less obtrusive to the code.
 #=== Version 1.1.0
-#Added a default value of false to signify that no default exists for a 
+#Added a default value of false to signify that no default exists for a
 #mandatory parameter.
 #Modified processing of array specs to avoid side effects in the parameters.
 class OptionList
 
   #The option list code version.
   def self.version
-    '1.1.0'
+    OptionList::VERSION
   end
-  
+
   #The option list code version. This is a redirect to the class method.
   def version
-    self.class.version
+    OptionList::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
-  #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. This value may be one of:
-  #* A symbol - The default symbolic value for this option.
-  #* nil - The default value is nil and this setting is optional.
-  #* false - There is no default value and this setting is mandatory.
-  #The symbols used in each category must be unique across
-  #all of the categories in the option list.
-  #==== Hash Specification
-  #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})
+  #Create an option list from an array of option specifications.
   #==== Parameters:
-  #* option_specs - The comma separated option specifications, made into an 
+  #* 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 value object that is calling it for validation.
-  #==== Dynamic Methods:
-  #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.
-  #* page_len - would return the value of the :page_len category.
   #==== Exceptions:
   #* ArgumentError for a number of invalid argument conditions.
   def initialize(*option_specs, &select_block)
-    fAE "Missing option specifications." if option_specs.empty?
+    error "Missing option specifications." if option_specs.empty?
     @mandatory  = Array.new
     @categories = Hash.new
     @default    = Hash.new
-    
+
     option_specs.each do |spec|
       if spec.is_a?(Hash)
         hash_spec(spec)
       elsif spec.is_a?(Array)
         array_spec(spec)
       else
-        fAE "Found #{spec.class} instead of Hash or Array."
+        error "Found #{spec.class} instead of Hash or Array."
       end
     end
-    
+
     @select_block = select_block
   end
 
   #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.
-  #* A hash - For any type of category, a hash may be used in the the form
-  #  {category => value}. Note that for categories with a specified symbol list
-  #  the value must be a symbol in the list.
-  #* 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:
-  # 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)
-  #=== Passing in option data:
-  #The caller of this method may pass these options in a number of ways:
-  #==== Array (via a splat)
-  #Given the example shown in the new method, consider:
-  # def test(count, *opt)
-  #   @opt_list.select(opt)
-  #   #etc, etc, etc...
-  # end
-  #With the caller now looking like:
-  # test(43, :history)
-  #==== Array (explicit)
-  #An alternative strategy, where the use of splat is not desired, is to simply
-  #have an array argument, as below:
-  # def test(*arg1, opt)
-  #   @opt_list.select(opt)
-  #   #etc, etc, etc...
-  # end
-  #With the caller now looking like:
-  # test(34, 53, 76, 'hike!', [:history])
-  #==== Hash
-  #Options may also be passed via a hash.
-  # test(34, 53, 76, 'hike!', {:history=>:history, :page_len=>55})
-  # test(34, 53, 76, 'hike!', history: :history, page_len: 55)
-  #==== Symbol
-  #If only a single option is required, it can be passed simply as:
-  # test(34, 53, 76, 'hike!', :history)
+  #an access object for use in the code.
   #==== Parameters:
   #* 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,
@@ -165,12 +66,25 @@ class OptionList
   #==== Exceptions:
   #* ArgumentError for a number of invalid argument conditions.
   #==== Notes:
-  #After processing the selections, the selection validation block is called 
+  #After processing the selections, the selection validation block is called
   #if one was defined for the constructor.
   def select(selections=[])
-    selected = @default.clone
     selections = [selections] unless selections.is_a?(Array)
-    dup = Set.new
+    selected = process_selections(selections)
+
+    @mandatory.each do |cat|
+      error "Missing mandatory setting #{cat}" unless selected[cat]
+    end
+
+    @select_block.call(selected) if @select_block
+    selected
+  end
+
+  private  #Private stuff follows.
+
+  #Process a list of option selections.
+  def process_selections(selections)
+    selected, dup = @default.clone, Set.new
 
     selections.each do |opt|
       if opt.is_a?(Symbol)
@@ -178,104 +92,136 @@ class OptionList
       elsif opt.is_a?(Hash)
         hash_selections(opt, selected, dup)
       else
-        fAE "Found #{opt.class} instead of Hash or Symbol."
+        error "Found #{opt.class} instead of Hash or Symbol."
       end
     end
-    
-    @mandatory.each do |cat|
-      fAE "Missing mandatory setting #{cat}" unless selected[cat]
-    end
-    
-    @select_block.call(selected) unless @select_block.nil?
+
     selected
   end
-  
-  private  #Private stuff follows.
 
   #Return a internal category marker constant for value entries.
   def value_entry
     'A value entry.'
   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[0]
-    spec = spec[1...spec.length]
-    
-    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|
+    category, default, spec_len = spec[0], spec[1], spec.length
+    error "Invalid number of entries for #{category}." unless spec_len > 2
+    add_option_reader(category)
+    array_spec_default(category, default)
+    array_spec_tail_rest(category, spec[2...spec_len])
+  end
+
+  #Process the first element of the array spec tail.
+  def array_spec_default(category, opt)
+    opt && array_spec_single(category, opt)
+    @default[category] = opt
+    @mandatory << category if opt == false
+  end
+
+  #Process the rest of the array spec tail.
+  def array_spec_tail_rest(category, spec_tail_rest)
+    spec_tail_rest.each do |opt|
       if opt
-        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] = opt
-        @mandatory << cat if opt == false
+        array_spec_single(category, opt)
       else
-        fAE "The values nil/false are only allowed as the default option."
+        error "The values nil/false are only allowed as the default option."
       end
     end
   end
-  
+
+  #Process a single array spec option
+  def array_spec_single(category, opt)
+    duplicate_entry_check(@categories, opt, 'option')
+    @categories[opt] = category
+    add_option_tester(category, opt)
+  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
+    error "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    
+    spec.each do |category, value|
+      add_option_reader(category)
+      set_default_option_value(category, value)
+      @mandatory << category if value == false
     end
   end
-  
+
+  #Set the default value of a value entry.
+  def set_default_option_value(category, value)
+    @categories[category] = value_entry
+    @default[category] = value
+  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, 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
+  def symbolic_selection(symbol_option, selected, dup)
+    missing_entry_check(@categories, symbol_option, 'option')
+    category = @categories[symbol_option]
+    hash_option_dup_check(category, dup)
+    selected[category] = symbol_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, 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?
-        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
+  def hash_selections(hash_options, selected, dup)
+    hash_options.each do |category, value|
+      missing_entry_check(@default, category, 'category')
+
+      hash_option_value_check(category, value)
+      hash_option_dup_check(category, dup)
+      selected[category] = value
+    end
+  end
+
+  #Validate a hash option value.
+  def hash_option_value_check(value_category, value)
+    if (@categories[value_category] != value_entry) && value
+      error "Found #{value.class}, expected Symbol." unless value.is_a?(Symbol)
+      error "Invalid option: #{value}." unless @categories[value] == value_category
     end
   end
 
+  #Add to set with no duplicates allowed.
+  def hash_option_dup_check(category, dup)
+    error "Category #{category} has multiple values." unless dup.add?(category)
+  end
+
+  #Add query method for the selected category.
+  def add_option_reader(name)
+    duplicate_entry_check(@default, name, 'category')
+    @default.define_singleton_method(name) { self[name] }
+  end
+
+  #Add a query method (eg: has_stuff? ) for the selected option.
+  def add_option_tester(target, value)
+    qry = (value.to_s + '?').to_sym
+    @default.define_singleton_method(qry) { self[target] == value}
+  end
+
+  #Flag any duplicate entry errors.
+  def duplicate_entry_check(target, entry, detail)
+    error "Found #{entry.class}, expected Symbol." unless entry.is_a?(Symbol)
+    error "Duplicate #{detail}: #{entry}" if target.has_key?(entry)
+  end
+
+  #Flag any missing entry errors.
+  def missing_entry_check(target, entry, detail)
+    error "Unknown #{detail}: #{entry}" unless target.has_key?(entry)
+  end
+
   #Fail with an argument error.
-  def fAE(msg)
-    fail(ArgumentError, msg, caller)
+  def error(messsage)
+    fail(ArgumentError, messsage, caller)
   end
 end

data/lib/option_list/version.rb

@@ -0,0 +1,3 @@
+class OptionList
+  VERSION = '1.1.5'
+end

data/license.txt

@@ -1,6 +1,6 @@
 === The MIT License (MIT).
 
-Copyright (c) 2013 Peter Camilleri
+Copyright (c) 2013, 2014 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

data/option_list.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+#Specify the building of the option_list gem.
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'option_list/version'
+
+Gem::Specification.new do |s|
+  s.name = "option_list"
+  s.summary = "Flexible, Easy Function Parameters with Validation."
+  s.description = '[Deprecated] Flexible, Easy Function Parameters with Validation. '
+  s.version = OptionList::VERSION
+  s.author = ["Peter Camilleri"]
+  s.email = "peter.c.camilleri@gmail.com"
+  s.homepage = "http://teuthida-technologies.com/"
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9.3'
+
+  s.add_development_dependency "bundler", ">= 2.1.0"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'reek', "~> 1.3.8"
+  s.add_development_dependency 'minitest', "~> 4.7.5"
+  s.add_development_dependency 'rdoc', "~> 4.0.1"
+  s.add_development_dependency 'awesome_print'
+
+  s.files       = `git ls-files`.split($/)
+  s.test_files  = s.files.grep(%r{^(test|spec|features)/})
+  s.extra_rdoc_files = ['license.txt']
+
+  s.license = 'MIT'
+  s.require_path = 'lib'
+end
+

data/rakefile.rb

@@ -1,11 +1,16 @@
 #!/usr/bin/env rake
+# coding: utf-8
+
 require 'rake/testtask'
 require 'rdoc/task'
+require "bundler/gem_tasks"
 
 RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
-  #rdoc.main = "option_list.rb"
-  rdoc.rdoc_files = ['lib/option_list.rb', 'tests/option_list_test.rb', 'license.txt']
+
+  #List out all the files to be documented.
+  rdoc.rdoc_files.include("lib/**/*.rb", "license.txt", "README.md")
+
   rdoc.options << '--visibility' << 'private'
 end
 
@@ -13,3 +18,14 @@ Rake::TestTask.new do |t|
   t.test_files = ['tests/option_list_test.rb']
   t.verbose = false
 end
+
+desc "Run a scan for smelly code!"
+task :reek do |t|
+  `reek lib\\*.rb > reek.txt`
+end
+
+desc "What version of option_list is this?"
+task :vers do |t|
+  puts
+  puts "option_list version = #{OptionList::VERSION}"
+end

data/reek.txt

@@ -0,0 +1 @@
+lib/option_list.rb -- 0 warnings

data/sire.rb

@@ -0,0 +1,51 @@
+# Really simple program # 3
+# A Simple Interactive Ruby Environment
+# SIRE Version 0.2.6
+
+require 'readline'
+require 'awesome_print'
+require_relative 'lib/option_list'
+include Readline
+
+class Object 
+  def classes
+    begin
+      klass = self
+      
+      begin
+        klass = klass.class unless klass.instance_of?(Class)
+        print klass
+        klass = klass.superclass
+        print " < " if klass
+      end while klass
+      
+      puts
+    end
+  end
+end
+
+def show_args(*args)
+  args
+end
+
+puts "Welcome to SIRE Version 0.2.6"
+puts "Simple Interactive Ruby Environment"
+done = false
+
+until done
+  begin
+    line = readline('SIRE>', true)
+    result = eval line
+    ap result unless result.nil?
+  rescue Interrupt
+    done = true
+  rescue Exception => e
+    puts "#{e.class} detected: #{e}"
+    puts e.backtrace
+    puts
+  end
+end
+
+puts
+puts "Bye bye for now!"
+

data/tests/option_list_test.rb

@@ -8,73 +8,73 @@ class OptionTest
   def initialize(opt)
     @opt = opt
   end
-  
+
   def test(*args)
-    o = @opt.select(args)
+    @opt.select(args)
   end
 end
 
-class OptionListTester < MiniTest::Unit::TestCase
+class OptionListTester < Minitest::Test
   $do_this_only_one_time = ""
-  
+
   def initialize(*all)
     if $do_this_only_one_time != __FILE__
       puts
-      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      puts "Running test file: #{File.split(__FILE__)[1]}"
       $do_this_only_one_time = __FILE__
     end
-    
+
     super(*all)
   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([])}
     assert_raises(ArgumentError) { @x = OptionList.new({})}
-    
+
     #Reject if not an array or a hash.
     assert_raises(ArgumentError) { @x = OptionList.new(4) }
-    assert_raises(ArgumentError) { @x = OptionList.new('foobar') }    
+    assert_raises(ArgumentError) { @x = OptionList.new('foobar') }
 
     #Reject for too few arguments.
     assert_raises(ArgumentError) { @x = OptionList.new([]) }
     assert_raises(ArgumentError) { @x = OptionList.new([:foo]) }
     assert_raises(ArgumentError) { @x = OptionList.new([:foo, :bar]) }
-    
+
     #Reject for the wrong types of arguments.
     assert_raises(ArgumentError) { @x = OptionList.new(['foo', :foo,  :bar] )}
     assert_raises(ArgumentError) { @x = OptionList.new([:foo,  'foo', :bar] )}
     assert_raises(ArgumentError) { @x = OptionList.new([:foo,  :foo,  'bar'])}
     assert_raises(ArgumentError) { @x = OptionList.new({'foo' => 42})}
-    
+
     #Reject for duplicate categories.
     assert_raises(ArgumentError) { @x = OptionList.new([:foo, :lala, :bar], [:foo, :kung, :east]) }
     assert_raises(ArgumentError) { @x = OptionList.new([:foo, :lala, :bar], {:foo => :kung}) }
     assert_raises(ArgumentError) { @x = OptionList.new({:foo => :lala}, {:foo => :kung}) }
     #The following is not detectable since :foo => :kung overwrites :foo => :lala
     #assert_raises(ArgumentError) { @x = OptionList.new({:foo => :lala, :foo => :kung}) }
-    
+
     #Reject for duplicate options.
     assert_raises(ArgumentError) { @x = OptionList.new([:foo, :bar, :bar]) }
-    assert_raises(ArgumentError) { @x = OptionList.new([:foo, :foo, :bar], [:bla, :food, :bar]) }    
+    assert_raises(ArgumentError) { @x = OptionList.new([:foo, :foo, :bar], [:bla, :food, :bar]) }
 
-    #Reject for nil in the wrong position.    
+    #Reject for nil in the wrong position.
     assert_raises(ArgumentError) { @x = OptionList.new([:foo, :bar, nil]) }
   end
-  
+
   def test_that_the_methods_were_added
     ol1 = OptionList.new([:history, :history, :nohistory], {:pg_len => 42})
     o = ol1.select
-  
+
     assert_respond_to(o, :history)
     assert_respond_to(o, :history? )
     assert_respond_to(o, :nohistory? )
     assert_respond_to(o, :pg_len)
 
-    ol2 = OptionList.new([:history, nil, :history, :nohistory]) 
+    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? )
@@ -83,76 +83,76 @@ class OptionListTester < MiniTest::Unit::TestCase
 
   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) }
-    
+
     #Reject if the option is not a symbol.
     assert_raises(ArgumentError) { ol1.select([34]) }
-    
+
     #Reject if the category is not a symbol.
     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}) }
-    
+
     #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, :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})}
   end
-  
+
   def test_that_it_handles_good_options
     #ol1 test series.
     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)    
-    
+    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)    
-    
+    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)    
-    
+    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)    
+    assert_equal(o.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)    
-    
+    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)    
+    assert_equal(o.pg_len, 42)
 
     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?)
@@ -177,10 +177,10 @@ class OptionListTester < MiniTest::Unit::TestCase
     assert_equal(o.history, :nohistory)
     assert_equal(o.pg_len, 55)
 
-    
+
     #ol2 test series.
-    ol2 = OptionList.new([:history, nil, :history, :nohistory]) 
-    
+    ol2 = OptionList.new([:history, nil, :history, :nohistory])
+
     o = ol2.select([:history])
     assert(o.history?)
     refute(o.nohistory?)
@@ -196,9 +196,9 @@ class OptionListTester < MiniTest::Unit::TestCase
     refute(o.nohistory?)
     assert(o.history.nil?)
   end
-  
+
   def test_that_mandatory_parms_work
-    ol2 = OptionList.new([:history, false, :history, :nohistory]) 
+    ol2 = OptionList.new([:history, false, :history, :nohistory])
 
     o = ol2.select([:history])
     assert(o.history?)
@@ -211,24 +211,30 @@ class OptionListTester < MiniTest::Unit::TestCase
     assert_equal(o.history, :nohistory)
 
     assert_raises(ArgumentError) { ol2.select() }
+
+    ol3 = OptionList.new(page_len: false)
+    o = ol3.select(page_len: 42)
+    assert_equal(o.page_len, 42)
+
+    assert_raises(ArgumentError) { ol3.select() }
   end
-  
+
   def test_that_it_does_not_munge_parms
     parm1 = [:history, false, :history, :nohistory]
     parm2 = parm1.clone
-    ol2 = OptionList.new(parm1)
+    OptionList.new(parm1)
     assert_equal(parm1, parm2)
   end
-  
+
   def test_that_the_select_block_works
     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

metadata

@@ -1,54 +1,121 @@
 --- !ruby/object:Gem::Specification
 name: option_list
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.5
 platform: ruby
 authors:
 - Peter Camilleri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-20 00:00:00.000000000 Z
+date: 2021-05-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 - !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: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.8
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.5
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  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. '
+description: "[Deprecated] Flexible, Easy Function Parameters with Validation. "
 email: peter.c.camilleri@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - license.txt
 files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- docs/OL_UG.odt
+- docs/OL_UG.pdf
+- docs/OL_UG_Version_1_1_1.pdf
 - lib/option_list.rb
-- tests/option_list_test.rb
-- rakefile.rb
+- lib/option_list/version.rb
 - license.txt
+- option_list.gemspec
+- rakefile.rb
+- reek.txt
+- sire.rb
+- tests/option_list_test.rb
 homepage: http://teuthida-technologies.com/
 licenses:
 - MIT
@@ -59,19 +126,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.1.4
+rubygems_version: 3.2.17
 signing_key: 
 specification_version: 4
-summary: A unified handler for flexible function option parameters.
-test_files:
-- tests/option_list_test.rb
+summary: Flexible, Easy Function Parameters with Validation.
+test_files: []