mspec 1.4.0 → 1.5.0

data/spec/helpers/ruby_exe_spec.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/helpers/ruby_exe' 
+require 'rbconfig'
+
+class RubyExeSpecs
+end
+
+describe "#ruby_exe_options" do
+  before :all do
+    @verbose = $VERBOSE
+    $VERBOSE = nil
+
+    @ruby_name = Object.const_get :RUBY_NAME
+    @ruby_exe_env = ENV['RUBY_EXE']
+
+    @script = RubyExeSpecs.new
+  end
+
+  after :all do
+    Object.const_set :RUBY_NAME, @ruby_name
+    ENV['RUBY_EXE'] = @ruby_exe_env
+    $VERBOSE = @verbose
+  end
+
+  before :each do
+    @script = RubyExeSpecs.new
+  end
+
+  it "returns ENV['RUBY_EXE'] when passed :env" do
+    ENV['RUBY_EXE'] = "kowabunga"
+    @script.ruby_exe_options(:env).should == "kowabunga"
+  end
+
+  it "returns 'bin/rbx' when passed :engine and RUBY_NAME is 'rbx'" do
+    Object.const_set :RUBY_NAME, 'rbx'
+    @script.ruby_exe_options(:engine).should == 'bin/rbx'
+  end
+
+  it "returns 'bin/jruby' when passed :engine and RUBY_NAME is 'jruby'" do
+    Object.const_set :RUBY_NAME, 'jruby'
+    @script.ruby_exe_options(:engine).should == 'bin/jruby'
+  end
+
+  it "returns 'ir' when passed :engine and RUBY_NAME is 'ironruby'" do
+    Object.const_set :RUBY_NAME, 'ironruby'
+    @script.ruby_exe_options(:engine).should == 'ir'
+  end
+
+  it "returns RUBY_NAME + $(EXEEXT) when passed :name" do
+    bin = RUBY_NAME + (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '')
+    name = File.join ".", bin
+    @script.ruby_exe_options(:name).should == name
+  end
+
+  it "returns $(bindir)/$(RUBY_INSTALL_NAME) + $(EXEEXT) when passed :install_name" do
+    bin = Config::CONFIG['RUBY_INSTALL_NAME'] + (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '')
+    name = File.join Config::CONFIG['bindir'], bin
+    @script.ruby_exe_options(:install_name).should == name
+  end
+end
+
+describe "#resolve_ruby_exe" do
+  before :all do
+    @script = RubyExeSpecs.new
+  end
+
+  it "returns the value returned by #ruby_exe_options if it exists and is executable" do
+    name = "ruby_spec_exe"
+    @script.should_receive(:ruby_exe_options).and_return(name)
+    File.should_receive(:exists?).with(name).and_return(true)
+    File.should_receive(:executable?).with(name).and_return(true)
+    @script.resolve_ruby_exe.should == name
+  end
+
+  it "returns nil if no exe is found" do
+    File.should_receive(:exists?).at_least(:once).and_return(false)
+    @script.resolve_ruby_exe.should be_nil
+  end
+end
+
+describe Object, "#ruby_exe" do
+  before :all do
+    @verbose = $VERBOSE
+    $VERBOSE = nil
+
+    @ruby_flags = ENV["RUBY_FLAGS"]
+    ENV["RUBY_FLAGS"] = "-w -Q"
+
+    @ruby_exe = Object.const_get :RUBY_EXE
+    Object.const_set :RUBY_EXE, 'ruby_spec_exe'
+
+    @script = RubyExeSpecs.new
+  end
+
+  after :all do
+    Object.const_set :RUBY_EXE, @ruby_exe
+    ENV["RUBY_FLAGS"] = @ruby_flags
+    $VERBOSE = @verbose
+  end
+
+  it "executes the argument if it is a file that exists and is executable" do
+    code = "some/ruby/file.rb"
+    File.should_receive(:exists?).with(code).and_return(true)
+    File.should_receive(:executable?).with(code).and_return(true)
+    @script.should_receive(:`).with("ruby_spec_exe -w -Q some/ruby/file.rb")
+    @script.ruby_exe code
+  end
+
+  it "executes the argument with -e" do
+    code = %(some "real" 'ruby' code)
+    File.should_receive(:exists?).with(code).and_return(false)
+    @script.should_receive(:`).with(%(ruby_spec_exe -w -Q -e "some \\"real\\" 'ruby' code"))
+    @script.ruby_exe code
+  end
+end

data/spec/runner/actions/filter_spec.rb

@@ -48,13 +48,13 @@ describe ActionFilter, "#load" do
   end
 
   it "creates a filter from a single tag" do
-    MSpec.should_receive(:read_tags).with("tag").and_return([@tag])
+    MSpec.should_receive(:read_tags).with(["tag"]).and_return([@tag])
     MatchFilter.should_receive(:new).with(nil, "description")
     ActionFilter.new("tag", nil).load
   end
 
   it "creates a filter from an array of tags" do
-    MSpec.should_receive(:read_tags).with("tag", "key").and_return([@tag])
+    MSpec.should_receive(:read_tags).with(["tag", "key"]).and_return([@tag])
     MatchFilter.should_receive(:new).with(nil, "description")
     ActionFilter.new(["tag", "key"], nil).load
   end
@@ -68,7 +68,7 @@ describe ActionFilter, "#load" do
 end
 
 describe ActionFilter, "#register" do
-  it "registers itself with MSpec for the :load, :unload actions" do
+  it "registers itself with MSpec for the :load actions" do
     filter = ActionFilter.new
     MSpec.should_receive(:register).with(:load, filter)
     filter.register
@@ -76,7 +76,7 @@ describe ActionFilter, "#register" do
 end
 
 describe ActionFilter, "#unregister" do
-  it "unregisters itself with MSpec for the :load, :unload actions" do
+  it "unregisters itself with MSpec for the :load actions" do
     filter = ActionFilter.new
     MSpec.should_receive(:unregister).with(:load, filter)
     filter.unregister

data/spec/runner/actions/tag_spec.rb

@@ -4,11 +4,7 @@ require 'mspec/runner/mspec'
 require 'mspec/runner/example'
 require 'mspec/runner/tag'
 
-describe TagAction do
-  before :each do
-    MSpec.stub!(:read_tags).and_return([])
-  end
-
+describe TagAction, ".new" do
   it "creates an MatchFilter with its tag and desc arguments" do
     filter = mock('action filter', :null_object => true)
     MatchFilter.should_receive(:new).with(nil, "some", "thing").and_return(filter)

data/spec/runner/actions/taglist_spec.rb

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'mspec/runner/actions/taglist'
+require 'mspec/runner/mspec'
+require 'mspec/runner/example'
+require 'mspec/runner/tag'
+
+describe TagListAction, "#include?" do
+  it "returns true" do
+    TagListAction.new.include?(:anything).should be_true
+  end
+end
+
+describe TagListAction, "#===" do
+  before :each do
+    tag = SpecTag.new "fails:description"
+    MSpec.stub!(:read_tags).and_return([tag])
+    @filter = mock("MatchFilter", :null_object => true)
+    MatchFilter.stub!(:new).and_return(@filter)
+    @action = TagListAction.new
+    @action.load
+  end
+
+  it "returns true if filter === string returns true" do
+    @filter.should_receive(:===).with("str").and_return(true)
+    @action.===("str").should be_true
+  end
+
+  it "returns false if filter === string returns false" do
+    @filter.should_receive(:===).with("str").and_return(false)
+    @action.===("str").should be_false
+  end
+end
+
+describe TagListAction, "#start" do
+  before :each do
+    @stdout = $stdout
+    $stdout = IOStub.new
+  end
+
+  after :each do
+    $stdout = @stdout
+  end
+
+  it "prints a banner for specific tags" do
+    action = TagListAction.new ["fails", "unstable"]
+    action.start
+    $stdout.should == "\nListing specs tagged with 'fails', 'unstable'\n\n"
+  end
+
+  it "prints a banner for all tags" do
+    action = TagListAction.new
+    action.start
+    $stdout.should == "\nListing all tagged specs\n\n"
+  end
+end
+
+describe TagListAction, "#laod" do
+  before :each do
+    @t1 = SpecTag.new "fails:I fail"
+    @t2 = SpecTag.new "unstable:I'm unstable"
+  end
+
+  it "creates a MatchFilter for matching tags" do
+    MSpec.should_receive(:read_tags).with(["fails"]).and_return([@t1])
+    MatchFilter.should_receive(:new).with(nil, "I fail")
+    TagListAction.new(["fails"]).load
+  end
+
+  it "creates a MatchFilter for all tags" do
+    MSpec.should_receive(:read_tags).and_return([@t1, @t2])
+    MatchFilter.should_receive(:new).with(nil, "I fail", "I'm unstable")
+    TagListAction.new.load
+  end
+
+  it "does not create a MatchFilter if there are no matching tags" do
+    MSpec.stub!(:read_tags).and_return([])
+    MatchFilter.should_not_receive(:new)
+    TagListAction.new(["fails"]).load
+  end
+end
+
+describe TagListAction, "#after" do
+  before :each do
+    @stdout = $stdout
+    $stdout = IOStub.new
+
+    @state = mock("ExampleState")
+    @state.stub!(:description).and_return("str")
+
+    @action = TagListAction.new
+  end
+
+  after :each do
+    $stdout = @stdout
+  end
+
+  it "prints nothing if the filter does not match" do
+    @action.should_receive(:===).with("str").and_return(false)
+    @action.after(@state)
+    $stdout.should == ""
+  end
+
+  it "prints the example description if the filter matches" do
+    @action.should_receive(:===).with("str").and_return(true)
+    @action.after(@state)
+    $stdout.should == "str\n"
+  end
+end
+
+describe TagListAction, "#register" do
+  before :each do
+    MSpec.stub!(:register)
+    @action = TagListAction.new
+  end
+
+  it "registers itself with MSpec for the :start event" do
+    MSpec.should_receive(:register).with(:start, @action)
+    @action.register
+  end
+
+  it "registers itself with MSpec for the :load event" do
+    MSpec.should_receive(:register).with(:load, @action)
+    @action.register
+  end
+
+  it "registers itself with MSpec for the :after event" do
+    MSpec.should_receive(:register).with(:after, @action)
+    @action.register
+  end
+end
+
+describe TagListAction, "#unregister" do
+  before :each do
+    MSpec.stub!(:unregister)
+    @action = TagListAction.new
+  end
+
+  it "unregisters itself with MSpec for the :start event" do
+    MSpec.should_receive(:unregister).with(:start, @action)
+    @action.unregister
+  end
+
+  it "unregisters itself with MSpec for the :load event" do
+    MSpec.should_receive(:unregister).with(:load, @action)
+    @action.unregister
+  end
+
+  it "unregisters itself with MSpec for the :after event" do
+    MSpec.should_receive(:unregister).with(:after, @action)
+    @action.unregister
+  end
+end

data/spec/runner/filters/tag_spec.rb

@@ -13,7 +13,7 @@ describe TagFilter, "#load" do
   end
 
   it "loads tags from the tag file" do
-    MSpec.should_receive(:read_tags).with("tag", "key").and_return([])
+    MSpec.should_receive(:read_tags).with(["tag", "key"]).and_return([])
     @filter.load
   end
 

data/spec/runner/mspec_spec.rb

@@ -368,7 +368,7 @@ describe MSpec, ".read_tags" do
 
   it "returns a list of tag instances for matching tag names found" do
     one = SpecTag.new "fail(broken):Some#method? works"
-    MSpec.read_tags("fail", "pass").should == [one]
+    MSpec.read_tags(["fail", "pass"]).should == [one]
   end
 
   it "returns [] if no tags names match" do

data/spec/spec_helper.rb

@@ -27,12 +27,13 @@ class MOSConfig < Hash
     self[:astrings]  = []
     self[:target]    = 'ruby'
     self[:command]   = nil
+    self[:ltags]     = []
   end
 end
 
 def new_option
   config = MOSConfig.new
-  return MSpecOptions.new(config, "spec"), config
+  return MSpecOptions.new("spec", 20, config), config
 end
 
 # Just to have an exception name output not be "Exception"

data/spec/utils/options_spec.rb

@@ -4,9 +4,444 @@ require 'mspec/version'
 require 'mspec/runner/mspec'
 require 'mspec/runner/formatters'
 
-describe MSpecOptions, "#parser" do
-  it "returns an OptionParser instance" do
-    MSpecOptions.new({}, "spec").parser.should be_kind_of(OptionParser)
+describe MSpecOption, ".new" do
+  before :each do
+    @opt = MSpecOption.new("-a", "--bdc", "ARG", "desc", :block)
+  end
+
+  it "sets the short attribute" do
+    @opt.short.should == "-a"
+  end
+
+  it "sets the long attribute" do
+    @opt.long.should == "--bdc"
+  end
+
+  it "sets the arg attribute" do
+    @opt.arg.should == "ARG"
+  end
+
+  it "sets the description attribute" do
+    @opt.description.should == "desc"
+  end
+
+  it "sets the block attribute" do
+    @opt.block.should == :block
+  end
+end
+
+describe MSpecOption, "#arg?" do
+  it "returns true if arg attribute is not nil" do
+    MSpecOption.new(nil, nil, "ARG", nil, nil).arg?.should be_true
+  end
+
+  it "returns false if arg attribute is nil" do
+    MSpecOption.new(nil, nil, nil, nil, nil).arg?.should be_false
+  end
+end
+
+describe MSpecOption, "#match?" do
+  before :each do
+    @opt = MSpecOption.new("-a", "--bdc", "ARG", "desc", :block)
+  end
+
+  it "returns true if the argument matches the short option" do
+    @opt.match?("-a").should be_true
+  end
+
+  it "returns true if the argument matches the long option" do
+    @opt.match?("--bdc").should be_true
+  end
+
+  it "returns false if the argument matches neither the short nor long option" do
+    @opt.match?("-b").should be_false
+    @opt.match?("-abdc").should be_false
+  end
+end
+
+describe MSpecOptions, ".new" do
+  before :each do
+    @opt = MSpecOptions.new("cmd", 20, :config)
+  end
+
+  it "sets the banner attribute" do
+    @opt.banner.should == "cmd"
+  end
+
+  it "sets the config attribute" do
+    @opt.config.should == :config
+  end
+
+  it "sets the width attribute" do
+    @opt.width.should == 20
+  end
+
+  it "sets the default width attribute" do
+    MSpecOptions.new.width.should == 30
+  end
+end
+
+describe MSpecOptions, "#on" do
+  before :each do
+    @opt = MSpecOptions.new
+  end
+
+  it "adds a short option" do
+    @opt.should_receive(:add).with("-a", nil, nil, "desc", nil)
+    @opt.on("-a", "desc")
+  end
+
+  it "adds a short option taking an argument" do
+    @opt.should_receive(:add).with("-a", nil, "ARG", "desc", nil)
+    @opt.on("-a", "ARG", "desc")
+  end
+
+  it "adds a long option" do
+    @opt.should_receive(:add).with("-a", nil, nil, "desc", nil)
+    @opt.on("-a", "desc")
+  end
+
+  it "adds a long option taking an argument" do
+    @opt.should_receive(:add).with("-a", nil, nil, "desc", nil)
+    @opt.on("-a", "desc")
+  end
+
+  it "adds a short and long option" do
+    @opt.should_receive(:add).with("-a", nil, nil, "desc", nil)
+    @opt.on("-a", "desc")
+  end
+
+  it "adds a short and long option taking an argument" do
+    @opt.should_receive(:add).with("-a", nil, nil, "desc", nil)
+    @opt.on("-a", "desc")
+  end
+
+  it "raises MSpecOptions::OptionError if pass less than 2 arguments" do
+    lambda { @opt.on    }.should raise_error(MSpecOptions::OptionError)
+    lambda { @opt.on "" }.should raise_error(MSpecOptions::OptionError)
+  end
+end
+
+describe MSpecOptions, "#add" do
+  before :each do
+    @opt = MSpecOptions.new "cmd", 20
+    @prc = lambda { }
+  end
+
+  it "adds documentation for an option" do
+    @opt.should_receive(:doc).with("   -t, --typo ARG   Correct typo ARG")
+    @opt.add("-t", "--typo", "ARG", "Correct typo ARG", @prc)
+  end
+
+  it "leaves spaces in the documentation for a missing short option" do
+    @opt.should_receive(:doc).with("       --typo ARG   Correct typo ARG")
+    @opt.add(nil, "--typo", "ARG", "Correct typo ARG", @prc)
+  end
+
+  it "handles a short option with argument but no long argument" do
+    @opt.should_receive(:doc).with("   -t ARG           Correct typo ARG")
+    @opt.add("-t", nil, "ARG", "Correct typo ARG", @prc)
+  end
+
+  it "registers an option" do
+    option = MSpecOption.new "-t", "--typo", "ARG", "Correct typo ARG", @prc
+    MSpecOption.should_receive(:new).with(
+        "-t", "--typo", "ARG", "Correct typo ARG", @prc).and_return(option)
+    @opt.add("-t", "--typo", "ARG", "Correct typo ARG", @prc)
+    @opt.options.should == [option]
+  end
+end
+
+describe MSpecOptions, "#match?" do
+  before :each do
+    @opt = MSpecOptions.new
+  end
+
+  it "returns the MSpecOption instance matching the argument" do
+    @opt.on "-a", "--abdc", "desc"
+    option = @opt.match? "-a"
+    @opt.match?("--abdc").should be(option)
+    option.should be_kind_of(MSpecOption)
+    option.short.should == "-a"
+    option.long.should == "--abdc"
+    option.description.should == "desc"
+  end
+end
+
+describe MSpecOptions, "#process" do
+  before :each do
+    @opt = MSpecOptions.new
+    ScratchPad.clear
+  end
+
+  it "calls the on_extra block if the argument does not match any option" do
+    @opt.on_extra { ScratchPad.record :extra }
+    @opt.process ["-a"], "-a", "-a", nil
+    ScratchPad.recorded.should == :extra
+  end
+
+  it "returns the matching option" do
+    @opt.on "-a", "ARG", "desc"
+    option = @opt.process [], "-a", "-a", "ARG"
+    option.should be_kind_of(MSpecOption)
+    option.short.should == "-a"
+    option.arg.should == "ARG"
+    option.description.should == "desc"
+  end
+
+  it "raises an MSpecOptions::ParseError if arg is nil and there are no more entries in argv" do
+    @opt.on "-a", "ARG", "desc"
+    lambda { @opt.process [], "-a", "-a", nil }.should raise_error(MSpecOptions::ParseError)
+  end
+
+  it "fetches the argument for the option from argv if arg is nil" do
+    @opt.on("-a", "ARG", "desc") { |o| ScratchPad.record o }
+    @opt.process ["ARG"], "-a", "-a", nil
+    ScratchPad.recorded.should == "ARG"
+  end
+
+  it "calls the option's block" do
+    @opt.on("-a", "ARG", "desc") { ScratchPad.record :option }
+    @opt.process [], "-a", "-a", "ARG"
+    ScratchPad.recorded.should == :option
+  end
+
+  it "does not call the option's block if it is nil" do
+    @opt.on "-a", "ARG", "desc"
+    lambda { @opt.process [], "-a", "-a", "ARG" }.should_not raise_error
+  end
+end
+
+describe MSpecOptions, "#split" do
+  before :each do
+    @opt = MSpecOptions.new
+  end
+
+  it "breaks a string at the nth character" do
+    opt, arg, rest = @opt.split "-bdc", 2
+    opt.should == "-b"
+    arg.should == "dc"
+    rest.should == "dc"
+  end
+
+  it "returns nil for arg if there are no characters left" do
+    opt, arg, rest = @opt.split "-b", 2
+    opt.should == "-b"
+    arg.should == nil
+    rest.should == ""
+  end
+end
+
+describe MSpecOptions, "#parse" do
+  before :each do
+    @opt = MSpecOptions.new
+    @prc = lambda { |o| ScratchPad.record [:parsed, o] }
+    ScratchPad.clear
+  end
+
+  it "parses a short option" do
+    @opt.on "-a", "desc", &@prc
+    @opt.parse ["-a"]
+    ScratchPad.recorded.should == [:parsed, nil]
+  end
+
+  it "parse a long option" do
+    @opt.on "--abdc", "desc", &@prc
+    @opt.parse ["--abdc"]
+    ScratchPad.recorded.should == [:parsed, nil]
+  end
+
+  it "parses a short option group" do
+    @opt.on "-a", "ARG", "desc", &@prc
+    @opt.parse ["-a", "ARG"]
+    ScratchPad.recorded.should == [:parsed, "ARG"]
+  end
+
+  it "parses a short option with an argument" do
+    @opt.on "-a", "ARG", "desc", &@prc
+    @opt.parse ["-a", "ARG"]
+    ScratchPad.recorded.should == [:parsed, "ARG"]
+  end
+
+  it "parses a short option with connected argument" do
+    @opt.on "-a", "ARG", "desc", &@prc
+    @opt.parse ["-aARG"]
+    ScratchPad.recorded.should == [:parsed, "ARG"]
+  end
+
+  it "parses a long option with an argument" do
+    @opt.on "--abdc", "ARG", "desc", &@prc
+    @opt.parse ["--abdc", "ARG"]
+    ScratchPad.recorded.should == [:parsed, "ARG"]
+  end
+
+  it "parses a long option with an '=' argument" do
+    @opt.on "--abdc", "ARG", "desc", &@prc
+    @opt.parse ["--abdc=ARG"]
+    ScratchPad.recorded.should == [:parsed, "ARG"]
+  end
+
+  it "parses a short option group with the final option taking an argument" do
+    ScratchPad.record []
+    @opt.on("-a", "desc") { |o| ScratchPad << :a }
+    @opt.on("-b", "ARG", "desc") { |o| ScratchPad << [:b, o] }
+    @opt.parse ["-ab", "ARG"]
+    ScratchPad.recorded.should == [:a, [:b, "ARG"]]
+  end
+
+  it "parses a short option group with a connected argument" do
+    ScratchPad.record []
+    @opt.on("-a", "desc") { |o| ScratchPad << :a }
+    @opt.on("-b", "ARG", "desc") { |o| ScratchPad << [:b, o] }
+    @opt.on("-c", "desc") { |o| ScratchPad << :c }
+    @opt.parse ["-acbARG"]
+    ScratchPad.recorded.should == [:a, :c, [:b, "ARG"]]
+  end
+
+  it "returns the unprocessed entries" do
+    @opt.on "-a", "ARG", "desc", &@prc
+    @opt.parse(["abdc", "-a", "ilny"]).should == ["abdc"]
+  end
+
+  it "calls the on_extra handler with unrecognized options" do
+    ScratchPad.record []
+    @opt.on_extra { |o| ScratchPad << o }
+    @opt.on "-a", "desc"
+    @opt.parse ["-a", "-b"]
+    ScratchPad.recorded.should == ["-b"]
+  end
+
+  it "does not attempt to call the block if it is nil" do
+    @opt.on "-a", "ARG", "desc"
+    @opt.parse(["-a", "ARG"]).should == []
+  end
+
+  it "raises MSpecOptions::ParseError if passed an unrecognized option" do
+    @opt.should_receive(:raise).with(MSpecOptions::ParseError, an_instance_of(String))
+    @opt.stub!(:puts)
+    @opt.stub!(:exit)
+    @opt.parse "-u"
+  end
+end
+
+describe MSpecOptions, "#banner=" do
+  before :each do
+    @opt = MSpecOptions.new
+  end
+
+  it "sets the banner attribute" do
+    @opt.banner.should == ""
+    @opt.banner = "banner"
+    @opt.banner.should == "banner"
+  end
+end
+
+describe MSpecOptions, "#width=" do
+  before :each do
+    @opt = MSpecOptions.new
+  end
+
+  it "sets the width attribute" do
+    @opt.width.should == 30
+    @opt.width = 20
+    @opt.width.should == 20
+  end
+end
+
+describe MSpecOptions, "#config=" do
+  before :each do
+    @opt = MSpecOptions.new
+  end
+
+  it "sets the config attribute" do
+    @opt.config.should be_nil
+    @opt.config = :config
+    @opt.config.should == :config
+  end
+end
+
+describe MSpecOptions, "#doc" do
+  before :each do
+    @opt = MSpecOptions.new "command"
+  end
+
+  it "adds text to be displayed with #to_s" do
+    @opt.doc "Some message"
+    @opt.doc "Another message"
+    @opt.to_s.should == <<-EOD
+command
+
+Some message
+Another message
+EOD
+  end
+end
+
+describe MSpecOptions, "#version" do
+  before :each do
+    @opt = MSpecOptions.new
+    ScratchPad.clear
+  end
+
+  it "installs a basic -v, --version option" do
+    @opt.should_receive(:puts)
+    @opt.should_receive(:exit)
+    @opt.version "1.0.0"
+    @opt.parse "-v"
+  end
+
+  it "accepts a block instead of using the default block" do
+    @opt.version("1.0.0") { |o| ScratchPad.record :version }
+    @opt.parse "-v"
+    ScratchPad.recorded.should == :version
+  end
+end
+
+describe MSpecOptions, "#help" do
+  before :each do
+    @opt = MSpecOptions.new
+    ScratchPad.clear
+  end
+
+  it "installs a basic -h, --help option" do
+    @opt.should_receive(:puts)
+    @opt.should_receive(:exit).with(1)
+    @opt.help
+    @opt.parse "-h"
+  end
+
+  it "accepts a block instead of using the default block" do
+    @opt.help { |o| ScratchPad.record :help }
+    @opt.parse "-h"
+    ScratchPad.recorded.should == :help
+  end
+end
+
+describe MSpecOptions, "#on_extra" do
+  before :each do
+    @opt = MSpecOptions.new
+    ScratchPad.clear
+  end
+
+  it "registers a block to be called when an option is not recognized" do
+    @opt.on_extra { ScratchPad.record :extra }
+    @opt.parse "-g"
+    ScratchPad.recorded.should == :extra
+  end
+end
+
+describe MSpecOptions, "#to_s" do
+  before :each do
+    @opt = MSpecOptions.new "command"
+  end
+
+  it "returns the banner and descriptive strings for all registered options" do
+    @opt.on "-t", "--this ARG", "Adds this ARG to the list"
+    @opt.to_s.should == <<-EOD
+command
+
+   -t, --this ARG             Adds this ARG to the list
+EOD
   end
 end
 
@@ -15,17 +450,17 @@ describe "The -B, --config FILE option" do
     @options, @config = new_option
   end
 
-  it "is enabled with #add_config { }" do
-    @options.should_receive(:on).with("-B", "--config FILE",
-        String, an_instance_of(String))
-    @options.add_config {}
+  it "is enabled with #configure { }" do
+    @options.should_receive(:on).with("-B", "--config", "FILE",
+        an_instance_of(String))
+    @options.configure {}
   end
 
   it "calls the passed block" do
     ["-B", "--config"].each do |opt|
       ScratchPad.clear
 
-      @options.add_config { |x| ScratchPad.record x }
+      @options.configure { |x| ScratchPad.record x }
       @options.parse [opt, "file"]
       ScratchPad.recorded.should == "file"
     end
@@ -42,15 +477,15 @@ describe "The -n, --name RUBY_NAME option" do
     $VERBOSE = @verbose
   end
 
-  it "is enabled with #add_name" do
-    @options.should_receive(:on).with("-n", "--name RUBY_NAME",
-        String, an_instance_of(String))
-    @options.add_name
+  it "is enabled with #name" do
+    @options.should_receive(:on).with("-n", "--name", "RUBY_NAME",
+        an_instance_of(String))
+    @options.name
   end
 
   it "sets RUBY_NAME when invoked" do
     Object.should_receive(:const_set).with(:RUBY_NAME, "name").twice
-    @options.add_name
+    @options.name
     @options.parse ["-n", "name"]
     @options.parse ["--name", "name"]
   end
@@ -59,21 +494,20 @@ end
 describe "The -t, --target TARGET option" do
   before :each do
     @options, @config = new_option
-    @options.add_targets
+    @options.targets
   end
 
-  it "is enabled with #add_targets" do
+  it "is enabled with #targets" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-t", "--target TARGET",
-        String, an_instance_of(String))
-    @options.add_targets
+    @options.should_receive(:on).with("-t", "--target", "TARGET",
+        an_instance_of(String))
+    @options.targets
   end
 
   it "sets the target to 'ruby' and flags to verbose with TARGET 'ruby'" do
     ["-t", "--target"].each do |opt|
       @options.parse [opt, "ruby"]
       @config[:target].should == "ruby"
-      @config[:flags].should include("-v")
     end
   end
 
@@ -99,7 +533,7 @@ describe "The -t, --target TARGET option" do
     ["-t", "--target"].each do |opt|
       ["x", "rubinius"].each do |t|
         @options.parse [opt, t]
-        @config[:target].should == "shotgun/rubinius"
+        @config[:target].should == "./bin/rbx"
       end
     end
   end
@@ -124,14 +558,14 @@ end
 describe "The -T, --target-opt OPT option" do
   before :each do
     @options, @config = new_option
-    @options.add_targets
+    @options.targets
   end
 
-  it "is enabled with #add_targets" do
+  it "is enabled with #targets" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-T", "--target-opt OPT",
-        String, an_instance_of(String))
-    @options.add_targets
+    @options.should_receive(:on).with("-T", "--target-opt", "OPT",
+        an_instance_of(String))
+    @options.targets
   end
 
   it "adds OPT to flags" do
@@ -146,14 +580,14 @@ end
 describe "The -I, --include DIR option" do
   before :each do
     @options, @config = new_option
-    @options.add_targets
+    @options.targets
   end
 
-  it "is enabled with #add_targets" do
+  it "is enabled with #targets" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-I", "--include DIR",
-        String, an_instance_of(String))
-    @options.add_targets
+    @options.should_receive(:on).with("-I", "--include", "DIR",
+        an_instance_of(String))
+    @options.targets
   end
 
   it "add DIR to the includes list" do
@@ -168,14 +602,14 @@ end
 describe "The -r, --require LIBRARY option" do
   before :each do
     @options, @config = new_option
-    @options.add_targets
+    @options.targets
   end
 
-  it "is enabled with #add_targets" do
+  it "is enabled with #targets" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-r", "--require LIBRARY",
-        String, an_instance_of(String))
-    @options.add_targets
+    @options.should_receive(:on).with("-r", "--require", "LIBRARY",
+        an_instance_of(String))
+    @options.targets
   end
 
   it "adds LIBRARY to the requires list" do
@@ -190,14 +624,14 @@ end
 describe "The -f, --format FORMAT option" do
   before :each do
     @options, @config = new_option
-    @options.add_formatters
+    @options.formatters
   end
 
-  it "is enabled with #add_formatters" do
+  it "is enabled with #formatters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-f", "--format FORMAT",
-        String, an_instance_of(String))
-    @options.add_formatters
+    @options.should_receive(:on).with("-f", "--format", "FORMAT",
+        an_instance_of(String))
+    @options.formatters
   end
 
   it "sets the SpecdocFormatter with FORMAT 's' or 'specdoc'" do
@@ -264,14 +698,14 @@ end
 describe "The -o, --output FILE option" do
   before :each do
     @options, @config = new_option
-    @options.add_formatters
+    @options.formatters
   end
 
-  it "is enabled with #add_formatters" do
+  it "is enabled with #formatters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-o", "--output FILE",
-        String, an_instance_of(String))
-    @options.add_formatters
+    @options.should_receive(:on).with("-o", "--output", "FILE",
+        an_instance_of(String))
+    @options.formatters
   end
 
   it "sets the output to FILE" do
@@ -286,14 +720,14 @@ end
 describe "The -e, --example STR" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-e", "--example STR",
-        String, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-e", "--example", "STR",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds STR to the includes list" do
@@ -308,14 +742,14 @@ end
 describe "The -E, --exclude STR" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-E", "--exclude STR",
-        String, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-E", "--exclude", "STR",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds STR to the excludes list" do
@@ -330,14 +764,14 @@ end
 describe "The -p, --pattern PATTERN" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-p", "--pattern PATTERN",
-        Regexp, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-p", "--pattern", "PATTERN",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds PATTERN to the included patterns list" do
@@ -352,14 +786,14 @@ end
 describe "The -P, --excl-pattern PATTERN" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-P", "--excl-pattern PATTERN",
-        Regexp, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-P", "--excl-pattern", "PATTERN",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds PATTERN to the excluded patterns list" do
@@ -374,14 +808,14 @@ end
 describe "The -g, --tag TAG" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-g", "--tag TAG",
-        String, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-g", "--tag", "TAG",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds TAG to the included tags list" do
@@ -396,14 +830,14 @@ end
 describe "The -G, --excl-tag TAG" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-G", "--excl-tag TAG",
-        String, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-G", "--excl-tag", "TAG",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds TAG to the excluded tags list" do
@@ -418,14 +852,14 @@ end
 describe "The -w, --profile FILE option" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-w", "--profile FILE",
-        String, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-w", "--profile", "FILE",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds FILE to the included profiles list" do
@@ -440,14 +874,14 @@ end
 describe "The -W, --excl-profile FILE option" do
   before :each do
     @options, @config = new_option
-    @options.add_filters
+    @options.filters
   end
 
-  it "is enabled with #add_filters" do
+  it "is enabled with #filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-W", "--excl-profile FILE",
-        String, an_instance_of(String))
-    @options.add_filters
+    @options.should_receive(:on).with("-W", "--excl-profile", "FILE",
+        an_instance_of(String))
+    @options.filters
   end
 
   it "adds FILE to the excluded profiles list" do
@@ -462,12 +896,12 @@ end
 describe "The -Z", "--dry-run option" do
   before :each do
     @options, @config = new_option
-    @options.add_pretend
+    @options.pretend
   end
 
-  it "is enabled with #add_pretend" do
+  it "is enabled with #pretend" do
     @options.should_receive(:on).with("-Z", "--dry-run", an_instance_of(String))
-    @options.add_pretend
+    @options.pretend
   end
 
   it "registers the MSpec pretend mode" do
@@ -481,12 +915,12 @@ end
 describe "The -H, --random option" do
   before :each do
     @options, @config = new_option
-    @options.add_randomize
+    @options.randomize
   end
 
-  it "is enabled with #add_randomize" do
+  it "is enabled with #randomize" do
     @options.should_receive(:on).with("-H", "--random", an_instance_of(String))
-    @options.add_randomize
+    @options.randomize
   end
 
   it "registers the MSpec randomize mode" do
@@ -500,13 +934,13 @@ end
 describe "The -V, --verbose option" do
   before :each do
     @options, @config = new_option
-    @options.add_verbose
+    @options.verbose
   end
 
-  it "is enabled with #add_verbose" do
+  it "is enabled with #verbose" do
     @options.stub!(:on)
     @options.should_receive(:on).with("-V", "--verbose", an_instance_of(String))
-    @options.add_verbose
+    @options.verbose
   end
 
   it "registers a verbose output object with MSpec" do
@@ -521,14 +955,14 @@ end
 describe "The -m, --marker MARKER option" do
   before :each do
     @options, @config = new_option
-    @options.add_verbose
+    @options.verbose
   end
 
-  it "is enabled with #add_verbose" do
+  it "is enabled with #verbose" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-m", "--marker MARKER",
-        String, an_instance_of(String))
-    @options.add_verbose
+    @options.should_receive(:on).with("-m", "--marker", "MARKER",
+        an_instance_of(String))
+    @options.verbose
   end
 
   it "registers a marker output object with MSpec" do
@@ -542,12 +976,12 @@ end
 describe "The --int-spec option" do
   before :each do
     @options, @config = new_option
-    @options.add_interrupt
+    @options.interrupt
   end
 
-  it "is enabled with #add_interrupt" do
+  it "is enabled with #interrupt" do
     @options.should_receive(:on).with("--int-spec", an_instance_of(String))
-    @options.add_interrupt
+    @options.interrupt
   end
 
   it "sets the abort config option to false to only abort the running spec with ^C" do
@@ -560,17 +994,17 @@ end
 describe "The -Y, --verify option" do
   before :each do
     @options, @config = new_option
-    @options.add_verify
+    @options.verify
   end
 
-  it "is enabled with #add_interrupt" do
+  it "is enabled with #interrupt" do
     @options.stub!(:on)
     @options.should_receive(:on).with("-Y", "--verify", an_instance_of(String))
-    @options.add_verify
+    @options.verify
   end
 
   it "sets the MSpec mode to :verify" do
-    MSpec.should_receive(:set_mode).with(:verify).twice
+    MSpec.should_receive(:register_mode).with(:verify).twice
     ["-Y", "--verify"].each do |m|
       @options.parse m
     end
@@ -580,147 +1014,34 @@ end
 describe "The -O, --report option" do
   before :each do
     @options, @config = new_option
-    @options.add_verify
+    @options.verify
   end
 
-  it "is enabled with #add_interrupt" do
+  it "is enabled with #interrupt" do
     @options.stub!(:on)
     @options.should_receive(:on).with("-O", "--report", an_instance_of(String))
-    @options.add_verify
+    @options.verify
   end
 
   it "sets the MSpec mode to :report" do
-    MSpec.should_receive(:set_mode).with(:report).twice
+    MSpec.should_receive(:register_mode).with(:report).twice
     ["-O", "--report"].each do |m|
       @options.parse m
     end
   end
 end
 
-describe "The -N, --add TAG option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_tagging
-  end
-
-  it "is enabled with #add_tagging" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-N", "--add TAG",
-        String, an_instance_of(String))
-    @options.add_tagging
-  end
-
-  it "sets the mode to :add and sets the tag to TAG" do
-    ["-N", "--add"].each do |opt|
-      @config[:tagger] = nil
-      @config[:tag] = nil
-      @options.parse [opt, "taggit"]
-      @config[:tagger].should == :add
-      @config[:tag].should == "taggit:"
-    end
-  end
-end
-
-describe "The -R, --del TAG option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_tagging
-  end
-
-  it "is enabled with #add_tagging" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-R", "--del TAG",
-        String, an_instance_of(String))
-    @options.add_tagging
-  end
-
-  it "it sets the mode to :del, the tag to TAG, and the outcome to :pass" do
-    ["-R", "--del"].each do |opt|
-      @config[:tagger] = nil
-      @config[:tag] = nil
-      @config[:outcome] = nil
-      @options.parse [opt, "taggit"]
-      @config[:tagger].should == :del
-      @config[:tag].should == "taggit:"
-      @config[:outcome].should == :pass
-    end
-  end
-end
-
-describe "The -Q, --pass option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_tagging
-  end
-
-  it "is enabled with #add_tagging" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-Q", "--pass", an_instance_of(String))
-    @options.add_tagging
-  end
-
-  it "sets the outcome to :pass" do
-    ["-Q", "--pass"].each do |opt|
-      @config[:outcome] = nil
-      @options.parse opt
-      @config[:outcome].should == :pass
-    end
-  end
-end
-
-describe "The -F, --fail option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_tagging
-  end
-
-  it "is enabled with #add_tagging" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-F", "--fail", an_instance_of(String))
-    @options.add_tagging
-  end
-
-  it "sets the outcome to :fail" do
-    ["-F", "--fail"].each do |opt|
-      @config[:outcome] = nil
-      @options.parse opt
-      @config[:outcome].should == :fail
-    end
-  end
-end
-
-describe "The -L, --all option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_tagging
-  end
-
-  it "is enabled with #add_tagging" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-L", "--all", an_instance_of(String))
-    @options.add_tagging
-  end
-
-  it "sets the outcome to :all" do
-    ["-L", "--all"].each do |opt|
-      @config[:outcome] = nil
-      @options.parse opt
-      @config[:outcome].should == :all
-    end
-  end
-end
-
 describe "The -K, --action-tag TAG option" do
   before :each do
     @options, @config = new_option
-    @options.add_action_filters
+    @options.action_filters
   end
 
-  it "is enabled with #add_action_filters" do
+  it "is enabled with #action_filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-K", "--action-tag TAG",
-        String, an_instance_of(String))
-    @options.add_action_filters
+    @options.should_receive(:on).with("-K", "--action-tag", "TAG",
+        an_instance_of(String))
+    @options.action_filters
   end
 
   it "adds TAG to the list of tags that trigger actions" do
@@ -735,14 +1056,14 @@ end
 describe "The -S, --action-string STR option" do
   before :each do
     @options, @config = new_option
-    @options.add_action_filters
+    @options.action_filters
   end
 
-  it "is enabled with #add_action_filters" do
+  it "is enabled with #action_filters" do
     @options.stub!(:on)
-    @options.should_receive(:on).with("-S", "--action-string STR",
-        String, an_instance_of(String))
-    @options.add_action_filters
+    @options.should_receive(:on).with("-S", "--action-string", "STR",
+        an_instance_of(String))
+    @options.action_filters
   end
 
   it "adds STR to the list of spec descriptions that trigger actions" do
@@ -757,17 +1078,17 @@ end
 describe "The --spec-debug option" do
   before :each do
     @options, @config = new_option
-    @options.add_actions
+    @options.actions
   end
 
-  it "is enabled with #add_actions" do
+  it "is enabled with #actions" do
     @options.stub!(:on)
     @options.should_receive(:on).with("--spec-debug", an_instance_of(String))
-    @options.add_actions
+    @options.actions
   end
 
   it "enables the triggering the ruby debugger" do
-    @options.add_action_filters
+    @options.action_filters
     @options.parse ["-S", "some spec"]
 
     @config[:debugger] = nil
@@ -779,17 +1100,17 @@ end
 describe "The --spec-gdb option" do
   before :each do
     @options, @config = new_option
-    @options.add_actions
+    @options.actions
   end
 
-  it "is enabled with #add_actions" do
+  it "is enabled with #actions" do
     @options.stub!(:on)
     @options.should_receive(:on).with("--spec-gdb", an_instance_of(String))
-    @options.add_actions
+    @options.actions
   end
 
   it "enables triggering the gdb debugger" do
-    @options.add_action_filters
+    @options.action_filters
     @options.parse ["-S", "some spec"]
 
     @config[:gdb] = nil
@@ -797,45 +1118,3 @@ describe "The --spec-gdb option" do
     @config[:gdb].should == true
   end
 end
-
-describe "The -v, --version option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_version
-  end
-
-  it "is enabled with #add_version" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-v", "--version", an_instance_of(String))
-    @options.add_version
-  end
-
-  it "prints the version and exits" do
-    @options.should_receive(:puts).twice
-    @options.should_receive(:exit).twice
-    ["-v", "--version"].each do |opt|
-      @options.parse opt
-    end
-  end
-end
-
-describe "The -h, --help option" do
-  before :each do
-    @options, @config = new_option
-    @options.add_help
-  end
-
-  it "is enabled with #add_help" do
-    @options.stub!(:on)
-    @options.should_receive(:on).with("-h", "--help", an_instance_of(String))
-    @options.add_help
-  end
-
-  it "prints help and exits" do
-    @options.should_receive(:puts).twice
-    @options.should_receive(:exit).twice
-    ["-h", "--help"].each do |opt|
-      @options.parse opt
-    end
-  end
-end