trollop 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7652739adf1d95b0325d061a1f6c3601ea9c2ad2
-  data.tar.gz: d85880211b235bcbc661981dba6b1f3cd1843cbb
+  metadata.gz: dbee7d87ff54b18dc15e986c58e8a9f511dda7d1
+  data.tar.gz: 6fc068202fc2863d9d851931cc67718e8c0b4bd1
 SHA512:
-  metadata.gz: ffc0188f1cf4e0c6295d6bd24f280ae9a09b74860e9b99023217613a156c52634a192a2522bdade449439832cc2d3d98613899b45da61e633a0fd056970cf7ea
-  data.tar.gz: e16e4a250eb2e29c3d905945cd3b2121ee71aaa3289b01ad5f3971512e729095ea745740ce29a59ef390ca0473b99d9f80ddd363b95c98aa1efcbd641a0475a1
+  metadata.gz: 4d79f559d36748e03c32069363d2d2415f341e13ffd5fb6165fb2e62dbfc7a8af70ae164d1c19f02d0be0ab056de2d0e6e15f6319b8f5a760087357db92d21cd
+  data.tar.gz: 4f0db3cd5cc44e6ff4e23abbc91a0175d9d0132af400cf13890696a9b68ccb8dadcef7b94f9bb3b1576cba6d549cf9b5d28a0c9a6635793fd28553524f641909

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
+  - "1.8.7"
   - "1.9.3"
-  - "2.0"
-  - "2.1"
-  - jruby-18mode # JRuby in 1.8 mode
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-2
+  - "2.2"
+  - ruby-head
+  - jruby-head
+gemfile: Gemfile.travis

data/Gemfile.travis

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+if RUBY_VERSION < "1.9"
+  gem 'rest-client', '< 1.7'
+  gem 'mime-types', '~> 1.16'
+end
+
+# Specify your gem's dependencies in trollop.gemspec
+gemspec

data/History.txt

@@ -1,3 +1,9 @@
+== 2.1.2 / 2015-03-10
+* loosen mime-types requirements (for better ruby 1.8.7 support)
+* use io/console gem instead of curses (for better jruby support)
+* fix parsing bug when chronic gem is not available
+* allow default array to be empty if a type is specified
+* better specified license and better spec coverage
 == 2.1.1 / 2015-01-03
 * Remove curses as a hard dependency. It is optional. This can leverage the gem if it is present.
 * Fix ruby -w warnings

data/README.md

@@ -54,4 +54,4 @@ Copyright © 2008-2014 [William Morgan](http://masanjin.net/).
 
 Copyright © 2014 Red Hat, Inc.
 
-Trollop is licensed under the same terms as Ruby.
+Trollop is released under the [MIT License][http://www.opensource.org/licenses/MIT].

data/Rakefile

@@ -1,6 +1,5 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rake/testtask'
-require 'coveralls/rake/task'
 
 task :default => :test
 
@@ -9,4 +8,8 @@ Rake::TestTask.new do |t|
   t.pattern = "test/test_*.rb"
 end
 
+begin
+require 'coveralls/rake/task'
 Coveralls::RakeTask.new
+rescue LoadError
+end

data/lib/trollop.rb

@@ -6,7 +6,7 @@
 require 'date'
 
 module Trollop
-VERSION = "2.1.1"
+VERSION = "2.1.2"
 
 ## Thrown by Parser in the event of a commandline error. Not needed if
 ## you're using the Trollop::options entry.
@@ -174,16 +174,22 @@ class Parser
       when Date; :date
       when Array
         if opts[:default].empty?
-          raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
-        end
-        case opts[:default][0]    # the first element determines the types
-        when Integer; :ints
-        when Numeric; :floats
-        when String; :strings
-        when IO; :ios
-        when Date; :dates
+          if opts[:type]
+            raise ArgumentError, "multiple argument type must be plural" unless MULTI_ARG_TYPES.include?(opts[:type])
+            nil
+          else
+            raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
+          end
         else
-          raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
+          case opts[:default][0]    # the first element determines the types
+          when Integer; :ints
+          when Numeric; :floats
+          when String; :strings
+          when IO; :ios
+          when Date; :dates
+          else
+            raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
+          end
         end
       when nil; nil
       else
@@ -204,7 +210,7 @@ class Parser
     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] unless opts[:short] == :none
+    opts[:short] = opts[:short].to_s if opts[:short] && opts[:short] != :none
     opts[:short] = case opts[:short]
       when /^-(.)$/; $1
       when nil, :none, /^.$/; opts[:short]
@@ -294,7 +300,7 @@ class Parser
     vals = {}
     required = {}
 
-    opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
+    opt :version, "Print version and exit" if @version && ! ( @specs[:version] || @long["version"])
     opt :help, "Show this message" unless @specs[:help] || @long["help"]
 
     @specs.each do |sym, opts|
@@ -323,10 +329,8 @@ class Parser
 
       sym = nil if arg =~ /--no-/ # explicitly invalidate --no-no- arguments
 
-      unless sym
-        next 0 if ignore_invalid_options
-        raise CommandlineError, "unknown argument '#{arg}'" unless sym
-      end
+      next 0 if ignore_invalid_options && !sym
+      raise CommandlineError, "unknown argument '#{arg}'" unless sym
 
       if given_args.include?(sym) && !@specs[sym][:multi]
         raise CommandlineError, "option '#{arg}' specified multiple times"
@@ -381,7 +385,7 @@ class Parser
       opts = @specs[sym]
       if params.empty? && opts[:type] != :flag
         raise CommandlineError, "option '#{arg}' needs a parameter" unless opts[:default]
-        params << [opts[:default]]
+        params << (opts[:default].kind_of?(Array) ? opts[:default].clone : [opts[:default]])
       end
 
       vals["#{sym}_given".intern] = true # mark argument as specified on the commandline
@@ -402,10 +406,10 @@ class Parser
       end
 
       if SINGLE_ARG_TYPES.include?(opts[:type])
-        unless opts[:multi]       # single parameter
-          vals[sym] = vals[sym][0][0]
-        else                      # multiple options, each with a single parameter
+        if opts[:multi]       # multiple options, each with a single parameter
           vals[sym] = vals[sym].map { |p| p[0] }
+        else                  # single parameter
+          vals[sym] = vals[sym][0][0]
         end
       elsif MULTI_ARG_TYPES.include?(opts[:type]) && !opts[:multi]
         vals[sym] = vals[sym][0]  # single option, with multiple parameters
@@ -434,7 +438,7 @@ class Parser
       begin
         require 'chronic'
         time = Chronic.parse(param)
-      rescue NameError
+      rescue LoadError
         # chronic is not available
       end
       time ? Date.new(time.year, time.month, time.day) : Date.parse(param)
@@ -516,19 +520,24 @@ class Parser
   def width #:nodoc:
     @width ||= if $stdout.tty?
       begin
-        require 'curses'
-        Curses::init_screen
-        x = Curses::cols
-        Curses::close_screen
-        x
-      rescue Exception
-        80
+        require 'io/console'
+        IO.console.winsize.last
+      rescue LoadError, NoMethodError, Errno::ENOTTY, Errno::EBADF, Errno::EINVAL
+        legacy_width
       end
     else
       80
     end
   end
 
+  def legacy_width
+    # Support for older Rubies where io/console is not available
+    `tput cols`.to_i
+  rescue Errno::ENOENT
+    80
+  end
+  private :legacy_width
+
   def wrap str, opts={} # :nodoc:
     if str == ""
       [""]
@@ -562,52 +571,48 @@ private
 
     until i >= args.length
       if @stop_words.member? args[i]
-        remains += args[i .. -1]
-        return remains
+        return remains += args[i .. -1]
       end
       case args[i]
       when /^--$/ # arg terminator
-        remains += args[(i + 1) .. -1]
-        return remains
+        return remains += args[(i + 1) .. -1]
       when /^--(\S+?)=(.*)$/ # long argument with equals
         yield "--#{$1}", [$2]
         i += 1
       when /^--(\S+)$/ # long argument
         params = collect_argument_parameters(args, i + 1)
-        unless params.empty?
+        if params.empty?
+          yield args[i], nil
+          i += 1
+        else
           num_params_taken = yield args[i], params
           unless num_params_taken
             if @stop_on_unknown
-              remains += args[i + 1 .. -1]
-              return remains
+              return remains += args[i + 1 .. -1]
             else
               remains += params
             end
           end
           i += 1 + num_params_taken
-        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)
             params = collect_argument_parameters(args, i + 1)
-            unless params.empty?
+            if params.empty?
+              yield "-#{a}", nil
+              i += 1
+            else
               num_params_taken = yield "-#{a}", params
               unless num_params_taken
                 if @stop_on_unknown
-                  remains += args[i + 1 .. -1]
-                  return remains
+                  return remains += args[i + 1 .. -1]
                 else
                   remains += params
                 end
               end
               i += 1 + num_params_taken
-            else # argument no parameter
-              yield "-#{a}", nil
-              i += 1
             end
           else
             yield "-#{a}", nil
@@ -615,8 +620,7 @@ private
         end
       else
         if @stop_on_unknown
-          remains += args[i .. -1]
-          return remains
+          return remains += args[i .. -1]
         else
           remains << args[i]
           i += 1
@@ -662,9 +666,8 @@ private
 
   def resolve_default_short_options!
     @order.each do |type, name|
-      next unless type == :opt
       opts = @specs[name]
-      next if opts[:short]
+      next if type != :opt || opts[:short]
 
       c = opts[:long].split(//).find { |d| d !~ INVALID_SHORT_ARG_REGEX && !@short.member?(d) }
       if c # found a character to use

data/test/test_helper.rb

@@ -1,14 +1,11 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
 unless ENV['MUTANT']
+  begin
   require "coveralls"
-  require "simplecov"
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    Coveralls::SimpleCov::Formatter,
-    SimpleCov::Formatter::HTMLFormatter,
-  ]
-
+  Coveralls.wear!
+  rescue LoadError
+  end
 end
 
 begin
@@ -16,8 +13,6 @@ begin
 rescue LoadError
 end
 
-require 'test/unit'
-
-SimpleCov.start unless ENV['MUTANT']
+require 'minitest/autorun'
 
 require 'trollop'

data/test/test_trollop.rb

@@ -1,33 +1,33 @@
 require 'stringio'
-require_relative 'test_helper'
+require 'test_helper'
 
 module Trollop
 module Test
 
-class Trollop < ::Test::Unit::TestCase
+class Trollop < ::MiniTest::Unit::TestCase
   def setup
     @p = Parser.new
   end
 
   def test_die_without_options_ever_run
     ::Trollop.send(:instance_variable_set, "@last_parser", nil)
-    assert_raise(ArgumentError) { ::Trollop.die 'hello' }
+    assert_raises(ArgumentError) { ::Trollop.die 'hello' }
   end
 
   def test_unknown_arguments
-    assert_raise(CommandlineError) { @p.parse(%w(--arg)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--arg)) }
     @p.opt "arg"
-    assert_nothing_raised { @p.parse(%w(--arg)) }
-    assert_raise(CommandlineError) { @p.parse(%w(--arg2)) }
+    @p.parse(%w(--arg))
+    assert_raises(CommandlineError) { @p.parse(%w(--arg2)) }
   end
 
   def test_syntax_check
     @p.opt "arg"
 
-    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)) }
+    @p.parse(%w(--arg))
+    @p.parse(%w(arg))
+    assert_raises(CommandlineError) { @p.parse(%w(---arg)) }
+    assert_raises(CommandlineError) { @p.parse(%w(-arg)) }
   end
 
   def test_required_flags_are_required
@@ -35,10 +35,10 @@ class Trollop < ::Test::Unit::TestCase
     @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)) }
+    @p.parse(%w(--arg))
+    @p.parse(%w(--arg --arg2))
+    assert_raises(CommandlineError) { @p.parse(%w(--arg2)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--arg2 --arg3)) }
   end
 
   ## flags that take an argument error unless given one
@@ -46,17 +46,17 @@ class Trollop < ::Test::Unit::TestCase
     @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)) }
+    @p.parse(%w(--goodarg goat))
+    assert_raises(CommandlineError) { @p.parse(%w(--goodarg --goodarg2 goat)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--goodarg)) }
   end
 
   ## flags that don't take arguments ignore them
   def test_arglessflags_refuse_args
     @p.opt "goodarg"
     @p.opt "goodarg2"
-    assert_nothing_raised { @p.parse(%w(--goodarg)) }
-    assert_nothing_raised { @p.parse(%w(--goodarg --goodarg2)) }
+    @p.parse(%w(--goodarg))
+    @p.parse(%w(--goodarg --goodarg2))
     opts = @p.parse %w(--goodarg a)
     assert_equal true, opts["goodarg"]
     assert_equal ["a"], @p.leftovers
@@ -65,125 +65,121 @@ class Trollop < ::Test::Unit::TestCase
   ## 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 }
+    @p.opt "goodarg", "desc", :type => :int
+    assert_raises(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)) }
+    @p.parse(%w(--goodarg 3))
+    assert_raises(CommandlineError) { @p.parse(%w(--goodarg 4.2)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--goodarg hello)) }
   end
 
   ## type is correctly derived from :default
   def test_type_correctly_derived_from_default
-    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :default => [] }
-    assert_raise(ArgumentError) { @p.opt "badarg3", "desc", :default => [{1 => 2}] }
-    assert_raise(ArgumentError) { @p.opt "badarg4", "desc", :default => Hash.new }
-
-    opts = nil
+    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :default => [] }
+    assert_raises(ArgumentError) { @p.opt "badarg3", "desc", :default => [{1 => 2}] }
+    assert_raises(ArgumentError) { @p.opt "badarg4", "desc", :default => Hash.new }
 
     # single arg: int
-    assert_nothing_raised { @p.opt "argsi", "desc", :default => 0 }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argsi", "desc", :default => 0
+    opts = @p.parse(%w(--))
     assert_equal 0, opts["argsi"]
-    assert_nothing_raised { opts = @p.parse(%w(--argsi 4)) }
+    opts = @p.parse(%w(--argsi 4))
     assert_equal 4, opts["argsi"]
-    assert_nothing_raised { opts = @p.parse(%w(--argsi=4)) }
+    opts = @p.parse(%w(--argsi=4))
     assert_equal 4, opts["argsi"]
-    assert_nothing_raised { opts = @p.parse(%w(--argsi=-4)) }
+    opts = @p.parse(%w(--argsi=-4))
     assert_equal -4, opts["argsi"]
 
-    assert_raise(CommandlineError) { @p.parse(%w(--argsi 4.2)) }
-    assert_raise(CommandlineError) { @p.parse(%w(--argsi hello)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argsi 4.2)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argsi hello)) }
 
     # single arg: float
-    assert_nothing_raised { @p.opt "argsf", "desc", :default => 3.14 }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argsf", "desc", :default => 3.14
+    opts = @p.parse(%w(--))
     assert_equal 3.14, opts["argsf"]
-    assert_nothing_raised { opts = @p.parse(%w(--argsf 2.41)) }
+    opts = @p.parse(%w(--argsf 2.41))
     assert_equal 2.41, opts["argsf"]
-    assert_nothing_raised { opts = @p.parse(%w(--argsf 2)) }
+    opts = @p.parse(%w(--argsf 2))
     assert_equal 2, opts["argsf"]
-    assert_nothing_raised { opts = @p.parse(%w(--argsf 1.0e-2)) }
+    opts = @p.parse(%w(--argsf 1.0e-2))
     assert_equal 1.0e-2, opts["argsf"]
-    assert_raise(CommandlineError) { @p.parse(%w(--argsf hello)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argsf hello)) }
 
     # single arg: date
     date = Date.today
-    assert_nothing_raised { @p.opt "argsd", "desc", :default => date }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argsd", "desc", :default => date
+    opts = @p.parse(%w(--))
     assert_equal Date.today, opts["argsd"]
-    assert_nothing_raised { opts = @p.parse(['--argsd', 'Jan 4, 2007']) }
+    opts = @p.parse(['--argsd', 'Jan 4, 2007'])
     assert_equal Date.civil(2007, 1, 4), opts["argsd"]
-    assert_raise(CommandlineError) { @p.parse(%w(--argsd hello)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argsd hello)) }
 
     # single arg: string
-    assert_nothing_raised { @p.opt "argss", "desc", :default => "foobar" }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argss", "desc", :default => "foobar"
+    opts = @p.parse(%w(--))
     assert_equal "foobar", opts["argss"]
-    assert_nothing_raised { opts = @p.parse(%w(--argss 2.41)) }
+    opts = @p.parse(%w(--argss 2.41))
     assert_equal "2.41", opts["argss"]
-    assert_nothing_raised { opts = @p.parse(%w(--argss hello)) }
+    opts = @p.parse(%w(--argss hello))
     assert_equal "hello", opts["argss"]
 
     # multi args: ints
-    assert_nothing_raised { @p.opt "argmi", "desc", :default => [3, 5] }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argmi", "desc", :default => [3, 5]
+    opts = @p.parse(%w(--))
     assert_equal [3, 5], opts["argmi"]
-    assert_nothing_raised { opts = @p.parse(%w(--argmi 4)) }
+    opts = @p.parse(%w(--argmi 4))
     assert_equal [4], opts["argmi"]
-    assert_raise(CommandlineError) { @p.parse(%w(--argmi 4.2)) }
-    assert_raise(CommandlineError) { @p.parse(%w(--argmi hello)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argmi 4.2)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argmi hello)) }
 
     # multi args: floats
-    assert_nothing_raised { @p.opt "argmf", "desc", :default => [3.34, 5.21] }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argmf", "desc", :default => [3.34, 5.21]
+    opts = @p.parse(%w(--))
     assert_equal [3.34, 5.21], opts["argmf"]
-    assert_nothing_raised { opts = @p.parse(%w(--argmf 2)) }
+    opts = @p.parse(%w(--argmf 2))
     assert_equal [2], opts["argmf"]
-    assert_nothing_raised { opts = @p.parse(%w(--argmf 4.0)) }
+    opts = @p.parse(%w(--argmf 4.0))
     assert_equal [4.0], opts["argmf"]
-    assert_raise(CommandlineError) { @p.parse(%w(--argmf hello)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argmf hello)) }
 
     # multi args: dates
     dates = [Date.today, Date.civil(2007, 1, 4)]
-    assert_nothing_raised { @p.opt "argmd", "desc", :default => dates }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argmd", "desc", :default => dates
+    opts = @p.parse(%w(--))
     assert_equal dates, opts["argmd"]
-    assert_nothing_raised { opts = @p.parse(['--argmd', 'Jan 4, 2007']) }
+    opts = @p.parse(['--argmd', 'Jan 4, 2007'])
     assert_equal [Date.civil(2007, 1, 4)], opts["argmd"]
-    assert_raise(CommandlineError) { @p.parse(%w(--argmd hello)) }
+    assert_raises(CommandlineError) { @p.parse(%w(--argmd hello)) }
 
     # multi args: strings
-    assert_nothing_raised { @p.opt "argmst", "desc", :default => %w(hello world) }
-    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    @p.opt "argmst", "desc", :default => %w(hello world)
+    opts = @p.parse(%w(--))
     assert_equal %w(hello world), opts["argmst"]
-    assert_nothing_raised { opts = @p.parse(%w(--argmst 3.4)) }
+    opts = @p.parse(%w(--argmst 3.4))
     assert_equal ["3.4"], opts["argmst"]
-    assert_nothing_raised { opts = @p.parse(%w(--argmst goodbye)) }
+    opts = @p.parse(%w(--argmst goodbye))
     assert_equal ["goodbye"], opts["argmst"]
   end
 
   ## :type and :default must match if both are specified
   def test_type_and_default_must_match
-    assert_raise(ArgumentError) { @p.opt "badarg", "desc", :type => :int, :default => "hello" }
-    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => 4 }
-    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => ["hi"] }
-    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :ints, :default => [3.14] }
+    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :type => :int, :default => "hello" }
+    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => 4 }
+    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => ["hi"] }
+    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :type => :ints, :default => [3.14] }
 
-    assert_nothing_raised { @p.opt "argsi", "desc", :type => :int, :default => 4 }
-    assert_nothing_raised { @p.opt "argsf", "desc", :type => :float, :default => 3.14 }
-    assert_nothing_raised { @p.opt "argsd", "desc", :type => :date, :default => Date.today }
-    assert_nothing_raised { @p.opt "argss", "desc", :type => :string, :default => "yo" }
-    assert_nothing_raised { @p.opt "argmi", "desc", :type => :ints, :default => [4] }
-    assert_nothing_raised { @p.opt "argmf", "desc", :type => :floats, :default => [3.14] }
-    assert_nothing_raised { @p.opt "argmd", "desc", :type => :dates, :default => [Date.today] }
-    assert_nothing_raised { @p.opt "argmst", "desc", :type => :strings, :default => ["yo"] }
+    @p.opt "argsi", "desc", :type => :int, :default => 4
+    @p.opt "argsf", "desc", :type => :float, :default => 3.14
+    @p.opt "argsd", "desc", :type => :date, :default => Date.today
+    @p.opt "argss", "desc", :type => :string, :default => "yo"
+    @p.opt "argmi", "desc", :type => :ints, :default => [4]
+    @p.opt "argmf", "desc", :type => :floats, :default => [3.14]
+    @p.opt "argmd", "desc", :type => :dates, :default => [Date.today]
+    @p.opt "argmst", "desc", :type => :strings, :default => ["yo"]
   end
 
   ##
   def test_flags_with_defaults_and_no_args_act_as_switches
-    opts = nil
-
     @p.opt :argd, "desc", :default => "default_string"
 
     opts = @p.parse(%w(--))
@@ -197,24 +193,48 @@ class Trollop < ::Test::Unit::TestCase
     opts = @p.parse(%w(--argd different_string))
     assert opts[:argd_given]
     assert_equal "different_string", opts[:argd]
+  end
 
+  def test_flag_with_no_defaults_and_no_args_act_as_switches_array
+    opts = nil
+
+    @p.opt :argd, "desc", :type => :strings, :default => ["default_string"]
+
+    opts = @p.parse(%w(--argd))
+    assert_equal ["default_string"], opts[:argd]
+  end
+
+  def test_type_and_empty_array
+    @p.opt "argmi", "desc", :type => :ints, :default => []
+    @p.opt "argmf", "desc", :type => :floats, :default => []
+    @p.opt "argmd", "desc", :type => :dates, :default => []
+    @p.opt "argms", "desc", :type => :strings, :default => []
+    assert_raises(ArgumentError) { @p.opt "badi", "desc", :type => :int, :default => [] }
+    assert_raises(ArgumentError) { @p.opt "badf", "desc", :type => :float, :default => [] }
+    assert_raises(ArgumentError) { @p.opt "badd", "desc", :type => :date, :default => [] }
+    assert_raises(ArgumentError) { @p.opt "bads", "desc", :type => :string, :default => [] }
+    opts = @p.parse([])
+    assert_equal(opts["argmi"], [])
+    assert_equal(opts["argmf"], [])
+    assert_equal(opts["argmd"], [])
+    assert_equal(opts["argms"], [])
   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" }
+    @p.opt "goodarg", "desc", :long => "none"
+    @p.opt "goodarg2", "desc", :long => "--two"
+    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :long => "" }
+    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :long => "--" }
+    assert_raises(ArgumentError) { @p.opt "badarg3", "desc", :long => "-one" }
+    assert_raises(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" }
+    @p.opt "goodarg", "desc", :short => "a"
+    @p.opt "goodarg2", "desc", :short => "-b"
+    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :short => "" }
+    assert_raises(ArgumentError) { @p.opt "badarg2", "desc", :short => "-ab" }
+    assert_raises(ArgumentError) { @p.opt "badarg3", "desc", :short => "--t" }
   end
 
   def test_short_names_created_automatically
@@ -231,8 +251,8 @@ class Trollop < ::Test::Unit::TestCase
     @p.opt :arg # auto: a
     @p.opt :arg_potato # auto: r
     @p.opt :arg_muffin # auto: g
-    assert_nothing_raised { @p.opt :arg_daisy } # auto: d (not _)!
-    assert_nothing_raised { @p.opt :arg_r2d2f } # auto: f (not 2)!
+    @p.opt :arg_daisy  # auto: d (not _)!
+    @p.opt :arg_r2d2f  # auto: f (not 2)!
 
     opts = @p.parse %w(-f -d)
     assert_equal true, opts[:arg_daisy]
@@ -247,38 +267,36 @@ class Trollop < ::Test::Unit::TestCase
     @p.opt :arg2 # auto: r
     @p.opt :arg3 # auto: g
     @p.opt :arg4 # auto: uh oh!
-    assert_nothing_raised { @p.parse [] }
+    @p.parse []
   end
 
   def test_short_can_be_nothing
-    assert_nothing_raised do
-      @p.opt "arg", "desc", :short => :none
-      @p.parse []
-    end
+    @p.opt "arg", "desc", :short => :none
+    @p.parse []
 
     sio = StringIO.new "w"
     @p.educate sio
     assert sio.string =~ /--arg\s+desc/
 
-    assert_raise(CommandlineError) { @p.parse %w(-a) }
+    assert_raises(CommandlineError) { @p.parse %w(-a) }
   end
 
   ## two args can't have the same name
   def test_conflicting_names_are_detected
-    assert_nothing_raised { @p.opt "goodarg" }
-    assert_raise(ArgumentError) { @p.opt "goodarg" }
+    @p.opt "goodarg"
+    assert_raises(ArgumentError) { @p.opt "goodarg" }
   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" }
+    @p.opt "goodarg", "desc", :long => "--goodarg"
+    assert_raises(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" }
+    @p.opt "goodarg", "desc", :short => "-g"
+    assert_raises(ArgumentError) { @p.opt "badarg", "desc", :short => "-g" }
   end
 
   ## note: this behavior has changed in trollop 2.0!
@@ -332,13 +350,13 @@ class Trollop < ::Test::Unit::TestCase
     assert_equal false, opts[:no_default_true]
 
     ## disallow double negatives for reasons of sanity preservation
-    assert_raise(CommandlineError) { @p.parse %w(--no-no-default-true) }
+    assert_raises(CommandlineError) { @p.parse %w(--no-no-default-true) }
   end
 
   def test_special_flags_work
     @p.version "asdf fdas"
-    assert_raise(VersionNeeded) { @p.parse(%w(-v)) }
-    assert_raise(HelpNeeded) { @p.parse(%w(-h)) }
+    assert_raises(VersionNeeded) { @p.parse(%w(-v)) }
+    assert_raises(HelpNeeded) { @p.parse(%w(-h)) }
   end
 
   def test_short_options_combine
@@ -346,18 +364,17 @@ class Trollop < ::Test::Unit::TestCase
     @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) }
+    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) }
+    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) }
+    opts = @p.parse %w(-ac 4 -b)
     assert_equal true, opts[:arg1]
     assert_equal true, opts[:arg2]
     assert_equal 4, opts[:arg3]
@@ -368,24 +385,23 @@ class Trollop < ::Test::Unit::TestCase
 
   def test_version_only_appears_if_set
     @p.opt "arg"
-    assert_raise(CommandlineError) { @p.parse %w(-v) }
+    assert_raises(CommandlineError) { @p.parse %w(-v) }
     @p.version "trollop 1.2.3.4"
-    assert_raise(VersionNeeded) { @p.parse %w(-v) }
+    assert_raises(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) }
+    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) }
+    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 --) }
+    opts = @p.parse %w(-a 3 -b 2 --)
     assert_equal opts[:arg1], 3
     assert_equal opts[:arg2], 2
     assert_equal %w(), @p.leftovers
@@ -428,24 +444,23 @@ Options:
 
   def test_floating_point_formatting
     @p.opt :arg, "desc", :type => :float, :short => "f"
-    opts = nil
-    assert_nothing_raised { opts = @p.parse %w(-f 1) }
+    opts = @p.parse %w(-f 1)
     assert_equal 1.0, opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(-f 1.0) }
+    opts = @p.parse %w(-f 1.0)
     assert_equal 1.0, opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(-f 0.1) }
+    opts = @p.parse %w(-f 0.1)
     assert_equal 0.1, opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(-f .1) }
+    opts = @p.parse %w(-f .1)
     assert_equal 0.1, opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(-f .99999999999999999999) }
+    opts = @p.parse %w(-f .99999999999999999999)
     assert_equal 1.0, opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(-f -1) }
+    opts = @p.parse %w(-f -1)
     assert_equal(-1.0, opts[:arg])
-    assert_nothing_raised { opts = @p.parse %w(-f -1.0) }
+    opts = @p.parse %w(-f -1.0)
     assert_equal(-1.0, opts[:arg])
-    assert_nothing_raised { opts = @p.parse %w(-f -0.1) }
+    opts = @p.parse %w(-f -0.1)
     assert_equal(-0.1, opts[:arg])
-    assert_nothing_raised { opts = @p.parse %w(-f -.1) }
+    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) }
@@ -458,10 +473,9 @@ Options:
 
   def test_date_formatting
     @p.opt :arg, "desc", :type => :date, :short => 'd'
-    opts = nil
-    assert_nothing_raised { opts = @p.parse(['-d', 'Jan 4, 2007']) }
+    opts = @p.parse(['-d', 'Jan 4, 2007'])
     assert_equal Date.civil(2007, 1, 4), opts[:arg]
-    assert_nothing_raised { opts = @p.parse(['-d', 'today']) }
+    opts = @p.parse(['-d', 'today'])
     assert_equal Date.today, opts[:arg]
   end
 
@@ -469,96 +483,82 @@ Options:
     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]
+    assert @p.specs[:a2b][:short].to_i == 0
   end
 
   def test_short_options_can_be_weird
-    assert_nothing_raised { @p.opt :arg1, "desc", :short => "#" }
-    assert_nothing_raised { @p.opt :arg2, "desc", :short => "." }
+    @p.opt :arg1, "desc", :short => "#"
+    @p.opt :arg2, "desc", :short => "."
     assert_raises(ArgumentError) { @p.opt :arg3, "desc", :short => "-" }
   end
 
   def test_options_cant_be_set_multiple_times_if_not_specified
     @p.opt :arg, "desc", :short => "-x"
-    assert_nothing_raised { @p.parse %w(-x) }
+    @p.parse %w(-x)
     assert_raises(CommandlineError) { @p.parse %w(-x -x) }
     assert_raises(CommandlineError) { @p.parse %w(-xx) }
   end
 
   def test_options_can_be_set_multiple_times_if_specified
-    assert_nothing_raised do
-      @p.opt :arg, "desc", :short => "-x", :multi => true
-    end
-    assert_nothing_raised { @p.parse %w(-x) }
-    assert_nothing_raised { @p.parse %w(-x -x) }
-    assert_nothing_raised { @p.parse %w(-xx) }
+    @p.opt :arg, "desc", :short => "-x", :multi => true
+    @p.parse %w(-x)
+    @p.parse %w(-x -x)
+    @p.parse %w(-xx)
   end
 
   def test_short_options_with_multiple_options
-    opts = nil
-
-    assert_nothing_raised do
-       @p.opt :xarg, "desc", :short => "-x", :type => String, :multi => true
-    end
-    assert_nothing_raised { opts = @p.parse %w(-x a -x b) }
+    @p.opt :xarg, "desc", :short => "-x", :type => String, :multi => true
+    opts = @p.parse %w(-x a -x b)
     assert_equal %w(a b), opts[:xarg]
     assert_equal [], @p.leftovers
   end
 
   def test_short_options_with_multiple_options_does_not_affect_flags_type
-    opts = nil
-
-    assert_nothing_raised do
-      @p.opt :xarg, "desc", :short => "-x", :type => :flag, :multi => true
-    end
+    @p.opt :xarg, "desc", :short => "-x", :type => :flag, :multi => true
 
-    assert_nothing_raised { opts = @p.parse %w(-x a) }
+    opts = @p.parse %w(-x a)
     assert_equal true, opts[:xarg]
     assert_equal %w(a), @p.leftovers
 
-    assert_nothing_raised { opts = @p.parse %w(-x a -x b) }
+    opts = @p.parse %w(-x a -x b)
     assert_equal true, opts[:xarg]
     assert_equal %w(a b), @p.leftovers
 
-    assert_nothing_raised { opts = @p.parse %w(-xx a -x b) }
+    opts = @p.parse %w(-xx a -x b)
     assert_equal true, opts[:xarg]
     assert_equal %w(a b), @p.leftovers
   end
 
   def test_short_options_with_multiple_arguments
-    opts = nil
-
     @p.opt :xarg, "desc", :type => :ints
-    assert_nothing_raised { opts = @p.parse %w(-x 3 4 0) }
+    opts = @p.parse %w(-x 3 4 0)
     assert_equal [3, 4, 0], opts[:xarg]
     assert_equal [], @p.leftovers
 
     @p.opt :yarg, "desc", :type => :floats
-    assert_nothing_raised { opts = @p.parse %w(-y 3.14 4.21 0.66) }
+    opts = @p.parse %w(-y 3.14 4.21 0.66)
     assert_equal [3.14, 4.21, 0.66], opts[:yarg]
     assert_equal [], @p.leftovers
 
     @p.opt :zarg, "desc", :type => :strings
-    assert_nothing_raised { opts = @p.parse %w(-z a b c) }
+    opts = @p.parse %w(-z a b c)
     assert_equal %w(a b c), opts[:zarg]
     assert_equal [], @p.leftovers
   end
 
   def test_short_options_with_multiple_options_and_arguments
-    opts = nil
-
     @p.opt :xarg, "desc", :type => :ints, :multi => true
-    assert_nothing_raised { opts = @p.parse %w(-x 3 4 5 -x 6 7) }
+    opts = @p.parse %w(-x 3 4 5 -x 6 7)
     assert_equal [[3, 4, 5], [6, 7]], opts[:xarg]
     assert_equal [], @p.leftovers
 
     @p.opt :yarg, "desc", :type => :floats, :multi => true
-    assert_nothing_raised { opts = @p.parse %w(-y 3.14 4.21 5.66 -y 6.99 7.01) }
+    opts = @p.parse %w(-y 3.14 4.21 5.66 -y 6.99 7.01)
     assert_equal [[3.14, 4.21, 5.66], [6.99, 7.01]], opts[:yarg]
     assert_equal [], @p.leftovers
 
     @p.opt :zarg, "desc", :type => :strings, :multi => true
-    assert_nothing_raised { opts = @p.parse %w(-z a b c -z d e) }
+    opts = @p.parse %w(-z a b c -z d e)
     assert_equal [%w(a b c), %w(d e)], opts[:zarg]
     assert_equal [], @p.leftovers
   end
@@ -569,14 +569,12 @@ Options:
     @p.opt :arg3, "desc", :short => "c", :type => :ints
     @p.opt :arg4, "desc", :short => "d", :type => :floats
 
-    opts = nil
-
-    assert_nothing_raised { opts = @p.parse %w(-abc 4 6 9) }
+    opts = @p.parse %w(-abc 4 6 9)
     assert_equal true, opts[:arg1]
     assert_equal true, opts[:arg2]
     assert_equal [4, 6, 9], opts[:arg3]
 
-    assert_nothing_raised { opts = @p.parse %w(-ac 4 6 9 -bd 3.14 2.41) }
+    opts = @p.parse %w(-ac 4 6 9 -bd 3.14 2.41)
     assert_equal true, opts[:arg1]
     assert_equal true, opts[:arg2]
     assert_equal [4, 6, 9], opts[:arg3]
@@ -587,79 +585,73 @@ Options:
 
   def test_long_options_with_multiple_options
     @p.opt :xarg, "desc", :type => String, :multi => true
-    opts = nil
-    assert_nothing_raised { opts = @p.parse %w(--xarg=a --xarg=b) }
+    opts = @p.parse %w(--xarg=a --xarg=b)
     assert_equal %w(a b), opts[:xarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--xarg a --xarg b) }
+    opts = @p.parse %w(--xarg a --xarg b)
     assert_equal %w(a b), opts[:xarg]
     assert_equal [], @p.leftovers
   end
 
   def test_long_options_with_multiple_arguments
-    opts = nil
-
     @p.opt :xarg, "desc", :type => :ints
-    assert_nothing_raised { opts = @p.parse %w(--xarg 3 2 5) }
+    opts = @p.parse %w(--xarg 3 2 5)
     assert_equal [3, 2, 5], opts[:xarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--xarg=3) }
+    opts = @p.parse %w(--xarg=3)
     assert_equal [3], opts[:xarg]
     assert_equal [], @p.leftovers
 
     @p.opt :yarg, "desc", :type => :floats
-    assert_nothing_raised { opts = @p.parse %w(--yarg 3.14 2.41 5.66) }
+    opts = @p.parse %w(--yarg 3.14 2.41 5.66)
     assert_equal [3.14, 2.41, 5.66], opts[:yarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--yarg=3.14) }
+    opts = @p.parse %w(--yarg=3.14)
     assert_equal [3.14], opts[:yarg]
     assert_equal [], @p.leftovers
 
     @p.opt :zarg, "desc", :type => :strings
-    assert_nothing_raised { opts = @p.parse %w(--zarg a b c) }
+    opts = @p.parse %w(--zarg a b c)
     assert_equal %w(a b c), opts[:zarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--zarg=a) }
+    opts = @p.parse %w(--zarg=a)
     assert_equal %w(a), opts[:zarg]
     assert_equal [], @p.leftovers
   end
 
   def test_long_options_with_multiple_options_and_arguments
-    opts = nil
-
     @p.opt :xarg, "desc", :type => :ints, :multi => true
-    assert_nothing_raised { opts = @p.parse %w(--xarg 3 2 5 --xarg 2 1) }
+    opts = @p.parse %w(--xarg 3 2 5 --xarg 2 1)
     assert_equal [[3, 2, 5], [2, 1]], opts[:xarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--xarg=3 --xarg=2) }
+    opts = @p.parse %w(--xarg=3 --xarg=2)
     assert_equal [[3], [2]], opts[:xarg]
     assert_equal [], @p.leftovers
 
     @p.opt :yarg, "desc", :type => :floats, :multi => true
-    assert_nothing_raised { opts = @p.parse %w(--yarg 3.14 2.72 5 --yarg 2.41 1.41) }
+    opts = @p.parse %w(--yarg 3.14 2.72 5 --yarg 2.41 1.41)
     assert_equal [[3.14, 2.72, 5], [2.41, 1.41]], opts[:yarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--yarg=3.14 --yarg=2.41) }
+    opts = @p.parse %w(--yarg=3.14 --yarg=2.41)
     assert_equal [[3.14], [2.41]], opts[:yarg]
     assert_equal [], @p.leftovers
 
     @p.opt :zarg, "desc", :type => :strings, :multi => true
-    assert_nothing_raised { opts = @p.parse %w(--zarg a b c --zarg d e) }
+    opts = @p.parse %w(--zarg a b c --zarg d e)
     assert_equal [%w(a b c), %w(d e)], opts[:zarg]
     assert_equal [], @p.leftovers
-    assert_nothing_raised { opts = @p.parse %w(--zarg=a --zarg=d) }
+    opts = @p.parse %w(--zarg=a --zarg=d)
     assert_equal [%w(a), %w(d)], opts[:zarg]
     assert_equal [], @p.leftovers
   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() }
+    opts = @p.parse %w()
     assert_equal "hello", opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(--arg goat) }
+    opts = @p.parse %w(--arg goat)
     assert_equal "goat", opts[:arg]
-    assert_nothing_raised { opts = @p.parse %w(--arg=goat) }
+    opts = @p.parse %w(--arg=goat)
     assert_equal "goat", opts[:arg]
     ## actually, this next one is valid. empty string for --arg, and goat as a
     ## leftover.
@@ -797,26 +789,26 @@ Options:
     @p.opt :hello, "desc", :short => "-h"
     @p.version "version"
 
-    assert_nothing_raised { @p.parse(%w(-v)) }
+    @p.parse(%w(-v))
     assert_raises(VersionNeeded) { @p.parse(%w(--version)) }
-    assert_nothing_raised { @p.parse(%w(-h)) }
+    @p.parse(%w(-h))
     assert_raises(HelpNeeded) { @p.parse(%w(--help)) }
   end
 
   def test_version_and_help_long_args_can_be_overridden
     @p.opt :asdf, "desc", :long => "help"
     @p.opt :asdf2, "desc2", :long => "version"
-    assert_nothing_raised { @p.parse %w() }
-    assert_nothing_raised { @p.parse %w(--help) }
-    assert_nothing_raised { @p.parse %w(--version) }
-    assert_nothing_raised { @p.parse %w(-h) }
-    assert_nothing_raised { @p.parse %w(-v) }
+    @p.parse %w()
+    @p.parse %w(--help)
+    @p.parse %w(--version)
+    @p.parse %w(-h)
+    @p.parse %w(-v)
   end
 
   def test_version_and_help_override_errors
     @p.opt :asdf, "desc", :type => String
     @p.version "version"
-    assert_nothing_raised { @p.parse %w(--asdf goat) }
+    @p.parse %w(--asdf goat)
     assert_raises(CommandlineError) { @p.parse %w(--asdf) }
     assert_raises(HelpNeeded) { @p.parse %w(--asdf --help) }
     assert_raises(VersionNeeded) { @p.parse %w(--asdf --version) }
@@ -826,9 +818,9 @@ Options:
     @p.opt :one
     assert_raises(ArgumentError) { @p.conflicts :one, :two }
     @p.opt :two
-    assert_nothing_raised { @p.conflicts :one, :two }
-    assert_nothing_raised { @p.parse %w(--one) }
-    assert_nothing_raised { @p.parse %w(--two) }
+    @p.conflicts :one, :two
+    @p.parse %w(--one)
+    @p.parse %w(--two)
     assert_raises(CommandlineError) { @p.parse %w(--one --two) }
 
     @p.opt :hello
@@ -840,13 +832,13 @@ Options:
     assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
     assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
 
-    assert_nothing_raised { @p.parse %w(--hello) }
-    assert_nothing_raised { @p.parse %w(--jello) }
-    assert_nothing_raised { @p.parse %w(--yellow) }
-    assert_nothing_raised { @p.parse %w(--mellow) }
+    @p.parse %w(--hello)
+    @p.parse %w(--jello)
+    @p.parse %w(--yellow)
+    @p.parse %w(--mellow)
 
-    assert_nothing_raised { @p.parse %w(--mellow --one) }
-    assert_nothing_raised { @p.parse %w(--mellow --two) }
+    @p.parse %w(--mellow --one)
+    @p.parse %w(--mellow --two)
 
     assert_raises(CommandlineError) { @p.parse %w(--mellow --two --jello) }
     assert_raises(CommandlineError) { @p.parse %w(--one --mellow --two --jello) }
@@ -857,21 +849,15 @@ Options:
     @p.opt "two"
     @p.conflicts :one, "two"
 
-    begin
-      @p.parse %w(--one --two)
-      flunk "no error thrown"
-    rescue CommandlineError => e
-      assert_match(/--one/, e.message)
-      assert_match(/--two/, e.message)
-    end
+    assert_raises(CommandlineError, /--one.*--two/) { @p.parse %w(--one --two) }
   end
 
   def test_depends
     @p.opt :one
     assert_raises(ArgumentError) { @p.depends :one, :two }
     @p.opt :two
-    assert_nothing_raised { @p.depends :one, :two }
-    assert_nothing_raised { @p.parse %w(--one --two) }
+    @p.depends :one, :two
+    @p.parse %w(--one --two)
     assert_raises(CommandlineError) { @p.parse %w(--one) }
     assert_raises(CommandlineError) { @p.parse %w(--two) }
 
@@ -880,15 +866,15 @@ Options:
     @p.opt :mellow
     @p.opt :jello
     @p.depends :hello, :yellow, :mellow, :jello
-    assert_nothing_raised { @p.parse %w(--hello --yellow --mellow --jello) }
+    @p.parse %w(--hello --yellow --mellow --jello)
     assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
     assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
 
     assert_raises(CommandlineError) { @p.parse %w(--hello) }
     assert_raises(CommandlineError) { @p.parse %w(--mellow) }
 
-    assert_nothing_raised { @p.parse %w(--hello --yellow --mellow --jello --one --two) }
-    assert_nothing_raised { @p.parse %w(--hello --yellow --mellow --jello --one --two a b c) }
+    @p.parse %w(--hello --yellow --mellow --jello --one --two)
+    @p.parse %w(--hello --yellow --mellow --jello --one --two a b c)
 
     assert_raises(CommandlineError) { @p.parse %w(--mellow --two --jello --one) }
   end
@@ -898,23 +884,10 @@ Options:
     @p.opt "two"
     @p.depends :one, "two"
 
-    assert_nothing_raised { @p.parse %w(--one --two) }
-
-    begin
-      @p.parse %w(--one)
-      flunk "no error thrown"
-    rescue CommandlineError => e
-      assert_match(/--one/, e.message)
-      assert_match(/--two/, e.message)
-    end
+    @p.parse %w(--one --two)
 
-    begin
-      @p.parse %w(--two)
-      flunk "no error thrown"
-    rescue CommandlineError => e
-      assert_match(/--one/, e.message)
-      assert_match(/--two/, e.message)
-    end
+    assert_raises(CommandlineError, /--one.*--two/) { @p.parse %w(--one) }
+    assert_raises(CommandlineError, /--one.*--two/) { @p.parse %w(--two) }
   end
 
   ## courtesy neill zero
@@ -922,21 +895,9 @@ Options:
     @p.opt "arg1", "desc1", :required => true
     @p.opt "arg2", "desc2", :required => true
 
-    begin
-      @p.parse(%w(--arg1))
-      flunk "should have failed on a missing req"
-    rescue CommandlineError => e
-      assert e.message =~ /arg2/, "didn't mention arg2 in the error msg: #{e.message}"
-    end
-
-    begin
-      @p.parse(%w(--arg2))
-      flunk "should have failed on a missing req"
-    rescue CommandlineError => e
-      assert e.message =~ /arg1/, "didn't mention arg1 in the error msg: #{e.message}"
-    end
-
-    assert_nothing_raised { @p.parse(%w(--arg1 --arg2)) }
+    assert_raises(CommandlineError, /arg2/) { @p.parse(%w(--arg1)) }
+    assert_raises(CommandlineError, /arg1/) { @p.parse(%w(--arg2)) }
+    @p.parse(%w(--arg1 --arg2))
   end
 
   def test_stopwords_mixed
@@ -1064,21 +1025,20 @@ Options:
     @p.opt :arg2, 'desc', :type => Date
     @p.opt :arg3, 'desc', :default => temp
 
-    opts = nil
-    assert_nothing_raised { opts = @p.parse }
+    opts = @p.parse []
     assert_equal temp, opts[:arg3]
 
-    assert_nothing_raised { opts = @p.parse %w(--arg 5/1/2010) }
+    opts = @p.parse %w(--arg 5/1/2010)
     assert_kind_of Date, opts[:arg]
     assert_equal Date.new(2010, 5, 1), opts[:arg]
 
-    assert_nothing_raised { opts = @p.parse %w(--arg2 5/1/2010) }
+    opts = @p.parse %w(--arg2 5/1/2010)
     assert_kind_of Date, opts[:arg2]
     assert_equal Date.new(2010, 5, 1), opts[:arg2]
   end
 
   def test_unknown_arg_class_type
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       @p.opt :arg, 'desc', :type => Hash
     end
   end
@@ -1088,19 +1048,18 @@ Options:
     @p.opt :arg2, "desc", :type => IO
     @p.opt :arg3, "desc", :default => $stdout
 
-    opts = nil
-    assert_nothing_raised { opts = @p.parse() }
+    opts = @p.parse []
     assert_equal $stdout, opts[:arg3]
 
-    assert_nothing_raised { opts = @p.parse %w(--arg /dev/null) }
+    opts = @p.parse %w(--arg /dev/null)
     assert_kind_of File, opts[:arg]
     assert_equal "/dev/null", opts[:arg].path
 
     #TODO: move to mocks
-    #assert_nothing_raised { opts = @p.parse %w(--arg2 http://google.com/) }
+    #opts = @p.parse %w(--arg2 http://google.com/)
     #assert_kind_of StringIO, opts[:arg2]
 
-    assert_nothing_raised { opts = @p.parse %w(--arg3 stdin) }
+    opts = @p.parse %w(--arg3 stdin)
     assert_equal $stdin, opts[:arg3]
 
     assert_raises(CommandlineError) { opts = @p.parse %w(--arg /fdasfasef/fessafef/asdfasdfa/fesasf) }
@@ -1112,8 +1071,8 @@ Options:
 
     opts = @p.parse(%w(--arg1 3 --arg2 4))
 
-    assert_nothing_raised { opts.arg1 }
-    assert_nothing_raised { opts.arg2 }
+    opts.arg1
+    opts.arg2
     assert_equal 3, opts.arg1
     assert_equal 4, opts.arg2
   end
@@ -1122,7 +1081,7 @@ Options:
     @p.opt :arg1, "desc", :default => "hello", :multi => true
     @p.opt :arg2, "desc", :default => ["hello"], :multi => true
 
-    opts = @p.parse
+    opts = @p.parse []
     assert_equal ["hello"], opts[:arg1]
     assert_equal ["hello"], opts[:arg2]
 
@@ -1227,7 +1186,6 @@ Options:
       ::Trollop::options do
         opt :potato
       end
-      raise "broken"
     end
   end
 
@@ -1239,18 +1197,14 @@ Options:
         version "1.2"
         opt :potato
       end
-      raise "broken"
     end
   end
 
   def test_simple_interface_handles_regular_usage
     ARGV.clear
     ARGV.unshift "--potato"
-    opts = nil
-    assert_nothing_raised do
-      opts = ::Trollop::options do
-        opt :potato
-      end
+    opts = ::Trollop::options do
+      opt :potato
     end
     assert opts[:potato]
   end
@@ -1281,7 +1235,7 @@ Options:
   end
 
   def test_with_standard_exception_handling
-    assert_raise(SystemExit) do
+    assert_raises(SystemExit) do
       ::Trollop.with_standard_exception_handling(@p) do
         raise ::Trollop::CommandlineError.new('cl error')
       end