rspec 1.3.2 → 2.0.0.a2

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

@@ -1,50 +0,0 @@
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
-  module Runner
-    module Formatter
-      class NestedTextFormatter < BaseTextFormatter
-
-        INDENT = '  '
-
-        def initialize(options, where)
-          super
-          @last_nested_descriptions = []
-        end
-
-        def example_group_started(example_group)
-          super
-
-          example_group.nested_descriptions.each_with_index do |nested_description, i|
-            unless example_group.nested_descriptions[0..i] == @last_nested_descriptions[0..i]
-              output.puts "#{INDENT*i}#{nested_description}"
-            end
-          end
-
-          @last_nested_descriptions = example_group.nested_descriptions
-        end
-
-        def example_failed(example, counter, failure)
-          output.puts(red("#{current_indentation}#{example.description} (FAILED - #{counter})"))
-          output.flush
-        end
-
-        def example_passed(example)
-          message = "#{current_indentation}#{example.description}"
-          output.puts green(message)
-          output.flush
-        end
-
-        def example_pending(example, message, deprecated_pending_location=nil)
-          super
-          output.puts yellow("#{current_indentation}#{example.description} (PENDING: #{message})")
-          output.flush
-        end
-
-        def current_indentation
-          INDENT*@last_nested_descriptions.length
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      module NOOPMethodMissing
-        def respond_to?(message, include_private = false)
-          if include_private
-            true
-          else
-            !private_methods.any? {|m| [message.to_s, message.to_sym].include?(m)}
-          end
-        end
-
-      private
-        
-        def method_missing(sym, *args)
-          # a no-op
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'spec/runner/formatter/progress_bar_formatter'
-
-module Spec
-  module Runner
-    module Formatter
-      class ProfileFormatter < ProgressBarFormatter
-        
-        def initialize(options, where)
-          super
-          @example_times = []
-        end
-        
-        def start(count)
-          @output.puts "Profiling enabled."
-        end
-        
-        def example_started(example)
-          @time = Time.now
-        end
-        
-        def example_passed(example)
-          super
-          @example_times << [
-            example_group.description,
-            example.description,
-            Time.now - @time
-          ]
-        end
-        
-        def start_dump
-          super
-          @output.puts "\n\nTop 10 slowest examples:\n"
-          
-          @example_times = @example_times.sort_by do |description, example, time|
-            time
-          end.reverse
-          
-          @example_times[0..9].each do |description, example, time|
-            @output.print red(sprintf("%.7f", time))
-            @output.puts " #{description} #{example}"
-          end
-          @output.flush
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec/runner/formatter/base_text_formatter'
-require 'spec/runner/formatter/no_op_method_missing'
-
-module Spec
-  module Runner
-    module Formatter
-      class ProgressBarFormatter < BaseTextFormatter
-        include NOOPMethodMissing
-
-        def example_failed(example, counter, failure)
-          @output.print colorize_failure('F', failure)
-          @output.flush
-        end
-
-        def example_passed(example)
-          @output.print green('.')
-          @output.flush
-        end
-      
-        def example_pending(example, message, deprecated_pending_location=nil)
-          super
-          @output.print yellow('*')
-          @output.flush
-        end
-        
-        def start_dump
-          @output.puts
-          @output.flush
-        end
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-require 'spec/runner/formatter/base_formatter'
-
-module Spec
-  module Runner
-    module Formatter
-      class SilentFormatter < BaseFormatter
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      # This class extracts code snippets by looking at the backtrace of the passed error
-      class SnippetExtractor #:nodoc:
-        class NullConverter; def convert(code, pre); code; end; end #:nodoc:
-        begin; require 'syntax/convertors/html'; @@converter = Syntax::Convertors::HTML.for_syntax "ruby"; rescue LoadError => e; @@converter = NullConverter.new; end
-        
-        def snippet(error)
-          raw_code, line = snippet_for(error.backtrace[0])
-          highlighted = @@converter.convert(raw_code, false)
-          highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
-          post_process(highlighted, line)
-        end
-        
-        def snippet_for(error_line)
-          if error_line =~ /(.*):(\d+)/
-            file = $1
-            line = $2.to_i
-            [lines_around(file, line), line]
-          else
-            ["# Couldn't get snippet for #{error_line}", 1]
-          end
-        end
-        
-        def lines_around(file, line)
-          if File.file?(file)
-            lines = File.open(file).read.split("\n")
-            min = [0, line-3].max
-            max = [line+1, lines.length-1].min
-            selected_lines = []
-            selected_lines.join("\n")
-            lines[min..max].join("\n")
-          else
-            "# Couldn't get snippet for #{file}"
-          end
-        end
-        
-        def post_process(highlighted, offending_line)
-          new_lines = []
-          highlighted.split("\n").each_with_index do |line, i|
-            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
-            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
-            new_lines << new_line
-          end
-          new_lines.join("\n")
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec/runner/formatter/base_text_formatter'
-
-module Spec
-  module Runner
-    module Formatter
-      class SpecdocFormatter < BaseTextFormatter
-        def example_group_started(example_group)
-          super
-          output.puts
-          output.puts example_group.description
-          output.flush
-        end
-      
-        def example_failed(example, counter, failure)
-          output.puts(red("- #{example.description} (FAILED - #{counter})"))
-          output.flush
-        end
-        
-        def example_passed(example)
-          message = "- #{example.description}"
-          output.puts green(message)
-          output.flush
-        end
-        
-        def example_pending(example, message, deprecated_pending_location=nil)
-          super
-          output.puts yellow("- #{example.description} (PENDING: #{message})")
-          output.flush
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-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

@@ -1,77 +0,0 @@
-if Spec::Ruby.version.to_f < 1.9
-  begin
-    require 'rubygems' unless ENV['NO_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
-          case @filter
-          when /(.*)#(.*)/  then heckle_method($1, $2)
-          when /(.*)\.(.*)/ then heckle_class_method($1, $2)
-          else
-            heckle_class_or_module(@filter)
-          end
-        end
-
-        def heckle_class_method(class_name, method_name)
-          heckle_method(class_name, "self.#{method_name}")
-        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
-    
-      class Heckler < Heckle
-        def initialize(klass_name, method_name, rspec_options)
-          super(klass_name, method_name)
-          @rspec_options = rspec_options
-        end
-
-        def tests_pass?
-          @rspec_options.run_examples
-        end
-
-      end
-    end
-  end
-end

data/lib/spec/runner/heckle_runner_unsupported.rb

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

data/lib/spec/runner/line_number_query.rb

@@ -1,78 +0,0 @@
-module Spec
-  module Runner
-    # Parses a spec file and finds the nearest example for a given line number.
-    class LineNumberQuery
-      attr_reader :best_match
-
-      def initialize(run_options)
-        @best_match = {}
-        @run_options = run_options
-      end
-
-      def spec_name_for(file, line_number)
-        best_match.clear
-        file = File.expand_path(file)
-        determine_best_match(file, line_number)
-        if best_match[:example_group]
-          if best_match[:example]
-            "#{best_match[:example_group].description} #{best_match[:example].description}"
-          else
-            best_match[:example_group].description
-          end
-        else
-          nil
-        end
-      end
-
-      def example_line_for(file, line_number)
-        determine_best_match(file, line_number)
-        best_match[:line]
-      end
-    
-    protected
-    
-      def determine_best_match(file, line_number)
-        best_match.clear
-        file = File.expand_path(file)
-        @run_options.example_groups.each do |example_group|
-          next unless example_group.location
-          consider_example_group_for_best_match(example_group, file, line_number)
-
-          example_group.examples.each do |example|
-            consider_example_for_best_match(example, example_group, file, line_number)
-          end
-        end
-      end
-
-      def consider_example_group_for_best_match(example_group, file, line_number)
-        example_group_file, example_group_line = parse_location(example_group.location)
-        if is_best_match?(file, line_number, example_group_file, example_group_line)
-          best_match.clear
-          best_match[:example_group] = example_group
-          best_match[:line] = example_group_line
-        end
-      end
-
-      def consider_example_for_best_match(example, example_group, file, line_number)
-        example_file, example_line = parse_location(example.location)
-        if is_best_match?(file, line_number, example_file, example_line)
-          best_match.clear
-          best_match[:example_group] = example_group
-          best_match[:example] = example
-          best_match[:line] = example_line
-        end
-      end
-
-      def is_best_match?(file, line_number, example_file, example_line)
-        file == File.expand_path(example_file) &&
-                example_line <= line_number &&
-                example_line > best_match[:line].to_i
-      end
-      
-      def parse_location(location)
-        location =~ /(.*)\:(\d*)(\:|$)/
-        return $1, Integer($2)
-      end
-    end
-  end
-end

data/lib/spec/runner/option_parser.rb

@@ -1,225 +0,0 @@
-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
-
-        def spec_command?
-          $0.split('/').last == 'spec'
-        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 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"]
-      }
-
-      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
-
-      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
-
-    protected
-
-      def invoke_requires(requires)
-        requires.split(",").each do |file|
-          require file
-        end
-      end
-
-      def parse_file_options(option_name, action)
-        # Remove the file option and the argument before handling the file
-        options_file = nil
-        options_list = OPTIONS[option_name][0..1]
-        options_list[1].gsub!(" PATH", "")
-        options_list.each do |option|
-          if index = @argv.index(option)
-            @argv.delete_at(index)
-            options_file = @argv.delete_at(index)
-          end
-        end
-        
-        if options_file.nil? &&
-           File.exist?('spec/spec.opts') &&
-           !@argv.any?{|a| a =~ /^\-/ }
-             options_file = 'spec/spec.opts'
-        end
-
-        if options_file
-          send(action, options_file)
-          return true
-        else
-          return false
-        end
-      end
-
-      def parse_options_file(options_file)
-        option_file_args = File.readlines(options_file).map {|l| l.chomp.split " "}.flatten
-        @argv.push(*option_file_args)
-      end
-
-      def write_options_file(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 = @options.argv
-        is_drb = false
-        is_drb ||= argv.delete(OPTIONS[:drb][0])
-        is_drb ||= argv.delete(OPTIONS[:drb][1])
-        return false unless is_drb
-        if DrbCommandLine.run(self.class.parse(argv, @error_stream, @out_stream))
-          @options.examples_should_not_be_run
-          true
-        else
-          @error_stream.puts "Running specs locally:"
-          false
-        end
-      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