parseOpts 0.0.2

data/CHANGELOG

@@ -0,0 +1,9 @@
+Changelog
+=========
+
+15/04/09:
+	parseArgs-0.0.1 released
+
+04/05/09:
+	Projects renamed parseOpts to avoid clash with existing parseArgs
+	parseOpts-0.0.2 released

data/LICENSE

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

data/README

@@ -0,0 +1,65 @@
+=parseOpts
+
+parseOpts is (yes, another) ruby library for parsing commandline options and arguments.
+
+It has the following features:
+
+- parses options (switches) as well as arguments
+- options and arguments are specified in an easy to read, declarative format
+- automatically generates a usage message if incorrect arguments are given
+- it is small (currently < 300 lines of code)
+
+==Description
+
+A specification written in ruby describes the allowable command line inputs.
+
+Individual command line parameters are divided into options and arguments.
+
+Options are command line switches, and start with at least one '-' character.  They can occur in any
+order, and may or may not take an argument.  They may occur multiple times if allowed.
+
+Arguments are parameters that may be constrained, either as a choice of options from a list, or by a
+regular expression.  It is possible to specificy how often an argument can occur.
+
+All options are parsed befor any arguments.  All mandatory options and arguments must be present in
+the command line otherwise parsing fails.
+
+==Usage
+
+For a simple example, see the following (from examples/example_grep.rb):
+
+  require "parseOpts"
+
+  opts = ParseOpts.run do
+    opt '-v|--invert-match',  'Select non-matching lines'
+    opt '-m|--max-count NUM', 'Stop reading a file after NUM matches'
+    arg 'pattern',            'Regular expression to match'
+    arg 'file+',              'File to search in'
+  end
+
+  $invert_match = opts['-v']
+  $max_count = opts['-m'] ? opts['-m'].to_i : nil
+  $pattern = Regexp.new(opts['pattern'])
+  $files = opts['file']
+
+Running the script with no arguments generates the following usage message:
+
+  usage: example_grep.rb options* pattern file+
+
+  Options:
+    -v, --invert-match: Select non-matching lines
+    -m, --max-count NUM: Stop reading a file after NUM matches
+
+  Arguments:
+    pattern: Regular expression to match
+    file: File to search in
+
+==Ideas for future work
+
+- define classes for commonly used types to parse argument strings (eg integer, float, etc)
+- format help so lines wrap nicely
+- allow sets of arguments and options in any order (allows subcommands)
+
+==Contact
+
+Please contact jon at coppeard dot net with bug reports and suggestions.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require './lib/parseOpts'
+
+source_files = Dir['lib/*.rb'] + Dir['test/*.rb'] + [ 'Rakefile' ]
+package_files = %w[README CHANGELOG LICENSE] + source_files
+
+Rake::TestTask.new :test do |t|
+  t.test_files = [ "test/test*" ]
+end
+
+desc "Build documentation"
+task :rdoc => source_files
+Rake::RDocTask.new( :rdoc ) do |rdoc|
+  rdoc.rdoc_dir = "api"
+  rdoc.title = "parseOpts - a library to parse commandline options and arguments"
+  rdoc.option_string << '--line-numbers --inline-source --main README'
+  rdoc.rdoc_files.include 'README'
+  rdoc.rdoc_files.include 'lib/parseOpts.rb'
+end
+
+desc "Build the gem"
+task :gem => package_files
+spec = Gem::Specification.new do |spec|
+  spec.name = 'parseOpts'
+  spec.version = ParseOpts::VERSION
+  spec.summary = "Library to parse commandline options and arguments"
+  spec.description = ""
+  spec.author = "Jon Coppeard"
+  spec.email = "jon at coppeard dot net"
+  spec.files = package_files
+  spec.has_rdoc = true
+  spec.test_file = 'test/test_parseOpts.rb'
+  spec.rubyforge_project = 'parseOpts'
+end
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end

data/lib/parseOpts.rb

@@ -0,0 +1,287 @@
+# parseOpts parses commandline options and arguments.
+#
+# For more information, please see the {README}[link:files/README.html]
+class ParseOpts
+
+  VERSION = "0.0.2"
+
+  class OptSpec # :nodoc: all
+
+	attr_reader :matches, :arg, :default, :desc, :multiple
+
+	def initialize(matches, arg, desc, multiple, default)
+	  raise ArgumentError, "Options must start with -" unless matches.all? {|m| m =~ /^-/ }
+	  raise ArgumentError, 'Default not allowed unless argument is present' if default && !arg  
+	  @matches, @arg, @desc, @multiple, @default = 
+		matches, arg, desc, multiple, default
+	end
+
+	def name
+	  @matches[0]
+	end
+
+	def init
+	  @matched = false
+	  @value = if @multiple
+				 @arg ? [] : 0 
+			   else
+				 nil
+			   end
+	end
+	
+	def match?(args)
+	  (!@matched || @multiple) && (@matches.include?(args[0])) && (!@arg || args.size >= 2)
+	end
+
+	def process(args)
+	  args.shift
+	  r = @arg ? args.shift : true
+	  if @multiple && @arg
+		@value << r
+	  elsif @multiple
+		@value += 1
+	  else
+		@value = r
+	  end
+	  @matched = true
+	end
+	
+	def value
+	  !@matched && @default ? @default : @value
+	end
+
+  end
+
+  class ArgSpec # :nodoc: all
+
+	QuantOptions = 
+	{
+	  ""  => [ false, false ],
+	  "?" => [ true,  false ],
+	  "*" => [ true,  true  ],
+	  "+" => [ false, true  ]
+	}
+
+	attr_reader :name, :desc, :multiple, :optional, :quant, :default
+
+	def initialize(name, quant, desc, pred, default)
+	  @name, @quant, @desc, @pred, @default = name, quant, desc, pred, default
+	  raise ArgumentError, "Unknown quantifier" unless QuantOptions.has_key?(quant)
+	  @optional, @multiple = *QuantOptions[quant]
+	  raise ArgumentError, "Default not allowed for mandatory argument" if @default && !@optional
+	end
+
+	def init
+	  @value = @multiple ? [] : nil
+	  @matched = false
+	end
+
+	def match?(args)
+	  @pred ? @pred.call(args[0]) : true
+	end
+
+	def process(args)
+	  @value = if @multiple
+				 a = [args.shift]
+				 a << args.shift while args.size > 0 && match?(args)
+				 a
+			   else
+				 args.shift
+			   end
+	  @matched = true
+	end
+
+	def value
+	  @default && !@matched ? @default : @value
+	end
+
+  end
+
+  # An exception raised by ParseOpts::parse when the command line arguments don't conform to the
+  # specification.
+  class BadUsageError < Exception; end
+
+  # Create a new object that parses the command line specified by the given block.
+  #
+  # The block is evaluated in the context of the new object instance and should call its summary,
+  # opt and arg methods.
+  def initialize (&block)
+	@summary = nil
+	@optList, @argList = [], []
+	instance_eval(&block)
+  end
+
+  # Set the summary text that is output in the usage message.
+  def summary(string)
+	@summary = string
+  end
+
+  # Add an option.
+  #
+  # [spec]   A string specifying the option name and alternatives, and whether the option can take an
+  #          argument.  Alternatives are specified by listing them separated by a '|' character and
+  #          an argument is specified by following that with a space and the argument name.  
+  #
+  #          The first word of the specification is the name, and is used as the hash key to return
+  #          its value.
+  #
+  #          For example: <tt>"-l|--long-name argName"</tt> will recognise both <tt>-l</tt> and
+  #          <tt>--long-name</tt>, and will take an argument.  The key used for the result hash is
+  #          "-l".
+  #          
+  # [desc]   Human readable description of the option.
+  # [params] An optional hash of additional parameters.
+  # 
+  # Allowed additonal parameters are:
+  # [:multiple] Indicates that this option is allowed to occur more than once.  In this case the
+  #             value returned for this option will be an array.
+  # [:default]  The default value if this option is not passed.  Only allowed when the option takes 
+  #             an argument
+  def opt(spec, desc, params = {})
+	words = spec.split(/ /)
+	raise "Bad format for option spec '#{spec}'" unless words.size <= 2
+	arg = words[1]
+	matches = words[0].split(/\|/)
+	default = params.delete(:default)
+	multiple = params.delete(:multiple)
+	raise ArgumentError, "Unknown keyword arguments passed: #{params.keys.join(", ")}" unless 
+	  params.size == 0
+	@optList << OptSpec.new(matches, arg, desc, multiple, default)
+  end
+
+  # Add an argument.
+  #
+  # [spec]   The name of the argument, possibly followed by a quantifier.  The name itself is used
+  #          as the hash key to return the argument's value(s)
+  # [desc]   Human readable description of the argument.
+  # [params] An optional hash of additional parameters.
+  # 
+  # Possible argument quantifiers are:
+  # [?] Indicates that this argument may occur zero or once only
+  # [*] Indicates that this argument may occur zero or more times
+  # [+] Indicates that this argument may occur one or more times
+  #
+  # If no quantifier is given, the argument must occur exactly once.  If an argument can occur more
+  # than once, the value returned for it will be an array of the values passed.
+  #
+  # Allowed keyword arguments are:
+  # [:choice]  An array contating the allowed values of this argument.
+  #
+  # [:match]   An object constraining the values of this argument.  The matching is done with ruby's
+  #            <tt>===</tt> operator, so any object that supports this will work - e.g. a regular
+  #            expression.
+  # [:default] A default value if the argument is not present.
+  def arg(spec, desc, params = {})
+	name = spec.sub(/(\?|\*|\+)$/, "")
+	quant = $1 || ""
+	pred = if params.has_key?(:choice)
+			 choices = params.delete(:choice)
+			 desc += "\n    One of: " + choices.join(' ')
+			 lambda {|x| choices.include?(x) }
+		   elsif params.has_key?(:match)
+			 match = params.delete(:match)
+			 lambda {|x| match === x }
+		   else
+			 nil
+		   end
+	default = params.delete(:default)
+	raise ArgumentError, "Unknown keyword arguments passed: #{params.keys.join(", ")}" unless
+	  params.size == 0
+	@argList << ArgSpec.new(name, quant, desc, pred, default)
+  end
+
+  # Parse the command line arguments given and return a hash where the keys are the names of the
+  # options and arguments and the values are those that have been extracted from the command line.
+  #
+  # Options are parsed first, and may be present in any order.  Option parsing stops when there are
+  # no more optons, or if <tt>"--"</tt> is encountered.
+  # 
+  # The remaining input is parsed as arguments.
+  #
+  # This method raised BadUsageError if the parameters do not conform to the specification given
+  # when the object was created.
+  def parse(args)
+	allSpecs = @optList + @argList
+	allSpecs.each {|spec| spec.init }
+	parse_next_opt(args) while args.size > 0 && args[0] =~ /^-/ && args[0] != '--'
+	args.shift if args[0] == '--'
+	@argPos = 0
+	while args.size > 0 && @argPos < @argList.size do
+	  parse_next_arg(@argList[@argPos], args)
+	  @argPos += 1
+	end
+	raise BadUsageError if args.size > 0  || @argList[@argPos..-1].find {|s| !s.optional }
+	result = {}
+	allSpecs.each {|spec| result[spec.name] = spec.value if spec.value}
+	return result
+  end
+
+  # Generate a usage message explaining the allowed syntax of the command line.
+  def usage_message
+	name = $0 =~ /[^\/]+$/ ? $& : ''
+	usageArgs = @argList.collect{|s| s.name + s.quant }
+	usageArgs.unshift('options*') if @optList.size > 0
+	usageArgs.unshift(name)
+
+	lines = [ "usage: " + usageArgs.join(' ') ]
+	lines += [ "", @summary ] if @summary
+
+	if @optList.size > 0
+	  lines += [ "", "Options:" ] + @optList.map do |opt|
+		line = "  " + opt.matches.join(", ")
+		line += " " + opt.arg if opt.arg
+		line += ": " + opt.desc
+		if opt.default
+		  d = opt.default
+		  d = d.kind_of?(Array) ? d.join(' ') : d.to_s
+		  line += "\n    Default: " + d
+		end
+		line
+	  end
+	end
+
+	if @argList.size > 0
+	  lines += [ "", "Arguments:" ] + @argList.map do |arg|
+		line = "  " + arg.name + ": " + arg.desc
+		if arg.default
+		  d = arg.default
+		  d = d.kind_of?(Array) ? d.join(' ') : d.to_s
+		  line += "\n    Default: " + d
+		end
+		line
+	  end
+	end
+
+	lines.join("\n")
+  end
+
+  # Convenience method to construct an parser object as specified by a block and call its parse
+  # method with the argument array given, or ARGV if it is ommitted.
+  #
+  # If parsing fails, the usage message is displayed on stderr and exit is called.
+  def ParseOpts.run (args = ARGV, &block)
+	parser = ParseOpts.new(&block)
+	begin
+	  parser.parse(args)
+	rescue BadUsageError
+	  $stderr.puts parser.usage_message
+	  exit(1)
+	end
+  end
+
+  private
+
+  def parse_next_opt(args)
+	optSpec = @optList.find {|s| s.match? args } or raise BadUsageError, args[0]
+	optSpec.process(args)
+  end
+
+  def parse_next_arg(argSpec, args)
+	if !argSpec.match? args
+	  raise BadUsageError unless argSpec.optional
+	else
+	  argSpec.process(args)
+	end
+  end
+
+end

data/test/test_parseOpts.rb

@@ -0,0 +1,271 @@
+#!/bin/ruby
+
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require 'runit/testsuite'
+require 'parseOpts'
+
+class ParseOptsTests < RUNIT::TestCase
+
+  def words(string)
+	string.split /\s+/
+  end
+
+  def assert_ok(expected, string)
+	assert_no_exception do
+	  assert_equal(expected, @parser.parse(words(string)))
+	end
+  end
+
+  def assert_bad(string)
+	assert_exception(ParseOpts::BadUsageError) { @parser.parse(words(string)) }
+  end
+
+  def test_empty
+	@parser = ParseOpts.new {}
+	assert_ok({}, '')
+	assert_bad('-x')
+	assert_bad('x')
+  end
+
+  def test_singleOption
+	@parser = ParseOpts.new do
+	  opt '-t', 'test'
+	end
+	assert_ok({}, '')
+	assert_ok({'-t' => true}, '-t')
+	assert_bad('-t bar')
+  end
+
+  def test_optionWithArg
+	@parser = ParseOpts.new do
+	  opt '-t FOO', 'test'
+	end
+	assert_ok({}, '')
+	assert_ok({'-t' => 'bar'}, '-t bar')
+	assert_bad('-t')
+	assert_bad('-t bar baz')
+  end
+
+  def test_multipleSingleOption
+	@parser = ParseOpts.new do
+	  opt '-t', 'test', :multiple => true
+	end
+	assert_ok({'-t' => 0}, '')
+	assert_ok({'-t' => 1}, '-t')
+	assert_ok({'-t' => 2}, '-t -t')
+  end
+
+  def test_multipleOptionWithArg
+	@parser = ParseOpts.new do
+	  opt '-t FOO', 'test', :multiple => true
+	end
+	assert_ok({'-t' => []}, '')
+	assert_ok({'-t' => ['bar']}, '-t bar')
+	assert_ok({'-t' => ['bar', 'baz']}, '-t bar -t baz')
+  end
+
+  def test_altOptions
+	@parser = ParseOpts.new do
+	  opt '-a|--aaa', 'test'
+	  opt '-b|--bbb|--whatever FOO', 'test'
+	end
+	assert_ok({'-a' => true}, '-a')
+	assert_ok({'-a' => true}, '--aaa')
+	assert_ok({'-b' => 'bar'}, '-b bar')
+	assert_ok({'-b' => 'bar'}, '--bbb bar')
+	assert_ok({'-b' => 'baz'}, '--whatever baz')
+  end
+
+  def test_combinationsOfOptions
+	@parser = ParseOpts.new do
+	  opt '-a',     'test'
+	  opt '-b ARG', 'test'
+	  opt '-c',     'test', :multiple => true
+	  opt '-d ARG', 'test', :multiple => true
+	end
+	assert_ok({'-a' => true, '-c' => 0, '-d' => []}, '-a')
+	assert_ok({'-b' => 'foo', '-c' => 0, '-d' => []}, '-b foo')
+	assert_ok({'-c' => 2, '-d' => []}, '-c -c')
+	assert_ok({'-c' => 0, '-d' => ['bar', 'baz']}, '-d bar -d baz')
+
+	expected = {'-a' => true, '-b' => 'foo', '-c' => 2, '-d' => ['bar', 'baz']}
+	assert_ok(expected, '-a -b foo -c -c -d bar -d baz')
+	assert_ok(expected, '-b foo -a -c -c -d bar -d baz')
+	assert_ok(expected, '-c -b foo -a -c -d bar -d baz')
+	assert_ok(expected, '-d bar -c -b foo -a -c -d baz')
+  end
+
+  def test_optionsWithDefaultArgs
+	@parser = ParseOpts.new do
+	  opt '-b ARG', 'test', :default => 'def'
+	  opt '-d ARG', 'test', :multiple => true, :default => ['foo']
+	end
+
+	assert_ok({'-b' => 'def', '-d' => ['foo']}, '')
+	assert_ok({'-b' => 'bar', '-d' => ['baz']}, '-b bar -d baz')
+
+	assert_exception(ArgumentError) { ParseOpts.new { opt '-a', '', :default => 'foo' } }
+  end
+
+  def test_optionsWithDefaultArgs2
+	@parser = ParseOpts.new do
+	  opt '-b ARG', 'test', :default => 13
+	  opt '-d ARG', 'test', :multiple => true, :default => [17]
+	end
+
+	assert_ok({'-b' => 13, '-d' => [17]}, '')
+	assert_ok({'-b' => 'bar', '-d' => ['baz']}, '-b bar -d baz')
+
+	assert_exception(ArgumentError) { ParseOpts.new { opt '-a', '', :default => 'foo' } }
+  end
+
+  def test_argRequired
+	@parser = ParseOpts.new do
+	  arg 'arg', 'test'
+	end
+	assert_bad('')
+	assert_ok({'arg' => 'foo'}, 'foo')
+	assert_bad('foo bar')
+  end
+
+  def test_argOptional
+	@parser = ParseOpts.new do
+	  arg 'arg?', 'test'
+	end
+	assert_ok({}, '')
+	assert_ok({'arg' => 'foo'}, 'foo')
+	assert_bad('foo bar')
+  end
+
+  def test_argZeroOrMore
+	@parser = ParseOpts.new do
+	  arg 'arg*', 'test'
+	end
+	assert_ok({'arg' => []}, '')
+	assert_ok({'arg' => ['foo']}, 'foo')
+	assert_ok({'arg' => ['foo', 'bar']}, 'foo bar')
+  end
+
+  def test_argOneOrMore
+	@parser = ParseOpts.new do
+	  arg 'arg+', 'test'
+	end
+	assert_bad('')
+	assert_ok({'arg' => ['foo']}, 'foo')
+	assert_ok({'arg' => ['foo', 'bar']}, 'foo bar')
+  end
+
+  def test_argRegexpMatch
+	@parser = ParseOpts.new do
+	  arg 'arg', 'test', :match => /^\w-\d$/
+	end
+	assert_ok({'arg' => 'k-9'}, 'k-9')
+	assert_bad('foo')
+  end
+
+  def test_argArrayChoice
+	@parser = ParseOpts.new do
+	  arg 'arg', 'test', :choice => ['foo', 'bar']
+	end
+	assert_ok({'arg' => 'bar'}, 'bar')
+	assert_bad('baz')
+  end
+
+  def test_argsWithDefaults
+	@parser = ParseOpts.new do
+	  arg 'a?', 'test', :default => 'foo'
+	end
+
+	assert_ok({'a' => 'foo'}, '')
+	assert_ok({'a' => 'bar'}, 'bar')
+
+	@parser = ParseOpts.new do
+	  arg 'a*', 'test', :default => ['bar']
+	end
+
+	assert_ok({'a' => ['bar']}, '')
+	assert_ok({'a' => ['foo']}, 'foo')
+
+	assert_exception(ArgumentError) { ParseOpts.new { arg 'a', '', :default => 'foo' } }
+  end
+
+  def test_combinationsOfArgs
+	@parser = ParseOpts.new do
+	  arg 'a',  'test', :match => /^a$/
+	  arg 'b?', 'test', :match => /^b$/
+	  arg 'c*', 'test', :match => /^c$/
+	  arg 'd+', 'test', :match => /^d$/
+	end
+
+	assert_ok({'a' => 'a', 'b' => 'b', 'c' => ['c'], 'd' => ['d']},
+			  'a b c d')
+	assert_ok({'a' => 'a', 'c' => [], 'd' => ['d']},
+			  'a d')
+	assert_ok({'a' => 'a', 'b' => 'b', 'c' => ['c', 'c'], 'd' => ['d', 'd']},
+			  'a b c c d d')
+  end
+
+  def test_optionsAndArgs
+	@parser = ParseOpts.new do
+	  opt '-a',     'test opt a'
+	  opt '-b ARG', 'test opt b'
+	  opt '-c',     'test opt c', :multiple => true
+	  opt '-d ARG', 'test opt d', :multiple => true
+	  arg 'e',  'test arg e', :match => /^e$/
+	  arg 'f?', 'test arg f', :match => /^f$/
+	  arg 'g*', 'test arg g', :match => /^g$/
+	  arg 'h+', 'test arg h', :match => /^h$/
+	end
+	
+	assert_ok({'-a' => true, '-b' => 'foo', '-c' => 2, '-d' => ['bar', 'baz'], 
+				'e' => 'e', 'f' => 'f', 'g' => ['g'], 'h' => ['h']},
+			  '-a -b foo -c -c -d bar -d baz e f g h')
+  end
+
+  def test_usageMessage
+	@parser = ParseOpts.new do
+	  opt '-a',     'test opt a'
+	  opt '-b ARG', 'test opt b', :default => "xxx"
+	  opt '-c|--cc',     'test opt c', :multiple => true
+	  opt '-d|--dd ARG', 'test opt d', :multiple => true, :default => ["yyy", "zzz"]
+	  arg 'e',  'test arg e', :match => /^e$/
+	  arg 'f?', 'test arg f', :match => /^f$/, :default => "aaa"
+	  arg 'g*', 'test arg g', :match => /^g$/, :default => ["bbb", "ccc"]
+	  arg 'h+', 'test arg h', :match => /^h$/
+	end
+
+	expectedUsage = <<END
+usage: rake_test_loader.rb options* e f? g* h+
+
+Options:
+  -a: test opt a
+  -b ARG: test opt b
+    Default: xxx
+  -c, --cc: test opt c
+  -d, --dd ARG: test opt d
+    Default: yyy zzz
+
+Arguments:
+  e: test arg e
+  f: test arg f
+    Default: aaa
+  g: test arg g
+    Default: bbb ccc
+  h: test arg h
+END
+
+	assert_equal(expectedUsage, @parser.usage_message + "\n")
+  end
+
+  def test_run
+	result = ParseOpts.run(['foo']) do
+	  opt '-a',     'test opt a'
+	  arg 'b',  'test arg b'
+	end
+	assert_equal('foo', result.delete('b'))
+	assert_equal({}, result)
+  end
+end
+
+RUNIT::CUI::TestRunner.run(ParseOptsTests.suite)

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: parseOpts
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jon Coppeard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-06 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: jon at coppeard dot net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- CHANGELOG
+- LICENSE
+- lib/parseOpts.rb
+- test/test_parseOpts.rb
+- Rakefile
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: parseOpts
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Library to parse commandline options and arguments
+test_files: 
+- test/test_parseOpts.rb