getopt 1.3.0 → 1.3.1

data/CHANGES

@@ -1,3 +1,7 @@
+== 18-Nov-2005 - 1.3.1
+* Added support for compressed switches with getopt/long.
+* More tests.
+
 == 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

data/README

@@ -117,19 +117,25 @@ INCREMENT
    For example, if you do Getopt::Std.getopts("o:ID"), it will not parse
    "-IDohello" properly.  Instead, you must do "-IDo hello".  Or, you can just
    separate the argument, e.g. "-I -D -o hello".
+
+=== Getopt::Long
+   If you mix and match compressed switches with separate, optional switches
+   the optional switch will be set to true instead of nil if it separated
+   from the compressed switches.
    
+=== Reporting Bugs
    If you find any other bugs, please log them on the project
    page at http://www.rubyforge.org/projects/shards.
 
 == Other Issues
-   Neither of the classes attempts to be POSIX compliant in any way, shape
-   or form.  And I don't care!
+   Neither class attempts to be POSIX compliant in any way, shape or form.
+   And I don't care!
 
 == Notes From the Author
    My main gripe with the getoptlong library currently in the standard library
    is that it doesn't return a hash, yet gives you partial hash behavior.  This
-   was both confusing and annoying, since the first thing I (and everyone else)
-   does is collect the results into a hash for later processing.
+   was both confusing and annoying, since the first thing I do (along with
+   everyone else) is collect the results into a hash for later processing.
 
    My main gripe with the optparse library (also in the standard library) is
    that it treats command line processing like event processing.  It's too

data/lib/getopt/long.rb

@@ -0,0 +1,200 @@
+module Getopt
+
+   REQUIRED  = 0
+   BOOLEAN   = 1
+   OPTIONAL  = 2
+   INCREMENT = 3
+   NEGATABLE = 4
+
+   class LongError < StandardError; end
+
+   class Long
+      VERSION = "1.3.1"
+
+      # takes an array of switches.  Each array consists of three elements.
+      def self.getopts(*switches)
+         hash  = {} # Hash returned to user
+         valid = [] # Tracks valid switches
+         types = {} # Tracks argument types
+         syns  = {} # Tracks long and short arguments, or multiple shorts
+
+         if switches.empty?
+            raise ArgumentError, "no switches provided"
+         end
+
+         # 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
+            switch[2] ||= BOOLEAN
+            types[switch[0]] = switch[2]
+
+            # Create synonym hash.  Default to first char of long switch for 
+            # short switch, e.g. "--verbose" creates a "-v" synonym.
+            switch[1] ||= switch[0][1..2]
+
+            syns[switch[0]] = switch[1]
+            syns[switch[1]] = switch[0]
+
+            switch[1].each{ |char|      
+               types[char] = switch[2]  # Set type for short switch
+               valid.push(char)         # Set valid short switches
+            }
+         }
+
+         re_long     = /^(--\w+)$/
+         re_short    = /^(-\w)$/
+         re_long_eq  = /^(--\w+?)=(.*?)$|^(-\w?)=(.*?)$/
+         re_short_sq = /^(-\w)(\S+?)$/
+
+         ARGV.each_with_index{ |opt, index|
+
+            # Allow either -x -v or -xv style for sing 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 LongError, "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 LongError, 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
+            unless valid.include?(switch)
+               raise LongError, "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 LongError, 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 LongError, 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 LongError, "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|
+            nkey = key.tr("-","")
+            hash.delete(key)
+            hash[nkey] = value
+         }
+
+         hash
+      end
+
+   end
+end

data/lib/getopt/std.rb

@@ -0,0 +1,78 @@
+module Getopt
+   class StdError < StandardError; end
+   class Std
+      VERSION = "1.3.0"
+
+      # Processes single character command line options with option
+      # clustering.  This information is parsed from ARGV and returned
+      # as a hash, with the switch (minus the "-") as the key.  The value
+      # for that key is either true/false (boolean switches) or the argument
+      # that was passed to the switch.
+      #
+      # Characters followed by a ":" require an argument.  The rest are
+      # considered boolean switches.  If a switch that accepts an argument
+      # appears more than once, the value for that key becomes an array
+      # of values.
+      # 
+      def self.getopts(switches)
+         args = switches.split(/ */)
+         hash = {}
+         
+         while !ARGV.empty? && ARGV.first =~ /^-(.)(.*)/s
+            first, rest = $1, $2
+            pos = switches.index(first)
+
+            # Switches on the command line must appear among the characters
+            # declared in +switches+.
+            raise StdError, "invalid option '#{first}'" unless pos
+
+            if args[pos+1] == ":"
+               ARGV.shift
+               if rest.empty?
+                  rest = ARGV.shift
+
+                  # Ensure that switches requiring arguments actually
+                  # receive a (non-switch) argument.
+                  if rest.nil? || rest.empty?
+                     raise StdError, "missing argument for '-#{args[pos]}'"
+                  end
+
+                  # Do not permit switches that require arguments to be
+                  # followed immediately by another switch.
+                  if args.include?(rest) || args.include?(rest[1..-1])
+                     err = "cannot use switch '#{rest}' as argument "
+                     err += "to another switch"
+                     raise StdError, err
+                  end
+
+                  # For non boolean switches, arguments that appear multiple
+                  # times are converted to an array (or pushed onto an already
+                  # existant array).
+                  if hash.has_key?(first)
+                     hash[first] = [hash[first], rest].flatten
+                  else
+                     hash[first] = rest
+                  end
+               else
+                  # Do not permit switches that require arguments to be
+                  # followed immediately by another switch.
+                  if args.include?(rest) || args.include?(rest[1..-1])
+                     err = "cannot use switch '#{rest}' as argument "
+                     err += "to another switch"
+                     raise StdError, err
+                  end
+               end
+            else
+               hash[first] = true # Boolean switch
+               if rest.empty?
+                  ARGV.shift
+               else
+                  ARGV[0] = "-#{rest}"
+               end
+            end
+         end
+
+         hash
+      end
+   end
+end

data/test/tc_getopt_long.rb

@@ -21,7 +21,7 @@ class TC_Getopt_Long < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal("1.3.0", Long::VERSION)
+      assert_equal("1.3.1", Long::VERSION)
    end
 
    def test_constants
@@ -112,6 +112,102 @@ class TC_Getopt_Long < Test::Unit::TestCase
       assert_equal({"foo"=>"1", "bar"=>"hello", "f"=>"1", "b"=>"hello"}, @opts)
    end
 
+   def test_compressed_switches
+      ARGV.push("-fb")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--foo", "-f", BOOLEAN],
+            ["--bar", "-b", BOOLEAN]
+         )
+      }
+      assert_equal({"foo"=>true, "f"=>true, "b"=>true, "bar"=>true}, @opts)
+   end
+
+   def test_compress_switches_with_required_arg
+      ARGV.push("-xf", "foo.txt")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--expand", "-x", BOOLEAN],
+            ["--file", "-f", REQUIRED]
+         )
+      }
+      assert_equal(
+         {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
+      )
+   end
+
+   def test_compress_switches_with_compressed_required_arg
+      ARGV.push("-xffoo.txt")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--expand", "-x", BOOLEAN],
+            ["--file", "-f", REQUIRED]
+         )
+      }
+      assert_equal(
+         {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
+      )
+   end
+
+   def test_compress_switches_with_optional_arg_not_defined
+      ARGV.push("-xf")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--expand", "-x", BOOLEAN],
+            ["--file", "-f", OPTIONAL]
+         )
+      }
+      assert_equal(
+         {"x"=>true, "expand"=>true, "f"=>nil, "file"=>nil}, @opts
+      )
+   end
+
+   def test_compress_switches_with_optional_arg
+      ARGV.push("-xf", "boo.txt")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--expand", "-x", BOOLEAN],
+            ["--file", "-f", OPTIONAL]
+         )
+      }
+      assert_equal(
+         {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
+      )
+   end
+
+   def test_compress_switches_with_compressed_optional_arg
+      ARGV.push("-xfboo.txt")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--expand", "-x", BOOLEAN],
+            ["--file", "-f", OPTIONAL]
+         )
+      }
+      assert_equal(
+         {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
+      )
+   end
+
+   def test_compressed_short_and_long_mixed
+      ARGV.push("-xb", "--file", "boo.txt", "-v")
+      assert_nothing_raised{
+         @opts = Long.getopts(
+            ["--expand", "-x", BOOLEAN],
+            ["--verbose", "-v", BOOLEAN],
+            ["--file", "-f", REQUIRED],
+            ["--bar", "-b", OPTIONAL]
+         )
+         assert_equal(
+            { "x"=>true, "expand"=>true,
+              "v"=>true, "verbose"=>true,
+              "f"=>"boo.txt", "file"=>"boo.txt",
+              "b"=>nil, "bar"=>nil
+            },
+            @opts
+         )
+      }
+   end
+
    def teardown
       @opts = nil
       ARGV.clear

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: getopt
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
-date: 2005-11-04 00:00:00 -07:00
+  version: 1.3.1
+date: 2005-11-18 00:00:00 -07:00
 summary: Getopt::Std for Ruby
 require_paths: 
   - lib
@@ -29,12 +29,16 @@ cert_chain:
 authors: 
   - Daniel J. Berger
 files: 
+  - lib/getopt/long.rb
+  - lib/getopt/std.rb
   - CHANGES
   - MANIFEST
   - README
+  - CVS
   - test/tc_getopt_long.rb
   - test/tc_getopt_std.rb
   - test/ts_all.rb
+  - test/CVS
 test_files: 
   - test/ts_all.rb
 rdoc_options: []