getopt 1.3.6 → 1.3.7

data/CHANGES

@@ -1,53 +1,61 @@
-== 8-Aug-2007 - 1.3.6
-* The Getopt::StdError class is now Getopt::Std::Error.
-* The Getopt::LongError class is now Getopt::Long::Error.
-* Added some inline rdoc documentation to the source code.
-* Added a Rakefile with tasks for installation and testing.
-* Removed the install.rb file - use the 'rake install' task instead.
-
-== 5-Jul-2006 - 1.3.5
-* Fixed a bug where multiple long switches with the same first character
-  could cause invalid results.  Thanks go to Michael Campbell for the spot.
-* Added documentation to the README file that explains what happens if you
-  specify multiple long switches with the same first character and no short
-  switch alias.
-
-== 7-Mar-2006 - 1.3.4
-* Fixed Getopt::Long so that it can handle embedded hyphens in the long
-  form, e.g. --foo-bar.  Thanks go to Mark Meves for the spot.
-* Corresponding test suite additions.
-* Added example to the 'example_long.rb' file that uses long form with
-  embedded hyphens.
-
-== 22-Feb-2006 - 1.3.3
-* Bug fix for the two argument form of Getopt::Long.getopts.
-* Corresponding test suite additions.
-
-== 13-Feb-2006 - 1.3.2
-* Improved error message if an option is passed without a preceding switch.
-* Minor documentation fixes and clarifications.
-
-== 18-Nov-2005 - 1.3.1
-* Added support for compressed switches with getopt/long.
-* More tests.
-* Fixed a bug in the gemspec.
-
-== 4-Nov-2005 - 1.3.0
-* Added the Getopt::Long class (long.rb).  This is a complete revamp of the
-  old getoptlong package, with ideas tossed in from Perl's Getopt::Long
-  package.  See the README and example script for more detail.
-* Added an example, and renamed the "test_std.rb" example to "example_std.rb".
-* Added lots of documentation to the README file.
-* Updated the MANIFEST, test suite, etc.
-
-== 24-Oct-2005 - 1.2.0
-* Altered the way multiple occurrences of the same switch are handled, for
-  those switches that accept arguments.
-
-== 7-Oct-2005 - 1.1.0
-* Changed parser, added a bit stricter enforcement
-* Now handles squished arguments properly, e.g. "-ID" as well as "-I -D"
-* Some test suite changes
-
-== 5-Oct-2005 - 1.0.0
-* Initial commit
+== 27-Jul-2008 - 1.3.7
+* Fixed a potential infinite hash recursion bug in ARGV processing. This
+  was smoked out as the result of the alternate hash implementations in
+  JRuby and Ruby 1.9.
+* Added the example programs to the gemspec.
+* Removed the ts_all.rb file, and renamed the other test files. The Rakefile
+  test task was updated accordingly.
+
+== 8-Aug-2007 - 1.3.6
+* The Getopt::StdError class is now Getopt::Std::Error.
+* The Getopt::LongError class is now Getopt::Long::Error.
+* Added some inline rdoc documentation to the source code.
+* Added a Rakefile with tasks for installation and testing.
+* Removed the install.rb file - use the 'rake install' task instead.
+
+== 5-Jul-2006 - 1.3.5
+* Fixed a bug where multiple long switches with the same first character
+  could cause invalid results.  Thanks go to Michael Campbell for the spot.
+* Added documentation to the README file that explains what happens if you
+  specify multiple long switches with the same first character and no short
+  switch alias.
+
+== 7-Mar-2006 - 1.3.4
+* Fixed Getopt::Long so that it can handle embedded hyphens in the long
+  form, e.g. --foo-bar.  Thanks go to Mark Meves for the spot.
+* Corresponding test suite additions.
+* Added example to the 'example_long.rb' file that uses long form with
+  embedded hyphens.
+
+== 22-Feb-2006 - 1.3.3
+* Bug fix for the two argument form of Getopt::Long.getopts.
+* Corresponding test suite additions.
+
+== 13-Feb-2006 - 1.3.2
+* Improved error message if an option is passed without a preceding switch.
+* Minor documentation fixes and clarifications.
+
+== 18-Nov-2005 - 1.3.1
+* Added support for compressed switches with getopt/long.
+* More tests.
+* Fixed a bug in the gemspec.
+
+== 4-Nov-2005 - 1.3.0
+* Added the Getopt::Long class (long.rb).  This is a complete revamp of the
+  old getoptlong package, with ideas tossed in from Perl's Getopt::Long
+  package.  See the README and example script for more detail.
+* Added an example, and renamed the "test_std.rb" example to "example_std.rb".
+* Added lots of documentation to the README file.
+* Updated the MANIFEST, test suite, etc.
+
+== 24-Oct-2005 - 1.2.0
+* Altered the way multiple occurrences of the same switch are handled, for
+  those switches that accept arguments.
+
+== 7-Oct-2005 - 1.1.0
+* Changed parser, added a bit stricter enforcement
+* Now handles squished arguments properly, e.g. "-ID" as well as "-I -D"
+* Some test suite changes
+
+== 5-Oct-2005 - 1.0.0
+* Initial commit

data/MANIFEST

@@ -1,12 +1,11 @@
-* CHANGES
-* MANIFEST
-* README
-* Rakefile
-* getopt.gemspec
-* examples/example_std.rb
-* examples/example_long.rb
-* lib/getopt/std.rb
-* lib/getopt/long.rb
-* test/tc_getopt_std.rb
-* test/tc_getopt_long.rb
-* test/ts_all.rb
+* CHANGES
+* MANIFEST
+* README
+* Rakefile
+* getopt.gemspec
+* examples/example_std.rb
+* examples/example_long.rb
+* lib/getopt/std.rb
+* lib/getopt/long.rb
+* test/test_getopt_std.rb
+* test/test_getopt_long.rb

data/Rakefile

@@ -1,23 +1,22 @@
-require 'rake'
-require 'rake/testtask'
-
-desc "Install the getopt package (non-gem)"
-task :install do
-   dest = File.join(Config::CONFIG['sitelibdir'], 'getopt')
-   Dir.mkdir(dest) unless File.exists? dest
-   cp 'lib/getopt/std.rb', dest, :verbose => true
-   cp 'lib/getopt/long.rb', dest, :verbose => true
-end
-
-desc "Install the getopt package as a gem"
-task :install_gem do
-   ruby 'getopt.gemspec'
-   file = Dir["*.gem"].first
-   sh "gem install #{file}"
-end
-
-Rake::TestTask.new do |t|
-   t.libs << 'lib'
-   t.warning = true
-   t.test_files = FileList['test/ts_all.rb']
-end
+require 'rake'
+require 'rake/testtask'
+
+desc "Install the getopt package (non-gem)"
+task :install do
+   dest = File.join(Config::CONFIG['sitelibdir'], 'getopt')
+   Dir.mkdir(dest) unless File.exists? dest
+   cp 'lib/getopt/std.rb', dest, :verbose => true
+   cp 'lib/getopt/long.rb', dest, :verbose => true
+end
+
+desc "Install the getopt package as a gem"
+task :install_gem do
+   ruby 'getopt.gemspec'
+   file = Dir["*.gem"].first
+   sh "gem install #{file}"
+end
+
+Rake::TestTask.new do |t|
+   t.warning = true
+   t.verbose = true
+end

data/examples/example_long.rb

@@ -0,0 +1,65 @@
+##########################################################################
+# example_long.rb
+#
+# A series of examples to demonstrate the different ways that you can
+# handle command line options.
+##########################################################################
+require "getopt/long"
+
+# The truly lazy way.  This creates two valid command line switches,
+# automatically creates single letter switches (-f, -b), and sets each
+# switch type to BOOLEAN.
+opts = Getopt::Long.getopts("--foo --bar")
+
+# Here's a comprehensive example that uses all types and options.
+opts = Getopt::Long.getopts(
+   ["--foo"],                    # --foo, -f, BOOLEAN
+   ["--bar",  "-z"],             # --bar, -z, BOOLEAN
+   ["--baz",  "-b", OPTIONAL],   # --baz, -b, OPTIONAL
+   ["--name", "-n", REQUIRED],   # --name, -n, REQUIRED
+   ["--more", "-m", INCREMENT],  # --more, -m, INCREMENT
+   ["--verbose", "-v", BOOLEAN], # --verbose, -v, BOOLEAN
+   ["--my-name", "-x", REQUIRED] # --my-name, -x, REQUIRED
+)
+
+# Using the above example:
+
+# User passes "-f"
+# opts -> { "f" => true, "foo" => true }
+
+# User passes "-z"
+# opts -> { "z" => true, "bar" => true }
+
+# User passes "--verbose"
+# opts -> { "v" => true, "verbose" => true }
+
+# User passes "-m"
+# opts -> { "m" => 1, "more" => 1 }
+
+# User passes "-m -m"
+# opts -> { "m" => 2, "more" => 2 }
+
+# User passes "--name Dan" or "--name=Dan" or "-n Dan" or "-nDan"
+# opts -> { "n" => "Dan", "name" => "Dan" }
+
+# User passes "--my-name Dan" or "--my-name=Dan" or "-x Dan" or "-xDan"
+# opts -> { "x" => "Dan", "my-name" => "Dan" }
+
+# User passes "--name Dan --name Matz"
+# opts -> { "n" => ["Dan","Matz"], "name" => ["Dan","Matz"] }
+
+# User passes "--baz" with no argument
+# opts -> { "b" => nil, "baz" => nil }
+
+# User passes "--baz hello"
+# opts =-> { "b" => "hello", "baz" => "hello" }
+
+# User passes "-n" with no argument
+# Getopt::LongError is raised, since an argument is REQUIRED.
+
+# User passes "-f hello"
+# Getopt::LongError is raised, since a BOOLEAN switch does not take an argument
+
+# User passes "--warning"
+# Getopt::LongError is raised, since "--warning" was not specified as a valid
+# switch in the call to Getopt::Long.getopts

data/examples/example_std.rb

@@ -0,0 +1,38 @@
+####################################################
+# example_std.rb
+#
+# Some samples of how to use the Getopt::Std class.
+#####################################################
+base = File.basename(Dir.pwd)
+
+if base == "examples" || base =~ /getopt/
+   Dir.chdir("..") if base == "examples"
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("examples") rescue nil
+end
+
+require "getopt/std"
+include Getopt
+
+# Try passing different switches to this script to see what happens
+opts = Std.getopts("o:ID")
+p opts
+
+# User passes "-o hello -I"
+# Result: {"o" => "hello", "I" => true}
+
+# User passes "-I -D"
+# Result: {"I" => true, "D" => true}
+
+# User passes nothing
+# Result: {}
+
+# User passes "-o hello -o world -I"
+# Result: {"I" => true, "o" => ["hello", "world"]}
+
+# User passes "-o -I"
+# Result: Getopt::StdError, because -o requires an argument (and does not
+#    accept -I as an argument, since it is a valid switch)
+
+# User passes "-I -X"
+# Result: Getopt::StdError, because -X was not listed as a valid switch.

data/getopt.gemspec

@@ -0,0 +1,24 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+   gem.name        = "getopt"
+   gem.version     = "1.3.7"
+   gem.author      = "Daniel J. Berger"
+   gem.email       = "djberg96@gmail.com"
+   gem.homepage    = "http://www.rubyforge.org/projects/shards"
+   gem.platform    = Gem::Platform::RUBY
+   gem.summary     = "Getopt::Std and Getopt::Long option parsers for Ruby"
+   gem.description = "Getopt::Std and Getopt::Long option parsers for Ruby"
+   gem.test_files  = Dir["test/*.rb"]
+   gem.has_rdoc    = true
+   gem.files = Dir['lib/**/*.rb'] + Dir['[A-Z]*']  + Dir['test/*'] + Dir['examples/*.rb']
+   gem.files.reject! { |fn| fn.include? "CVS" }
+   gem.require_path = "lib"
+   gem.extra_rdoc_files = ["README", "CHANGES", "MANIFEST"]
+   gem.rubyforge_project = 'shards'
+end
+
+if $0 == __FILE__
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

data/lib/getopt/long.rb

@@ -1,232 +1,234 @@
-module Getopt
-
-   REQUIRED  = 0
-   BOOLEAN   = 1
-   OPTIONAL  = 2
-   INCREMENT = 3
-   NEGATABLE = 4
-   NUMERIC   = 5
-
-   class Long
-      class Error < StandardError; end
-
-      VERSION = '1.3.6'
-
-      # Takes an array of switches. Each array consists of up to three
-      # elements that indicate the name and type of switch. Returns a hash
-      # containing each switch name, minus the '-', as a key. The value
-      # for each key depends on the type of switch and/or the value provided
-      # by the user.
-      #
-      # The long switch _must_ be provided. The short switch defaults to the
-      # first letter of the short switch. The default type is BOOLEAN.
-      #
-      # Example:
-      #
-      # opts = Getopt::Long.getopts(
-      #    ["--debug"],
-      #    ["--verbose", "-v"],
-      #    ["--level", "-l", NUMERIC]
-      # )
-      #
-      # See the README file for more information.
-      #
-      def self.getopts(*switches)
-         if switches.empty?
-            raise ArgumentError, "no switches provided"
-         end
-
-         hash  = {} # Hash returned to user
-         valid = [] # Tracks valid switches
-         types = {} # Tracks argument types
-         syns  = {} # Tracks long and short arguments, or multiple shorts
-
-         # If a string is passed, split it and convert it to an array of arrays
-         if switches.first.kind_of?(String)
-            switches = switches.join.split
-            switches.map!{ |switch| switch = [switch] }
-         end
-
-         # Set our list of valid switches, and proper types for each switch
-         switches.each{ |switch|
-            valid.push(switch[0])       # Set valid long switches
-
-            # Set type for long switch, default to BOOLEAN.
-            if switch[1].kind_of?(Fixnum)
-               switch[2] = switch[1]
-               types[switch[0]] = switch[2]
-               switch[1] = switch[0][1..2]
-            else
-               switch[2] ||= BOOLEAN
-               types[switch[0]] = switch[2]
-               switch[1] ||= switch[0][1..2]
-            end
-
-            # Create synonym hash.  Default to first char of long switch for 
-            # short switch, e.g. "--verbose" creates a "-v" synonym.  The same
-            # synonym can only be used once - first one wins.
-            syns[switch[0]] = switch[1] unless syns[switch[1]]
-            syns[switch[1]] = switch[0] unless syns[switch[1]]
-
-            switch[1].each{ |char|      
-               types[char] = switch[2]  # Set type for short switch
-               valid.push(char)         # Set valid short switches
-            }
-         }
-
-         re_long     = /^(--\w+[-\w+]*)?$/
-         re_short    = /^(-\w)$/
-         re_long_eq  = /^(--\w+[-\w+]*)?=(.*?)$|(-\w?)=(.*?)$/
-         re_short_sq = /^(-\w)(\S+?)$/
-
-         ARGV.each_with_index{ |opt, index|
-
-            # Allow either -x -v or -xv style for single char args
-            if re_short_sq.match(opt)
-               chars = opt.split("")[1..-1].map{ |s| s = "-#{s}" }
-
-               chars.each_with_index{ |char, i|
-                  unless valid.include?(char)  
-                     raise Error, "invalid switch '#{char}'"
-                  end
-
-                  # Grab the next arg if the switch takes a required arg
-                  if types[char] == REQUIRED
-                     # Deal with a argument squished up against switch
-                     if chars[i+1]
-                        arg = chars[i+1..-1].join.tr("-","")
-                        ARGV.push(char, arg)
-                        break
-                     else
-                        arg = ARGV.delete_at(index+1)
-                        if arg.nil? || valid.include?(arg) # Minor cheat here
-                           err = "no value provided for required argument '#{char}'"
-                           raise Error, err
-                        end
-                        ARGV.push(char, arg)
-                     end
-                  elsif types[char] == OPTIONAL
-                     if chars[i+1] && !valid.include?(chars[i+1])
-                        arg = chars[i+1..-1].join.tr("-","")
-                        ARGV.push(char, arg)
-                        break
-                     elsif
-                        if ARGV[index+1] && !valid.include?(ARGV[index+1])
-                           arg = ARGV.delete_at(index+1)
-                           ARGV.push(char, arg)
-                        end
-                     else
-                        ARGV.push(char)
-                     end
-                  else
-                     ARGV.push(char)
-                  end
-               }
-               next
-            end
-
-            if match = re_long.match(opt) || match = re_short.match(opt)
-               switch = match.captures.first
-            end
-
-            if match = re_long_eq.match(opt)
-               switch, value = match.captures.compact
-               ARGV.push(switch, value)
-               next
-            end
-
-            # Make sure that all the switches are valid.  If 'switch' isn't
-            # defined at this point, it means an option was passed without
-            # a preceding switch, e.g. --option foo bar.
-            unless valid.include?(switch)
-               switch ||= opt
-               raise Error, "invalid switch '#{switch}'"
-            end
-
-            # Required arguments
-            if types[switch] == REQUIRED
-               nextval = ARGV[index+1]
-
-               # Make sure there's a value for mandatory arguments
-               if nextval.nil?
-                  err = "no value provided for required argument '#{switch}'"
-                  raise Error, err
-               end
-
-               # If there is a value, make sure it's not another switch
-               if valid.include?(nextval)
-                  err = "cannot pass switch '#{nextval}' as an argument"
-                  raise Error, err
-               end
-
-               # If the same option appears more than once, put the values
-               # in array.
-               if hash[switch]
-                  hash[switch] = [hash[switch], nextval].flatten
-               else
-                  hash[switch] = nextval
-               end
-               ARGV.delete_at(index+1)
-            end
-
-            # For boolean arguments set the switch's value to true.
-            if types[switch] == BOOLEAN
-               if hash.has_key?(switch)
-                  raise Error, "boolean switch already set"
-               end
-               hash[switch] = true
-            end
-
-            # For increment arguments, set the switch's value to 0, or
-            # increment it by one if it already exists.
-            if types[switch] == INCREMENT
-               if hash.has_key?(switch)
-                  hash[switch] += 1
-               else
-                  hash[switch] = 1
-               end
-            end
-
-            # For optional argument, there may be an argument.  If so, it
-            # cannot be another switch.  If not, it is set to true.
-            if types[switch] == OPTIONAL
-               nextval = ARGV[index+1]
-               if valid.include?(nextval)
-                  hash[switch] = true
-               else
-                  hash[switch] = nextval
-                  ARGV.delete_at(index+1)
-               end
-            end
-         }
-
-         # Set synonymous switches to the same value, e.g. if -t is a synonym
-         # for --test, and the user passes "--test", then set "-t" to the same
-         # value that "--test" was set to.
-         #
-         # This allows users to refer to the long or short switch and get
-         # the same value
-         hash.each{ |switch, val|
-            if syns.keys.include?(switch)
-               syns[switch].each{ |key|
-                  hash[key] = val   
-               }
-            end
-         }
-
-         # Get rid of leading "--" and "-" to make it easier to reference
-         hash.each{ |key, value|
-            if key[0,2] == '--'
-               nkey = key.sub('--', '')
-            else
-               nkey = key.sub('-', '')
-            end
-            hash.delete(key)
-            hash[nkey] = value
-         }
-
-         hash
-      end
-
-   end
-end
+module Getopt
+
+   REQUIRED  = 0
+   BOOLEAN   = 1
+   OPTIONAL  = 2
+   INCREMENT = 3
+   NEGATABLE = 4
+   NUMERIC   = 5
+
+   class Long
+      class Error < StandardError; end
+
+      VERSION = '1.3.7'
+
+      # Takes an array of switches. Each array consists of up to three
+      # elements that indicate the name and type of switch. Returns a hash
+      # containing each switch name, minus the '-', as a key. The value
+      # for each key depends on the type of switch and/or the value provided
+      # by the user.
+      #
+      # The long switch _must_ be provided. The short switch defaults to the
+      # first letter of the short switch. The default type is BOOLEAN.
+      #
+      # Example:
+      #
+      # opts = Getopt::Long.getopts(
+      #    ["--debug"],
+      #    ["--verbose", "-v"],
+      #    ["--level", "-l", NUMERIC]
+      # )
+      #
+      # See the README file for more information.
+      #
+      def self.getopts(*switches)
+         if switches.empty?
+            raise ArgumentError, "no switches provided"
+         end
+
+         hash  = {} # Hash returned to user
+         valid = [] # Tracks valid switches
+         types = {} # Tracks argument types
+         syns  = {} # Tracks long and short arguments, or multiple shorts
+
+         # If a string is passed, split it and convert it to an array of arrays
+         if switches.first.kind_of?(String)
+            switches = switches.join.split
+            switches.map!{ |switch| switch = [switch] }
+         end
+
+         # Set our list of valid switches, and proper types for each switch
+         switches.each{ |switch|
+            valid.push(switch[0])       # Set valid long switches
+
+            # Set type for long switch, default to BOOLEAN.
+            if switch[1].kind_of?(Fixnum)
+               switch[2] = switch[1]
+               types[switch[0]] = switch[2]
+               switch[1] = switch[0][1..2]
+            else
+               switch[2] ||= BOOLEAN
+               types[switch[0]] = switch[2]
+               switch[1] ||= switch[0][1..2]
+            end
+
+            # Create synonym hash.  Default to first char of long switch for 
+            # short switch, e.g. "--verbose" creates a "-v" synonym.  The same
+            # synonym can only be used once - first one wins.
+            syns[switch[0]] = switch[1] unless syns[switch[1]]
+            syns[switch[1]] = switch[0] unless syns[switch[1]]
+
+            switch[1].each{ |char|      
+               types[char] = switch[2]  # Set type for short switch
+               valid.push(char)         # Set valid short switches
+            }
+         }
+
+         re_long     = /^(--\w+[-\w+]*)?$/
+         re_short    = /^(-\w)$/
+         re_long_eq  = /^(--\w+[-\w+]*)?=(.*?)$|(-\w?)=(.*?)$/
+         re_short_sq = /^(-\w)(\S+?)$/
+
+         ARGV.each_with_index{ |opt, index|
+
+            # Allow either -x -v or -xv style for single char args
+            if re_short_sq.match(opt)
+               chars = opt.split("")[1..-1].map{ |s| s = "-#{s}" }
+
+               chars.each_with_index{ |char, i|
+                  unless valid.include?(char)  
+                     raise Error, "invalid switch '#{char}'"
+                  end
+
+                  # Grab the next arg if the switch takes a required arg
+                  if types[char] == REQUIRED
+                     # Deal with a argument squished up against switch
+                     if chars[i+1]
+                        arg = chars[i+1..-1].join.tr("-","")
+                        ARGV.push(char, arg)
+                        break
+                     else
+                        arg = ARGV.delete_at(index+1)
+                        if arg.nil? || valid.include?(arg) # Minor cheat here
+                           err = "no value provided for required argument '#{char}'"
+                           raise Error, err
+                        end
+                        ARGV.push(char, arg)
+                     end
+                  elsif types[char] == OPTIONAL
+                     if chars[i+1] && !valid.include?(chars[i+1])
+                        arg = chars[i+1..-1].join.tr("-","")
+                        ARGV.push(char, arg)
+                        break
+                     elsif
+                        if ARGV[index+1] && !valid.include?(ARGV[index+1])
+                           arg = ARGV.delete_at(index+1)
+                           ARGV.push(char, arg)
+                        end
+                     else
+                        ARGV.push(char)
+                     end
+                  else
+                     ARGV.push(char)
+                  end
+               }
+               next
+            end
+
+            if match = re_long.match(opt) || match = re_short.match(opt)
+               switch = match.captures.first
+            end
+
+            if match = re_long_eq.match(opt)
+               switch, value = match.captures.compact
+               ARGV.push(switch, value)
+               next
+            end
+
+            # Make sure that all the switches are valid.  If 'switch' isn't
+            # defined at this point, it means an option was passed without
+            # a preceding switch, e.g. --option foo bar.
+            unless valid.include?(switch)
+               switch ||= opt
+               raise Error, "invalid switch '#{switch}'"
+            end
+
+            # Required arguments
+            if types[switch] == REQUIRED
+               nextval = ARGV[index+1]
+
+               # Make sure there's a value for mandatory arguments
+               if nextval.nil?
+                  err = "no value provided for required argument '#{switch}'"
+                  raise Error, err
+               end
+
+               # If there is a value, make sure it's not another switch
+               if valid.include?(nextval)
+                  err = "cannot pass switch '#{nextval}' as an argument"
+                  raise Error, err
+               end
+
+               # If the same option appears more than once, put the values
+               # in array.
+               if hash[switch]
+                  hash[switch] = [hash[switch], nextval].flatten
+               else
+                  hash[switch] = nextval
+               end
+               ARGV.delete_at(index+1)
+            end
+
+            # For boolean arguments set the switch's value to true.
+            if types[switch] == BOOLEAN
+               if hash.has_key?(switch)
+                  raise Error, "boolean switch already set"
+               end
+               hash[switch] = true
+            end
+
+            # For increment arguments, set the switch's value to 0, or
+            # increment it by one if it already exists.
+            if types[switch] == INCREMENT
+               if hash.has_key?(switch)
+                  hash[switch] += 1
+               else
+                  hash[switch] = 1
+               end
+            end
+
+            # For optional argument, there may be an argument.  If so, it
+            # cannot be another switch.  If not, it is set to true.
+            if types[switch] == OPTIONAL
+               nextval = ARGV[index+1]
+               if valid.include?(nextval)
+                  hash[switch] = true
+               else
+                  hash[switch] = nextval
+                  ARGV.delete_at(index+1)
+               end
+            end
+         }
+
+         # Set synonymous switches to the same value, e.g. if -t is a synonym
+         # for --test, and the user passes "--test", then set "-t" to the same
+         # value that "--test" was set to.
+         #
+         # This allows users to refer to the long or short switch and get
+         # the same value
+         hash.each{ |switch, val|
+            if syns.keys.include?(switch)
+               syns[switch].each{ |key|
+                  hash[key] = val   
+               }
+            end
+         }
+
+         # Get rid of leading "--" and "-" to make it easier to reference
+         hash.each{ |key, value|
+            if key =~ /^-/
+               if key[0,2] == '--'
+                  nkey = key.sub('--', '')
+               else
+                  nkey = key.sub('-', '')
+               end
+               hash.delete(key)
+               hash[nkey] = value
+            end
+         }
+
+         hash
+      end
+
+   end
+end