oyster 0.9.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-07-09
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/oyster.rb
+lib/oyster/specification.rb
+lib/oyster/option.rb
+lib/oyster/options/flag.rb
+lib/oyster/options/string.rb
+lib/oyster/options/integer.rb
+lib/oyster/options/float.rb
+lib/oyster/options/file.rb
+lib/oyster/options/array.rb
+lib/oyster/options/glob.rb
+lib/oyster/options/shortcut.rb
+lib/oyster/options/subcommand.rb
+test/test_oyster.rb

data/README.txt

@@ -0,0 +1,214 @@
+= Oyster
+
+http://github.com/jcoglan/oyster
+
+=== Description
+
+Oyster is a command-line input parser that doesn't hate you. It provides a simple
+API that you use to write a spec for the user interface to your program, and it
+handles mapping the input to a hash for you. It supports both long and short option
+names, subcommands, and various types of input data.
+
+=== Features
+
+* Parses command line options into a hash for easy access
+* Supports long (--example) and short (-e) names, including compound (-zxvf) short options
+* Supports subcommand recognition
+* Can parse options as booleans, strings, arrays, files, globs
+* Automatically handles single-letter shortcuts for option names
+* Allows shortcuts to be specified for common groupings of flags
+* Is easily extensible to support custom input types
+* Automatically outputs man-page-style help for your program
+
+=== Usage
+
+You begin your command-line script by writing a spec for its options, layed out
+like a Unix manual page. This spec will be used to parse input and to generate
+help text using the --help flag. This example demonstrates a wide range of the
+spec API. You can use as much or as little of it as you like, none of the fields
+are required.
+
+  require 'rubygems'
+  require 'oyster'
+  
+  spec = Oyster.spec do
+    name  'myprog -- something to move files around'
+    
+    synopsis <<-EOS
+      myprog [options] --sources SCR --dest DEST
+      myprog [options] --sources SRC --exec SCRIPT
+    EOS
+    
+    description <<-EOS
+      myprog is a command-line utility for moving files around or executing
+      scripts against them. It can be invoked from any directory.
+    EOS
+    
+    flag    :verbose,   :default => false,
+    :desc => 'Print verbose output'
+    
+    flag    :recurse,   :default => true,
+    :desc => 'Enter directories recursively'
+    
+    string  :type,      :default => 'f',
+    :desc => 'Which type of files to move'
+    
+    integer :status,    :default => 200,
+    :desc => 'Tell the program the status code to return'
+    
+    float   :quality,   :default => 0.5,
+    :desc => 'Level of compression loss incurred when copying'
+    
+    glob    :files,     :desc => <<-EOS
+    Pattern for selecting which files to move. For example, to select all the
+    JavaScript files, you might use:
+    
+      --files ./*.js    (this directory)
+      --files **/*.js   (search recursively)
+    EOS
+    
+    array   :sources,   :desc => 'List of files to move'
+    
+    string  :dest,      :desc => 'Location of directory to move to'
+    
+    file    :exec,      :desc => 'File to read script from'
+    
+    notes <<-EOS
+      This program may make destructive changes to your files. Make
+      sure you have a full backup before running any dangerous scripts.
+    EOS
+    
+    author    'James Coglan <jcoglan@nospam.com>'
+    
+    copyright <<-EOS
+      (c) 2008 James Coglan. This program is free software, distributed under
+      the MIT license. You are free to use it for whatever purpose you see fit.
+    EOS
+  end
+
+Having defined your spec, you can use it to parse user input. Input is specified
+as an array of string tokens, and defaults to ARGV. If the program is invoked using
+--help, Oyster will throw a <tt>Oyster::HelpRendered</tt> exception that you can
+use to halt your program if necessary. An example taking input from the command
+line:
+
+  begin; opts = spec.parse
+  rescue Oyster::HelpRendered; exit
+  end
+  
+<tt>spec.parse</tt> will return a <tt>Hash</tt> containing the values of the options
+as specified by the user. For example:
+
+  Input:    --verbose
+  Output:   opts[:verbose] == true
+  
+  Input:    --no-recurse
+  Oupput:   opts[:recurse] == false
+  
+  Input:    --dest /path/to/mydir
+  Output:   opts[:dest] == '/path/to/mydir'
+  
+  Input:    -q 0.7
+  Output:   opts[:quality] == 0.7
+  
+  Input:    --sources foo bar baz -d somewhere
+  Output:   opts[:sources] == ['foo', 'bar', 'baz']
+            opts[:dest] == 'somewhere'
+
+Options specified as +file+ options will take the input and read the contents of
+the specified file. Use this option if you want to take input from files without
+knowing the name of the file itself:
+
+  Input:    --exec myscript.sh
+  Output:   opts[:exec] == '(contents of myscript.sh)'
+
+If you have a +glob+ option, it will expand its input using <tt>Dir.glob</tt>.
+You must quote your input for this to work, otherwise the shell will expand the
+glob before handing it to the Ruby interpreter.
+
+  Input:    -f **/*.rb
+  Output:   ARGV == ['-f', 'foo.rb', 'bar.rb']
+            -- Oyster will call Dir.glob('foo.rb')
+               opts[:files] == ['foo.rb']
+  
+  Input:    -f '**/*.rb'
+  Output:   ARGV == ['-f', '**/*.rb']
+            -- Oyster will call Dir.glob('**/*.rb')
+               opts[:files] == ['foo.rb', 'bar.rb', 'dir/baz.rb', ...]
+
+=== Unclaimed input
+
+Any input tokens not absorbed by one of the option flags will be written to an
+array in <tt>opts[:unclaimed]</tt>:
+
+  Input:    -s foo.rb bar.rb -d /path/to/dir some_arg
+  Output:   opts[:sources] == ['foo.rb', 'bar.rb']
+            opts[:dest] == '/path/to/dir'
+            opts[:unclaimed] == ['some_arg']
+
+=== Subcommands
+
+You can easily create subcommands by nesting specs inside the main one:
+
+  # Main program spec
+  spec = Oyster.spec do
+    # Front matter
+    name    'someprog'
+    
+    # Options
+    flag    :verbose,   :default => true
+    
+    # Subcommand 'add'
+    subcommand :add do
+      name    'someprog-add'
+      flag    :force,   :default => false
+    end
+  end
+
+Subcommand options are stored as a hash inside the main options hash:
+  
+  Input:    --no-verbose
+  Output:   opts == {:verbose => false}
+  
+  Input:    -v add -f
+  Output:   opts == {:verbose => true, :add => {:force => true}}
+  
+  Input:    add --help
+  Output:   prints help for 'add' command only
+
+Beware that you cannot give a subcommand the same name as an option flag,
+otherwise you'll get a name collision in the output.
+
+=== Requirements
+
+* Rubygems
+* Oyster gem
+
+=== Installation
+
+  sudo gem install oyster
+
+=== License
+
+(The MIT License)
+
+Copyright (c) 2008 James Coglan
+
+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/Rakefile

@@ -0,0 +1,11 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/oyster.rb'
+
+Hoe.new('oyster', Oyster::VERSION) do |p|
+  p.developer('James Coglan', 'jcoglan@googlemail.com')
+end
+
+# vim: syntax=Ruby

data/lib/oyster.rb

@@ -0,0 +1,40 @@
+module Oyster
+  VERSION = '0.9.0'
+  
+  LONG_NAME   = /^--([a-z\[][a-z0-9\]\-]+)$/i
+  SHORT_NAME  = /^-([a-z0-9]+)$/i
+  
+  HELP_INDENT = 7
+  HELP_WIDTH  = 72
+  
+  WINDOWS = RUBY_PLATFORM.split('-').any? { |part| part =~ /mswin\d*/i }
+  
+  class HelpRendered < StandardError; end
+  
+  def self.spec(*args, &block)
+    spec = Specification.new
+    spec.instance_eval(&block)
+    spec.flag(:help, :default => false, :desc => 'Displays this help message') unless spec.has_option?(:help)
+    spec
+  end
+  
+  def self.is_name?(string)
+    !string.nil? and !!(string =~ LONG_NAME || string =~ SHORT_NAME || string == '--')
+  end
+end
+
+[ 'specification',
+  'option',
+  'options/flag',
+  'options/string',
+  'options/integer',
+  'options/float',
+  'options/file',
+  'options/array',
+  'options/glob',
+  'options/shortcut',
+  'options/subcommand'
+].each do |file|
+  require File.dirname(__FILE__) + '/oyster/' + file
+end
+

data/lib/oyster/option.rb

@@ -0,0 +1,43 @@
+module Oyster
+  class Option
+    
+    def self.create(type, *args)
+      name = type.to_s.sub(/^(.)/) { |m| m.upcase } + 'Option'
+      klass = Oyster.const_get(name)
+      klass.new(*args)
+    end
+    
+    attr_reader :description
+    
+    def initialize(name, options = {})
+      @names       = [name.to_sym]
+      @description = options[:desc] || ''
+      @settings    = options
+    end
+    
+    def has_name?(name)
+      name && @names.include?(name.to_sym)
+    end
+    
+    def name
+      @names.first
+    end
+    
+    def alternate(name)
+      @names << name.to_sym unless has_name?(name) || name.nil?
+    end
+    
+    def consume(list); end
+    
+    def default_value(value = nil)
+      @settings[:default].nil? ? value : @settings[:default]
+    end
+    
+    def help_names
+      @names.map { |name| name.to_s }.sort.map {
+          |name| (name.size > 1 ? '--' : '-') + name }
+    end
+    
+  end
+end
+

data/lib/oyster/options/array.rb

@@ -0,0 +1,20 @@
+module Oyster
+  class ArrayOption < Option
+    
+    def consume(list)
+      data = []
+      data << list.shift while list.first and !Oyster.is_name?(list.first)
+      data
+    end
+    
+    def default_value
+      super([])
+    end
+    
+    def help_names
+      super.map { |name| name + ' ARG1 [ARG2 [...]]' }
+    end
+    
+  end
+end
+

data/lib/oyster/options/file.rb

@@ -0,0 +1,18 @@
+module Oyster
+  class FileOption < Option
+    
+    def consume(list)
+      File.read(list.shift)
+    end
+    
+    def default_value
+      super(nil)
+    end
+    
+    def help_names
+      super.map { |name| name + ' ARG' }
+    end
+    
+  end
+end
+

data/lib/oyster/options/flag.rb

@@ -0,0 +1,23 @@
+module Oyster
+  class FlagOption < Option
+    
+    def consume(list)
+    end
+    
+    def default_value
+      super(false)
+    end
+    
+    def help_names
+      default_value ?
+          super.map { |name| name.sub(/^--/, '--[no-]') } :
+          super
+    end
+    
+    def description
+      super + (default_value ? ' (This is the default)' : '')
+    end
+    
+  end
+end
+

data/lib/oyster/options/float.rb

@@ -0,0 +1,14 @@
+module Oyster
+  class FloatOption < StringOption
+    
+    def consume(list)
+      super.to_f
+    end
+    
+    def default_value
+      super(0)
+    end
+    
+  end
+end
+

data/lib/oyster/options/glob.rb

@@ -0,0 +1,18 @@
+module Oyster
+  class GlobOption < Option
+    
+    def consume(list)
+      Dir.glob(list.shift)
+    end
+    
+    def default_value
+      super([])
+    end
+    
+    def help_names
+      super.map { |name| name + ' ARG' }
+    end
+    
+  end
+end
+

data/lib/oyster/options/integer.rb

@@ -0,0 +1,14 @@
+module Oyster
+  class IntegerOption < StringOption
+    
+    def consume(list)
+      super.to_i
+    end
+    
+    def default_value
+      super(0)
+    end
+    
+  end
+end
+

data/lib/oyster/options/shortcut.rb

@@ -0,0 +1,20 @@
+module Oyster
+  class ShortcutOption < Option
+    
+    def initialize(name, expansion, options = {})
+      super(name, options)
+      @expansion = expansion.split(/\s+/).reverse
+    end
+    
+    def consume(list)
+      @expansion.each { |e| list.unshift(e) }
+      nil
+    end
+    
+    def description
+      "Same as '#{@expansion.reverse.join(' ')}'"
+    end
+    
+  end
+end
+

data/lib/oyster/options/string.rb

@@ -0,0 +1,18 @@
+module Oyster
+  class StringOption < Option
+    
+    def consume(list)
+      list.shift
+    end
+    
+    def default_value(value = nil)
+      super(value || nil)
+    end
+    
+    def help_names
+      super.map { |name| name + ' ARG' }
+    end
+    
+  end
+end
+

data/lib/oyster/options/subcommand.rb

@@ -0,0 +1,21 @@
+module Oyster
+  class SubcommandOption < Option
+    
+    def initialize(name, spec)
+      super(name)
+      @spec = spec
+    end
+    
+    def consume(list)
+      output = @spec.parse(list)
+      list.clear
+      output
+    end
+    
+    def parse(*args)
+      @spec.parse(*args)
+    end
+    
+  end
+end
+

data/lib/oyster/specification.rb

@@ -0,0 +1,170 @@
+module Oyster
+  class Specification
+    
+    include Enumerable
+    
+    def initialize
+      @options     = []
+      @subcommands = []
+      @data        = {}
+    end
+    
+    def each(&block)
+      @options.sort_by { |o| o.name.to_s }.each(&block)
+    end
+    
+    def method_missing(*args)
+      opt = Option.create(*args)
+      raise "Option name '#{opt.name}' is already used" if has_option?(opt.name)
+      opt.alternate(shorthand_for(opt.name))
+      @options << opt
+    rescue
+      name, value = args[0..1]
+      @data[name.to_sym] = value.to_s
+    end
+    
+    def subcommand(name, &block)
+      opt = SubcommandOption.new(name, Oyster.spec(&block))
+      raise "Subcommand name '#{opt.name}' is already used" if has_command?(name)
+      @subcommands << opt
+    end
+    
+    def has_option?(name)
+      !self[name].nil?
+    end
+    
+    def has_command?(name)
+      !command(name).nil?
+    end
+    
+    def command(name)
+      @subcommands.each do |command|
+        return command if command.has_name?(name)
+      end
+      nil
+    end
+    
+    def parse(input = ARGV)
+      input = input.dup
+      output = {:unclaimed => []}
+      
+      while token = input.shift
+        if token == '--'
+          output[:unclaimed] = output[:unclaimed] + input
+          break
+        end
+        
+        option = command(token)
+        
+        long, short = token.scan(LONG_NAME), token.scan(SHORT_NAME)
+        long, short = [long, short].map { |s| s.flatten.first }
+        
+        input = short.scan(/./).map { |s| "-#{s}" } + input and next if short and short.size > 1
+        
+        negative = !!(long && long =~ /^no-/)
+        long.sub!(/^no-/, '') if negative
+        
+        option ||= self[long] || self[short]
+        output[:unclaimed] << token and next unless option
+        
+        output[option.name] = option.is_a?(FlagOption) ? !negative : option.consume(input)
+      end
+      
+      @options.each do |option|
+        next unless output[option.name].nil?
+        output[option.name] ||= option.default_value
+      end
+      
+      help and raise HelpRendered if output[:help]
+      output
+    end
+    
+  private
+    
+    def [](name)
+      @options.each do |opt|
+        return opt if opt.has_name?(name)
+      end
+      nil
+    end
+    
+    def shorthand_for(name)
+      initial = name.to_s.scan(/^./).first.downcase
+      initial.upcase! if has_option?(initial)
+      return nil if has_option?(initial)
+      initial
+    end
+    
+    def help
+      display(@data[:name],         1, 'NAME')
+      display(@data[:synopsis],     1, 'SYNOPSIS', false, true)
+      display(@data[:description],  1, 'DESCRIPTION')
+      puts "\n#{ bold }OPTIONS#{ normal }"
+      each do |option|
+        display(option.help_names.join(', '), 1, nil, false, true)
+        display(option.description, 2)
+        puts "\n"
+      end
+      display(@data[:notes],        1, 'NOTES')
+      display(@data[:author],       1, 'AUTHOR')
+      display(@data[:copyright],    1, 'COPYRIGHT')
+      self
+    end
+    
+    def display(text, level = 1, title = nil, join = true, man = false)
+      return unless text
+      puts "\n" + format("#{ bold }#{ title }#{ normal }", level - 1) if title
+      text = man_format(text) if man
+      puts format(text, level, join)
+    end
+    
+    def format(text, level = 1, join = true)
+      lines   = text.split(/\n/)
+      outdent = lines.inject(1000) { |n,s| [s.scan(/^\s*/).first.size, n].min }
+      indent  = level * HELP_INDENT
+      width   = HELP_WIDTH - indent
+      
+      lines.map { |line|
+        line.sub(/\s*$/, '').sub(%r{^\s{#{outdent}}}, '')
+      }.inject(['']) { |groups, line|
+        groups << '' if line.empty? && !groups.last.empty?
+        buffer = groups.last
+        buffer << (line =~ /^\s+/ || !join ? "\n" : " ") unless buffer.empty?
+        buffer << line
+        groups
+      }.map { |buffer|
+        lines = (buffer =~ /\n/) ?
+            buffer.split(/\n/) :
+            buffer.scan(%r{((?:.(?:\e\[\dm)*){1,#{width}}\S*)\s*}).flatten
+        lines.map { |l| (' ' * indent) + l }.join("\n")
+      }.join("\n\n")
+    end
+    
+    def man_format(text)
+      text.split(/\n/).map { |line|
+        " #{line}".scan(/(.+?)([a-z0-9\-\_]*)/i).flatten.map { |token|
+          formatter = case true
+            when Oyster.is_name?(token)                      :  bold
+            when token =~ /[A-Z]/ && token.upcase == token   :  underline
+            when token =~ /[a-z]/ && token.downcase == token :  bold
+          end
+          formatter ? "#{ formatter }#{ token }#{ normal }" : token
+        }.join('')
+      }.join("\n")
+    end
+    
+    def bold
+      WINDOWS ? "" : "\e[1m"
+    end
+    
+    def underline
+      WINDOWS ? "" : "\e[4m"
+    end
+    
+    def normal
+      WINDOWS ? "" : "\e[0m"
+    end
+    
+  end
+end
+

data/test/test_oyster.rb

@@ -0,0 +1,195 @@
+require 'test/unit'
+require 'oyster'
+
+class OysterTest < Test::Unit::TestCase
+  
+  def setup
+    @spec = Oyster.spec do
+      name      'oyster'
+      synopsis <<-EOS
+      oyster [OPTIONS] filename
+      oyster [-e PATTERN] file1 [, file2 [, file3 [, ...]]]
+      EOS
+      description <<-EOS
+      Oyster is a Ruby command-line option parser that doesn't hate you. It lets
+      you specify options using a simple DSL and parses user input into a hash to
+      match the options your program accepts.
+      
+        class Foo < Option
+          def consume(list); end
+        end
+      
+      Nothing to see here.
+      EOS
+      
+      flag    :verbose, :default => true,  :desc => 'Print verbose output'
+      flag    :all,     :default => false, :desc => 'Include all files?'
+      
+      shortcut :woop,   '--verbose --all --files'
+      
+      string  :k,       :default => 'Its short', :desc => 'Just a little string'
+      
+      string  :user
+      
+      string  :binary,  :default => 'ruby', :desc => <<-EOS
+      Which binary to use. You can change the executable used to format the output
+      of this command, setting it to your scripting language of choice. This is just
+      a lot of text to make sure help formatting works.
+      EOS
+      
+      integer :status,    :default => 200,
+      :desc => 'Tell the program the status code to return'
+      
+      float   :quality,   :default => 0.5,
+      :desc => 'Level of compression loss incurred when copying'
+      
+      array   :files, :desc => 'The files you want to process'
+      
+      file    :path,  :desc => 'Path to read program input from'
+      
+      notes <<-EOS
+      This program is free software, distributed under the MIT license.
+      EOS
+      
+      author 'James Coglan <jcoglan@googlemail.com>'
+      
+      subcommand :add do
+        name 'oyster-add'
+        synopsis <<-EOS
+        oyster add [--squash] file1 [file2 [...]]
+        EOS
+        description <<-EOS
+        oyster-add is a subcommand of oyster. This text is here
+        to test subcommand recognition so it probably doesn't
+        matter much what it says, as long it's long enough to
+        wrap to a few lines and it lets us tell commands apart.
+        EOS
+        
+        glob :filelist
+        
+        flag :squash, :desc => 'Squashes all the files into one string'
+        
+        subcommand :nothing do
+          flag  :something
+        end
+      end
+    end
+  end
+  
+  def test_help
+    @spec.parse %w(--help)
+  rescue Oyster::HelpRendered
+  end
+  
+  def test_dash_length
+    opts = @spec.parse %w(-user me)
+    assert_equal '-s', opts[:user]
+    opts = @spec.parse %w(--u me)
+    assert_equal nil, opts[:user]
+  end
+  
+  def test_flags
+    opts = @spec.parse %w(myfile.txt)
+    assert_equal true, opts[:verbose]
+    opts = @spec.parse %w(myfile.txt --verbose)
+    assert_equal true, opts[:verbose]
+    assert_equal 'myfile.txt', opts[:unclaimed].first
+    opts = @spec.parse %w(myfile.text -v)
+    assert_equal true, opts[:verbose]
+    opts = @spec.parse %w(--no-verbose)
+    assert_equal false, opts[:verbose]
+    
+    assert_equal false, opts[:help]
+  end
+  
+  def test_shorthand_flags
+    opts = @spec.parse %w(something -vau jcoglan)
+    assert_equal true, opts[:verbose]
+    assert_equal true, opts[:all]
+    assert_equal 'jcoglan', opts[:user]
+  end
+  
+  def test_shortcuts
+    opts = @spec.parse %w(-u little-old-me --woop help.txt cmd.rb)
+    assert_equal 'little-old-me', opts[:user]
+    assert_equal true, opts[:verbose]
+    assert_equal true, opts[:all]
+    assert_equal 'help.txt, cmd.rb', opts[:files].join(', ')
+  end
+  
+  def test_strings
+    opts = @spec.parse %w(-v --user jcoglan something)
+    assert_equal 'jcoglan', opts[:user]
+    assert_equal 'something', opts[:unclaimed].first
+    opts = @spec.parse %w(-v)
+    assert_equal nil, opts[:user]
+    opts = @spec.parse ['-u', "My name is"]
+    assert_equal 'My name is', opts[:user]
+    
+    opts = @spec.parse %w(-b)
+    assert_equal 'ruby', opts[:binary]
+    opts = @spec.parse %w(--binary some_other_prog)
+    assert_equal 'some_other_prog', opts[:binary]
+  end
+  
+  def test_single_letter_option
+    opts = @spec.parse %w(-k so-whats-up)
+    assert_equal 'so-whats-up', opts[:k]
+  end
+  
+  def test_string_with_flag
+    opts = @spec.parse %w(the first --user is -v)
+    assert_equal 'the, first', opts[:unclaimed].join(', ')
+    assert_equal 'is', opts[:user]
+    assert_equal true, opts[:verbose]
+  end
+  
+  def test_numerics
+    opts = @spec.parse %w(-q 0.99 --status 20.4)
+    assert_equal 0.99, opts[:quality]
+    assert Float === opts[:quality]
+    assert_equal 20, opts[:status]
+    assert Integer === opts[:status]
+  end
+  
+  def test_array
+    opts = @spec.parse %w(--files foo bar baz -u jcoglan)
+    assert_equal 'foo, bar, baz', opts[:files].join(', ')
+    assert_equal 'jcoglan', opts[:user]
+    opts = @spec.parse %w(--files foo bar baz)
+    assert_equal 'foo, bar, baz', opts[:files].join(', ')
+  end
+  
+  def test_stop_parsing
+    opts = @spec.parse %w(--files something.txt my.rb -- some more args)
+    assert_equal 'something.txt, my.rb', opts[:files].join(', ')
+    assert_equal 'some more args', opts[:unclaimed].join(' ')
+  end
+  
+  def test_globs
+    opts = @spec.parse %w(add --filelist ./*.txt)
+    assert_equal './History.txt, ./Manifest.txt, ./README.txt', opts[:add][:filelist].sort.join(', ')
+  end
+  
+  def test_subcommands
+    opts = @spec.parse %w(-v add --help)
+  rescue Oyster::HelpRendered
+    opts = @spec.parse %w(-v --user someguy thingy add -s arg1 arg2)
+    assert_equal true, opts[:verbose]
+    assert_equal 'someguy', opts[:user]
+    assert_equal 'thingy', opts[:unclaimed].join(', ')
+    assert_equal true, opts[:add][:squash]
+    assert_equal 'arg1, arg2', opts[:add][:unclaimed].join(', ')
+    opts = @spec.parse %w(-v add nothing -s)
+    assert_equal true, opts[:verbose]
+    assert_equal false, opts[:add][:squash]
+    assert_equal true, opts[:add][:nothing][:something]
+  end
+  
+  def test_file
+    opts = @spec.parse %w(--path Rakefile)
+    assert opts[:path] =~ /Oyster::VERSION/
+  end
+  
+end
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: oyster
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- James Coglan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: Oyster is a command-line input parser that doesn't hate you. It provides a simple API that you use to write a spec for the user interface to your program, and it handles mapping the input to a hash for you. It supports both long and short option names, subcommands, and various types of input data.
+email: 
+- jcoglan@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/oyster.rb
+- lib/oyster/specification.rb
+- lib/oyster/option.rb
+- lib/oyster/options/flag.rb
+- lib/oyster/options/string.rb
+- lib/oyster/options/integer.rb
+- lib/oyster/options/float.rb
+- lib/oyster/options/file.rb
+- lib/oyster/options/array.rb
+- lib/oyster/options/glob.rb
+- lib/oyster/options/shortcut.rb
+- lib/oyster/options/subcommand.rb
+- test/test_oyster.rb
+has_rdoc: true
+homepage: http://github.com/jcoglan/oyster
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: oyster
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Oyster is a command-line input parser that doesn't hate you
+test_files: 
+- test/test_oyster.rb