getoptions 0.1

data/README

@@ -0,0 +1,117 @@
+== Synopsis
+
+GetOptions - Yet another command line argument parser for Ruby. 
+
+If you are familiar with Perl's Getopt::Long specification syntax you should 
+feel right at home.  The following specifications are currently supported:
+
+   default    -- This is the default case, the option is either there or it isn't
+   flag!      -- You can specify either --flag or --no-flag to set true or false
+   name|a1|a2 -- You can use '|' to set up option aliases.  In this example, the
+                 'name' option will be set if either 'name', 'a1', or 'a2' is 
+                 specified on the command line.
+
+   optional:x -- An argument with an optional argument of type x
+   required=x -- An argument with a required argument of type x 
+   alist=@x   -- An argument that takes a list of things of type x
+
+The following types are currently supported:
+       s|string  -- A string value 
+       i|integer -- An integer value
+       f|float   -- A floating point value
+       For integer and float, an exception will be thrown if ruby
+       can't find a way to convert the supplied argument string.
+
+As with Getopt::Long, you specify the long form of the option, but it can 
+parse short options as well.  For example, if you have an option named 'help',
+both --help and -h would enable the option.  You can also specify a small 
+portion of the long form, and if it is enough to uniquely identify the option,
+it will work.  For example, --he or --hel would map to --help as long as you
+don't have --hell, --hello, ... as an option.
+
+There are several ways to get the option data after parsing.  Of course there
+is the hash style, which could look something like:
+ 
+  options = GetOptions.new(%w(help verbose!))
+  puts "I'm going to go do stuff now..." if options['verbose']
+
+You can also use a symbol (options[:verbose]) instead of a string if you want.
+In addition, you can access fields using the .-style accessor syntax:
+
+  show_help() if options.help
+
+
+== Examples
+
+Kicking the tires:
+
+  $ cat myscript1.rb
+  require 'getoptions'
+
+  opt = GetOptions.new(%w(help debug! verbose+ prefix:s size=i host=@s)) 
+  p opt
+
+  $ ./myscript1.rb --help 
+  help: true  
+
+  $ ./myscript1.rb --debug   
+  debug: true
+
+  $ ./myscript1.rb --no-debug
+  debug: false
+
+  $ ./myscript1.rb -vvvvv    
+  verbose: 5
+
+  $ ./myscript1.rb -vv --verbose
+  verbose: 3
+
+  $ ./myscript1.rb --pre        
+  prefix: nil
+
+  $ ./myscript1.rb --pre myprefix
+  prefix: "myprefix"
+
+  $ ./myscript1.rb --size 5      
+  size: 5
+
+
+Mixing arguments with non-arguments:
+
+  $ cat myscript2.rb
+  require 'getoptions'
+
+  opt = GetOptions.new(%w(help debug! verbose+ prefix:s size=i host=@s)) 
+  p opt
+  puts '--'
+  p ARGV
+
+  $ ./myscript2.rb --siz 10 file1 file2 file3
+  size: 10
+  --
+  ["file1", "file2", "file3"]
+
+  $ ./myscript2.rb --host host1 host2 -- file1 file2 file3
+  host: ["host1", "host2"]
+  --
+  ["file1", "file2", "file3"]
+
+
+Processing your own input stream:
+
+  $ cat myscript3.rb
+  require 'getoptions'
+
+  input = %w(-vv -w 1 -2 -- file1)
+  opt = GetOptions.new(%w(verbose+ weights:@i), input)
+  p opt
+  puts '--'
+  p input
+
+  $ ./myscript3.rb
+  verbose: 2
+  weights: [1, -2]
+  --
+  ["file1"]
+
+

data/lib/getoptions.rb

@@ -0,0 +1,427 @@
+#!/usr/bin/env ruby
+ 
+#
+# == Synopsis
+#
+# GetOptions - Yet another command line argument parser for Ruby. 
+#
+# If you are familiar with Perl's Getopt::Long specification syntax you should 
+# feel right at home.  The following specifications are currently supported:
+#
+#    default    -- This is the default case, the option is either there or it isn't
+#    flag!      -- You can specify either --flag or --no-flag to set true or false
+#    name|a1|a2 -- You can use '|' to set up option aliases.  In this example, the
+#                  'name' option will be set if either 'name', 'a1', or 'a2' is 
+#                  specified on the command line.
+#
+#    optional:x -- An argument with an optional argument of type x
+#    required=x -- An argument with a required argument of type x 
+#    alist=@x   -- An argument that takes a list of things of type x
+#
+# The following types are currently supported:
+#        s|string  -- A string value 
+#        i|integer -- An integer value
+#        f|float   -- A floating point value
+#        For integer and float, an exception will be thrown if ruby
+#        can't find a way to convert the supplied argument string.
+# 
+# As with Getopt::Long, you specify the long form of the option, but it can 
+# parse short options as well.  For example, if you have an option named 'help',
+# both --help and -h would enable the option.  You can also specify a small 
+# portion of the long form, and if it is enough to uniquely identify the option,
+# it will work.  For example, --he or --hel would map to --help as long as you
+# don't have --hell, --hello, ... as an option.
+# 
+# There are several ways to get the option data after parsing.  Of course there
+# is the hash style, which could look something like:
+#  
+#   options = GetOptions.new(%w(help verbose!))
+#   puts "I'm going to go do stuff now..." if options['verbose']
+#
+# You can also use a symbol (options[:verbose]) instead of a string if you want.
+# In addition, you can access fields using the .-style accessor syntax:
+#
+#   show_help() if options.help
+#
+#
+# == Examples
+#
+# Kicking the tires:
+#
+#   $ cat myscript1.rb
+#   require 'getoptions'
+#
+#   opt = GetOptions.new(%w(help debug! verbose+ prefix:s size=i host=@s)) 
+#   p opt
+#
+#   $ ./myscript1.rb --help 
+#   help: true  
+#
+#   $ ./myscript1.rb --debug   
+#   debug: true
+#
+#   $ ./myscript1.rb --no-debug
+#   debug: false
+#
+#   $ ./myscript1.rb -vvvvv    
+#   verbose: 5
+#
+#   $ ./myscript1.rb -vv --verbose
+#   verbose: 3
+#
+#   $ ./myscript1.rb --pre        
+#   prefix: nil
+#
+#   $ ./myscript1.rb --pre myprefix
+#   prefix: "myprefix"
+#
+#   $ ./myscript1.rb --size 5      
+#   size: 5
+#
+#
+# Mixing arguments with non-arguments:
+#
+#   $ cat myscript2.rb
+#   require 'getoptions'
+#
+#   opt = GetOptions.new(%w(help debug! verbose+ prefix:s size=i host=@s)) 
+#   p opt
+#   puts '--'
+#   p ARGV
+#
+#   $ ./myscript2.rb --siz 10 file1 file2 file3
+#   size: 10
+#   --
+#   ["file1", "file2", "file3"]
+#
+#   $ ./myscript2.rb --host host1 host2 -- file1 file2 file3
+#   host: ["host1", "host2"]
+#   --
+#   ["file1", "file2", "file3"]
+#
+#
+# Processing your own input stream:
+#
+#   $ cat myscript3.rb
+#   require 'getoptions'
+#
+#   input = %w(-vv -w 1 -2 -- file1)
+#   opt = GetOptions.new(%w(verbose+ weights:@i), input)
+#   p opt
+#   puts '--'
+#   p input
+#
+#   $ ./myscript3.rb
+#   verbose: 2
+#   weights: [1, -2]
+#   --
+#   ["file1"]
+#
+#
+
+require 'rdoc/usage'
+require 'abbrev'
+
+class GetOptions
+
+  class ParseError < Exception
+  end
+
+  # For select, reject, and other goodies
+  include Enumerable
+
+  # :call-seq:
+  #   new(option_specs, input = ARGV) -> opt
+  #
+  # Parse input based on metadata in option_specs.
+  #
+  # == Examples
+  # 
+  #   opt = GetOptions.new(%w(help verbose! strarg=s))
+  #   puts "I'm going to go do stuff..." if (opt.verbose)
+  #   ...
+  #
+  def initialize(option_specs, input = ARGV)
+    build_dict(option_specs)
+
+    @options = {}
+    leftover = []
+    until input.empty?
+      arg = input.shift
+
+      case arg
+      # Stop if you hit --
+      when '--' 
+        break 
+
+      # Long form 
+      when /^--(\S+)/
+        o, a = $1.split('=', 2)
+        input.unshift(a) if a
+        input = process_arguments(o, input) 
+
+      # Short form
+      when /^-(\S+)/
+        o, a = $1.split('=', 2)
+        input.unshift(a) if a
+        o.scan(/./) do |c|
+          input = process_arguments(c, input)
+        end
+
+      # Not an option, leave it
+      else
+        leftover << arg
+      end
+    end 
+
+    # Put what didn't parse back into input
+    input.concat(leftover)
+  end 
+
+  # :call-seq:
+  #   opt[key] -> value
+  #
+  # Returns the value of the specified option.  If the option was in
+  # the specification but not found in the input data, nill is returned.
+  #
+  def [](k)
+    raise ParseError.new("`nil' cannot be an option key") if (k.nil?)
+    sym = k.to_sym
+    key = k.to_s
+
+    case
+    when @options.has_key?(sym); @options[sym]
+    when @dict.has_key?(key);    nil
+    else raise ParseError.new("program tried to access an unknown option: #{key.inspect}")
+    end
+  end
+
+  # :call-seq:
+  #   has_option?(key) -> true or false
+  #
+  # Returns true if the specified key exists in the option input.
+  #
+  # == Examples
+  # 
+  #   opt = GetOptions.new(%w(help verbose! strarg=s))
+  #   puts "I'm going to go do stuff..." if (opt.has_option(:verbose))
+  #   puts "I don't exist..." if (opt.has_option(:bogus))
+  #   ...
+  #
+  def has_option?(k)
+    raise ParseError.new("`nil' cannot be an option key") if (k.nil?)
+    @options.has_key?(k.to_sym)
+  end
+
+  alias to_s inspect
+
+  def inspect
+    @options.sort_by{|k| k.to_s}.collect do |key, val|
+      "%s: %s" % [key.inspect, val.inspect]  
+    end.join($/)
+  end
+
+  # :call-seq:
+  #   opt.each { |key,val| block } -> Hash 
+  # 
+  # Iterate over each parsed option name and value.
+  #
+  # == Examples
+  # opt.each do |key,val|
+  #   puts "#{key} -> #{val.inspect}"
+  # end
+  # 
+  def each
+    @options.each do |key,value|
+      yield key.to_s, value
+    end
+  end
+
+  private
+
+  # Wrapper to hash accessor
+  def method_missing(method, *args) #:nodoc:
+    self[method]
+  end
+
+  # Builds a keyword dictionary based on option specification
+  def build_dict(option_specs) #:nodoc:
+    @dict = {}
+    keys = []
+    option_specs.each do |option_spec|
+      # Parse the specification
+      m, label, oper, cont, arg = *option_spec.match(/([^=:]+)(?:([=:])([@])?(\w+))?/)
+      raise ParseError.new("invalid option format for '#{option_spec}'") unless m
+
+      # Figure out the specification type
+      is_bang_arg  = label.gsub!(/!$/, '')
+      is_increment = label.gsub!(/\+$/, '')
+      forms        = label.split('|')
+      key          = forms.first
+
+      # Create an instance of OptionDefinition to hold metat data
+      od = OptionDefinition.new(key)
+      od.option_type = :boolean   if is_bang_arg
+      od.option_type = :increment if is_increment
+      if (arg)
+        od.option_type = (oper == '=') ? :required_argument : :optional_argument
+        od.container_type = case cont
+          when '@'; :array
+          else      :scalar
+          end
+        od.argument_type = case arg
+          when 'f', 'float'  ; :float
+          when 'i', 'integer'; :integer
+          when 's', 'string' ; :string
+          else raise ParseError.new("unknown argument type '#{arg}'")
+          end
+      end
+
+      # Process alternate key names
+      forms.each do |k|
+        @dict[k] = od.dup
+        keys << k
+      end
+
+      # Only support negation on long option names
+      if (is_bang_arg)
+        @dict["no-#{key}"] = od.dup
+      end
+    end
+
+    # Allow abbreviated long options
+    keys.abbrev.each do |ab,key|
+      @dict[ab] = @dict[key].dup
+      @dict[ab].abbreviated = true unless (ab == key)
+    end
+  end 
+
+  # Parse all arguments for the current option
+  def process_arguments(k, input) #:nodoc:
+    if (opt = @dict[k])
+      key = opt.key
+      case opt.option_type
+      when :boolean  
+        @options[key] = (k != "no-#{key}")
+      when :increment
+        @options[key] ||= 0
+        @options[key] +=  1
+      when :optional_argument, :required_argument
+        args = []
+        loop do 
+          break if (input.empty?)
+          arg = input.shift
+
+          is_arg = case arg
+          # If it matches a long argument name, it isn't an argument
+          when '--'
+            false
+          when /^--(\S+)/
+            o, a = $1.split('=', 2)
+            !@dict.has_key?(o)
+          # If this is a valid shorthand option string, abort
+          when /^-(\S+)/
+            o, a = $1.split('=', 2)
+            !o.scan(/./).all? { |c| @dict.has_key?(c) }
+          else 
+            true
+          end
+
+          # We've hit another option, get outta here
+          #if (arg =~ /^-/)
+          unless (is_arg)
+            input.unshift(arg) 
+            break
+          end
+          args << arg
+          # If this is a scalar type, stop after the first argument
+          break if opt.container_type == :scalar
+        end
+
+        if (args.empty?) 
+          # No argument found, and one was required, complain about it
+          if (opt.option_type == :required_argument) 
+            raise ParseError.new("missing required argument for '#{key}'")
+          # No argument found, but it was optional, set a default value
+          else            
+            case opt.container_type
+            when :scalar; @options[key] = nil
+            when :array;  @options[key] = []
+            end
+          end
+        else
+          args.each do |arg|
+            val = case opt.argument_type
+            when :float   
+              # Try to parse float option, toss an exception if the parse failed
+              Float(arg) rescue 
+                raise ParseError.new("expecting float value for option '#{key}'") 
+            when :integer 
+              # Try to parse integer option, toss an exception if the parse failed
+              Integer(arg) rescue  
+                raise ParseError.new("expecting integer value for option '#{key}'") 
+            else
+              # Assume string type (no processing needed)
+              arg
+            end
+            # Either set the option value (scalar) or add it to the list (array)
+            case opt.container_type
+            when :scalar; @options[key] = val
+            when :array;  (@options[key] ||= []) << val
+            end
+          end
+        end
+      end
+    else
+      # If an exact match isn't found, try to make a suggestion
+      candidates = @dict.keys.select do |c|
+        (!@dict[c].is_abbreviated? && c =~ /^#{k}/)
+      end
+      matches = case candidates.size
+      when 0
+        nil
+      when 1
+        ", did you mean #{candidates.first}?"
+      else
+        ", close matches are: " +
+        candidates[0, candidates.size - 1].join(", ") +
+        " and " + candidates.last
+      end
+      raise ParseError.new("unknown option '#{k}'#{matches || ''}")
+    end
+
+    input
+  end
+
+
+  class OptionDefinition #:nodoc: all
+    attr_accessor :key
+    attr_accessor :option_type
+    attr_accessor :argument_type
+    attr_accessor :container_type
+    attr_accessor :abbreviated
+
+    def initialize(key)
+      @key = key.to_sym
+      @option_type = :boolean
+      @abbreviated = false
+    end
+
+    def is_abbreviated? 
+      @abbreviated
+    end
+  end
+
+end
+
+
+# Spit out usage if --help is specified 
+if __FILE__ == $0
+  begin
+    RDoc::usage if GetOptions.new(%w(help)).help 
+  rescue 
+    warn $!
+    exit 1
+  end
+end
+

data/test/standard.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+
+# Unit test for GetOptions
+
+require File.join(File.dirname(__FILE__), '../lib/getoptions')
+require 'spec'
+
+
+describe GetOptions do
+
+  # String tests
+  it "should parse strings, short type name" do
+    opt = GetOptions.new(%w(string=s), %w(--str test))
+    opt.string.should eql('test')
+  end
+  it "should parse strings, long type name" do
+    opt = GetOptions.new(%w(string=string), %w(--str test))
+    opt.string.should eql('test')
+  end
+
+  # Integer tests
+  it "should parse integers, short type name" do
+    opt = GetOptions.new(%w(int=i), %w(--int 5))
+    opt.int.should eql(5)
+  end
+  it "should parse integers, long type name" do
+    opt = GetOptions.new(%w(int=integer), %w(--int 5))
+    opt.int.should eql(5)
+  end
+  it "should throw an exception on non integers" do
+    lambda {
+      GetOptions.new(%w(int=i), %w(--int NaN))
+    }.should raise_error(GetOptions::ParseError, /expecting integer value/)
+  end
+
+  # Float tests
+  it "should parse floats, short type name" do
+    opt = GetOptions.new(%w(float=f), %w(--float 0.5))
+    opt.float.should eql(0.5)
+  end
+  it "should parse floats, long type name" do
+    opt = GetOptions.new(%w(float=float), %w(--float 0.5))
+    opt.float.should eql(0.5)
+  end
+  it "should throw an exception on non floats" do
+    lambda {
+      GetOptions.new(%w(float=f), %w(--float NaN))
+    }.should raise_error(GetOptions::ParseError, /expecting float value/)
+  end
+
+  # Flag tests
+  it "should parse flags set to true" do
+    opt = GetOptions.new(%w(flag!), %w(--flag))
+    opt.flag.should eql(true)
+  end
+  it "should parse flags set to false" do
+    opt = GetOptions.new(%w(flag!), %w(--no-flag))
+    opt.flag.should eql(false)
+  end
+
+  # List tests
+  it "should parse a list of strings" do
+    opt = GetOptions.new(%w(list=@s), %w(--list foo bar --li baz -l qux))
+    opt.list.should eql(%w(foo bar baz qux))
+  end
+  it "should parse a list of integers" do 
+    opt = GetOptions.new(%w(list=@i), %w(--list 1 2 --li 3 -l 4))
+    opt.list.should eql([1,2,3,4])
+  end
+  it "should parse a list of integers w/ negative numbers" do 
+    opt = GetOptions.new(%w(list=@i), %w(--list 1 -2 --li 3 -l -4))
+    opt.list.should eql([1,-2,3,-4])
+  end
+  it "should not parse a list of non-integers" do
+    lambda {
+      GetOptions.new(%w(list=@i), %w(--list 1 2 oops 3))
+    }.should raise_error(GetOptions::ParseError, /expecting integer value/)
+  end
+  it "should parse a list of floats" do
+    opt = GetOptions.new(%w(list=@f), %w(--list 0.1 0.2 --li 0.3 -l 0.4))
+    opt.list.should eql([0.1,0.2,0.3,0.4])
+  end
+  it "should parse a list of floats w/ negative numbers" do
+    opt = GetOptions.new(%w(list=@f), %w(--list 0.1 -0.2 --li -0.3 -l 0.4))
+    opt.list.should eql([0.1,-0.2,-0.3,0.4])
+  end
+  it "should not parse a list of non-floats" do
+    lambda {
+      GetOptions.new(%w(list=@f), %w(--list 0.1 0.2 oops 0.3))
+    }.should raise_error(GetOptions::ParseError, /expecting float value/)
+  end
+
+  # Optional argument tests
+  it "should parse an optional string argument" do
+    opt = GetOptions.new(%w(string:s), %w(--str))
+    opt.string.should eql(nil)
+  end
+  it "should parse an optional integer argument" do
+    opt = GetOptions.new(%w(int:i), %w(--int))
+    opt.int.should eql(nil)
+  end
+  it "should parse an optional float argument" do
+    opt = GetOptions.new(%w(float:f), %w(--float))
+    opt.float.should eql(nil)
+  end
+  it "should parse an optional list argument" do
+    opt = GetOptions.new(%w(list:@s), %w(--list))
+    opt.list.should eql([])
+  end
+
+  # has_option test
+  it "should check option presence" do
+    opt = GetOptions.new(%w(string:s), %w(--string))
+    opt.has_option?(:string).should eql(true) 
+  end
+  it "should fail on invalid option presence" do
+    opt = GetOptions.new(%w(string:s), %w(--string))
+    opt.has_option?(:blah).should_not eql(true) 
+  end
+  it "should fail on `nil' key option check" do
+    lambda {
+      opt = GetOptions.new(%w(string:s), %w(--string))
+      opt.has_option?(nil).should_not eql(true) 
+    }.should raise_error(GetOptions::ParseError, /`nil' cannot be an option key/)
+  end
+
+  # input array tests
+  it "should retain non-options in input list (no option)" do
+    input = %w(--flag x1 x2 x3)
+    opt = GetOptions.new(%w(flag), input)
+    input.should eql(%w(x1 x2 x3))
+  end
+  it "should retain non-options in input list (required option)" do
+    input = %w(--string test x1 x2 x3)
+    opt = GetOptions.new(%w(string=s), input)
+    input.should eql(%w(x1 x2 x3))
+  end
+  it "should retain non-options in input list (optional option)" do
+    input = %w(--string x1 x2 x3)
+    opt = GetOptions.new(%w(string:s), input)
+    input.should eql(%w(x2 x3))
+  end
+  it "should stop options parsing on --" do
+    input = %w(--list x1 x2 x3 -- x4 x5 x6)
+    opt = GetOptions.new(%w(list=@s), input)
+    input.should eql(%w(x4 x5 x6))
+  end
+
+  # Accessor tests
+  it "should be accessed as a hash (string key)" do
+    opt = GetOptions.new(%w(flag!), %w(--flag))
+    opt['flag'].should eql(true)
+  end
+  it "should be accessed as a hash (symbol key)" do
+    opt = GetOptions.new(%w(flag!), %w(--flag))
+    opt[:flag].should eql(true)
+  end
+  it "should fail on nil key" do
+    lambda {
+      opt = GetOptions.new(%w(flag!), %w(--flag))
+      opt[nil]
+    }.should raise_error(GetOptions::ParseError, /`nil' cannot be an option key/)
+  end
+  it "should fail on unknown key (string key)" do
+    lambda {
+      opt = GetOptions.new(%w(flag!), %w(--flag))
+      opt['notanoption']
+    }.should raise_error(GetOptions::ParseError, /program tried to access/)
+  end
+  it "should fail on unknown key (symbol key)" do
+    lambda {
+      opt = GetOptions.new(%w(flag!), %w(--flag))
+      opt[:notanoption]
+    }.should raise_error(GetOptions::ParseError, /program tried to access/)
+  end
+
+  # shorthand tests
+  it "shorthand test, multiple flags" do
+    opt = GetOptions.new(%w(aflag bflag cflag), %w(-ac)) 
+    opt.aflag.should eql(true) 
+    opt.bflag.should eql(nil) 
+    opt.cflag.should eql(true)
+  end
+  it "shorthand test, multiple arguments" do
+    opt = GetOptions.new(%w(astr=s bstr=s cstr=s), %w(-abc x1 x2 x3)) 
+    opt.astr.should eql('x1') 
+    opt.bstr.should eql('x2') 
+    opt.cstr.should eql('x3')
+  end
+  it "shorthand test, list interoperability" do
+    opt = GetOptions.new(%w(aflag bflag cflag list=@s), %w(--list foo -bar -ac)) 
+    opt.aflag.should eql(true) 
+    opt.bflag.should eql(nil) 
+    opt.cflag.should eql(true) 
+    opt.list.should eql(%w(foo -bar)) 
+  end
+  it "shorthand test, list interoperability with invalid option" do
+    lambda {
+      GetOptions.new(%w(aflag bflag cflag list=@s), %w(--list foo -bar -ac -q)) 
+    }.should raise_error(GetOptions::ParseError, "unknown option 'q'")
+  end
+
+  # last option tests
+  it "last option wins (boolean), true at the end" do
+    opt = GetOptions.new(%w(flag!), %w(--flag --no-flag -f)) 
+    opt.flag.should eql(true)
+  end
+  it "last option wins (boolean), false at the end" do
+    opt = GetOptions.new(%w(flag!), %w(--flag --no-flag)) 
+    opt.flag.should eql(false)
+  end
+  it "last option wins (float)" do
+    opt = GetOptions.new(%w(float=f), %w(--float 0.1 -f 0.2)) 
+    opt.float.should eql(0.2)
+  end
+  it "last option wins (int)" do
+    opt = GetOptions.new(%w(int=i), %w(--int 1 -i 2)) 
+    opt.int.should eql(2)
+  end
+  it "last option wins (string)" do
+    opt = GetOptions.new(%w(string=s), %w(-s x1 --string x2)) 
+    opt.string.should eql('x2')
+  end
+
+  # misc make it break tests
+  it "should throw an exception on invalid types" do
+    lambda {
+      GetOptions.new(%w(arg=bogus), %w(--arg val))
+    }.should raise_error(GetOptions::ParseError, /unknown argument type/)
+  end
+  it "should throw an exception when supplying an option that doesn't exist" do
+    lambda {
+      GetOptions.new(%w(string=s), %w(--notanoption))
+    }.should raise_error(GetOptions::ParseError, /unknown option/)
+  end
+  it "should throw an exception when fetching an option that doesn't exist" do
+    lambda {
+      opt = GetOptions.new(%w(string=s), %w(--string test))
+      opt.notanoption
+    }.should raise_error(GetOptions::ParseError, /program tried to access an unknown/)
+  end
+
+  # inspect test
+  it "inspect method should return proper results" do
+    opt = GetOptions.new(%w(flag string=s int:i verbose+ list=@s), 
+        %w(--int 5 -vvv --list 1 2 3 --flag --string test))
+    opt.to_s
+  end
+
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: getoptions
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2007-11-30 00:00:00 -08:00
+summary: Yet another command line option parser in Ruby, based on Perl's Getopt::Long module.
+require_paths: 
+- lib
+email: dparker @nospam@ liveops.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Delaney Parker
+files: 
+- lib/getoptions.rb
+- test/standard.rb
+- README
+test_files: 
+- test/standard.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+