trollop 1.0

data/FAQ.txt

@@ -0,0 +1,31 @@
+Trollop FAQ
+-----------
+
+Q: Whither Trollop?
+A: There are more than a few pre-existing commandline argument
+   processing libraries for Ruby. I was never too happy with any of
+   them. They all seemed to want me to type way too much for what I
+   wanted to get done. I just wanted to parse some options and be
+   done with it.
+
+Q: Whither "Trollop"?
+A: No reason. Just thought it sounded funny.
+
+Q: Why does Trollop disallow numeric short argument names, like '-1'
+   and '-9'?
+A: Because it's ambiguous whether these are arguments or negative
+   integer or floating-point parameters to arguments. E.g., what
+   about "-f -3". Is that a negative three parameter to -f, or two
+   separate parameters? 
+
+   I could be very clever and detect when there are no arguments
+   that require floating-point parameters, and allow such short option
+   names in those cases, but I'd rather be simple and consistent.
+
+Q: Why does Trollop disallow options appearing multiple times, despite
+   the POSIX standard allowing it?
+A: Because basically I think it's confusing, and more often than
+   not, a symptom of you making a mistake (e.g. getting lost in a long
+   command line and accidentally setting the same thing twice.)  Given
+   that, I really don't see that much advantage to "-vvvvv" over "-v
+   5", so Trollop will produce an error if it happens.

data/History.txt

@@ -0,0 +1,2 @@
+== 1.0 / 2007-01-29
+* Initial release.

data/Manifest.txt

@@ -0,0 +1,7 @@
+FAQ.txt
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/trollop.rb
+test/test_trollop.rb

data/README.txt

@@ -0,0 +1,73 @@
+== trollop
+
+by William Morgan <wmorgan-trollop@masanjin.net>
+
+http://trollop.rubyforge.org
+
+== DESCRIPTION:
+
+Trollop is YAFCLAP --- yet another fine commandline argument
+processing library for Ruby. Trollop is designed to provide the
+maximal amount of GNU-style argument processing in the minimum number
+of lines of code (for you, the programmer).
+
+Trollop provides a nice automatically-generated help page, robust
+option parsing, and sensible defaults for everything you don't
+specify.
+
+Trollop: getting you 90% of the way there with only 10% of the effort.
+
+== FEATURES/PROBLEMS:
+
+- Simple usage.
+- Sensible defaults. No tweaking necessary, much tweaking possible.
+- Support for long options, short options, short option bundling,
+  and automatic type validation and conversion.
+- Automatic help message generation, wrapped to current screen width.
+- Lots of unit tests.
+
+== SYNOPSIS:
+
+  ###### simple ######
+
+  opts = Trollop::options do
+    opt :monkey, "Use monkey mode."
+    opt :goat, "Use goat model", :default => true
+    opt :num_limbs, "Set number of limbs", :default => 4
+  end
+
+  p opts
+
+  ###### complex ######
+
+  opts = Trollop::options do
+    version "test 1.2.3 (c) 2007 William Morgan"
+    banner <<-EOS
+  Test is an awesome program that does something very, very important.
+
+  Usage:
+         test [options] <filenames>+
+  where [options] are:
+  EOS
+
+    opt :ignore, "Ignore incorrect values"
+    opt :file, "Extra data filename to read in, with a very long option description like this one", :type => String
+    opt :volume, "Volume level", :default => 3.0
+    opt :iters, "Number of iterations", :default => 5
+  end
+  Trollop::die :volume, "must be non-negative" if opts[:volume] < 0
+  Trollop::die :file, "must exist" unless File.exists?(opts[:file]) if opts[:file]
+
+== REQUIREMENTS:
+
+* none
+
+== INSTALL:
+
+* gem install trollop
+
+== LICENSE:
+
+Copyright (c) 2007 William Morgan.
+
+Trollop is distributed under the same terms as Ruby.

data/Rakefile

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'trollop'
+
+Hoe.new('trollop', Trollop::VERSION) do |p|
+  p.rubyforge_name = 'trollop'
+  p.author = "William Morgan"
+  p.summary = "Trollop is YAFCLAP --- yet another fine commandline argument processing library for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer)."
+
+  p.description = p.paragraphs_of('README.txt', 4..5, 9..18).join("\n\n").gsub(/== SYNOPSIS/, "Synopsis")
+  p.url = "http://trollop.rubyforge.org"
+  p.changes = p.paragraphs_of('History.txt', 0..0).join("\n\n")
+  p.email = "wmorgan-trollop@masanjin.net"
+end
+
+## is there really no way to make a rule for this?
+WWW_FILES = %w(www/index.html README.txt FAQ.txt)
+
+task :upload_webpage => WWW_FILES do |t|
+  sh "scp -C #{t.prerequisites * ' '} wmorgan@rubyforge.org:/var/www/gforge-projects/trollop/"
+end
+
+# vim: syntax=Ruby

data/lib/trollop.rb

@@ -0,0 +1,392 @@
+## lib/trollop.rb -- trollop command-line processing library
+## Author::    William Morgan (mailto: wmorgan-trollop@masanjin.net)
+## Copyright:: Copyright 2007 William Morgan
+## License::   GNU GPL version 2
+
+module Trollop
+
+VERSION = "1.0"
+
+## Thrown by Parser in the event of a commandline error. Not needed if
+## you're using the Trollop::options entry.
+class CommandlineError < StandardError; end
+  
+## Thrown by Parser if the user passes in '-h' or '--help'. Handled
+## automatically by Trollop#options.
+class HelpNeeded < StandardError; end
+
+## Thrown by Parser if the user passes in '-h' or '--version'. Handled
+## automatically by Trollop#options.
+class VersionNeeded < StandardError; end
+
+## Regex for floating point numbers
+FLOAT_RE = /^-?((\d+(\.\d+)?)|(\.\d+))$/
+
+## Regex for parameters
+PARAM_RE = /^-(-|\.$|[^\d\.])/
+
+## The commandline parser. In typical usage, the methods in this class
+## will be handled internally by Trollop#options, in which case only
+## the methods #opt, #banner and #version will be called.
+class Parser
+  ## The set of values specifiable as the :type parameter to #opt.
+  TYPES = [:flag, :boolean, :bool, :int, :integer, :string, :double, :float]
+
+  ## The values from the commandline that were not interpreted by #parse.
+  attr_reader :leftovers
+
+  ## The complete configuration hashes for each option. (Mainly useful
+  ## for testing.)
+  attr_reader :specs
+
+  ## Initializes the parser, and instance-evaluates any block given.
+  def initialize &b
+    @version = nil
+    @banner = nil
+    @leftovers = []
+    @specs = {}
+    @long = {}
+    @short = {}
+
+    opt :help, "Show this message"
+    instance_eval(&b) if b
+  end
+
+  ## Add an option. 'name' is the argument name, a unique identifier
+  ## for the option that you will use internally. 'desc' a string
+  ## description which will be displayed in help messages. Takes the
+  ## following optional arguments:
+  ##
+  ## * :long: Specify the long form of the argument, i.e. the form
+  ##   with two dashes. If unspecified, will be automatically derived
+  ##   based on the argument name.
+  ## * :short: Specify the short form of the argument, i.e. the form
+  ##   with one dash. If unspecified, will be automatically derived
+  ##   based on the argument name.
+  ## * :type: Require that the argument take a parameter of type
+  ##   'type'. Can by any member of the TYPES constant or a
+  ##   corresponding class (e.g. Integer for :int). If unset, the
+  ##   default argument type is :flag, meaning the argument does not
+  ##   take a parameter. Not necessary if :default: is specified.
+  ## * :default: Set the default value for an argument. Without a
+  ##   default value, the hash returned by #parse (and thus
+  ##   Trollop#options) will not contain the argument unless it is
+  ##   given on the commandline. The argument type is derived
+  ##   automatically from the class of the default value given, if
+  ##   any. Specifying a :flag argument on the commandline whose
+  ##   default value is true will change its value to false.
+  ## * :required: if set to true, the argument must be provided on the
+  ##   commandline.
+  def opt name, desc="", opts={}
+    raise ArgumentError, "you already have an argument named #{name.inspect}" if @specs.member? name
+
+    ## fill in :type
+    opts[:type] = 
+      case opts[:type]
+      when :flag, :boolean, :bool: :flag
+      when :int, :integer: :int
+      when :string: :string
+      when :double, :float: :float
+      when Class
+        case opts[:type].to_s # sigh... there must be a better way to do this
+        when 'TrueClass', 'FalseClass': :flag
+        when 'String': :string
+        when 'Integer': :int
+        when 'Float': :float
+        else
+          raise ArgumentError, "unsupported argument type '#{opts[:type].class.name}'"
+        end
+      when nil: nil
+      else
+        raise ArgumentError, "unsupported argument type '#{opts[:type]}'" unless TYPES.include?(opts[:type])
+      end
+
+    type_from_default =
+      case opts[:default]
+      when Integer: :int
+      when Numeric: :float
+      when TrueClass, FalseClass: :flag
+      when String: :string
+      when nil: nil
+      else
+        raise ArgumentError, "unsupported argument type '#{opts[:default].class.name}'"
+      end
+
+    raise ArgumentError, ":type specification and default type don't match" if opts[:type] && type_from_default && opts[:type] != type_from_default
+
+    opts[:type] = (opts[:type] || type_from_default || :flag)
+
+    ## fill in :long
+    opts[:long] = opts[:long] ? opts[:long].to_s : name.to_s.gsub("_", "-")
+    opts[:long] =
+      case opts[:long]
+      when /^--([^-].*)$/
+        $1
+      when /^[^-]/
+        opts[:long]
+      else
+        raise ArgumentError, "invalid long option name #{opts[:long].inspect}"
+      end
+    raise ArgumentError, "long option name #{opts[:long].inspect} is already taken; please specify a (different) :long" if @long[opts[:long]]
+
+    ## fill in :short
+    opts[:short] = opts[:short].to_s if opts[:short]
+    opts[:short] =
+      case opts[:short]
+      when nil
+        opts[:long].split(//).find { |c| c !~ /[\d]/ && !@short.member?(c) }
+      when /^-(.)$/
+        $1
+      when /^.$/
+        opts[:short]
+      else
+        raise ArgumentError, "invalid short option name #{opts[:long].inspect}"
+      end
+    raise ArgumentError, "can't generate a short option name (out of characters)" unless opts[:short]
+    raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
+    raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ /[\d-]/
+
+    ## fill in :default for flags
+    opts[:default] = false if opts[:type] == :flag && opts[:default].nil?
+
+    opts[:desc] ||= desc
+    @short[opts[:short]] = @long[opts[:long]] = name
+    @specs[name] = opts
+  end
+
+  ## Sets the version string. If set, the user can request the version
+  ## on the commandline. Should be of the form "<program name>
+  ## <version number>".
+  def version s=nil;
+    if s
+      @version = s
+      opt :version, "Print version and exit"
+    end
+    @version
+  end
+
+  ## Sets the banner. If set, this will be printed at the top of the
+  ## help display.
+  def banner s=nil; @banner = s if s; @banner end
+
+  ## yield successive arg, parameter pairs
+  def each_arg args # :nodoc:
+    remains = []
+    i = 0
+
+    until i >= args.length
+      case args[i]
+      when /^--$/ # arg terminator
+        remains += args[(i + 1) .. -1]
+        break
+      when /^--(\S+?)=(\S+)$/ # long argument with equals
+        yield "--#{$1}", $2
+        i += 1
+      when /^--(\S+)$/ # long argument
+        if args[i + 1] && args[i + 1] !~ PARAM_RE
+          remains << args[i + 1] unless yield args[i], args[i + 1]
+          i += 2
+        else # long argument no parameter
+          yield args[i], nil
+          i += 1
+        end
+      when /^-(\S+)$/ # one or more short arguments
+        shortargs = $1.split(//)
+        shortargs.each_with_index do |a, j|
+          if j == (shortargs.length - 1) && args[i + 1] && args[i + 1] !~ PARAM_RE
+            remains << args[i + 1] unless yield "-#{a}", args[i + 1]
+            i += 1 # once more below
+          else
+            yield "-#{a}", nil
+          end
+        end
+        i += 1
+      else
+        remains << args[i]
+        i += 1
+      end
+    end
+    remains
+  end
+
+  def parse args #:nodoc:
+    vals = {}
+    required = {}
+    found = {}
+
+    @specs.each do |name, opts|
+      required[name] = true if opts[:required]
+      vals[name] = opts[:default]
+    end
+
+    @leftovers = each_arg args do |arg, param|
+      raise VersionNeeded if @version && %w(-v --version).include?(arg)
+      raise HelpNeeded if %w(-h --help).include?(arg)
+
+      name = 
+        case arg
+        when /^-([^-])$/
+          @short[$1]
+        when /^--([^-]\S*)$/
+          @long[$1]
+        else
+          raise CommandlineError, "invalid argument syntax: '#{arg}'"
+        end
+      raise CommandlineError, "unknown argument '#{arg}'" unless name
+      raise CommandlineError, "option '#{arg}' specified multiple times" if found[name]
+
+      found[name] = true
+      opts = @specs[name]
+
+      case opts[:type]
+      when :flag
+        vals[name] = !opts[:default]
+        false
+      when :int
+        raise CommandlineError, "option '#{arg}' needs a parameter" unless param
+        raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
+        vals[name] = param.to_i
+        true
+      when :float
+        raise CommandlineError, "option '#{arg}' needs a parameter" unless param
+        raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
+        vals[name] = param.to_f
+        true
+      when :string
+        raise CommandlineError, "option '#{arg}' needs a parameter" unless param
+        vals[name] = param
+        true
+      end
+    end
+
+    raise CommandlineError, "option '#{required.keys.first}' must be specified" if required.any? { |name, x| !found[name] }
+    vals
+  end
+
+  def width #:nodoc:
+    @width ||= 
+      begin
+        require 'curses'
+        Curses::init_screen
+        x = Curses::cols
+        Curses::close_screen
+        x
+      rescue Exception
+        80
+      end
+  end
+
+  ## Print the help message to 'stream'.
+  def educate stream=$stdout
+    width # just calculate it now; otherwise we have to be careful not to
+          # call this unless the cursor's at the beginning of a line.
+    if @banner
+      stream.puts wrap(@banner)
+    elsif @version
+      stream.puts
+      stream.puts @version
+    end
+
+    unless @banner
+      stream.puts "Options: "
+    end
+
+    specs = @long.keys.sort.map { |longname| @specs[@long[longname]] }
+    leftcols = specs.map { |spec| "--#{spec[:long]}, -#{spec[:short]}" }
+    leftcol_width = leftcols.map { |s| s.length }.max
+    rightcol_start = leftcol_width + 6 # spaces
+    specs.each_with_index do |spec, i|
+      stream.printf("  %#{leftcol_width}s:   ", leftcols[i]);
+      desc = spec[:desc] + 
+        if spec[:default]
+          if spec[:desc] =~ /\.$/
+            " (Default: #{spec[:default]})"
+          else
+            " (default: #{spec[:default]})"
+          end
+        else
+          ""
+        end
+      stream.puts wrap(desc, :width => width - rightcol_start, :prefix => rightcol_start)
+    end
+  end
+
+  def wrap_line str, opts={} # :nodoc:
+    prefix = opts[:prefix] || 0
+    width = opts[:width] || self.width
+    start = 0
+    ret = []
+    until start > str.length
+      nextt = 
+        if start + width >= str.length
+          str.length
+        else
+          x = str.rindex(/\s/, start + width)
+          x = str.index(/\s/, start) if x && x < start
+          x || str.length
+        end
+      ret << (ret.empty? ? "" : " " * prefix) + str[start ... nextt]
+      start = nextt + 1
+    end
+    ret
+  end
+
+  def wrap str, opts={} # :nodoc:
+    if str == ""
+      [""]
+    else
+      str.split("\n").map { |s| wrap_line s, opts }.flatten
+    end
+  end
+end
+
+## The top-level entry method into Trollop. Creates a Parser object,
+## passes the block to it, then parses ARGV with it, handling any
+## errors or requests for help or version information appropriately
+## (and then exiting). Modifies ARGV in place. Returns a hash of
+## option values.
+##
+## The block passed in should contain one or more calls to #opt
+## (Parser#opt), and optionally a call to banner (Parser#banner)
+## and a call to version (Parser#version).
+##
+## See the synopsis in README.txt for examples.
+def options &b
+  @p = Parser.new(&b)
+  begin
+    vals = @p.parse ARGV
+    ARGV.clear
+    @p.leftovers.each { |l| ARGV << l }
+    vals
+  rescue CommandlineError => e
+    $stderr.puts "Error: #{e.message}."
+    $stderr.puts "Try --help for help."
+    exit(-1)
+  rescue HelpNeeded
+    @p.educate
+    exit
+  rescue VersionNeeded
+    puts @p.version
+    exit
+  end
+end
+
+## Informs the user that their usage of 'arg' was wrong, as detailed by
+## 'msg', and dies. Example:
+##
+##   options do
+##     opt :volume, :default => 0.0
+##   end
+##
+##   die :volume, "too loud" if opts[:volume] > 10.0
+##   die :volume, "too soft" if opts[:volume] < 0.1
+
+def die arg, msg
+  $stderr.puts "Error: parameter for option '--#{@p.specs[arg][:long]}' or '-#{@p.specs[arg][:short]}' #{msg}."
+  $stderr.puts "Try --help for help."
+  exit(-1)
+end
+
+module_function :options, :die
+
+end # module

data/test/test_trollop.rb

@@ -0,0 +1,300 @@
+## test/test_trollop.rb -- unit tests for trollop
+## Author::    William Morgan (mailto: wmorgan-trollop@masanjin.net)
+## Copyright:: Copyright 2007 William Morgan
+## License::   GNU GPL version 2
+
+require 'test/unit'
+require 'yaml'
+require 'trollop'
+
+module Trollop
+module Test
+
+class Trollop < ::Test::Unit::TestCase
+  def setup
+    @p = Parser.new
+  end
+
+  def test_unknown_arguments
+    assert_raise(CommandlineError) { @p.parse(%w(--arg)) }
+    @p.opt "arg", "desc"
+    assert_nothing_raised { @p.parse(%w(--arg)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--arg2)) }
+  end
+
+  def test_syntax_check
+    @p.opt "arg", "desc"
+
+    assert_nothing_raised { @p.parse(%w(--arg)) }
+    assert_nothing_raised { @p.parse(%w(arg)) }
+    assert_raise(CommandlineError) { @p.parse(%w(---arg)) }
+    assert_raise(CommandlineError) { @p.parse(%w(-arg)) }
+  end
+
+  def test_required_flags_are_required
+    @p.opt "arg", "desc", :required => true
+    @p.opt "arg2", "desc", :required => false
+    @p.opt "arg3", "desc", :required => false
+
+    assert_nothing_raised { @p.parse(%w(--arg)) }
+    assert_nothing_raised { @p.parse(%w(--arg --arg2)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--arg2)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--arg2 --arg3)) }
+  end
+  
+  ## flags that take an argument error unless given one
+  def test_argflags_demand_args
+    @p.opt "goodarg", "desc", :type => String
+    @p.opt "goodarg2", "desc", :type => String
+
+    assert_nothing_raised { @p.parse(%w(--goodarg goat)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--goodarg --goodarg2 goat)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--goodarg)) }
+  end
+
+  ## flags that don't take arguments ignore them
+  def test_arglessflags_refuse_args
+    @p.opt "goodarg", "desc"
+    @p.opt "goodarg2", "desc"
+    assert_nothing_raised { @p.parse(%w(--goodarg)) }
+    assert_nothing_raised { @p.parse(%w(--goodarg --goodarg2)) }
+    opts = @p.parse %w(--goodarg a)
+    assert_equal true, opts["goodarg"]
+    assert_equal ["a"], @p.leftovers
+  end
+
+  ## flags that require args of a specific type refuse args of other
+  ## types
+  def test_typed_args_refuse_args_of_other_types
+    assert_nothing_raised { @p.opt "goodarg", "desc", :type => :int }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :type => :asdf }
+
+    assert_nothing_raised { @p.parse(%w(--goodarg 3)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--goodarg 4.2)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--goodarg hello)) }
+  end
+
+  ## type is correctly derived from :default
+  def test_type_correctly_derived_from_default
+    assert_nothing_raised { @p.opt "goodarg", "desc", :default => 0 }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :default => [] }
+
+    assert_nothing_raised { @p.parse(%w(--goodarg 3)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--goodarg 4.2)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--goodarg hello)) }
+  end    
+
+  ## :type and :default must match if both are specified
+  def test_type_and_default_must_match
+    assert_nothing_raised { @p.opt "goodarg", "desc", :type => :int, :default => 4 }
+    assert_nothing_raised { @p.opt "goodarg2", "desc", :type => :string, :default => "yo" }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :type => :int, :default => "hello" }
+    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => 4 }
+  end
+
+  def test_long_detects_bad_names
+    assert_nothing_raised { @p.opt "goodarg", "desc", :long => "none" }
+    assert_nothing_raised { @p.opt "goodarg2", "desc", :long => "--two" }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :long => "" }
+    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :long => "--" }
+    assert_raise(ArgumentError) { @p.opt "badarg3", "desc", :long => "-one" }
+    assert_raise(ArgumentError) { @p.opt "badarg4", "desc", :long => "---toomany" }
+  end
+
+  def test_short_detects_bad_names
+    assert_nothing_raised { @p.opt "goodarg", "desc", :short => "a" }
+    assert_nothing_raised { @p.opt "goodarg2", "desc", :short => "-b" }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :short => "" }
+    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :short => "-ab" }
+    assert_raise(ArgumentError) { @p.opt "badarg3", "desc", :short => "--t" }
+  end
+
+  def test_short_names_determined_automatically
+    @p.opt "arg"
+    @p.opt "arg2"
+    @p.opt "arg3"
+    assert_raise(ArgumentError) { @p.opt "gra" }
+    opts = @p.parse %w(-a -g)
+    assert_equal true, opts["arg"]
+    assert_equal false, opts["arg2"]
+    assert_equal true, opts["arg3"]
+  end
+
+  ## two args can't have the same name
+  def test_conflicting_names_are_detected
+    assert_nothing_raised { @p.opt "goodarg", "desc" }
+    assert_raise(ArgumentError) { @p.opt "goodarg", "desc" }
+  end
+
+  ## two args can't have the same :long
+  def test_conflicting_longs_detected
+    assert_nothing_raised { @p.opt "goodarg", "desc", :long => "--goodarg" }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :long => "--goodarg" }
+  end  
+
+  ## two args can't have the same :short
+  def test_conflicting_shorts_detected
+    assert_nothing_raised { @p.opt "goodarg", "desc", :short => "-g" }
+    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :short => "-g" }
+  end  
+
+  def test_flag_defaults
+    @p.opt "defaultfalse", "desc"
+    @p.opt "defaulttrue", "desc", :default => true
+    opts = @p.parse []
+    assert_equal false, opts["defaultfalse"]
+    assert_equal true, opts["defaulttrue"]
+
+    opts = @p.parse %w(--defaultfalse --defaulttrue)
+    assert_equal true, opts["defaultfalse"]
+    assert_equal false, opts["defaulttrue"]
+  end
+
+  def test_special_flags_work
+    @p.version "asdf fdas"
+    assert_raise(VersionNeeded) { @p.parse(%w(-v)) }
+    assert_raise(HelpNeeded) { @p.parse(%w(-h)) }
+  end
+
+  def test_short_options_combine
+    @p.opt :arg1, "desc", :short => "a"
+    @p.opt :arg2, "desc", :short => "b"
+    @p.opt :arg3, "desc", :short => "c", :type => :int
+
+    opts = nil
+    assert_nothing_raised { opts = @p.parse %w(-a -b) }
+    assert_equal true, opts[:arg1]
+    assert_equal true, opts[:arg2]
+    assert_equal nil, opts[:arg3]
+
+    assert_nothing_raised { opts = @p.parse %w(-ab) }
+    assert_equal true, opts[:arg1]
+    assert_equal true, opts[:arg2]
+    assert_equal nil, opts[:arg3]
+
+    assert_nothing_raised { opts = @p.parse %w(-ac 4 -b) }
+    assert_equal true, opts[:arg1]
+    assert_equal true, opts[:arg2]
+    assert_equal 4, opts[:arg3]
+
+    assert_raises(CommandlineError) { @p.parse %w(-cab 4) }
+    assert_raises(CommandlineError) { @p.parse %w(-cba 4) }
+  end
+
+  def test_version_only_appears_if_set
+    @p.opt "arg", "desc"
+    assert_raise(CommandlineError) { @p.parse %w(-v) }
+    @p.version "trollop 1.2.3.4"
+    assert_raise(VersionNeeded) { @p.parse %w(-v) }
+  end
+
+  def test_doubledash_ends_option_processing
+    @p.opt :arg1, "desc", :short => "a", :default => 0
+    @p.opt :arg2, "desc", :short => "b", :default => 0
+    opts = nil
+    assert_nothing_raised { opts = @p.parse %w(-- -a 3 -b 2) }
+    assert_equal opts[:arg1], 0
+    assert_equal opts[:arg2], 0
+    assert_equal %w(-a 3 -b 2), @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(-a 3 -- -b 2) }
+    assert_equal opts[:arg1], 3
+    assert_equal opts[:arg2], 0
+    assert_equal %w(-b 2), @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(-a 3 -b 2 --) }
+    assert_equal opts[:arg1], 3
+    assert_equal opts[:arg2], 2
+    assert_equal %w(), @p.leftovers
+  end
+
+  def test_wrap
+    assert_equal [""], @p.wrap("")
+    assert_equal ["a"], @p.wrap("a")
+    assert_equal ["one two", "three"], @p.wrap("one two three", :width => 8)
+    assert_equal ["one two three"], @p.wrap("one two three", :width => 80)
+    assert_equal ["one", "two", "three"], @p.wrap("one two three", :width => 3)
+    assert_equal ["onetwothree"], @p.wrap("onetwothree", :width => 3)
+    assert_equal [
+      "Test is an awesome program that does something very, very important.",
+      "",
+      "Usage:",
+      "  test [options] <filenames>+",
+      "where [options] are:"], @p.wrap(<<EOM, :width => 100)
+Test is an awesome program that does something very, very important.
+
+Usage:
+  test [options] <filenames>+
+where [options] are:
+EOM
+  end
+
+  def test_floating_point_formatting
+    @p.opt :arg, "desc", :type => :float, :short => "f"
+    opts = nil
+    assert_nothing_raised { opts = @p.parse %w(-f 1) }
+    assert_equal 1.0, opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(-f 1.0) }
+    assert_equal 1.0, opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(-f 0.1) }
+    assert_equal 0.1, opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(-f .1) }
+    assert_equal 0.1, opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(-f .99999999999999999999) }
+    assert_equal 1.0, opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(-f -1) }
+    assert_equal(-1.0, opts[:arg])
+    assert_nothing_raised { opts = @p.parse %w(-f -1.0) }
+    assert_equal(-1.0, opts[:arg])
+    assert_nothing_raised { opts = @p.parse %w(-f -0.1) }
+    assert_equal(-0.1, opts[:arg])
+    assert_nothing_raised { opts = @p.parse %w(-f -.1) }
+    assert_equal(-0.1, opts[:arg])
+    assert_raises(CommandlineError) { @p.parse %w(-f a) }
+    assert_raises(CommandlineError) { @p.parse %w(-f 1a) }
+    assert_raises(CommandlineError) { @p.parse %w(-f 1.a) }
+    assert_raises(CommandlineError) { @p.parse %w(-f a.1) }
+    assert_raises(CommandlineError) { @p.parse %w(-f 1.0.0) }
+    assert_raises(CommandlineError) { @p.parse %w(-f .) }
+    assert_raises(CommandlineError) { @p.parse %w(-f -.) }
+  end
+
+  def test_short_options_cant_be_numeric
+    assert_raises(ArgumentError) { @p.opt :arg, "desc", :short => "-1" }
+    @p.opt :a1b, "desc"
+    @p.opt :a2b, "desc"
+    assert_not_equal "2", @p.specs[:a2b][:short]
+  end
+
+  def test_short_options_can_be_weird
+    assert_nothing_raised { @p.opt :arg1, "desc", :short => "#" }
+    assert_nothing_raised { @p.opt :arg2, "desc", :short => "." }
+    assert_raises(ArgumentError) { @p.opt :arg3, "desc", :short => "-" }
+  end
+
+  def test_options_cant_be_set_multiple_times
+    @p.opt :arg, "desc", :short => "-x"
+    assert_nothing_raised { @p.parse %w(-x) }
+    assert_raises(CommandlineError) { @p.parse %w(-x -x) }
+    assert_raises(CommandlineError) { @p.parse %w(-xx) }
+  end
+
+  def test_long_options_also_take_equals
+    @p.opt :arg, "desc", :long => "arg", :type => String, :default => "hello"
+    opts = nil
+    assert_nothing_raised { opts = @p.parse %w() }
+    assert_equal "hello", opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(--arg goat) }
+    assert_equal "goat", opts[:arg]
+    assert_nothing_raised { opts = @p.parse %w(--arg=goat) }
+    assert_equal "goat", opts[:arg]
+    assert_raises(CommandlineError) { opts = @p.parse %w(--arg= goat) }
+  end
+
+  def test_auto_generated_long_names_convert_underscores_to_hyphens
+    @p.opt :hello_there
+    assert_equal "hello-there", @p.specs[:hello_there][:long]
+  end
+
+end
+
+end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: trollop
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+date: 2007-01-29 00:00:00 -08:00
+summary: Trollop is YAFCLAP --- yet another fine commandline argument processing library for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer).
+require_paths: 
+- lib
+email: wmorgan-trollop@masanjin.net
+homepage: http://trollop.rubyforge.org
+rubyforge_project: trollop
+description: "Trollop is YAFCLAP --- yet another fine commandline argument processing library for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer).  Trollop provides a nice automatically-generated help page, robust option parsing, and sensible defaults for everything you don't specify.  Synopsis:  ###### simple ######  opts = Trollop::options do opt :monkey, \"Use monkey mode.\" opt :goat, \"Use goat model\", :default => true opt :num_limbs, \"Set number of limbs\", :default => 4 end  p opts  ###### complex ######  opts = Trollop::options do version \"test 1.2.3 (c) 2007 William Morgan\" banner <<-EOS Test is an awesome program that does something very, very important.  Usage: test [options] <filenames>+ where [options] are: EOS  opt :ignore, \"Ignore incorrect values\" opt :file, \"Extra data filename to read in, with a very long option description like this one\", :type => String opt :volume, \"Volume level\", :default => 3.0 opt :iters, \"Number of iterations\", :default => 5 end Trollop::die :volume, \"must be non-negative\" if opts[:volume] < 0 Trollop::die :file, \"must exist\" unless File.exists?(opts[:file]) if opts[:file]  == REQUIREMENTS:  * none"
+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: 
+authors: 
+- William Morgan
+files: 
+- FAQ.txt
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/trollop.rb
+- test/test_trollop.rb
+test_files: 
+- test/test_trollop.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.7
+    version: