Class: Spec::Runner::OptionParser

Inherits:
OptionParser
  • Object
show all
Defined in:
lib/spec/runner/option_parser.rb

Constant Summary collapse

OPTIONS = 
{
  :pattern => ["-p", "--pattern [PATTERN]","Limit files loaded to those matching this pattern. Defaults to '**/*_spec.rb'",
                                           "Separate multiple patterns with commas.",
                                           "Applies only to directories named on the command line (files",
                                           "named explicitly on the command line will be loaded regardless)."],
  :diff =>    ["-D", "--diff [FORMAT]","Show diff of objects that are expected to be equal when they are not",
                                       "Builtin formats: unified|u|context|c",
                                       "You can also specify a custom differ class",
                                       "(in which case you should also specify --require)"],
  :colour =>  ["-c", "--colour", "--color", "Show coloured (red/green) output"],
  :example => ["-e", "--example [NAME|FILE_NAME]",  "Execute example(s) with matching name(s). If the argument is",
                                                    "the path to an existing file (typically generated by a previous",
                                                    "run using --format failing_examples:file.txt), then the examples",
                                                    "on each line of that file will be executed. If the file is empty,",
                                                    "all examples will be run (as if --example was not specified).",
                                                    " ",
                                                    "If the argument is not an existing file, then it is treated as",
                                                    "an example name directly, causing RSpec to run just the example",
                                                    "matching that name"],
  :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"],
  :line => ["-l", "--line LINE_NUMBER", Integer, "Execute example group or example at given line.",
                                                 "(does not work for dynamically generated examples)"],
  :format => ["-f", "--format FORMAT[:WHERE]","Specifies what format to use for output. Specify WHERE to tell",
                                              "the formatter where to write the output. All built-in formats",
                                              "expect WHERE to be a file name, and will write to $stdout if it's",
                                              "not specified. The --format option may be specified several times",
                                              "if you want several outputs",
                                              " ",
                                              "Builtin formats:",
                                              "silent|l                 : No output",                                                    "progress|p               : Text-based progress bar",
                                              "profile|o                : Text-based progress bar with profiling of 10 slowest examples",
                                              "specdoc|s                : Code example doc strings",
                                              "nested|n                 : Code example doc strings with nested groups indented",
                                              "html|h                   : A nice HTML report",
                                              "failing_examples|e       : Write all failing examples - input for --example",
                                              "failing_example_groups|g : Write all failing example groups - input for --example",
                                              " ",
                                              "FORMAT can also be the name of a custom formatter class",
                                              "(in which case you should also specify --require to load it)"],
  :require => ["-r", "--require FILE", "Require FILE before running specs",
                                       "Useful for loading custom formatters or other extensions.",
                                       "If this option is used it must come before the others"],
  :backtrace => ["-b", "--backtrace", "Output full backtrace"],
  :loadby => ["-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.",
                                         "STRATEGY can currently only be 'mtime' (File modification time)",
                                         "By default, spec files are loaded in alphabetical order if --loadby",
                                         "is not specified."],
  :reverse => ["-R", "--reverse", "Run examples in reverse order"],
  :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the",
                                        "specified time"],
  :heckle => ["-H", "--heckle CODE", "If all examples pass, this will mutate the classes and methods",
                                     "identified by CODE little by little and run all the examples again",
                                     "for each mutation. The intent is that for each mutation, at least",
                                     "one example *should* fail, and RSpec will tell you if this is not the",
                                     "case. CODE should be either Some::Module, Some::Class or",
                                     "Some::Fabulous#method}"],
  :dry_run => ["-d", "--dry-run", "Invokes formatters without executing the examples."],
  :options_file => ["-O", "--options PATH", "Read options from a file"],
  :generate_options => ["-G", "--generate-options PATH", "Generate an options file for --options"],
  :runner => ["-U", "--runner RUNNER", "Use a custom Runner."],
  :debug => ["-u", "--debugger", "Enable ruby-debugging."],
  :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"],
  :drb_port => ["--port PORT", "Port for DRb server. (Ignored without --drb)"],
  :version => ["-v", "--version", "Show version"],
  :help => ["-h", "--help", "You're looking at it"]
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(err, out) ⇒ OptionParser

Returns a new instance of OptionParser.



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/spec/runner/option_parser.rb', line 88

def initialize(err, out)
  super()
  @error_stream = err
  @out_stream = out
  @options = Options.new(@error_stream, @out_stream)

  @file_factory = File

  self.banner = "Usage: spec (FILE(:LINE)?|DIRECTORY|GLOB)+ [options]"
  self.separator ""
  on(*OPTIONS[:pattern])          {|pattern| @options.filename_pattern = pattern}
  on(*OPTIONS[:diff])             {|diff| @options.parse_diff(diff)}
  on(*OPTIONS[:colour])           {@options.colour = true}
  on(*OPTIONS[:example])          {|example| @options.parse_example(example)}
  on(*OPTIONS[:specification])    {|example| @options.parse_example(example)}
  on(*OPTIONS[:line])             {|line_number| @options.line_number = line_number.to_i}
  on(*OPTIONS[:format])           {|format| @options.parse_format(format)}
  on(*OPTIONS[:require])          {|requires| invoke_requires(requires)}
  on(*OPTIONS[:backtrace])        {@options.backtrace_tweaker = NoisyBacktraceTweaker.new}
  on(*OPTIONS[:loadby])           {|loadby| @options.loadby = loadby}
  on(*OPTIONS[:reverse])          {@options.reverse = true}
  on(*OPTIONS[:timeout])          {|timeout| @options.timeout = timeout.to_f}
  on(*OPTIONS[:heckle])           {|heckle| @options.load_heckle_runner(heckle)}
  on(*OPTIONS[:dry_run])          {@options.dry_run = true}
  on(*OPTIONS[:options_file])     {|options_file|}
  on(*OPTIONS[:generate_options]) {|options_file|}
  on(*OPTIONS[:runner])           {|runner|  @options.user_input_for_runner = runner}
  on(*OPTIONS[:debug])            {@options.debug = true}
  on(*OPTIONS[:drb])              {}
  on(*OPTIONS[:drb_port])         {|port| @options.drb_port = port}
  on(*OPTIONS[:version])          {parse_version}
  on("--autospec")                {@options.autospec = true}
  on_tail(*OPTIONS[:help])        {parse_help}
end

Instance Attribute Details

#options ⇒ Object (readonly)

Returns the value of attribute options.



19
20
21
 
# File 'lib/spec/runner/option_parser.rb', line 19

def options
  @options
end

Class Method Details

.parse(args, err, out) ⇒ Object 



8
9
10
11
12
 
# File 'lib/spec/runner/option_parser.rb', line 8

def parse(args, err, out)
  parser = new(err, out)
  parser.parse(args)
  parser.options
end

.spec_command? ⇒ Boolean

Returns:

  • (Boolean) 


14
15
16
 
# File 'lib/spec/runner/option_parser.rb', line 14

def spec_command?
  $0.split('/').last == 'spec'
end

Instance Method Details

#order!(argv, &blk) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/spec/runner/option_parser.rb', line 123

def order!(argv, &blk)
  @argv = argv.dup
  @argv = (@argv.empty? & self.class.spec_command?) ? ['--help'] : @argv

  # Parse options file first
  parse_file_options(:options_file, :parse_options_file)

  @options.argv = @argv.dup
  return if parse_file_options(:generate_options, :write_options_file)
  return if parse_drb

  super(@argv) do |file|
    if file =~ /^(.+):(\d+)$/
      file = $1
      @options.line_number = $2.to_i
    end

    @options.files << file
    blk.call(file) if blk
  end

  @options
end