wool 0.5.1

data/spec/warning_specs/rescue_exception_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RescueExceptionWarning do
+  it 'is a file-based warning' do
+    RescueExceptionWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  it 'matches against a rescue of Exception as the only type' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue Exception; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is used' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError; end')
+  end
+  
+  it 'matches against a rescue of Exception with an additional identifier' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue Exception => e; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is used with an additional identifier' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError => e; end')
+  end
+  
+  it 'matches against a rescue of Exception that is specified second' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue StandardError, Exception; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is specified second' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError, StandardError; end')
+  end
+  
+  it 'matches against a rescue of Exception that is specified second w/ addl identifier' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue StandardError, Exception => err; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is specified second w/ addl identifier' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError, StandardError => err; end')
+  end
+
+  context '#fix' do
+    it 'fixes a rescue of Exception as the only type' do
+      input = <<-EOF
+begin
+  puts x
+rescue Exception  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+    
+    it 'fixes a rescue of Exception with an additional identifier' do
+      input = <<-EOF
+begin
+  puts x
+rescue Exception => e  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError => e  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+    
+    it 'fixes a rescue of Exception that is specified second' do
+      input = <<-EOF
+begin
+  puts x
+rescue StandardError, Exception  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError, StandardError  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+    
+    it 'fixes a rescue of Exception that is specified second w/ addl identifier' do
+      input = <<-EOF
+begin
+  puts x
+rescue StandardError, Exception => e  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError, StandardError => e  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+  end
+end

data/spec/warning_specs/semicolon_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe SemicolonWarning do
+  it 'is a line-based warning' do
+    SemicolonWarning.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it 'matches when a semicolon splits two expressions' do
+    SemicolonWarning.should warn('puts x; puts y')
+  end
+
+  it 'matches when a semicolon splits two expressions that have strings' do
+    SemicolonWarning.should warn('puts "x"; puts "y"')
+  end
+
+  it "doesn't match when a semicolon is in a string" do
+    SemicolonWarning.should_not warn('puts "x;y"')
+  end
+
+  it "doesn't match when a semicolon is in a single-quoted string" do
+    SemicolonWarning.should_not warn("puts 'x;y'")
+  end
+
+  it "doesn't match when a semicolon is used in an Exception definition" do
+    SemicolonWarning.should_not warn('class AError < BError; end"')
+  end
+
+  it 'has a lower severity when quotes are involved due to unsure-ness' do
+    SemicolonWarning.new('(stdin)', "hello' world' ; there").severity.should <
+    SemicolonWarning.new('(stdin)', 'hello world ; there').severity
+  end
+
+  it 'has a remotely descriptive description' do
+    SemicolonWarning.new('(stdin)', 'hello ; world').desc.should =~ /semicolon/
+  end
+
+  it "doesn't match when a semicolon is in a comment" do
+    SemicolonWarning.should_not warn("hello # indeed; i agree")
+  end
+
+  context '#fix' do
+    it 'converts the simplest semicolon use to two lines' do
+      SemicolonWarning.should correct_to('a;b', "a\nb")
+    end
+
+    it 'converts the simplest triple semicolon use to two lines' do
+      SemicolonWarning.should correct_to('a;b;c', "a\nb\nc")
+    end
+
+    it 'maintains indentation on new lines' do
+      SemicolonWarning.should correct_to('  a;b', "  a\n  b")
+    end
+
+    it 'maintains indentation on all new lines' do
+      SemicolonWarning.should correct_to('  a;b;c', "  a\n  b\n  c")
+    end
+  end
+end

data/spec/warning_specs/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')

data/spec/warning_specs/useless_double_quotes_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe UselessDoubleQuotesWarning do
+  it 'is a file-based warning' do
+    UselessDoubleQuotesWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  it 'matches when a simple string is in double quotes unnecessarily' do
+    UselessDoubleQuotesWarning.should warn('simple "example, okay?"')
+  end
+  
+  it 'matches when a simple string is in %Q{} unnecessarily' do
+    UselessDoubleQuotesWarning.should warn('simple %Q{example, okay?}')
+  end
+  
+  it 'does not match when an escape sequence is used' do
+    UselessDoubleQuotesWarning.should_not warn('simple "example\n okay?"')
+  end
+  
+  it 'does not match when an apostrophe is present' do
+    UselessDoubleQuotesWarning.should_not warn('simple "example\' okay?"')
+  end
+  
+  it 'does not match when text interpolation is used' do
+    UselessDoubleQuotesWarning.should_not warn('simple "exaple\n #{h stuff} okay?"')
+  end
+  
+  it 'does match when a useless double-quoted string is used inside text interpolation' do
+    UselessDoubleQuotesWarning.should warn('simple "example, #{h "guy"} okay?"')
+  end
+  
+  it 'does not warn about single quotes that are nice and simple' do
+    UselessDoubleQuotesWarning.should_not warn("simple 'string is okay'")
+  end
+  
+  it 'does not warn about %q syntax that are simple' do
+    UselessDoubleQuotesWarning.should_not warn("simple %q{string is okay}")
+  end
+
+  context '#fix' do
+    it 'fixes a simple string using double quotes unnecessarily' do
+      checker = UselessDoubleQuotesWarning.new('(stdin)', 'simple "example, okay?"')
+      warnings = checker.match?
+      warnings.size.should == 1
+      warnings.first.fix('simple "example, okay?"').should == "simple 'example, okay?'"
+    end
+    
+    it 'fixes a simple string using %Q{} unnecessarily' do
+      checker = UselessDoubleQuotesWarning.new('(stdin)', 'simple %Q{example, okay?}')
+      warnings = checker.match?
+      warnings.size.should == 1
+      warnings.first.fix('simple %Q{example, okay?}').should == "simple %q{example, okay?}"
+    end
+        
+    it 'fixes a simple string inside a complex one' do
+      checker = UselessDoubleQuotesWarning.new('(stdin)', 'simple "example, #{h "guy"} okay?"')
+      warnings = checker.match?
+      warnings.size.should == 1
+      warnings.first.fix('simple "example, #{h "guy"} okay?"').should == 'simple "example, #{h \'guy\'} okay?"'
+    end
+  end
+end

data/spec/wool_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Wool do
+  it "has a version" do
+    VERSION.should_not be_nil
+    VERSION.should >= "0.5.0"
+  end
+end

data/status_reports/2010/12/2010-12-14.md

@@ -0,0 +1,163 @@
+Today, I've pushed significant work on Wool. It's still very rough around the edges, but I've got it doing the following new, cool, and somewhat-advanced analyses:
+
+## Using a semicolon to separate statements
+
+If you'd like to warn against using a semicolon to separate statements on a single line, you can turn this warning on. However, due to personal preference, if you do this:
+
+    class MyError < StandardError; end
+
+it won't complain. This, though:
+
+    puts x; puts y
+
+will be an error. Wool is capable of fixing this error while maintaining indentation levels, up to arbitrary number of violating semicolons:
+
+    # some comment
+      p x; p y; p z; p 10
+
+becomes
+
+    # some comment
+      p x
+      p y
+      p z
+      p 10
+
+Cool, eh? I think I have this one nailed down to 100% accuracy, too.
+
+## Whitespace Tomfoolery
+
+Two separate ones here, extra blank lines and trailing whitespace. Both of these are significant mainly because when you violate them, you hurt signal-to-noise in VCS diffs. Committing 2 rows deleted and added with just trailing whitespace differences is just a shame.
+
+### Extra Blank Lines
+
+Ever leave blank lines at the end of your file? This warning tells you how many lines you left at the end, and fixes them if you wish.
+
+### Trailing Whitespace
+
+Extra spaces and tabs at the end of a line fall in this category, and can be fixed without disturbing the source code.
+
+## Operator Spacing
+
+This one is a bit dicy, but it tries to enforce spacing between operators. This gets tough because of lines with block declarations (where `|`s form the variable declaration area in a block, and do not act as a binary or operator), array splatting, block argument declarations, and so on. That's mainly a problem if you use regexes, which the current implementation does use. The parser will be employed shortly to remedy this situation.
+
+## Misaligned Indentation
+
+This is another one that needs a bit of an overhaul, but it works pretty well so far. This warning checks how well you indent, namely, that you indent at consistent multiples, and that you unindent evenly. However, it doesn't yet take into account line continuation, where you should then indent relevant to the previous line (and not via the multiplication pattern). So it can detect and correct these mistakes:
+
+    if x
+      if y
+          if z
+            p x
+          end
+        end
+        end
+
+becoming
+
+    if x
+      if y
+        if z
+          p x
+        end
+      end
+    end
+
+Cool eh? It does make some mistakes though, and there are definite examples in the wool code itself that this will mess up on.
+
+## Line Length
+
+Line Length is a fun one!
+
+The line length warnings let you specify multiple levels of severity for different violations, such as a level 2 warning for being between 80-89 chars and a 4 for 90+. Detecting this is extremely simple. Also, it considers whitespace stripping when calculating a line's minimum possible length.
+
+The really fun part is *fixing* it. Because Ruby code is sensitive to newlines, we can't just break it up into neat 80-char lines on the whitespace. So there's a few quick heuristics currently in play that I think are significant to brag about.
+
+### Comment Rearranging
+
+If a line is over the limit, but it has a comment at the end of it, we know we can take the comment and put it on the line above. It really belongs there anyway if it's going off the edge – the line it's describing is long enough to go near the edge, so it's probably quite complex. Its comment should have its own line.
+
+This heuristic however could create a *new* line that's over the limit, if the comment is comically long. So we also break the comment into correctly-sized lines, all indented to match the original line.
+
+An example, if the max line length is 20:
+
+    puts x * y * z / a # this computes a significant equation involving math
+
+you'll get back:
+
+    # this computes a
+    # significant
+    # equation involving
+    # math
+    # puts x * y * z / a
+
+which still has no line length violations! It naturally smooths out at longer line lengths.
+
+### Guard rearranging
+
+Here's one that bugs me. When I write a conditional Exception raise, I think of it this way:
+
+    raise FooBarError.new('Steve forgot to write the Foo bar library') unless steve.finished?
+
+but that's usually way over the line length limit. In truth, I should check it in like this:
+
+    unless steve.finished?
+      raise FooBarError.new('Steve forgot to write the Foo bar library')
+    end
+
+And if you use Wool now, you can leave code in the first form and it will transform to the second form! In fact, it works for multiple guards, too:
+
+    raise FooBarError.new('Steve forgot to write the Foo bar library') unless steve.finished?(schedule) if foo_bar.missing?(search_results) unless working?(test_data, &test_proc)
+
+wool magically transforms into:
+
+    unless working?(test_data, &test_proc)
+      if foo_bar.missing?(search_results)
+        unless steve.finished?(schedule)
+          raise FooBarError.new('Steve forgot to write the Foo bar library')
+        end
+      end
+    end
+
+Which is clean and better. It actually picks up on-the-line cases I missed on a somewhat regular basis!
+
+That's all for line length shortening. I know there's a lot more to do with continued lines (ending a line with a `+` token before the line-length cutoff, for example, means you know you can break the line into a new one at that point, resulting in a smaller problem and 1 valid line. Repeating this with all the safe tokens should result in a *lot* of progress.
+
+## Inline comment spacing
+
+My style guide (derived mainly from the Google style guide, with a few exceptions that everyone takes because it's a wee bit off) says that inline comments must have exactly 2 spaces between the last non-whitespace character and the hash mark beginning the comment. This is easily detected, enforced, and corrected. So Wool does!
+
+## Unnecessary Double Quotes
+
+When you use double quotes, the parser has to go and check for string interpolation and escape sequences. This is also true when you use the `%Q{}` syntax. Thus it is slower to use double quotes or `%Q{}` when you don't need those features. Wool detects this and corrects double-quotes to single quotes (unless there is an escape sequence in the text or an apostrophe) and `%Q{}` to `%q{}`. It uses the raw AST, so it isn't error-prone like the regex-based passes.
+
+## `rescue Exception`
+
+is bad! If you're rescuing Exception, you're rescuing a *lot* of things. You're covering up syntax errors. Just about the only thing you don't rescue is `SystemExit`. Almost always, you should be `rescue`ing `StandardError`. Wool currently can detect this based on the AST in all cases, but it cannot auto-correct them yet.
+
+# Up Next: Immediate
+
+Next, I'm going to start defining the API for constant-ness, with a tag on the AST that I'll make a pass to infer. I'll also be adding
+
+    default_attr_accessor :pure, false
+
+to Method and Proc, so methods can be annotated as Pure. Thus, a method call on a constant object with constant arguments (if any) and a constant proc for a block (because it contains only pure calls...) is itself a constant expression. All these rules can be enumerated and inferred, and once the standard library batch of annotations is underway a lot of cool examples of success are going to come out of this. For example, [Rubinius](http://rubini.us) could use our constant-ness evaluator to (with a flag of course, not by default) allow constant assignment in methods to constant expressions:
+
+    def enable_global_settings
+      LOGGER = DEBUG_MODE ? StdoutLogger.new : nil
+    end
+
+# Down The Line
+
+Here's a quick brain dump of down-the-line ideas:
+
+* Next large goal: Load in class and method defs in the main, simple cases, and hammer out an annotation system and a LALR(1) parser for it. Use racc to implement parser.
+* I could discuss getting the annotations contributed to RubySpec. That's a bit boastful but hey, if they're accurate, they could be helpful.
+* I'll be starting with the assumption that type annotations are available. That is because, in the spirit of [Gilad's pluggable types](http://bracha.org/pluggableTypesPosition.pdf) inference can be provided as tooling, but is not necessary to develop the rich type system you wish to describe.
+* Rubinius could use an annotated method to improve code paths.
+* I could dump the basic flow data I collect, including types of blocks and return types, variables, etc. to a database or YAML or something. I'll be getting a lot. That YAML could be integrated into an editor to provide hover-over type information. Smart autocomplete could be within reach, not that RubyMine is that bad.
+* A few more syntax things should get done, and I need to overhaul how tokens come out of the lexer process, as right now I'm just handling them raw, which makes for horrible-to-maintain code.
+* Coverage is near-100% in my eyes. The specs are just wonderful. There are a couple known bugs and those are in my sights.
+* I tried integrating with Redcar to get an automatic "fix unnecessary double quotes" plugin going, but I ran into huge trouble. Wool needs Ruby 1.9.2, and Redcar uses JRuby, but for some reason when I ran redcar with `rvm use 1.9.2-head`, it blows up on startup. If I run redcar with `rvm use system`, it runs just as dandily as always, but now Wool won't run because it needs 1.9.2. Probably some loader magic to do to find a 1.9 ruby executable, potentially having to interact with `rvm` to infer it.
+
+Stay tuned, as always, for more.

data/test/third_party_tests/test_trollop.rb

@@ -0,0 +1,1181 @@
+## 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 'stringio'
+require 'wool/third_party/trollop'
+
+module Trollop
+module Test
+
+class Trollop < ::Test::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' }
+  end
+
+  def test_unknown_arguments
+    assert_raise(CommandlineError) { @p.parse(%w(--arg)) }
+    @p.opt "arg"
+    assert_nothing_raised { @p.parse(%w(--arg)) }
+    assert_raise(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)) }
+  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"
+    @p.opt "goodarg2"
+    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_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
+
+    # single arg: int
+    assert_nothing_raised { @p.opt "argsi", "desc", :default => 0 }
+    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    assert_equal 0, opts["argsi"]
+    assert_nothing_raised { 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)) }
+
+    # single arg: float
+    assert_nothing_raised { @p.opt "argsf", "desc", :default => 3.14 }
+    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    assert_equal 3.14, opts["argsf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argsf 2.41)) }
+    assert_equal 2.41, opts["argsf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argsf 2)) }
+    assert_equal 2, opts["argsf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argsf 1.0e-2)) }
+    assert_equal 1.0e-2, opts["argsf"]
+    assert_raise(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(--)) }
+    assert_equal Date.today, opts["argsd"]
+    assert_nothing_raised { opts = @p.parse(['--argsd', 'Jan 4, 2007']) }
+    assert_equal Date.civil(2007, 1, 4), opts["argsd"]
+    assert_raise(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(--)) }
+    assert_equal "foobar", opts["argss"]
+    assert_nothing_raised { opts = @p.parse(%w(--argss 2.41)) }
+    assert_equal "2.41", opts["argss"]
+    assert_nothing_raised { 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(--)) }
+    assert_equal [3, 5], opts["argmi"]
+    assert_nothing_raised { 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)) }
+
+    # multi args: floats
+    assert_nothing_raised { @p.opt "argmf", "desc", :default => [3.34, 5.21] }
+    assert_nothing_raised { opts = @p.parse(%w(--)) }
+    assert_equal [3.34, 5.21], opts["argmf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argmf 2)) }
+    assert_equal [2], opts["argmf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argmf 4.0)) }
+    assert_equal [4.0], opts["argmf"]
+    assert_raise(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(--)) }
+    assert_equal dates, opts["argmd"]
+    assert_nothing_raised { opts = @p.parse(['--argmd', 'Jan 4, 2007']) }
+    assert_equal [Date.civil(2007, 1, 4)], opts["argmd"]
+    assert_raise(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(--)) }
+    assert_equal %w(hello world), opts["argmst"]
+    assert_nothing_raised { opts = @p.parse(%w(--argmst 3.4)) }
+    assert_equal ["3.4"], opts["argmst"]
+    assert_nothing_raised { 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_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"] }
+  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_created_automatically
+    @p.opt "arg"
+    @p.opt "arg2"
+    @p.opt "arg3"
+    opts = @p.parse %w(-a -g)
+    assert_equal true, opts["arg"]
+    assert_equal false, opts["arg2"]
+    assert_equal true, opts["arg3"]
+  end
+
+  def test_short_autocreation_skips_dashes_and_numbers
+    @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)!
+
+    opts = @p.parse %w(-f -d)
+    assert_equal true, opts[:arg_daisy]
+    assert_equal true, opts[:arg_r2d2f]
+    assert_equal false, opts[:arg]
+    assert_equal false, opts[:arg_potato]
+    assert_equal false, opts[:arg_muffin]
+  end
+
+  def test_short_autocreation_is_ok_with_running_out_of_chars
+    @p.opt :arg1 # auto: a
+    @p.opt :arg2 # auto: r
+    @p.opt :arg3 # auto: g
+    @p.opt :arg4 # auto: uh oh!
+    assert_nothing_raised { @p.parse [] }
+  end
+
+  def test_short_can_be_nothing
+    assert_nothing_raised do
+      @p.opt "arg", "desc", :short => :none
+      @p.parse []
+    end
+
+    sio = StringIO.new "w"
+    @p.educate sio
+    assert sio.string =~ /--arg:\s+desc/
+
+    assert_raise(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" }
+  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"
+    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_date_formatting
+    @p.opt :arg, "desc", :type => :date, :short => 'd'
+    opts = nil
+    assert_nothing_raised { opts = @p.parse(['-d', 'Jan 4, 2007']) }
+    assert_equal Date.civil(2007, 1, 4), opts[:arg]
+  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_if_not_specified
+    @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_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) }
+  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) }
+    assert_equal %w(a b), opts[:xarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def 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
+
+    assert_nothing_raised { 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) }
+    assert_equal true, opts[:xarg]
+    assert_equal %w(a b), @p.leftovers
+
+    assert_nothing_raised { 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) }
+    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) }
+    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) }
+    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) }
+    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) }
+    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) }
+    assert_equal [%w(a b c), %w(d e)], opts[:zarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def test_combined_short_options_with_multiple_arguments
+    @p.opt :arg1, "desc", :short => "a"
+    @p.opt :arg2, "desc", :short => "b"
+    @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) }
+    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) }
+    assert_equal true, opts[:arg1]
+    assert_equal true, opts[:arg2]
+    assert_equal [4, 6, 9], opts[:arg3]
+    assert_equal [3.14, 2.41], opts[:arg4]
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(-abcd 3.14 2.41) }
+  end
+
+  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) }
+    assert_equal %w(a b), opts[:xarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { 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) }
+    assert_equal [3, 2, 5], opts[:xarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { 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) }
+    assert_equal [3.14, 2.41, 5.66], opts[:yarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { 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) }
+    assert_equal %w(a b c), opts[:zarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { 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) }
+    assert_equal [[3, 2, 5], [2, 1]], opts[:xarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { 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) }
+    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) }
+    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) }
+    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) }
+    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() }
+    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]
+    ## actually, this next one is valid. empty string for --arg, and goat as a
+    ## leftover.
+    ## 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
+
+  def test_arguments_passed_through_block
+    @goat = 3
+    boat = 4
+    Parser.new(@goat) do |goat|
+      boat = goat
+    end
+    assert_equal @goat, boat
+  end
+
+  def test_help_has_default_banner
+    @p = Parser.new
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /options/i
+    assert_equal 2, help.length # options, then -h
+
+    @p = Parser.new
+    @p.version "my version"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /my version/i
+    assert_equal 4, help.length # version, options, -h, -v
+
+    @p = Parser.new
+    @p.banner "my own banner"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /my own banner/i
+    assert_equal 2, help.length # banner, -h
+  end
+
+  def test_help_preserves_positions
+    @p.opt :zzz, "zzz"
+    @p.opt :aaa, "aaa"
+    sio = StringIO.new "w"
+    @p.educate sio
+
+    help = sio.string.split "\n"
+    assert help[1] =~ /zzz/
+    assert help[2] =~ /aaa/
+  end
+  
+  def test_help_includes_option_types
+    @p.opt :arg1, 'arg', :type => :int
+    @p.opt :arg2, 'arg', :type => :ints
+    @p.opt :arg3, 'arg', :type => :string
+    @p.opt :arg4, 'arg', :type => :strings
+    @p.opt :arg5, 'arg', :type => :float
+    @p.opt :arg6, 'arg', :type => :floats
+    @p.opt :arg7, 'arg', :type => :io
+    @p.opt :arg8, 'arg', :type => :ios
+    @p.opt :arg9, 'arg', :type => :date
+    @p.opt :arg10, 'arg', :type => :dates
+    sio = StringIO.new "w"
+    @p.educate sio
+    
+    help = sio.string.split "\n"
+    assert help[1] =~ /<i>/
+    assert help[2] =~ /<i\+>/
+    assert help[3] =~ /<s>/
+    assert help[4] =~ /<s\+>/
+    assert help[5] =~ /<f>/
+    assert help[6] =~ /<f\+>/
+    assert help[7] =~ /<filename\/uri>/
+    assert help[8] =~ /<filename\/uri\+>/
+    assert help[9] =~ /<date>/
+    assert help[10] =~ /<date\+>/
+  end
+  
+  def test_help_has_grammatical_default_text
+    @p.opt :arg1, 'description with period.', :default => 'hello'
+    @p.opt :arg2, 'description without period', :default => 'world'
+    sio = StringIO.new 'w'
+    @p.educate sio
+    
+    help = sio.string.split "\n"
+    assert help[1] =~ /Default/
+    assert help[2] =~ /default/
+  end
+
+  def test_version_and_help_short_args_can_be_overridden
+    @p.opt :verbose, "desc", :short => "-v"
+    @p.opt :hello, "desc", :short => "-h"
+    @p.version "version"
+
+    assert_nothing_raised { @p.parse(%w(-v)) }
+    assert_raises(VersionNeeded) { @p.parse(%w(--version)) }
+    assert_nothing_raised { @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) }
+  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) }
+    assert_raises(CommandlineError) { @p.parse %w(--asdf) }
+    assert_raises(HelpNeeded) { @p.parse %w(--asdf --help) }
+    assert_raises(VersionNeeded) { @p.parse %w(--asdf --version) }
+  end
+
+  def test_conflicts
+    @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) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--one --two) }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.conflicts :hello, :yellow, :mellow, :jello
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --yellow --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --jello) }
+
+    assert_nothing_raised { opts = @p.parse %w(--hello) }
+    assert_nothing_raised { opts = @p.parse %w(--jello) }
+    assert_nothing_raised { opts = @p.parse %w(--yellow) }
+    assert_nothing_raised { opts = @p.parse %w(--mellow) }
+
+    assert_nothing_raised { opts = @p.parse %w(--mellow --one) }
+    assert_nothing_raised { opts = @p.parse %w(--mellow --two) }
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--mellow --two --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--one --mellow --two --jello) }
+  end
+
+  def test_conflict_error_messages
+    @p.opt :one
+    @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
+  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 { opts = @p.parse %w(--one --two) }
+    assert_raises(CommandlineError) { @p.parse %w(--one) }
+    assert_raises(CommandlineError) { @p.parse %w(--two) }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.depends :hello, :yellow, :mellow, :jello
+    assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --jello) }
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--mellow) }
+
+    assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello --one --two) }
+    assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello --one --two a b c) }
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--mellow --two --jello --one) }
+  end
+
+  def test_depend_error_messages
+    @p.opt :one
+    @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
+
+    begin
+      @p.parse %w(--two)
+      flunk "no error thrown"
+    rescue CommandlineError => e
+      assert_match(/--one/, e.message)
+      assert_match(/--two/, e.message)
+    end
+  end
+
+  ## courtesy neill zero
+  def test_two_required_one_missing_accuses_correctly
+    @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)) }
+  end
+
+  def test_stopwords_mixed
+    @p.opt "arg1", :default => false
+    @p.opt "arg2", :default => false
+    @p.stop_on %w(happy sad)
+
+    opts = @p.parse %w(--arg1 happy --arg2)
+    assert_equal true, opts["arg1"]
+    assert_equal false, opts["arg2"]
+
+    ## restart parsing
+    @p.leftovers.shift
+    opts = @p.parse @p.leftovers
+    assert_equal false, opts["arg1"]
+    assert_equal true, opts["arg2"]
+  end
+
+  def test_stopwords_no_stopwords
+    @p.opt "arg1", :default => false
+    @p.opt "arg2", :default => false
+    @p.stop_on %w(happy sad)
+
+    opts = @p.parse %w(--arg1 --arg2)
+    assert_equal true, opts["arg1"]
+    assert_equal true, opts["arg2"]
+
+    ## restart parsing
+    @p.leftovers.shift
+    opts = @p.parse @p.leftovers
+    assert_equal false, opts["arg1"]
+    assert_equal false, opts["arg2"]
+  end
+
+  def test_stopwords_multiple_stopwords
+    @p.opt "arg1", :default => false
+    @p.opt "arg2", :default => false
+    @p.stop_on %w(happy sad)
+
+    opts = @p.parse %w(happy sad --arg1 --arg2)
+    assert_equal false, opts["arg1"]
+    assert_equal false, opts["arg2"]
+
+    ## restart parsing
+    @p.leftovers.shift
+    opts = @p.parse @p.leftovers
+    assert_equal false, opts["arg1"]
+    assert_equal false, opts["arg2"]
+
+    ## restart parsing again
+    @p.leftovers.shift
+    opts = @p.parse @p.leftovers
+    assert_equal true, opts["arg1"]
+    assert_equal true, opts["arg2"]
+  end
+
+  def test_stopwords_with_short_args
+    @p.opt :global_option, "This is a global option", :short => "-g"
+    @p.stop_on %w(sub-command-1 sub-command-2)
+
+    global_opts = @p.parse %w(-g sub-command-1 -c)
+    cmd = @p.leftovers.shift
+
+    @q = Parser.new
+    @q.opt :cmd_option, "This is an option only for the subcommand", :short => "-c"
+    cmd_opts = @q.parse @p.leftovers
+
+    assert_equal true, global_opts[:global_option]
+    assert_nil global_opts[:cmd_option]
+
+    assert_equal true, cmd_opts[:cmd_option]
+    assert_nil cmd_opts[:global_option]
+
+    assert_equal cmd, "sub-command-1"
+    assert_equal @q.leftovers, []
+  end
+
+  def assert_parses_correctly(parser, commandline, expected_opts,
+                              expected_leftovers)
+    opts = parser.parse commandline
+    assert_equal expected_opts, opts
+    assert_equal expected_leftovers, parser.leftovers
+  end
+
+  def test_unknown_subcommand
+    @p.opt :global_flag, "Global flag", :short => "-g", :type => :flag
+    @p.opt :global_param, "Global parameter", :short => "-p", :default => 5
+    @p.stop_on_unknown
+
+    expected_opts = { :global_flag => true, :help => false, :global_param => 5, :global_flag_given => true }
+    expected_leftovers = [ "my_subcommand", "-c" ]
+
+    assert_parses_correctly @p, %w(--global-flag my_subcommand -c), \
+      expected_opts, expected_leftovers
+    assert_parses_correctly @p, %w(-g my_subcommand -c), \
+      expected_opts, expected_leftovers
+
+    expected_opts = { :global_flag => false, :help => false, :global_param => 5, :global_param_given => true }
+    expected_leftovers = [ "my_subcommand", "-c" ]
+
+    assert_parses_correctly @p, %w(-p 5 my_subcommand -c), \
+      expected_opts, expected_leftovers
+    assert_parses_correctly @p, %w(--global-param 5 my_subcommand -c), \
+      expected_opts, expected_leftovers
+  end
+
+  def test_alternate_args
+    args = %w(-a -b -c)
+
+    opts = ::Trollop.options(args) do
+      opt :alpher, "Ralph Alpher", :short => "-a"
+      opt :bethe, "Hans Bethe", :short => "-b"
+      opt :gamow, "George Gamow", :short => "-c"
+    end
+
+    physicists_with_humor = [:alpher, :bethe, :gamow]
+    physicists_with_humor.each do |physicist|
+      assert_equal true, opts[physicist]
+    end
+  end
+  
+  def test_date_arg_type
+    temp = Date.new
+    @p.opt :arg, 'desc', :type => :date
+    @p.opt :arg2, 'desc', :type => Date
+    @p.opt :arg3, 'desc', :default => temp
+    
+    opts = nil
+    assert_nothing_raised { opts = @p.parse }
+    assert_equal temp, opts[:arg3]
+    
+    assert_nothing_raised { opts = @p.parse %w(--arg 5/1/2010) }
+    assert_kind_of Date, opts[:arg]
+    assert_equal Date.parse('5/1/2010'), opts[:arg]
+    
+    assert_nothing_raised { opts = @p.parse %w(--arg2 5/1/2010) }
+    assert_kind_of Date, opts[:arg2]
+    assert_equal Date.parse('5/1/2010'), opts[:arg2]
+  end
+  
+  def test_unknown_arg_class_type
+    assert_raise ArgumentError do
+      @p.opt :arg, 'desc', :type => Hash
+    end
+  end
+  
+  def test_io_arg_type
+    @p.opt :arg, "desc", :type => :io
+    @p.opt :arg2, "desc", :type => IO
+    @p.opt :arg3, "desc", :default => $stdout
+
+    opts = nil
+    assert_nothing_raised { opts = @p.parse() }
+    assert_equal $stdout, opts[:arg3]
+
+    assert_nothing_raised { 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/) }
+    #assert_kind_of StringIO, opts[:arg2]
+
+    assert_nothing_raised { opts = @p.parse %w(--arg3 stdin) }
+    assert_equal $stdin, opts[:arg3]
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--arg /fdasfasef/fessafef/asdfasdfa/fesasf) }
+  end
+
+  def test_openstruct_style_access
+    @p.opt "arg1", "desc", :type => :int
+    @p.opt :arg2, "desc", :type => :int
+
+    opts = @p.parse(%w(--arg1 3 --arg2 4))
+
+    assert_nothing_raised { opts.arg1 }
+    assert_nothing_raised { opts.arg2 }
+    assert_equal 3, opts.arg1
+    assert_equal 4, opts.arg2
+  end
+
+  def test_multi_args_autobox_defaults
+    @p.opt :arg1, "desc", :default => "hello", :multi => true
+    @p.opt :arg2, "desc", :default => ["hello"], :multi => true
+
+    opts = @p.parse
+    assert_equal ["hello"], opts[:arg1]
+    assert_equal ["hello"], opts[:arg2]
+
+    opts = @p.parse %w(--arg1 hello)
+    assert_equal ["hello"], opts[:arg1]
+    assert_equal ["hello"], opts[:arg2]
+
+    opts = @p.parse %w(--arg1 hello --arg1 there)
+    assert_equal ["hello", "there"], opts[:arg1]
+  end
+
+  def test_ambigious_multi_plus_array_default_resolved_as_specified_by_documentation
+    @p.opt :arg1, "desc", :default => ["potato"], :multi => true
+    @p.opt :arg2, "desc", :default => ["potato"], :multi => true, :type => :strings
+    @p.opt :arg3, "desc", :default => ["potato"]
+    @p.opt :arg4, "desc", :default => ["potato", "rhubarb"], :short => :none, :multi => true
+
+    ## arg1 should be multi-occurring but not multi-valued
+    opts = @p.parse %w(--arg1 one two)
+    assert_equal ["one"], opts[:arg1]
+    assert_equal ["two"], @p.leftovers
+
+    opts = @p.parse %w(--arg1 one --arg1 two)
+    assert_equal ["one", "two"], opts[:arg1]
+    assert_equal [], @p.leftovers
+
+    ## arg2 should be multi-valued and multi-occurring
+    opts = @p.parse %w(--arg2 one two)
+    assert_equal [["one", "two"]], opts[:arg2]
+    assert_equal [], @p.leftovers
+
+    ## arg3 should be multi-valued but not multi-occurring
+    opts = @p.parse %w(--arg3 one two)
+    assert_equal ["one", "two"], opts[:arg3]
+    assert_equal [], @p.leftovers
+
+    ## arg4 should be multi-valued but not multi-occurring
+    opts = @p.parse %w()
+    assert_equal ["potato", "rhubarb"], opts[:arg4]
+  end
+
+  def test_given_keys
+    @p.opt :arg1
+    @p.opt :arg2
+
+    opts = @p.parse %w(--arg1)
+    assert opts[:arg1_given]
+    assert !opts[:arg2_given]
+
+    opts = @p.parse %w(--arg2)
+    assert !opts[:arg1_given]
+    assert opts[:arg2_given]
+
+    opts = @p.parse []
+    assert !opts[:arg1_given]
+    assert !opts[:arg2_given]
+
+    opts = @p.parse %w(--arg1 --arg2)
+    assert opts[:arg1_given]
+    assert opts[:arg2_given]
+  end
+
+  def test_default_shorts_assigned_only_after_user_shorts
+    @p.opt :aab, "aaa" # should be assigned to -b
+    @p.opt :ccd, "bbb" # should be assigned to -d
+    @p.opt :user1, "user1", :short => 'a'
+    @p.opt :user2, "user2", :short => 'c'
+
+    opts = @p.parse %w(-a -b)
+    assert opts[:user1]
+    assert !opts[:user2]
+    assert opts[:aab]
+    assert !opts[:ccd]
+
+    opts = @p.parse %w(-c -d)
+    assert !opts[:user1]
+    assert opts[:user2]
+    assert !opts[:aab]
+    assert opts[:ccd]
+  end
+
+  def test_accepts_arguments_with_spaces
+    @p.opt :arg1, "arg", :type => String
+    @p.opt :arg2, "arg2", :type => String
+
+    opts = @p.parse ["--arg1", "hello there", "--arg2=hello there"]
+    assert_equal "hello there", opts[:arg1]
+    assert_equal "hello there", opts[:arg2]
+    assert_equal 0, @p.leftovers.size
+  end
+
+  def test_multi_args_default_to_empty_array
+    @p.opt :arg1, "arg", :multi => true
+    opts = @p.parse []
+    assert_equal [], opts[:arg1]
+  end
+
+  def test_simple_interface_handles_help
+    ARGV.clear
+    ARGV.unshift "-h"
+    assert_raises(SystemExit) do
+      opts = ::Trollop::options do
+        opt :potato
+      end
+      raise "broken"
+    end
+  end
+
+  def test_simple_interface_handles_version
+    ARGV.clear
+    ARGV.unshift "-v"
+    assert_raises(SystemExit) do
+      opts = ::Trollop::options do
+        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
+    end
+    assert opts[:potato]
+  end
+
+  def test_simple_interface_handles_die
+    old_stderr, $stderr = $stderr, StringIO.new('w')
+    ARGV.clear
+    ARGV.unshift "--potato"
+    opts = ::Trollop::options do
+      opt :potato
+    end
+    assert_raises(SystemExit) { ::Trollop::die :potato, "is invalid" }
+  ensure
+    $stderr = old_stderr
+  end
+  
+  def test_simple_interface_handles_die_without_message
+    old_stderr, $stderr = $stderr, StringIO.new('w')
+    ARGV.clear
+    ARGV.unshift "--potato"
+    opts = ::Trollop::options do
+      opt :potato
+    end
+    assert_raises(SystemExit) { ::Trollop::die :potato }
+    assert $stderr.string =~ /Error:/
+  ensure
+    $stderr = old_stderr
+  end
+  
+  def test_with_standard_exception_handling
+    assert_raise(SystemExit) do
+      ::Trollop.with_standard_exception_handling(@p) do
+        raise ::Trollop::CommandlineError.new('cl error')
+      end
+    end
+  end
+end
+
+end
+end