dchelimsky-rspec 1.1.10

data/lib/spec/runner/formatter/story/progress_bar_formatter.rb

@@ -0,0 +1,42 @@
+require 'spec/runner/formatter/story/plain_text_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      module Story
+        class ProgressBarFormatter < PlainTextFormatter
+
+          def story_started(title, narrative) end
+          def story_ended(title, narrative) end
+
+          def run_started(count)
+            @start_time = Time.now
+            super
+          end
+          
+          def run_ended
+            @output.puts
+            @output.puts
+            @output.puts "Finished in %f seconds" % (Time.now - @start_time)
+            @output.puts
+            super
+          end
+
+          def scenario_ended
+            if @scenario_failed
+              @output.print red('F')
+              @output.flush
+            elsif @scenario_pending
+              @output.print yellow('P')
+              @output.flush
+            else
+              @output.print green('.')
+              @output.flush
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/formatter/text_mate_formatter.rb

@@ -0,0 +1,16 @@
+require 'spec/runner/formatter/html_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      # Formats backtraces so they're clickable by TextMate
+      class TextMateFormatter < HtmlFormatter
+        def backtrace_line(line)
+          line.gsub(/([^:]*\.rb):(\d*)/) do
+            "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/heckle_runner.rb

@@ -0,0 +1,72 @@
+begin
+  require 'rubygems'
+  require 'heckle'
+rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end
+
+module Spec
+  module Runner
+    # Creates a new Heckler configured to heckle all methods in the classes
+    # whose name matches +filter+
+    class HeckleRunner
+      def initialize(filter, heckle_class=Heckler)
+        @filter = filter
+        @heckle_class = heckle_class
+      end
+      
+      # Runs all the example groups held by +rspec_options+ once for each of the
+      # methods in the matched classes.
+      def heckle_with
+        if @filter =~ /(.*)[#\.](.*)/
+          heckle_method($1, $2)
+        else
+          heckle_class_or_module(@filter)
+        end
+      end
+      
+      def heckle_method(class_name, method_name)
+        verify_constant(class_name)
+        heckle = @heckle_class.new(class_name, method_name, Spec::Runner.options)
+        heckle.validate
+      end
+      
+      def heckle_class_or_module(class_or_module_name)
+        verify_constant(class_or_module_name)
+        pattern = /^#{class_or_module_name}/
+        classes = []
+        ObjectSpace.each_object(Class) do |klass|
+          classes << klass if klass.name =~ pattern
+        end
+        
+        classes.each do |klass|
+          klass.instance_methods(false).each do |method_name|
+            heckle = @heckle_class.new(klass.name, method_name, Spec::Runner.options)
+            heckle.validate
+          end
+        end
+      end
+      
+      def verify_constant(name)
+        begin
+          # This is defined in Heckle
+          name.to_class
+        rescue
+          raise "Heckling failed - \"#{name}\" is not a known class or module"
+        end
+      end
+    end
+    
+    #Supports Heckle 1.2 and prior (earlier versions used Heckle::Base)
+    class Heckler < (Heckle.const_defined?(:Base) ? Heckle::Base : Heckle)
+      def initialize(klass_name, method_name, rspec_options)
+        super(klass_name, method_name)
+        @rspec_options = rspec_options
+      end
+
+      def tests_pass?
+        success = @rspec_options.run_examples
+        success
+      end
+
+    end
+  end
+end

data/lib/spec/runner/heckle_runner_unsupported.rb

@@ -0,0 +1,10 @@
+module Spec
+  module Runner
+    # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
+    class HeckleRunner
+      def initialize(filter)
+        raise "Heckle not supported on Windows"
+      end
+    end
+  end
+end

data/lib/spec/runner/option_parser.rb

@@ -0,0 +1,205 @@
+require 'optparse'
+require 'stringio'
+
+module Spec
+  module Runner
+    class OptionParser < ::OptionParser
+      class << self
+        def parse(args, err, out)
+          parser = new(err, out)
+          parser.parse(args)
+          parser.options
+        end
+      end
+
+      attr_reader :options
+
+      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 thatfile 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 behaviour or specification at given line.",
+                                                       "(does not work for dynamically generated specs)"],
+        :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 for code examples:",
+                                                    "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 intented",
+                                                    "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",
+                                                    " ",
+                                                    "Builtin formats for stories:",
+                                                    "plain|p                  : Plain Text",
+                                                    "html|h                   : A nice HTML report",
+                                                    "progress|r               : Text progress",
+                                                    " ",
+                                                    "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."],
+        :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"],
+        :version => ["-v", "--version", "Show version"],
+        :help => ["-h", "--help", "You're looking at it"]
+      }
+
+      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|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| parse_options_file(options_file)}
+        on(*OPTIONS[:generate_options]) {|options_file|}
+        on(*OPTIONS[:runner])           {|runner|  @options.user_input_for_runner = runner}
+        on(*OPTIONS[:drb])              {}
+        on(*OPTIONS[:version])          {parse_version}
+        on_tail(*OPTIONS[:help])        {parse_help}
+      end
+
+      def order!(argv, &blk)
+        @argv = argv.dup
+        @argv = (@argv.empty? && Spec.spec_command?) ? ['--help'] : @argv 
+        @options.argv = @argv.dup
+        return if parse_generate_options
+        return if parse_drb
+        
+        super(@argv) do |file|
+          @options.files << file
+          blk.call(file) if blk
+        end
+
+        @options
+      end
+      
+      protected
+      def invoke_requires(requires)
+        requires.split(",").each do |file|
+          require file
+        end
+      end
+      
+      def parse_options_file(options_file)
+        option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
+        @argv.push(*option_file_args)
+        # TODO - this is a brute force solution to http://rspec.lighthouseapp.com/projects/5645/tickets/293.
+        # Let's look for a cleaner way. Might not be one. But let's look. If not, perhaps
+        # this can be moved to a different method to indicate the special handling for drb?
+        parse_drb(@argv)
+      end
+
+      def parse_generate_options
+        # Remove the --generate-options option and the argument before writing to file
+        options_file = nil
+        ['-G', '--generate-options'].each do |option|
+          if index = @argv.index(option)
+            @argv.delete_at(index)
+            options_file = @argv.delete_at(index)
+          end
+        end
+        
+        if options_file
+          write_generated_options(options_file)
+          return true
+        else
+          return false
+        end
+      end
+      
+      def write_generated_options(options_file)
+        File.open(options_file, 'w') do |io|
+          io.puts @argv.join("\n")
+        end
+        @out_stream.puts "\nOptions written to #{options_file}. You can now use these options with:"
+        @out_stream.puts "spec --options #{options_file}"
+        @options.examples_should_not_be_run
+      end
+
+      def parse_drb(argv = nil)
+        argv ||= @options.argv # TODO - see note about about http://rspec.lighthouseapp.com/projects/5645/tickets/293
+        is_drb = false
+        is_drb ||= argv.delete(OPTIONS[:drb][0])
+        is_drb ||= argv.delete(OPTIONS[:drb][1])
+        return false unless is_drb
+        @options.examples_should_not_be_run
+        DrbCommandLine.run(
+          self.class.parse(argv, @error_stream, @out_stream)
+        )
+        true
+      end
+
+      def parse_version
+        @out_stream.puts ::Spec::VERSION::SUMMARY
+        exit if stdout?
+      end
+
+      def parse_help
+        @out_stream.puts self
+        exit if stdout?
+      end      
+
+      def stdout?
+        @out_stream == $stdout
+      end
+    end
+  end
+end

data/lib/spec/runner/options.rb

@@ -0,0 +1,320 @@
+module Spec
+  module Runner
+    class Options
+      FILE_SORTERS = {
+        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
+      }
+
+      EXAMPLE_FORMATTERS = { # Load these lazily for better speed
+               'specdoc' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
+                     's' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
+                'nested' => ['spec/runner/formatter/nested_text_formatter',            'Formatter::NestedTextFormatter'],
+                     'n' => ['spec/runner/formatter/nested_text_formatter',            'Formatter::NestedTextFormatter'],
+                  'html' => ['spec/runner/formatter/html_formatter',                   'Formatter::HtmlFormatter'],
+                     'h' => ['spec/runner/formatter/html_formatter',                   'Formatter::HtmlFormatter'],
+              'progress' => ['spec/runner/formatter/progress_bar_formatter',           'Formatter::ProgressBarFormatter'],
+                     'p' => ['spec/runner/formatter/progress_bar_formatter',           'Formatter::ProgressBarFormatter'],
+      'failing_examples' => ['spec/runner/formatter/failing_examples_formatter',       'Formatter::FailingExamplesFormatter'],
+                     'e' => ['spec/runner/formatter/failing_examples_formatter',       'Formatter::FailingExamplesFormatter'],
+'failing_example_groups' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
+                     'g' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
+               'profile' => ['spec/runner/formatter/profile_formatter',                'Formatter::ProfileFormatter'],
+                     'o' => ['spec/runner/formatter/profile_formatter',                'Formatter::ProfileFormatter'],
+              'textmate' => ['spec/runner/formatter/text_mate_formatter',              'Formatter::TextMateFormatter']
+      }
+
+      STORY_FORMATTERS = {
+        'plain' => ['spec/runner/formatter/story/plain_text_formatter',   'Formatter::Story::PlainTextFormatter'],
+            'p' => ['spec/runner/formatter/story/plain_text_formatter',   'Formatter::Story::PlainTextFormatter'],
+         'html' => ['spec/runner/formatter/story/html_formatter',         'Formatter::Story::HtmlFormatter'],
+            'h' => ['spec/runner/formatter/story/html_formatter',         'Formatter::Story::HtmlFormatter'],
+     'progress' => ['spec/runner/formatter/story/progress_bar_formatter', 'Formatter::Story::ProgressBarFormatter'],
+            'r' => ['spec/runner/formatter/story/progress_bar_formatter', 'Formatter::Story::ProgressBarFormatter']
+            
+      }
+
+      attr_accessor(
+        :filename_pattern,
+        :backtrace_tweaker,
+        :context_lines,
+        :diff_format,
+        :dry_run,
+        :profile,
+        :examples,
+        :heckle_runner,
+        :line_number,
+        :loadby,
+        :reporter,
+        :reverse,
+        :timeout,
+        :verbose,
+        :user_input_for_runner,
+        :error_stream,
+        :output_stream,
+        :before_suite_parts,
+        :after_suite_parts,
+        # TODO: BT - Figure out a better name
+        :argv
+      )
+      attr_reader :colour, :differ_class, :files, :example_groups
+      
+      def initialize(error_stream, output_stream)
+        @error_stream = error_stream
+        @output_stream = output_stream
+        @filename_pattern = "**/*_spec.rb"
+        @backtrace_tweaker = QuietBacktraceTweaker.new
+        @examples = []
+        @colour = false
+        @profile = false
+        @dry_run = false
+        @reporter = Reporter.new(self)
+        @context_lines = 3
+        @diff_format  = :unified
+        @files = []
+        @example_groups = []
+        @result = nil
+        @examples_run = false
+        @examples_should_be_run = nil
+        @user_input_for_runner = nil
+        @before_suite_parts = []
+        @after_suite_parts = []
+      end
+
+      def add_example_group(example_group)
+        @example_groups << example_group
+      end
+
+      def remove_example_group(example_group)
+        @example_groups.delete(example_group)
+      end
+
+      def run_examples
+        return true unless examples_should_be_run?
+        success = true
+        begin
+          runner = custom_runner || ExampleGroupRunner.new(self)
+
+          unless @files_loaded
+            runner.load_files(files_to_load)
+            @files_loaded = true
+          end
+
+          # TODO - this has to happen after the files get loaded,
+          # otherwise the before_suite_parts are not populated
+          # from the configuration. There is no spec for this
+          # directly, but stories/configuration/before_blocks.story
+          # will fail if this happens before the files are loaded.
+          before_suite_parts.each do |part|
+            part.call
+          end
+
+          if example_groups.empty?
+            true
+          else
+            set_spec_from_line_number if line_number
+            success = runner.run
+            @examples_run = true
+            heckle if heckle_runner
+            success
+          end
+        ensure
+          after_suite_parts.each do |part|
+            part.call(success)
+          end
+        end
+      end
+
+      def examples_run?
+        @examples_run
+      end
+
+      def examples_should_not_be_run
+        @examples_should_be_run = false
+      end      
+
+      def colour=(colour)
+        @colour = colour
+        if @colour && RUBY_PLATFORM =~ /mswin|mingw/ ;\
+          begin ;\
+            replace_output = @output_stream.equal?($stdout) ;\
+            require 'rubygems' ;\
+            require 'Win32/Console/ANSI' ;\
+            @output_stream = $stdout if replace_output ;\
+          rescue LoadError ;\
+            warn "You must 'gem install win32console' to use colour on Windows" ;\
+            @colour = false ;\
+          end
+        end
+      end
+
+      def parse_diff(format)
+        case format
+        when :context, 'context', 'c'
+          @diff_format  = :context
+          default_differ
+        when :unified, 'unified', 'u', '', nil
+          @diff_format  = :unified
+          default_differ
+        else
+          @diff_format  = :custom
+          self.differ_class = load_class(format, 'differ', '--diff')
+        end
+      end
+
+      def parse_example(example)
+        if(File.file?(example))
+          @examples = File.open(example).read.split("\n")
+        else
+          @examples = [example]
+        end
+      end
+
+      def parse_format(format_arg)
+        format, where = ClassAndArgumentsParser.parse(format_arg)
+        unless where
+          raise "When using several --format options only one of them can be without a file" if @out_used
+          where = @output_stream
+          @out_used = true
+        end
+        @format_options ||= []
+        @format_options << [format, where]
+      end
+      
+      def formatters
+        @format_options ||= [['progress', @output_stream]]
+        @formatters ||= load_formatters(@format_options, EXAMPLE_FORMATTERS)
+      end
+
+      def story_formatters
+        @format_options ||= [['plain', @output_stream]]
+        @formatters ||= load_formatters(@format_options, STORY_FORMATTERS)
+      end
+      
+      def load_formatters(format_options, formatters)
+        format_options.map do |format, where|
+          formatter_type = if formatters[format]
+            require formatters[format][0]
+            eval(formatters[format][1], binding, __FILE__, __LINE__)
+          else
+            load_class(format, 'formatter', '--format')
+          end
+          formatter_type.new(self, where)
+        end
+      end
+
+      def load_heckle_runner(heckle)
+        suffix = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? '_unsupported' : ''
+        require "spec/runner/heckle_runner#{suffix}"
+        @heckle_runner = HeckleRunner.new(heckle)
+      end
+
+      def number_of_examples
+        total = 0
+        @example_groups.each do |example_group|
+          total += example_group.number_of_examples
+        end
+        total
+      end
+
+      def files_to_load
+        result = []
+        sorted_files.each do |file|
+          if File.directory?(file)
+            filename_pattern.split(",").each do |pattern|
+              result += Dir[File.expand_path("#{file}/#{pattern.strip}")]
+            end
+          elsif File.file?(file)
+            result << file
+          else
+            raise "File or directory not found: #{file}"
+          end
+        end
+        result
+      end
+      
+      protected
+      def examples_should_be_run?
+        return @examples_should_be_run unless @examples_should_be_run.nil?
+        @examples_should_be_run = true
+      end
+      
+      def differ_class=(klass)
+        return unless klass
+        @differ_class = klass
+        Spec::Expectations.differ = self.differ_class.new(self)
+      end
+
+      def load_class(name, kind, option)
+        if name =~ /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
+          arg = $2 == "" ? nil : $2
+          [$1, arg]
+        else
+          m = "#{name.inspect} is not a valid class name"
+          @error_stream.puts m
+          raise m
+        end
+        begin
+          eval(name, binding, __FILE__, __LINE__)
+        rescue NameError => e
+          @error_stream.puts "Couldn't find #{kind} class #{name}"
+          @error_stream.puts "Make sure the --require option is specified *before* #{option}"
+          if $_spec_spec ; raise e ; else exit(1) ; end
+        end
+      end
+      
+      def custom_runner
+        return nil unless custom_runner?
+        klass_name, arg = ClassAndArgumentsParser.parse(user_input_for_runner)
+        runner_type = load_class(klass_name, 'behaviour runner', '--runner')
+        return runner_type.new(self, arg)
+      end
+
+      def custom_runner?
+        return user_input_for_runner ? true : false
+      end
+      
+      def heckle
+        heckle_runner = self.heckle_runner
+        self.heckle_runner = nil
+        heckle_runner.heckle_with
+      end
+      
+      def sorted_files
+        return sorter ? files.sort(&sorter) : files
+      end
+
+      def sorter
+        FILE_SORTERS[loadby]
+      end
+
+      def default_differ
+        require 'spec/expectations/differs/default'
+        self.differ_class = Spec::Expectations::Differs::Default
+      end
+
+      def set_spec_from_line_number
+        if examples.empty?
+          if files.length == 1
+            if File.directory?(files[0])
+              error_stream.puts "You must specify one file, not a directory when using the --line option"
+              exit(1) if stderr?
+            else
+              example = SpecParser.new.spec_name_for(files[0], line_number)
+              @examples = [example]
+            end
+          else
+            error_stream.puts "Only one file can be specified when using the --line option: #{files.inspect}"
+            exit(3) if stderr?
+          end
+        else
+          error_stream.puts "You cannot use both --line and --example"
+          exit(4) if stderr?
+        end
+      end
+
+      def stderr?
+        @error_stream == $stderr
+      end
+    end
+  end
+end