deckshuffler 0.0.2

data/vendor/plugins/rspec/lib/spec/runner/formatter/progress_bar_formatter.rb

@@ -0,0 +1,31 @@
+module Spec
+  module Runner
+    module Formatter
+      class ProgressBarFormatter < BaseTextFormatter
+        def add_behaviour(name)
+        end
+      
+        def example_failed(example, counter, failure)
+          @output.print colourise('F', failure)
+          @output.flush
+        end
+
+        def example_passed(example)
+          @output.print green('.')
+          @output.flush
+        end
+      
+        def example_pending(behaviour_name, example_name, message)
+          super
+          @output.print yellow('P')
+          @output.flush
+        end
+        
+        def start_dump
+          @output.puts
+          @output.flush
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/runner/formatter/rdoc_formatter.rb

@@ -0,0 +1,24 @@
+module Spec
+  module Runner
+    module Formatter
+      class RdocFormatter < BaseTextFormatter
+        def add_behaviour(name)
+          @output.puts "# #{name}"
+        end
+  
+        def example_passed(example)
+          @output.puts "# * #{example.description}"
+          @output.flush
+        end
+
+        def example_failed(example, counter, failure)
+          @output.puts "# * #{example.description} [#{counter} - FAILED]"
+        end
+        
+        def example_pending(behaviour_name, example_name, message)
+          @output.puts "# * #{behaviour_name} #{example_name} [PENDING: #{message}]"
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/runner/formatter/snippet_extractor.rb

@@ -0,0 +1,52 @@
+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 'rubygems'; 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/vendor/plugins/rspec/lib/spec/runner/formatter/specdoc_formatter.rb

@@ -0,0 +1,29 @@
+module Spec
+  module Runner
+    module Formatter
+      class SpecdocFormatter < BaseTextFormatter      
+        def add_behaviour(name)
+          @output.puts
+          @output.puts name
+          @output.flush
+        end
+      
+        def example_failed(example, counter, failure)
+          @output.puts failure.expectation_not_met? ? red("- #{example.description} (FAILED - #{counter})") : magenta("- #{example.description} (ERROR - #{counter})")
+          @output.flush
+        end
+      
+        def example_passed(example)
+          @output.puts green("- #{example.description}")
+          @output.flush
+        end
+        
+        def example_pending(behaviour_name, example_name, message)
+          super
+          @output.puts yellow("- #{example_name} (PENDING: #{message})")
+          @output.flush
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/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 behaviours 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, rspec_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, rspec_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
+        @rspec_options.load_paths
+      end
+
+      def tests_pass?
+        failure_count = @rspec_options.run_examples
+        failure_count == 0
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/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/vendor/plugins/rspec/lib/spec/runner/option_parser.rb

@@ -0,0 +1,222 @@
+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 = {
+        :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 behaviout 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: ",
+                                                    "progress|p           : Text progress",
+                                                    "specdoc|s            : Example doc as text",
+                                                    "rdoc|r               : Example doc as RDoc",
+                                                    "html|h               : A nice HTML report",
+                                                    "failing_examples|e   : Write all failing examples - input for --example",
+                                                    "failing_behaviours|b : Write all failing behaviours - 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 BehaviourRunner."],
+        :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)
+
+        @spec_parser = SpecParser.new
+        @file_factory = File
+
+        self.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
+        self.separator ""
+        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]) {|req| @options.parse_require(req)}
+        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.parse_heckle(heckle)}
+        on(*OPTIONS[:dry_run]) {@options.dry_run = true}
+        on(*OPTIONS[:options_file]) {|options_file| parse_options_file(options_file)}
+        on(*OPTIONS[:generate_options]) do |options_file|
+        end
+        on(*OPTIONS[:runner]) do |runner|
+          @options.runner_arg = runner
+        end
+        on(*OPTIONS[:drb]) {}
+        on(*OPTIONS[:version]) {parse_version}
+        self.on_tail(*OPTIONS[:help]) {parse_help}
+      end
+
+      def order!(argv=default_argv, &blk)
+        @argv = argv
+        @options.current_argv = @argv
+        return if parse_generate_options
+        return if parse_drb
+        
+        super(@argv) do |file|
+          @options.files << file
+          blk.call(file) if blk
+        end
+
+        if @options.line_number
+          set_spec_from_line_number
+        end
+
+        if @options.formatters.empty?
+          @options.create_formatter(Formatter::ProgressBarFormatter)
+        end
+
+        @options
+      end
+
+      protected
+      def parse_options_file(options_file)
+        option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
+        @argv.push(*option_file_args)
+      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.generate = true
+      end
+
+      def parse_drb
+        is_drb = false
+        is_drb ||= @argv.delete(OPTIONS[:drb][0])
+        is_drb ||= @argv.delete(OPTIONS[:drb][1])
+        return nil unless is_drb
+        @options.generate = true
+        DrbCommandLine.run(
+          self.class.parse(@argv, @error_stream, @out_stream)
+        )
+        true
+      end
+
+      def parse_version
+        @out_stream.puts ::Spec::VERSION::DESCRIPTION
+        exit if stdout?
+      end
+
+      def parse_help
+        @out_stream.puts self
+        exit if stdout?
+      end      
+
+      def set_spec_from_line_number
+        if @options.examples.empty?
+          if @options.files.length == 1
+            if @file_factory.file?(@options.files[0])
+              source = @file_factory.open(@options.files[0])
+              example = @spec_parser.spec_name_for(source, @options.line_number)
+              @options.parse_example(example)
+            elsif @file_factory.directory?(@options.files[0])
+              @error_stream.puts "You must specify one file, not a directory when using the --line option"
+              exit(1) if stderr?
+            else
+              @error_stream.puts "#{@options.files[0]} does not exist"
+              exit(2) if stderr?
+            end
+          else
+            @error_stream.puts "Only one file can be specified when using the --line option: #{@options.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 stdout?
+        @out_stream == $stdout
+      end
+
+      def stderr?
+        @error_stream == $stderr
+      end
+    end
+  end
+end