mspec 1.4.0 → 1.5.0

data/lib/mspec/commands/mspec.rb

@@ -2,7 +2,7 @@
 
 MSPEC_HOME = File.expand_path(File.dirname(__FILE__) + '/../../..')
 
-require 'optparse'
+require 'mspec/version'
 require 'mspec/utils/options'
 require 'mspec/utils/script'
 require 'mspec/helpers/tmp'
@@ -20,24 +20,19 @@ class MSpecMain < MSpecScript
   end
 
   def options(argv=ARGV)
-    if ["ci", "run", "tag"].include? argv[0]
-      config[:command] = argv.shift
-      config[:options] << "-h" if argv.delete("-h") || argv.delete("--help")
-      config[:options] << "-v" if argv.delete("-v") || argv.delete("--version")
-    end
+    config[:command] = argv.shift if ["ci", "run", "tag"].include?(argv[0])
 
-    options = MSpecOptions.new config, "[COMMAND]", "", 28, "   "
+    options = MSpecOptions.new "mspec [COMMAND] [options] (FILE|DIRECTORY|GLOB)+", 30, config
 
-    options.separator ""
-    options.separator "  The mspec command sets up and invokes the sub-commands"
-    options.separator "  (see below) to enable, for instance, running the specs"
-    options.separator "  with different implementations like ruby, jruby, rbx, etc.\n"
+    options.doc "  The mspec command sets up and invokes the sub-commands"
+    options.doc "  (see below) to enable, for instance, running the specs"
+    options.doc "  with different implementations like ruby, jruby, rbx, etc.\n"
 
-    options.add_config do |f|
+    options.configure do |f|
       config[:options] << '-B' << f
     end
 
-    options.add_targets
+    options.targets
 
     options.on("-D", "--gdb", "Run under gdb") do
       config[:flags] << '--gdb'
@@ -53,21 +48,32 @@ class MSpecMain < MSpecScript
       config[:multi] = true
       config[:options] << "-fy"
     end
-    options.add_version
-    options.on("-h", "--help", "Show this message") do
-      puts options.parser
-      exit
+    options.version MSpec::VERSION do
+      if config[:command]
+        config[:options] << "-v"
+      else
+        puts options
+        exit
+      end
+    end
+    options.help do
+      if config[:command]
+        config[:options] << "-h"
+      else
+        puts options
+        exit 1
+      end
     end
 
     # The rest of the help output
-    options.separator "\n  where COMMAND is one of:\n"
-    options.separator "    run - Run the specified specs (default)"
-    options.separator "    ci  - Run the known good specs"
-    options.separator "    tag - Add or remove tags\n"
-    options.separator "  mspec COMMAND -h for more options\n"
-
-    config[:options] += options.parser.filter! argv
-    options.parse argv
+    options.doc "\n  where COMMAND is one of:\n"
+    options.doc "    run - Run the specified specs (default)"
+    options.doc "    ci  - Run the known good specs"
+    options.doc "    tag - Add or remove tags\n"
+    options.doc "  mspec COMMAND -h for more options\n"
+
+    options.on_extra { |o| config[:options] << o }
+    config[:options].concat options.parse(argv)
   end
 
   def register; end
@@ -126,11 +132,14 @@ class MSpecMain < MSpecScript
 
   def run
     ENV['MSPEC_RUNNER'] = '1'
+    ENV['RUBY_EXE']     = config[:target]
+    ENV['RUBY_FLAGS']   = config[:flags].join " "
 
-    argv = ["-v"]
+    argv = []
     argv.concat config[:flags]
     argv.concat config[:includes]
     argv.concat config[:requires]
+    argv << "-v"
     argv << "#{MSPEC_HOME}/bin/mspec-#{ config[:command] || "run" }"
     argv.concat config[:options]
 

data/lib/mspec/guards.rb

@@ -1,3 +1,4 @@
+require 'mspec/ruby_name'
 require 'mspec/guards/bug'
 require 'mspec/guards/compliance'
 require 'mspec/guards/extensions'

data/lib/mspec/guards/guard.rb

@@ -1,21 +1,6 @@
 require 'mspec/runner/mspec'
 require 'mspec/runner/actions/tally'
 
-unless defined?(RUBY_NAME) and RUBY_NAME
-  if defined?(RUBY_ENGINE) and RUBY_ENGINE
-    RUBY_NAME = RUBY_ENGINE
-    if defined?(ARG0)
-      RUBY_CLI = /rubinius|rbx/.match(ARG0) ? "shotgun/rubinius" : ARG0
-    else
-      RUBY_CLI = RUBY_NAME
-    end
-  else
-    require 'rbconfig'
-    RUBY_NAME = Config::CONFIG["RUBY_INSTALL_NAME"] || Config::CONFIG["ruby_install_name"]
-    RUBY_CLI  = RUBY_NAME
-  end
-end
-
 class SpecGuard
   def self.register
     unless @registered
@@ -81,6 +66,8 @@ class SpecGuard
         RUBY_NAME =~ /^ruby(1.9)?/ and RUBY_VERSION =~ /^1.9/
       when :jruby
         RUBY_NAME =~ /^jruby/
+      when :ironruby, :ir
+        RUBY_NAME =~ /^ironruby/
       else
         false
       end

data/lib/mspec/helpers.rb

@@ -4,3 +4,4 @@ require 'mspec/helpers/io'
 require 'mspec/helpers/scratch'
 require 'mspec/helpers/tmp'
 require 'mspec/helpers/const_lookup'
+require 'mspec/helpers/ruby_exe'

data/lib/mspec/helpers/ruby_exe.rb

@@ -0,0 +1,101 @@
+require 'mspec/ruby_name'
+
+# The ruby_exe helper provides a wrapper for invoking the
+# same Ruby interpreter as the one running the specs and
+# getting the output from running the code. If +code+ is a
+# file that exists, it will be run. Otherwise, +code+ should
+# be Ruby code that will be run with the -e command line
+# option. For example:
+#
+#   ruby_exe('path/to/some/file.rb')
+#
+# will be executed as
+#
+#   `#{RUBY_EXE} #{'path/to/some/file.rb'}`
+#
+# while
+#
+#   ruby_exe('puts "hello, world."')
+#
+# will be executed as
+#
+#   `#{RUBY_EXE} -e #{'puts "hello, world."'}`
+#
+# The RUBY_EXE constant can be set explicitly since the value
+# is used each time ruby_exe is invoked. The mspec runner script
+# will set ENV['RUBY_EXE'] to the name of the executable used
+# to invoke the mspec-run script. The value of RUBY_EXE will be
+# constructed as follows:
+#
+#   1. the value of ENV['RUBY_EXE']
+#   2. an explicit value based on RUBY_NAME
+#   3. cwd/(RUBY_NAME + $(EXEEXT) || $(exeext) || '')
+#   4. $(bindir)/$(RUBY_INSTALL_NAME)
+#
+# The value will only be used if the file exists and is executable.
+#
+# These 4 ways correspond to the following scenarios:
+#
+#   1. Using the MSpec runner scripts, the name of the
+#      executable is explicitly passed by ENV['RUBY_EXE']
+#      so there is no ambiguity.
+#
+#  Otherwise, if using RSpec (or something else)
+#
+#   2. Running the specs while developing an alternative
+#      Ruby implementation. This explicitly names the
+#      executable in the development directory based on
+#      the value of RUBY_NAME, which is probably initialized
+#      from the value of RUBY_ENGINE.
+#   3. Running the specs within the source directory for
+#      some implementation. (E.g. a local build directory.)
+#   4. Running the specs against some installed Ruby
+#      implementation.
+
+class Object
+  def ruby_exe_options(option)
+    case option
+    when :env
+      ENV['RUBY_EXE']
+    when :engine
+      case RUBY_NAME
+      when 'rbx'
+        "bin/rbx"
+      when 'jruby'
+        "bin/jruby"
+      when 'ironruby'
+        "ir"
+      end
+    when :name
+      bin = RUBY_NAME + (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '')
+      File.join(".", bin)
+    when :install_name
+      bin = Config::CONFIG["RUBY_INSTALL_NAME"] || Config::CONFIG["ruby_install_name"]
+      bin << (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '')
+      File.join(Config::CONFIG['bindir'], bin)
+    end
+  end
+
+  def resolve_ruby_exe
+    [:env, :engine, :name, :install_name].each do |option|
+      exe = ruby_exe_options option
+      return exe if exe and File.exists?(exe) and File.executable?(exe)
+    end
+    nil
+  end
+
+  def ruby_exe(code)
+    if File.exists?(code) and File.executable?(code)
+      `#{RUBY_EXE} #{ENV['RUBY_FLAGS']} #{code}`
+    else
+      `#{RUBY_EXE} #{ENV['RUBY_FLAGS']} -e #{code.inspect}`
+    end
+  end
+
+  unless Object.const_defined?(:RUBY_EXE) and RUBY_EXE
+    require 'rbconfig'
+
+    RUBY_EXE = resolve_ruby_exe or
+      raise Exception, "Unable to find a suitable ruby executable."
+  end
+end

data/lib/mspec/ruby_name.rb

@@ -0,0 +1,8 @@
+unless Object.const_defined?(:RUBY_NAME) and RUBY_NAME
+  if Object.const_defined?(:RUBY_ENGINE) and RUBY_ENGINE
+    RUBY_NAME = RUBY_ENGINE
+  else
+    require 'rbconfig'
+    RUBY_NAME = Config::CONFIG["RUBY_INSTALL_NAME"] || Config::CONFIG["ruby_install_name"]
+  end
+end

data/lib/mspec/runner/actions.rb

@@ -2,5 +2,6 @@ require 'mspec/runner/actions/tally'
 require 'mspec/runner/actions/timer'
 require 'mspec/runner/actions/filter'
 require 'mspec/runner/actions/tag'
+require 'mspec/runner/actions/taglist'
 require 'mspec/runner/actions/debug'
 require 'mspec/runner/actions/gdb'

data/lib/mspec/runner/actions/filter.rb

@@ -24,7 +24,7 @@ class ActionFilter
     @tfilter = nil
     return if @tags.empty?
 
-    desc = MSpec.read_tags(*@tags).map { |t| t.description }
+    desc = MSpec.read_tags(@tags).map { |t| t.description }
     return if desc.empty?
 
     @tfilter = MatchFilter.new(nil, *desc)

data/lib/mspec/runner/actions/taglist.rb

@@ -0,0 +1,56 @@
+require 'mspec/runner/actions/filter'
+
+# TagListAction - prints out the descriptions for any specs
+# tagged with +tags+. If +tags+ is an empty list, prints out
+# descriptions for any specs that are tagged.
+class TagListAction
+  def initialize(tags=nil)
+    @tags = tags.nil? || tags.empty? ? nil : Array(tags)
+    @filter = nil
+  end
+
+  # Returns true. This enables us to match any tag when loading
+  # tags from the file.
+  def include?(arg)
+    true
+  end
+
+  # Returns true if any tagged descriptions matches +string+.
+  def ===(string)
+    @filter === string
+  end
+
+  # Prints a banner about matching tagged specs.
+  def start
+    if @tags
+      print "\nListing specs tagged with #{@tags.map { |t| "'#{t}'" }.join(", ") }\n\n"
+    else
+      print "\nListing all tagged specs\n\n"
+    end
+  end
+
+  # Creates a MatchFilter for specific tags or for all tags.
+  def load
+    @filter = nil
+    desc = MSpec.read_tags(@tags || self).map { |t| t.description }
+    @filter = MatchFilter.new(nil, *desc) unless desc.empty?
+  end
+
+  # Prints the spec description if it matches the filter.
+  def after(state)
+    return unless self === state.description
+    print state.description, "\n"
+  end
+
+  def register
+    MSpec.register :start, self
+    MSpec.register :load,  self
+    MSpec.register :after, self
+  end
+
+  def unregister
+    MSpec.unregister :start, self
+    MSpec.unregister :load,  self
+    MSpec.unregister :after, self
+  end
+end

data/lib/mspec/runner/filters/tag.rb

@@ -7,7 +7,7 @@ class TagFilter
   end
 
   def load
-    desc = MSpec.read_tags(*@tags).map { |t| t.description }
+    desc = MSpec.read_tags(@tags).map { |t| t.description }
 
     @filter = MatchFilter.new(@what, *desc)
     @filter.register

data/lib/mspec/runner/mspec.rb

@@ -237,7 +237,9 @@ module MSpec
     end
   end
 
-  def self.read_tags(*keys)
+  # Returns a list of tags matching any tag string in +keys+ based
+  # on the return value of <tt>keys.include?("tag_name")</tt>
+  def self.read_tags(keys)
     tags = []
     file = tags_file
     if File.exist? file

data/lib/mspec/utils/options.rb

@@ -1,215 +1,341 @@
-# FIXME: There are essentially two options for these runner
-# scripts: 1. all in one file, 2. in separate files. The fact
-# that the subcommands share a number of options weighs
-# toward having a single script. However, the subcommands
-# also take specialized options which can be confusing. Added
-# to this the support for switches to specify a different
-# implementation and the balance swings to separate scripts.
-#
-# Now, the fun begins. The main script needs a way to specify
-# certain command line options and then pass the rest to the
-# invoked subscript. Unfortunately, this possibility does not
-# exist in the universe inhabited by OptionParser or GetoptLong.
-#
-# The #filter! method below does not properly handle optional
-# arguments to a switch.
-class OptionParser
-  class Switch
-    def consume?(opt)
-      if opt == short.to_s or opt == long.to_s
-        return arg ? 2 : 1
-      elsif opt[0..1] == short.to_s and opt.size > 2
-        return 1
+require 'mspec/version'
+
+class MSpecOption
+  attr_reader :short, :long, :arg, :description, :block
+
+  def initialize(short, long, arg, description, block)
+    @short       = short
+    @long        = long
+    @arg         = arg
+    @description = description
+    @block       = block
+  end
+
+  def arg?
+    @arg != nil
+  end
+
+  def match?(opt)
+    opt == @short or opt == @long
+  end
+end
+
+# MSpecOptions provides a parser for command line options. It also
+# provides a composable set of options from which the runner scripts
+# can select for their particular functionality.
+class MSpecOptions
+  # Raised if incorrect or incomplete formats are passed to #on.
+  class OptionError < Exception; end
+
+  # Raised if an unrecognized option is encountered.
+  class ParseError < Exception; end
+
+  attr_accessor :config, :banner, :width, :options
+
+  def initialize(banner="", width=30, config=nil)
+    @banner   = banner
+    @config   = config
+    @width    = width
+    @options  = []
+    @doc      = []
+    @extra    = []
+    @on_extra = lambda { |x|
+      raise ParseError, "Unrecognized option: #{x}" if x[0] == ?-
+      @extra << x
+    }
+
+    yield self if block_given?
+  end
+
+  # Registers an option. Acceptable formats for arguments are:
+  #
+  #  on "-a", "description"
+  #  on "-a", "--abdc", "description"
+  #  on "-a", "ARG", "description"
+  #  on "--abdc", "ARG", "description"
+  #  on "-a", "--abdc", "ARG", "description"
+  #
+  # If an block is passed, it will be invoked when the option is
+  # matched. Not passing a block is permitted, but nonsensical.
+  def on(*args, &block)
+    raise OptionError, "option and description are required" if args.size < 2
+
+    description = args.pop
+    short, long, argument = nil
+    args.each do |arg|
+      if arg[0] == ?-
+        if arg[1] == ?-
+          long = arg
+        else
+          short = arg
+        end
       else
-        return 0
+        argument = arg
       end
     end
+
+    add short, long, argument, description, block
   end
 
-  def filter!(argv)
-    @stack.inject(options=[]) do |list, entry|
-      entry.list.each do |switch|
-        next unless switch.kind_of? OptionParser::Switch
-        list << switch
+  # Adds documentation text for an option and adds an +MSpecOption+
+  # instance to the list of registered options.
+  def add(short, long, arg, description, block)
+    s = short ? short.dup : "  "
+    s << (short ? ", " : "  ") if long
+    doc "   #{s}#{long} #{arg}".ljust(@width-1) + " #{description}"
+    @options << MSpecOption.new(short, long, arg, description, block)
+  end
+
+  # Searches all registered options to find a match for +opt+. Returns
+  # +nil+ if no registered options match.
+  def match?(opt)
+    @options.find { |o| o.match? opt }
+  end
+
+  # Processes an option. Calles the #on_extra block (or default) for
+  # unrecognized options. For registered options, possibly fetches an
+  # argument and invokes the option's block if it is not nil.
+  def process(argv, entry, opt, arg)
+    unless option = match?(opt)
+      @on_extra[entry]
+    else
+      if option.arg?
+        arg = argv.shift if arg.nil?
+        raise ParseError, "No argument provided for #{opt}" unless arg
       end
-      list
+      option.block[arg] if option.block
     end
+    option
+  end
 
-    filtered = []
-    recognized = []
-    consume = nil
-    until argv.empty?
-      opt = argv.shift
-      options.find { |o| consume = o.consume?(opt); consume != 0 }
-      if consume == 0
-        filtered << opt
-      else
-        recognized << opt
-        recognized << argv.shift if consume == 2
+  # Splits a string at +n+ characters into the +opt+ and the +rest+.
+  # The +arg+ is set to +nil+ if +rest+ is an empty string.
+  def split(str, n)
+    opt  = str[0, n]
+    rest = str[n, str.size]
+    arg  = rest == "" ? nil : rest
+    return opt, arg, rest
+  end
+
+  # Parses an array of command line entries, calling blocks for
+  # registered options.
+  def parse(argv=ARGV)
+    argv = Array(argv).dup
+
+    while entry = argv.shift
+      # collect everything that is not an option
+      if entry[0] != ?- or entry.size < 2
+        @on_extra[entry]
+        next
+      end
+
+      # this is a long option
+      if entry[1] == ?-
+        opt, arg = entry.split "="
+        process argv, entry, opt, arg
+        next
+      end
+
+      # disambiguate short option group from short option with argument
+      opt, arg, rest = split entry, 2
+
+      # process first option
+      option = process argv, entry, opt, arg
+      next unless option and not option.arg?
+
+      # process the rest of the options
+      while rest.size > 0
+        opt, arg, rest = split rest, 1
+        opt = "-" + opt
+        option = process argv, opt, opt, arg
+        break if option.arg?
       end
     end
-    argv.replace recognized
-    filtered
+
+    @extra
+  rescue ParseError => e
+    puts self
+    puts e
+    exit 1
   end
-end
 
-require 'mspec/version'
+  # Adds a string of documentation text inline in the text generated
+  # from the options. See #on and #add.
+  def doc(str)
+    @doc << str
+  end
 
-# MSpecOptions wraps OptionParser and provides a composable set of
-# options that the runner scripts pick from.
-class MSpecOptions
-  attr_reader :parser
+  # Convenience method for providing -v, --version options.
+  def version(version, &block)
+    show = block || lambda { puts "#{File.basename $0} #{version}"; exit }
+    on "-v", "--version", "Show version", &show
+  end
 
-  def initialize(config, command, *args)
-    @parser = OptionParser.new(*args) do |opts|
-      opts.banner = "mspec #{command} [options] (FILE|DIRECTORY|GLOB)+"
-      opts.separator ""
-    end
+  # Convenience method for providing -h, --help options.
+  def help(&block)
+    help = block || lambda { puts self; exit 1 }
+    on "-h", "--help", "Show this message", &help
+  end
 
-    @config = config
+  # Stores a block that will be called with unrecognized options
+  def on_extra(&block)
+    @on_extra = block
   end
 
-  def add_config(&block)
-    on("-B", "--config FILE", String,
+  # Returns a string representation of the options and doc strings.
+  def to_s
+    @banner + "\n\n" + @doc.join("\n") + "\n"
+  end
+
+  # The methods below provide groups of options that
+  # are composed by the particular runners to provide
+  # their functionality
+
+  def configure(&block)
+    on("-B", "--config", "FILE",
        "Load FILE containing configuration options", &block)
   end
 
-  def add_name
-    on("-n", "--name RUBY_NAME", String,
+  def name
+    on("-n", "--name", "RUBY_NAME",
        "Set the value of RUBY_NAME (used to determine the implementation)") do |n|
       Object.const_set :RUBY_NAME, n
     end
   end
 
-  def add_targets
-    on("-t", "--target TARGET", String,
+  def targets
+    on("-t", "--target", "TARGET",
        "Implementation to run the specs, where:") do |t|
       case t
       when 'r', 'ruby'
-        @config[:target] = 'ruby'
-        @config[:flags] << '-v'
+        config[:target] = 'ruby'
       when 'r19', 'ruby19'
-        @config[:target] = 'ruby19'
+        config[:target] = 'ruby19'
       when 'x', 'rubinius'
-        @config[:target] = 'shotgun/rubinius'
+        config[:target] = './bin/rbx'
       when 'X', 'rbx'
-        @config[:target] = 'rbx'
+        config[:target] = 'rbx'
       when 'j', 'jruby'
-        @config[:target] = 'jruby'
+        config[:target] = 'jruby'
+      when 'i','ironruby'
+        config[:target] = 'ir'
       else
-        @config[:target] = t
+        config[:target] = t
       end
     end
 
-    separator ""
-    separator "   'r' or 'ruby'     invokes ruby in PATH"
-    separator "   'r19' or 'ruby19' invokes ruby19 in PATH"
-    separator "   'x' or 'rubinius' invokes ./shotgun/rubinius"
-    separator "   'X' or 'rbx'      invokes rbx in PATH"
-    separator "   'j' or 'jruby'    invokes jruby in PATH\n"
+    doc ""
+    doc "     r or ruby     invokes ruby in PATH"
+    doc "     r19 or ruby19 invokes ruby19 in PATH"
+    doc "     x or rubinius invokes ./bin/rbx"
+    doc "     X or rbx      invokes rbx in PATH"
+    doc "     j or jruby    invokes jruby in PATH"
+    doc "     i or ironruby invokes ir in PATH\n"
 
-    on("-T", "--target-opt OPT", String,
+    on("-T", "--target-opt", "OPT",
        "Pass OPT as a flag to the target implementation") do |t|
-      @config[:flags] << t
+      config[:flags] << t
     end
-    on("-I", "--include DIR", String,
+    on("-I", "--include", "DIR",
        "Pass DIR through as the -I option to the target") do |d|
-      @config[:includes] << "-I#{d}"
+      config[:includes] << "-I#{d}"
     end
-    on("-r", "--require LIBRARY", String,
+    on("-r", "--require", "LIBRARY",
        "Pass LIBRARY through as the -r option to the target") do |f|
-      @config[:requires] << "-r#{f}"
+      config[:requires] << "-r#{f}"
     end
   end
 
-  def add_formatters
-    on("-f", "--format FORMAT", String,
+  def formatters
+    on("-f", "--format", "FORMAT",
        "Formatter for reporting, where FORMAT is one of:") do |o|
       case o
       when 's', 'spec', 'specdoc'
-        @config[:formatter] = SpecdocFormatter
+        config[:formatter] = SpecdocFormatter
       when 'h', 'html'
-        @config[:formatter] = HtmlFormatter
+        config[:formatter] = HtmlFormatter
       when 'd', 'dot', 'dotted'
-        @config[:formatter] = DottedFormatter
+        config[:formatter] = DottedFormatter
       when 'u', 'unit', 'unitdiff'
-        @config[:formatter] = UnitdiffFormatter
+        config[:formatter] = UnitdiffFormatter
       when 'm', 'summary'
-        @config[:formatter] = SummaryFormatter
+        config[:formatter] = SummaryFormatter
       when 'a', '*', 'spin'
-        @config[:formatter] = SpinnerFormatter
+        config[:formatter] = SpinnerFormatter
       when 'y', 'yaml'
-        @config[:formatter] = YamlFormatter
+        config[:formatter] = YamlFormatter
       else
         puts "Unknown format: #{o}"
         puts @parser
         exit
       end
     end
-    separator("")
-    separator("       s, spec, specdoc         SpecdocFormatter")
-    separator("       h, html,                 HtmlFormatter")
-    separator("       d, dot, dotted           DottedFormatter")
-    separator("       u, unit, unitdiff        UnitdiffFormatter")
-    separator("       m, summary               SummaryFormatter")
-    separator("       a, *, spin               SpinnerFormatter")
-    separator("       y, yaml                  YamlFormatter\n")
-    on("-o", "--output FILE", String,
+
+    doc ""
+    doc "       s, spec, specdoc         SpecdocFormatter"
+    doc "       h, html,                 HtmlFormatter"
+    doc "       d, dot, dotted           DottedFormatter"
+    doc "       u, unit, unitdiff        UnitdiffFormatter"
+    doc "       m, summary               SummaryFormatter"
+    doc "       a, *, spin               SpinnerFormatter"
+    doc "       y, yaml                  YamlFormatter\n"
+
+    on("-o", "--output", "FILE",
        "Write formatter output to FILE") do |f|
-      @config[:output] = f
+      config[:output] = f
     end
   end
 
-  def add_filters
-    on("-e", "--example STR", String,
+  def filters
+    on("-e", "--example", "STR",
        "Run examples with descriptions matching STR") do |o|
-      @config[:includes] << o
+      config[:includes] << o
     end
-    on("-E", "--exclude STR", String,
+    on("-E", "--exclude", "STR",
        "Exclude examples with descriptions matching STR") do |o|
-      @config[:excludes] << o
+      config[:excludes] << o
     end
-    on("-p", "--pattern PATTERN", Regexp,
+    on("-p", "--pattern", "PATTERN",
        "Run examples with descriptions matching PATTERN") do |o|
-      @config[:patterns] << o
+      config[:patterns] << Regexp.new(o)
     end
-    on("-P", "--excl-pattern PATTERN", Regexp,
+    on("-P", "--excl-pattern", "PATTERN",
        "Exclude examples with descriptions matching PATTERN") do |o|
-      @config[:xpatterns] << o
+      config[:xpatterns] << Regexp.new(o)
     end
-    on("-g", "--tag TAG", String,
+    on("-g", "--tag", "TAG",
        "Run examples with descriptions matching ones tagged with TAG") do |o|
-      @config[:tags] << o
+      config[:tags] << o
     end
-    on("-G", "--excl-tag TAG", String,
+    on("-G", "--excl-tag", "TAG",
        "Exclude examples with descriptions matching ones tagged with TAG") do |o|
-      @config[:xtags] << o
+      config[:xtags] << o
     end
-    on("-w", "--profile FILE", String,
+    on("-w", "--profile", "FILE",
        "Run examples for methods listed in the profile FILE") do |f|
-      @config[:profiles] << f
+      config[:profiles] << f
     end
-    on("-W", "--excl-profile FILE", String,
+    on("-W", "--excl-profile", "FILE",
        "Exclude examples for methods listed in the profile FILE") do |f|
-      @config[:xprofiles] << f
+      config[:xprofiles] << f
     end
   end
 
-  def add_pretend
+  def pretend
     on("-Z", "--dry-run",
        "Invoke formatters and other actions, but don't execute the specs") do
       MSpec.register_mode :pretend
     end
   end
 
-  def add_randomize
+  def randomize
     on("-H", "--random",
        "Randomize the list of spec files") do
       MSpec.randomize
     end
   end
 
-  def add_verbose
+  def verbose
     on("-V", "--verbose", "Output the name of each file processed") do
       obj = Object.new
       def obj.start
@@ -223,7 +349,7 @@ class MSpecOptions
       MSpec.register :load, obj
     end
 
-    on("-m", "--marker MARKER", String,
+    on("-m", "--marker", "MARKER",
        "Output MARKER for each file processed") do |o|
       obj = Object.new
       obj.instance_variable_set :@marker, o
@@ -234,104 +360,41 @@ class MSpecOptions
     end
   end
 
-  def add_interrupt
+  def interrupt
     on("--int-spec", "Control-C interupts the current spec only") do
-      @config[:abort] = false
+      config[:abort] = false
     end
   end
 
-  def add_verify
+  def verify
     on("-Y", "--verify",
        "Verify that guarded specs pass and fail as expected") do
-      MSpec.set_mode :verify
+      MSpec.register_mode :verify
     end
     on("-O", "--report", "Report guarded specs") do
-      MSpec.set_mode :report
-    end
-  end
-
-  def add_tagging
-    on("-N", "--add TAG", String,
-       "Add TAG with format 'tag' or 'tag(comment)' (see -Q, -F, -L)") do |o|
-      @config[:tagger] = :add
-      @config[:tag] = "#{o}:"
-    end
-    on("-R", "--del TAG", String,
-       "Delete TAG (see -Q, -F, -L)") do |o|
-      @config[:tagger] = :del
-      @config[:tag] = "#{o}:"
-      @config[:outcome] = :pass
-    end
-    on("-Q", "--pass", "Apply action to specs that pass (default for --del)") do
-      @config[:outcome] = :pass
-    end
-    on("-F", "--fail", "Apply action to specs that fail (default for --add)") do
-      @config[:outcome] = :fail
-    end
-    on("-L", "--all", "Apply action to all specs") do
-      @config[:outcome] = :all
+      MSpec.register_mode :report
     end
   end
 
-  def add_action_filters
-    on("-K", "--action-tag TAG", String,
+  def action_filters
+    on("-K", "--action-tag", "TAG",
        "Spec descriptions marked with TAG will trigger the specified action") do |o|
-      @config[:atags] << o
+      config[:atags] << o
     end
-    on("-S", "--action-string STR", String,
+    on("-S", "--action-string", "STR",
        "Spec descriptions matching STR will trigger the specified action") do |o|
-      @config[:astrings] << o
+      config[:astrings] << o
     end
   end
 
-  def add_actions
+  def actions
     on("--spec-debug",
        "Invoke the debugger when a spec description matches (see -K, -S)") do
-      @config[:debugger] = true
+      config[:debugger] = true
     end
     on("--spec-gdb",
        "Invoke Gdb when a spec description matches (see -K, -S)") do
-      @config[:gdb] = true
+      config[:gdb] = true
     end
   end
-
-  def add_version
-    on("-v", "--version", "Show version") do
-      puts "#{File.basename $0} #{MSpec::VERSION}"
-      exit
-    end
-  end
-
-  def add_help
-    on("-h", "--help", "Show this message") do
-      puts @parser
-      exit
-    end
-  end
-
-  def on(*args, &block)
-    @parser.on(*args, &block)
-  end
-
-  def separator(str)
-    @parser.separator str
-  end
-
-  def parse(argv=ARGV)
-    result = @parser.parse argv
-
-    if (@config[:debugger] || @config[:gdb]) &&
-        @config[:atags].empty? && @config[:astrings].empty?
-      puts "Missing --action-tag or --action-string."
-      puts @parser
-      exit 1
-    end
-
-    result
-  rescue OptionParser::ParseError => e
-    puts @parser
-    puts
-    puts e
-    exit 1
-  end
 end