slop 2.4.4 → 3.0.0.rc1

data/test/option_test.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class OptionTest < TestCase
   def option(*args, &block)
-    Slop.new.option(*args, &block)
+    Slop.new.on(*args, &block)
   end
 
   def option_with_argument(*args, &block)
@@ -10,196 +10,102 @@ class OptionTest < TestCase
     slop = Slop.new
     option = slop.opt(*args)
     slop.parse(options)
-    slop.find {|opt| opt.key == option.key }
+    slop.options.find {|opt| opt.key == option.key }
   end
 
   def option_value(*args, &block)
-    option_with_argument(*args, &block).argument_value
+    option_with_argument(*args, &block).value
   end
 
-  test 'expects an argument if argument is true or optional is false' do
-    assert option(:f, :foo, 'foo', true).expects_argument?
-    assert option(:f, :argument => true).expects_argument?
-    assert option(:f, :optional => false).expects_argument?
-
-    refute option(:f, :foo).expects_argument?
-  end
-
-  test 'expects an argument if long option is suffixed with =' do
-    assert option(:f, :foo=).expects_argument?
-    assert option('f', 'foo=').expects_argument?
+  test "expects_argument?" do
     assert option(:f=).expects_argument?
+    assert option(:foo=).expects_argument?
+    assert option(:foo, :argument => true).expects_argument?
   end
 
-  test 'accepts an optional argument if optional is true' do
-    assert option(:f, :optional => true).accepts_optional_argument?
-    assert option(:f, false, :optional => true).accepts_optional_argument?
-
-    refute option(:f, true).accepts_optional_argument?
+  test "accepts_optional_argument?" do
+    refute option(:f=).accepts_optional_argument?
+    assert option(:f=, :argument => :optional).accepts_optional_argument?
+    assert option(:f, :optional_argument => true).accepts_optional_argument?
   end
 
-  test 'has a callback when passed a block or callback option' do
-    item = nil
-    option(:f){ item = "foo" }.call
-    assert_equal "foo", item
-
-    assert option(:callback => proc { item = "bar" }).call
-    assert_equal "bar", item
-
-    refute option(:f).call
-  end
-
-  test 'splits argument_value with :as => array' do
-    assert_equal %w/lee john bill/, option_value(
-      %w/--people lee,john,bill/, :people, true, :as => Array
-    )
-
-    assert_equal %w/lee john bill/, option_value(
-      %w/--people lee:john:bill/,
-      :people, true, :as => Array, :delimiter => ':'
-    )
-
-    assert_equal ['lee', 'john,bill'], option_value(
-      %w/--people lee,john,bill/,
-      :people, true, :as => Array, :limit => 2
-    )
-
-    assert_equal ['lee', 'john:bill'], option_value(
-      %w/--people lee:john:bill/,
-      :people, true, :as => Array, :limit => 2, :delimiter => ':'
-    )
+  test "key" do
+    assert_equal 'foo', option(:foo).key
+    assert_equal 'foo', option(:f, :foo).key
+    assert_equal 'f', option(:f).key
   end
 
-  test 'casting' do
-    assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => Symbol)
-    assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => :symbol)
-    assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => :sym)
-    assert_equal 30, option_value(%w/--age 30/, :age, true, :as => Integer)
-    assert_equal "1.0", option_value(%w/--id 1/, :id, true, :as => Float).to_s
-
-    assert_equal -1, option_value(%w/-i -1/, :i, true, :as => Integer)
-    assert_equal -1, option_value(%w/-i -1.1/, :i, true, :as => Integer)
-    assert_equal "-1.1", option_value(%w/-i -1.1/, :i, true, :as => Float).to_s
-    assert_equal "foo", option_value(%w/--foo1 foo/, :foo1, true)
-
-    assert_equal 0, option_value(%w//, :v, :verbose, :as => :count)
-    assert_equal 1, option_value(%w/--verbose/, :v, :verbose, :as => :count)
-    assert_equal 2, option_value(%w/--verbose -v/, :v, :verbose, :as => :count)
-    assert_equal 3, option_value(%w/-vvv/, :v, :verbose, :as => :count)
-
-    assert_equal 1, option_value(%w/-i 1/, :i, true, :as => proc { |x| x.to_i })
-    assert_equal "oof", option_value(%w/-i foo/, :i, true, :as => proc { |x| x.reverse })
+  test "call" do
+    foo = nil
+    option(:f, :callback => proc { foo = "bar" }).call
+    assert_equal "bar", foo
+    option(:f) { foo = "baz" }.call
+    assert_equal "baz", foo
+    option(:f) { |o| assert_equal 1, o }.call(1)
   end
 
-  test 'casting should return nil for optionless arguments' do
-    assert_equal nil, option_value(%w/-i/, :i, :as => :int)
-    assert_equal nil, option_value(%w/-i/, :i, :as => :str)
-    assert_equal nil, option_value(%w/-i/, :i, :as => :float)
-    assert_equal nil, option_value(%w/-i/, :i, :as => :array)
-    assert_equal nil, option_value(%w/-i/, :i, :as => :range)
+  # type casting
 
-    assert_equal nil, option_value(%w/-i/, :i, :optional => true, :as => :range)
+  test "proc/custom type cast" do
+    assert_equal 1, option_value(%w'-f 1', :f=, :as => proc {|x| x.to_i })
+    assert_equal "oof", option_value(%w'-f foo', :f=, :as => proc {|x| x.reverse })
   end
 
-  test 'ranges' do
-    assert_equal (1..10), option_value(%w/-r 1..10/, :r, true, :as => Range)
-    assert_equal (1..10), option_value(%w/-r 1-10/, :r, true, :as => Range)
-    assert_equal (1..10), option_value(%w/-r 1,10/, :r, true, :as => Range)
-    assert_equal (1...10), option_value(%w/-r 1...10/, :r, true, :as => Range)
-    assert_equal (-1..10), option_value(%w/-r -1..10/, :r, true, :as => Range)
-    assert_equal (1..-10), option_value(%w/-r 1..-10/, :r, true, :as => Range)
-
-    # default back to the string unless a regex is successful
-    # return value.to_i if the value is /\A\d+\z/
-    # maybe this should raise if Slop#strict?
-    assert_equal "1abc10", option_value(%w/-r 1abc10/, :r, true, :as => Range)
-    assert_equal (1..1), option_value(%w/-r 1/, :r, true, :as => Range)
-    assert_equal (2..2), option_value(%w/-r 2/, :r, true, :as => Range)
+  test "integer type cast" do
+    assert_equal 1, option_value(%w'-f 1', :f=, :as => Integer)
   end
 
-  test 'printing options' do
-    slop = Slop.new
-    slop.opt :n, :name, 'Your name', true
-    slop.opt :age, 'Your age', true
-    slop.opt :V, 'Display the version'
-
-    assert_equal "    -n, --name      Your name", slop.options[:name].to_s
-    assert_equal "        --age       Your age", slop.options[:age].to_s
-    assert_equal "    -V,             Display the version", slop.options[:V].to_s
+  test "symbol type cast" do
+    assert_equal :foo, option_value(%w'-f foo', :f=, :as => Symbol)
   end
 
-  test 'falls back to default option' do
-    slop = Slop.new
-    slop.opt :foo, :optional => true, :default => 'lee'
-    slop.parse %w/--foo/
-    assert_equal 'lee', slop[:foo]
+  test "range type cast" do
+    assert_equal (1..10), option_value(%w/-r 1..10/, :r=, :as => Range)
+    assert_equal (1..10), option_value(%w/-r 1-10/, :r=, :as => Range)
+    assert_equal (1..10), option_value(%w/-r 1,10/, :r=, :as => Range)
+    assert_equal (1...10), option_value(%w/-r 1...10/, :r=, :as => Range)
+    assert_equal (-1..10), option_value(%w/-r -1..10/, :r=, :as => Range)
+    assert_equal (1..-10), option_value(%w/-r 1..-10/, :r=, :as => Range)
   end
 
-  test 'key should default to long flag otherwise use short flag' do
-    assert_equal 'foo', option(:f, :foo).key
-    assert_equal 'b', option(:b).key
+  test "array type cast" do
+    assert_equal %w/lee john bill/, option_value(%w/-p lee,john,bill/, :p=, :as => Array)
+    assert_equal %w/lee john bill/, option_value(%w/-p lee:john:bill/, :p=, :as => Array, :delimiter => ':')
+    assert_equal %w/lee john,bill/, option_value(%w/-p lee,john,bill/, :p=, :as => Array, :limit => 2)
+    assert_equal %w/lee john:bill/, option_value(%w/-p lee:john:bill/, :p=, :as => Array, :limit => 2, :delimiter => ':')
   end
 
-  test 'tail to append items to the options list when printing help' do
-    slop = Slop.new
-    slop.on :f, :foo, :tail => true
-    slop.on :b, :bar
-    assert slop.to_s.strip =~ /foo$/
+  test "adding custom types" do
+    opts = Slop.new
+    opt = opts.on :f=, :as => :reverse
+    opt.types[:reverse] = proc { |v| v.reverse }
+    opts.parse %w'-f bar'
+    assert_equal 'rab', opt.value
   end
 
-  test 'do not print help for options with :help => false' do
-    slop = Slop.new
-    slop.on :f, :foo, :help => false
-    refute slop.help.include?('foo')
-  end
+  # end type casting tests
 
-  test 'appends a help string with :help => "string"' do
-    slop = Slop.new
-    slop.on :n, :name, 'Your name', true, :help => '<YOUR NAME HERE>'
-    assert_equal '    -n, --name <YOUR NAME HERE>     Your name', slop.options[:name].to_s
+  test "using a default value as fallback" do
+    opts = Slop.new
+    opt = opts.on :f, :argument => :optional, :default => 'foo'
+    opts.parse %w'-f'
+    assert_equal 'foo', opts[:f]
   end
 
-  test 'argument matching' do
+  test "printing options" do
     slop = Slop.new
-    slop.on :f, :foo, true, :match => /^h/
-
-    assert_raises(Slop::InvalidArgumentError, /world/) { slop.parse %w/--foo world/ }
-    assert slop.parse %w/--foo hello/
-  end
-
-  test 'non-casting of nil options' do
-    slop = Slop.new { on :f, :foo, true, :as => String }
-    slop.parse []
-
-    assert_equal nil, slop[:foo]
-    refute_equal "", slop[:foo]
-  end
-
-  test 'counting options' do
-    slop = Slop.new { on :v; on :x }
-    slop.parse %w/-v -v -v -x/
-    assert_equal 1, slop.options[:x].count
-    assert_equal 3, slop.options[:v].count
-  end
-
-  test 'omit block execution with :unless option' do
-    item = nil
-    opts = Slop.new do
-      on :foo
-      on :bar, true, :unless => 'foo' do; item = "foo"; end
-    end
-    opts.parse %w/--foo --bar 1/
+    slop.opt :n, :name=, 'Your name'
+    slop.opt :age=, 'Your age'
+    slop.opt :V, 'Display the version'
 
-    assert_equal "1", opts[:bar]
-    refute item
+    assert_equal "    -n, --name      Your name", slop.fetch_option(:name).to_s
+    assert_equal "        --age       Your age", slop.fetch_option(:age).to_s
+    assert_equal "    -V,             Display the version", slop.fetch_option(:V).help
   end
 
-  test 'raises MissingOptionError when an option is :required' do
-    opts = Slop.new do
-      on :foo, :required => true
-    end
-
-    assert_raises(Slop::MissingOptionError, /foo is required/) { opts.parse %w[ --bar ] }
-    assert_raises(Slop::MissingOptionError, /foo is required/) { opts.parse %w[ foo ] }
+  test "overwriting the help text" do
+    slop = Slop.new
+    slop.on :foo, :help => '    -f, --foo  SOMETHING FOOEY'
+    assert_equal '    -f, --foo  SOMETHING FOOEY', slop.fetch_option(:foo).help
   end
-end
+end

data/test/slop_test.rb

@@ -1,8 +1,11 @@
 require 'helper'
 
 class SlopTest < TestCase
-  def clean_options(*args)
-    Slop.new.send(:clean_options, args)
+
+  def build_option(*args)
+    opt = Slop.new.send(:build_option, args)
+    config = opt.config.reject { |k, v| v == Slop::Option::DEFAULT_OPTIONS[k] }
+    [opt.short, opt.long, opt.description, config]
   end
 
   def temp_argv(items)
@@ -13,590 +16,264 @@ class SlopTest < TestCase
     ARGV.replace old_argv
   end
 
-  test 'includes Enumerable' do
-    assert Slop.included_modules.include?(Enumerable)
-  end
-
-  test 'new accepts a hash or array of symbols' do
-    slop = Slop.new :strict, :multiple_switches => true
-    [ :@multiple_switches, :@strict ].each do |var|
-      assert slop.instance_variable_get var
-    end
-  end
-
-  test 'parse returns a Slop object' do
-    slop = Slop.parse([])
-    assert_kind_of Slop, slop
+  def temp_stderr
+    $stderr = StringIO.new
+    yield $stderr.string
+  ensure
+    $stderr = STDERR
   end
 
-  test 'parsing calls to_s on all of the items in the array' do
-    opts = Slop.parse([:'--foo']) { on :foo }
-    assert opts.foo?
-  end
+  test "build_option" do
+    assert_equal ['f', nil, nil, {}], build_option(:f)
+    assert_equal [nil, 'foo', nil, {}], build_option(:foo)
+    assert_equal ['f', nil, 'Some description', {}], build_option(:f, 'Some description')
+    assert_equal ['f', 'foo', nil, {}], build_option(:f, :foo)
 
-  test '#opt returns an Slop::Option' do
-    assert_kind_of Slop::Option, Slop.new.option(:n)
+    # with arguments
+    assert_equal ['f', nil, nil, {:argument=>true}], build_option('f=')
+    assert_equal [nil, 'foo', nil, {:argument=>true}], build_option('foo=')
+    assert_equal [nil, 'foo', nil, {:optional_argument=>true}], build_option('foo=?')
   end
 
-  test 'enumerating options' do
+  test "fetch_option" do
     slop = Slop.new
-    slop.opt(:f, :foo, 'foo')
-    slop.opt(:b, :bar, 'bar')
+    opt1 = slop.on :f, :foo
+    opt2 = slop.on :bar
 
-    slop.each { |option| assert_kind_of Slop::Option, option }
+    assert_equal opt1, slop.fetch_option(:foo)
+    assert_equal opt1, slop.fetch_option(:f)
+    assert_equal opt2, slop.fetch_option(:bar)
+    assert_equal opt2, slop.fetch_option('--bar')
+    assert_nil slop.fetch_option(:baz)
   end
 
-  test 'defaulting to ARGV' do
-    temp_argv(%w/--name lee/) do
-      assert_equal('lee', Slop.parse { on :name, true }[:name])
-    end
-  end
+  test "default all options to take arguments" do
+    slop = Slop.new(:arguments => true)
+    opt1 = slop.on :foo
+    opt2 = slop.on :bar, :argument => false
 
-  test 'callback when option array is empty' do
-    item1 = nil
-    temp_argv([]) do
-      Slop.new { on_empty { item1 = 'foo' } }.parse
-    end
-
-    assert_equal 'foo', item1
-
-    temp_argv([]) do
-      assert_equal [], Slop.new { on_empty {} }.parse
-    end
-  end
-
-  test 'callback when arguments contain no options' do
-    item = nil
-    Slop.new { on_optionless { item = 'foo' } }.parse %w/a b c/
-    assert_equal 'foo', item
+    assert opt1.expects_argument?
+    refute opt2.expects_argument?
   end
 
-  test 'multiple switches with the :multiple_switches flag' do
-    slop = Slop.new :multiple_switches => true, :strict => true
-    %w/a b c/.each { |f| slop.on f }
-    slop.on :z, true
-    slop.parse %w/-abc/
-
-    %w/a b c/.each do |flag|
-      assert slop[flag]
-      assert slop.send(flag + '?')
-    end
-
-    assert_raises(Slop::InvalidOptionError, /d/)   { slop.parse %w/-abcd/ }
-    assert_raises(Slop::MissingArgumentError, /z/) { slop.parse %w/-abcz/ }
-
-    slop = Slop.new(:multiple_switches)
-    slop.on :a
-    slop.on :f, true
-    args = %w[-abc -f foo bar]
-    slop.parse! args
-
-    assert_equal %w[ bar ], args
-    assert_equal 'foo', slop[:f]
-    assert slop[:a]
-  end
-
-  test 'passing a block' do
-    assert Slop.new {}
-    slop = nil
-    assert Slop.new {|s| slop = s }
-    assert_kind_of Slop, slop
-  end
-
-  test 'automatically adding the help option' do
+  test "extract_option" do
     slop = Slop.new
-    assert_empty slop.options
-
-    slop = Slop.new :help => true
-    refute_empty slop.options
-    assert_equal 'Print this help message', slop.options[:help].description
-  end
-
-  test ':all_accept_arguments' do
-    opts = Slop.new(:all_accept_arguments) do
-      on :foo
-      on :bar, :optional => true
-    end
-    opts.parse %w[ --foo hello --bar ]
-
-    assert_equal 'hello', opts[:foo]
-    assert_nil opts[:bar]
-    assert_raises(Slop::MissingArgumentError) { opts.parse %w[ --foo --bar ] }
-  end
+    extract = proc { |flag| slop.send(:extract_option, flag) }
+    slop.on :opt=
 
-  test 'yielding non-options when a block is passed to "parse"' do
-    opts = Slop.new do
-      on :name, true
-    end
-    opts.parse(%w/--name lee a/) do |v|
-      assert_equal 'a', v
-    end
+    assert_kind_of Array, extract['--foo']
+    assert_equal 'bar', extract['--foo=bar'][1]
+    assert_equal 'bar', extract['-f=bar'][1]
+    assert_nil extract['--foo'][0]
+    assert_kind_of Slop::Option, extract['--opt'][0]
+    assert_equal false, extract['--no-opt'][1]
   end
 
-  test 'preserving order when yielding non-options' do
-    items = []
-    slop = Slop.new { on(:name, true) { |name| items << name } }
-    slop.parse(%w/foo --name bar baz/) { |value| items << value }
-    assert_equal %w/foo bar baz/, items
-  end
-
-  test 'only parsing options' do
-    slop = Slop.new { on :n, true }
-    assert slop.parse %w/n/
-  end
-
-  test 'setting the banner' do
-    slop = Slop.new
-    slop.banner = "foo bar"
-
-    assert_equal "foo bar", slop.banner
-    assert slop.to_s =~ /^foo bar/
-
-    slop.banner = nil
-    assert_equal "", slop.to_s
-
-    slop = Slop.new "foo bar"
-    assert_equal "foo bar", slop.banner
-
-    slop = Slop.new :banner => "foo bar"
-    assert_equal "foo bar", slop.banner
-  end
-
-  test 'setting the summary' do
-    slop = Slop.new
-    slop.banner = "foo bar"
-    slop.summary = "does stuff"
-
-    assert_equal "foo bar\n\ndoes stuff", slop.to_s
-  end
-
-  test 'setting the description' do
+  test "non-options yielded to parse()" do
+    foo = nil
     slop = Slop.new
-    slop.banner     = "foo bar"
-    slop.summary = "does stuff"
-    slop.description  = "This does stuff."
-
-    assert_equal "foo bar\n\ndoes stuff\n\n    This does stuff.", slop.to_s
+    slop.parse ['foo'] do |x| foo = x end
+    assert_equal 'foo', foo
   end
 
-  test 'setting the description without matching summary' do
-    slop = Slop.new
-    slop.banner     = "foo bar"
-    slop.description  = "This does stuff."
-
-    assert_equal "foo bar\n\n    This does stuff.", slop.to_s
+  test "::parse returns a Slop object" do
+    assert_kind_of Slop, Slop.parse([])
   end
 
-  test 'storing long option lengths' do
+  test "parse" do
     slop = Slop.new
-    assert_equal 0, slop.longest_flag
-    slop.opt(:name)
-    assert_equal 4, slop.longest_flag
-    slop.opt(:username)
-    assert_equal 8, slop.longest_flag
-  end
-
-  test 'parse returning the list of arguments left after parsing' do
-    opts = Slop.new do
-      on :name, true
-    end
-    assert_equal %w/a/, opts.parse!(%w/--name lee a/)
-    assert_equal %w/--name lee a/, opts.parse(%w/--name lee a/)
-    assert_equal ['foo', :bar, 1], opts.parse(['foo', :bar, 1])
-  end
-
-  test '#parse does not remove parsed items' do
-    items = %w/--foo/
-    Slop.new { |opt| opt.on :foo }.parse(items)
-    assert_equal %w/--foo/, items
-  end
-
-  test '#parse! removes parsed items' do
-    items = %w/--foo/
-    Slop.new { |opt| opt.on :foo }.parse!(items)
-    assert_empty items
-  end
-
-  test '#parse! does not remove unparsed items with same value as a parsed item' do
-    items = %w/bar --foo bar/
-    Slop.new { |opt| opt.on :foo, 'foo', true }.parse!(items)
-    assert_equal %w/bar/, items
+    assert_equal ['foo'], slop.parse(%w'foo')
+    assert_equal ['foo'], slop.parse!(%w'foo')
   end
 
-  test '#parse! removes parsed items prefixed with --no-' do
-    items = %w/--no-foo/
-    Slop.new { |opt| opt.on :foo }.parse!(items)
-    assert_empty items
+  test "parse!" do
+    slop = Slop.new { on :foo= }
+    assert_equal [], slop.parse!(%w'--foo bar')
+    slop = Slop.new {  on :baz }
+    assert_equal ['etc'], slop.parse!(%w'--baz etc')
   end
 
-  test 'the shit out of clean_options' do
-    assert_equal(
-      ['s', 'short', 'short option', false, {}],
-      clean_options('-s', '--short', 'short option')
-    )
-
-    assert_equal(
-      [nil, 'long', 'long option only', true, {}],
-      clean_options('--long', 'long option only', true)
-    )
-
-    assert_equal(
-      ['S', 'symbol', 'symbolize', false, {}],
-      clean_options(:S, :symbol, 'symbolize')
-    )
-
-    assert_equal(
-      ['a', nil, 'alphabetical only', true, {}],
-      clean_options('a', 'alphabetical only', true)
-    )
-
-    assert_equal( # for description-less options
-      [nil, 'optiononly', nil, false, {}],
-      clean_options('--optiononly')
-    )
-
-    assert_equal(
-      ['f', 'foo', 'some description', false, {:optional => false, :help => 'BAR'}],
-      clean_options(:f, 'foo BAR', 'some description')
-    )
-
-    assert_equal(
-      [nil, 'bar', nil, false, {:optional => true, :help => '[STUFF]'}],
-      clean_options('bar [STUFF]')
-    )
-
-    assert_equal([nil, 'foo', nil, false, {:as => Array}], clean_options(:foo, Array, false))
-    assert_equal([nil, 'foo', nil, false, {:as => Array}], clean_options(Array, :foo, false))
-
-    assert_equal(['c', nil, nil, true, {}], clean_options(:c, true))
-    assert_equal(['c', nil, nil, false, {}], clean_options(:c, false))
+  test "new() accepts a hash of configuration options" do
+    slop = Slop.new(:foo => :bar)
+    assert_equal :bar, slop.config[:foo]
   end
 
-  test '[] returns an options argument value or a command or nil (in that order)' do
-    slop = Slop.new
-    slop.opt :n, :name, true
-    slop.opt :foo
-    slop.command(:foo) { }
-    slop.command(:bar) { }
-    slop.parse %w/--name lee --foo/
-
-    assert_equal 'lee', slop[:name]
-    assert_equal 'lee', slop[:n]
-
-    assert_equal true, slop[:foo]
-    assert_kind_of Slop, slop[:bar]
-
-    assert_nil slop[:baz]
-  end
-
-  test 'arguments ending ? test for option existance' do
-    slop = Slop.new
-    slop.opt :v, :verbose
-    slop.opt :d, :debug
-    slop.parse %w/--verbose/
-
-    assert slop[:verbose]
-    assert slop.verbose?
-
-    refute slop[:debug]
-    refute slop.debug?
-  end
-
-  test 'options are present' do
-    opts = Slop.new do
-      on :f, 'foo-bar'
-      on :b, 'bar-baz'
-      on :h, :optional => true
+  test "defaulting to ARGV" do
+    temp_argv(%w/--name lee/) do
+      opts = Slop.parse { on :name= }
+      assert_equal 'lee', opts[:name]
     end
-    opts.parse %w/--foo-bar -h/
-
-    assert opts.present?('foo-bar')
-    refute opts.present?('bar-baz')
-    refute opts.present?('foo-bar', 'bar-baz')
-    assert opts.present?(:h)
   end
 
-  test 'raises if an option expects an argument and none is given' do
-    slop = Slop.new
-    slop.opt :name, true
-    slop.opt :age, :optional => true
-
-    assert_raises(Slop::MissingArgumentError, /name/) { slop.parse %w/--name/ }
-    assert slop.parse %w/--name 'foo'/
-  end
-
-  test 'returning a hash of options' do
-    slop = Slop.new
-    slop.opt :name, true
-    slop.opt :version
-    slop.opt :V, :verbose, :default => false
-    slop.parse %w/--name lee --version/
-
-    assert_equal({'name' => 'lee', 'version' => true, 'verbose' => false}, slop.to_hash(false))
-    assert_equal({:name => 'lee', :version => true, :verbose => false}, slop.to_hash(true))
+  test "automatically adding the help option" do
+    slop = Slop.new :help => true
+    refute_empty slop.options
+    assert_equal 'Display this help message.', slop.options.first.description
   end
 
-  test 'iterating options' do
-    slop = Slop.new
-    slop.opt :a, :abc
-    slop.opt :f, :foo
+  test ":arguments and :optional_arguments config options" do
+    slop = Slop.new(:arguments => true) { on :foo }
+    assert slop.fetch_option(:foo).expects_argument?
 
-    assert_equal 2, slop.count
-    slop.each {|opt| assert_kind_of Slop::Option, opt }
+    slop = Slop.new(:optional_arguments => true) { on :foo }
+    assert slop.fetch_option(:foo).accepts_optional_argument?
   end
 
-  test 'fetching options and option values' do
-    slop = Slop.new
-    slop.opt :foo, true
-    slop.parse %w/--foo bar/
-
-    assert_kind_of Slop::Option, slop.options[:foo]
-    assert_equal "bar", slop[:foo]
-    assert_equal "bar", slop['foo']
-    assert_kind_of Slop::Option, slop.options[0]
-    assert_nil slop.options['0']
+  test "yielding non-options when a block is passed to parse()" do
+    items = []
+    opts = Slop.new { on :name= }
+    opts.parse(%w/--name lee a b c/) { |v| items << v }
+    assert_equal ['a', 'b', 'c'], items
   end
 
-  test 'printing help' do
-    slop = Slop.new
-    slop.banner = 'Usage: foo [options]'
-    slop.parse
-    assert slop.to_s =~ /^Usage: foo/
+  test "on empty callback" do
+    opts = Slop.new
+    foo = nil
+    opts.add_callback(:empty) { foo = "bar" }
+    opts.parse []
+    assert_equal "bar", foo
   end
 
-  test 'passing argument values to blocks' do
-    name = nil
+  test "on no_options callback" do
     opts = Slop.new
-    opts.on :name, true, :callback => proc {|n| name = n}
-    opts.parse %w/--name lee/
-    assert_equal 'lee', name
+    foo = nil
+    opts.add_callback(:no_options) { foo = "bar" }
+    opts.parse %w( --foo --bar etc hello )
+    assert_equal "bar", foo
   end
 
-  test 'strict mode' do
-    strict = Slop.new :strict => true
-    totallynotstrict = Slop.new
-
-    assert_raises(Slop::InvalidOptionError, /--foo/) { strict.parse %w/--foo/ }
-    assert totallynotstrict.parse %w/--foo/
+  test "to_hash()" do
+    opts = Slop.new { on :foo=; on :bar }
+    opts.parse(%w'--foo hello --bar')
+    assert_equal({ :foo => 'hello', :bar => nil }, opts.to_hash)
   end
 
-  test 'strict mode parses options before raising Slop::InvalidOptionError' do
-    strict = Slop.new :strict => true
-    strict.opt :n, :name, true
-
-    assert_raises(Slop::InvalidOptionError, /--foo/) { strict.parse %w/--foo --name nelson/ }
-    assert_equal 'nelson', strict[:name]
+  test "missing() returning all missing option keys" do
+    opts = Slop.new { on :foo; on :bar }
+    opts.parse %w'--foo'
+    assert_equal ['bar'], opts.missing
   end
 
-  test 'short option flag with no space between flag and argument, with :multiple_switches => false' do
-    slop = Slop.new :multiple_switches => false
-    slop.opt :p, :password, true
-    slop.opt :s, :shortpass, true
-    slop.parse %w/-pfoo -sbar/
-
-    assert_equal 'foo', slop[:password]
-    assert_equal 'bar', slop[:shortpass]
+  test "autocreating options" do
+    opts = Slop.new :autocreate => true
+    opts.parse %w[ --foo bar --baz ]
+    assert opts.fetch_option(:foo).expects_argument?
+    assert opts.fetch_option(:foo).autocreated?
+    assert_equal 'bar', opts.fetch_option(:foo).value
+    refute opts.fetch_option(:baz).expects_argument?
   end
 
-  test 'prefixing --no- onto options for a negative result' do
-    slop = Slop.new
-    slop.opt :d, :debug
-    slop.opt :v, :verbose, :default => true
-    slop.parse %w/--no-debug --no-verbose --no-nothing/
-
-    refute slop.verbose?
-    refute slop.debug?
-    refute slop[:verbose]
-    refute slop[:debug]
+  test "raising an InvalidArgumentError when the argument doesn't match" do
+    opts = Slop.new { on :foo=, :match => /^[a-z]+$/ }
+    assert_raises(Slop::InvalidArgumentError) { opts.parse %w' --foo b4r '}
   end
 
-  test 'option=value' do
-    slop = Slop.new
-    slop.opt :n, :name, true
-    slop.parse %w/--name=lee/
-
-    assert_equal 'lee', slop[:name]
-    assert slop.name?
+  test "raising a MissingArgumentError when the option expects an argument" do
+    opts = Slop.new { on :foo= }
+    assert_raises(Slop::MissingArgumentError) { opts.parse %w' --foo '}
   end
 
-  test 'parsing options with options as arguments' do
-    slop = Slop.new { on :f, :foo, true }
-    assert_raises(Slop::MissingArgumentError) { slop.parse %w/-f --bar/ }
+  test "raising a MissingOptionError when a required option is missing" do
+    opts = Slop.new { on :foo, :required => true }
+    assert_raises(Slop::MissingOptionError) { opts.parse %w'' }
   end
 
-  test 'respond_to?' do
-    slop = Slop.new { on :f, :foo }
-    assert slop.respond_to?('foo?')
-    refute slop.respond_to?('foo')
+  test "raising InvalidOptionError when strict mode is enabled and an unknown option appears" do
+    opts = Slop.new :strict => true
+    assert_raises(Slop::InvalidOptionError) { opts.parse %w'--foo' }
+    assert_raises(Slop::InvalidOptionError) { opts.parse %w'-fabc' }
   end
 
-  test 'reusable slop object (ie not using define_method for present?())' do
-    slop = Slop.new { on :f, :foo }
-
-    slop.parse %w()
-    assert_equal false, slop.foo?
-
-    slop.parse %w( --foo )
-    assert_equal true, slop.foo?
+  test "multiple_switches is enabled by default" do
+    opts = Slop.new { on :f; on :b }
+    opts.parse %w[ -fb ]
+    assert opts.present?(:f)
+    assert opts.present?(:b)
   end
 
-  test 'custom IO object' do
-    io = StringIO.new
-    slop = Slop.new(:help => true, :io => io)
-    slop.on :f, :foo, 'something fooey'
-    begin
-      slop.parse %w/--help/
-    rescue SystemExit
-    end
-    assert io.string.include? 'something fooey'
+  test "multiple_switches disabled" do
+    opts = Slop.new(:multiple_switches => false) { on :f= }
+    opts.parse %w[ -fabc123 ]
+    assert_equal 'abc123', opts[:f]
   end
 
-  test 'exiting when using :help option' do
-    io = StringIO.new
-    opts = Slop.new(:help => true, :io => io)
-    assert_raises(SystemExit) { opts.parse %w/--help/ }
+  test "setting/getting the banner" do
+    opts = Slop.new :banner => 'foo'
+    assert_equal 'foo', opts.banner
 
-    opts = Slop.new(:help => true, :io => io, :exit_on_help => false)
-    assert opts.parse %w/--help/
-  end
+    opts = Slop.new
+    opts.banner 'foo'
+    assert_equal 'foo', opts.banner
 
-  test 'ignoring case' do
-    opts = Slop.new(:ignore_case => true)
-    opts.on :n, :name, true
-    opts.parse %w/--NAME lee/
-    assert_equal 'lee', opts[:name]
+    opts = Slop.new
+    opts.banner = 'foo'
+    assert_equal 'foo', opts.banner
   end
 
-  test 'autocreating options' do
-    opts = Slop.new(:autocreate => true) do |o|
-      o.on '--lorem', true
-    end
-    opts.parse %w/--hello --foo bar -a --lorem ipsum/
-
-    assert opts.hello?
-    assert opts.foo?
-    assert_equal 'bar', opts[:foo]
-    assert opts.a?
-    assert_equal 'ipsum', opts[:lorem]
+  test "get/[] fetching an options argument value" do
+    opts = Slop.new { on :foo=; on :bar; on :baz }
+    opts.parse %w' --foo hello --bar '
+    assert_equal 'hello', opts[:foo]
+    assert_nil opts[:bar]
+    assert_nil opts[:baz]
   end
 
-  test 'multiple elements for array option' do
-    opts = Slop.new do
-      on :a, true, :as => Array
-    end
-    opts.parse %w/-a foo -a bar baz -a etc/
-
-    assert_equal %w/foo bar etc/, opts[:a]
+  test "checking for an options presence" do
+    opts = Slop.new { on :foo; on :bar }
+    opts.parse %w' --foo '
+    assert opts.present?(:foo)
+    refute opts.present?(:bar)
   end
 
-  test ':arguments => true' do
-    opts = Slop.new(:arguments) { on :foo }
-    opts.parse %w/--foo bar/
+  test "ignoring case" do
+    opts = Slop.new { on :foo }
+    opts.parse %w' --FOO bar '
+    assert_nil opts[:foo]
 
+    opts = Slop.new(:ignore_case => true) { on :foo= }
+    opts.parse %w' --FOO bar '
     assert_equal 'bar', opts[:foo]
   end
 
-  test 'long flag strings' do
-    opts = Slop.new do
-      on 'f', 'foo BAR'
-      on 'bar [HELLO]'
-    end
-
-    assert opts.options[:foo].expects_argument?
-    assert opts.options[:bar].accepts_optional_argument?
-
-    assert_equal '    -f, --foo BAR     ', opts.options[:foo].to_s
-    assert_equal '        --bar [HELLO] ', opts.options[:bar].to_s
-  end
-
-  test 'not parsing options if after --' do
-    args = %w[ foo bar -- --foo bar ]
-    opts = Slop.parse!(args) do
-      on :foo, true
-    end
-
-    assert_equal %w[ foo bar --foo bar ], args
-  end
-
-  test 'inline classes' do
-    opts = Slop.new do
-      on :foo, Array, true
-      on Symbol, :bar, true
-    end
-    opts.parse %w/--foo one,two --bar hello/
-
-    assert_equal %w[one two], opts[:foo]
-    assert_equal :hello, opts[:bar]
-  end
-
-  test 'wrap and indent' do
-    slop = Slop.new
-
-    assert_equal(
-      "Lorem ipsum dolor sit amet, consectetur\n" +
-      "adipisicing elit, sed do eiusmod tempor\n" +
-      "incididunt ut labore et dolore magna\n" +
-      "aliqua.",
-      slop.send(:wrap_and_indent, "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.", 40, 0))
-
-    assert_equal(
-      "    Lorem ipsum dolor sit amet,\n" +
-      "    consectetur adipisicing elit, sed\n" +
-      "    do eiusmod tempor incididunt ut\n" +
-      "    labore et dolore magna aliqua.",
-      slop.send(:wrap_and_indent, "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.", 36, 4))
-  end
-
-  test 'to_struct' do
-    assert_nil Slop.new.to_struct
-
-    slop = Slop.new { on :a, true }
-    slop.parse %w[ -a foo -b ]
-    struct = slop.to_struct
-
-    assert_equal 'foo', struct.a
-    assert_kind_of Struct, struct
-    assert_raises(NoMethodError) { struct.b }
-
-    pstruct = slop.to_struct('Foo')
-    assert_kind_of Struct::Foo, pstruct
-  end
-
-  test 'returning missing options' do
-    slop = Slop.new { on :a; on :b, :bar; on :c; }
-    slop.parse %w[ -a ]
-
-    assert_equal %w[ bar c ], slop.missing
-  end
-
-  test 'parsing an optspec and building options' do
+  test "parsing an optspec and building options" do
     optspec = <<-SPEC
     ruby foo.rb [options]
     --
     v,verbose  enable verbose mode
     q,quiet   enable quiet mode
-    debug      enable debug mode
-    H          enable hax mode (srsly)
     n,name=    set your name
-    -a,--age= set your age
+    p,pass=?   set your password
     SPEC
     opts = Slop.optspec(optspec.gsub(/^\s+/, ''))
     opts.parse %w[ --verbose --name Lee ]
 
     assert_equal 'Lee', opts[:name]
-    assert opts.verbose?
-    assert_equal 'enable quiet mode', opts.options[:quiet].description
+    assert opts.present?(:verbose)
+    assert_equal 'enable quiet mode', opts.fetch_option(:quiet).description
+    assert opts.fetch_option(:pass).accepts_optional_argument?
   end
 
-  test "negative integers should not be processed as options and removed" do
+  test "ensure negative integers are not processed as options" do
     items = %w(-1)
     Slop.parse!(items)
     assert_equal %w(-1), items
   end
 
-  test "options taking arguments should ignore argument that look like options (wut?)" do
-    opts = Slop.new { on :v; on :foo, :optional => true, :default => 5, :as => Integer }
-    opts.parse %w[ -c -v ]
-    assert_equal 5, opts[:foo]
+  test "separators" do
+    opts = Slop.new do
+      on :foo
+      separator "hello"
+      on :bar
+    end
+    assert_equal "        --foo      \nhello\n        --bar      ", opts.help
+  end
+
+  test "printing help with :help => true" do
+    temp_stderr do |string|
+      opts = Slop.new(:help => true)
+      opts.parse %w( --help )
+      assert_equal "    -h, --help      Display this help message.\n", string
+    end
   end
-end
+
+end