has_finder 0.1.3 → 0.1.4

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

@@ -1,30 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      class ProgressBarFormatter < BaseTextFormatter
-        def add_behaviour(name)
-        end
-      
-        def example_failed(name, counter, failure)
-          @output.print failure.expectation_not_met? ? red('F') : magenta('F')
-          @output.flush
-        end
-
-        def example_passed(name)
-          @output.print green('.')
-          @output.flush
-        end
-      
-        def example_not_implemented(name)
-          @output.print yellow('*')
-          @output.flush
-        end
-        
-        def start_dump
-          @output.puts
-          @output.flush
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      class RdocFormatter < BaseTextFormatter
-        def add_behaviour(name)
-          @output.puts "# #{name}"
-        end
-  
-        def example_passed(name)
-          @output.puts "# * #{name}"
-          @output.flush
-        end
-
-        def example_failed(name, counter, failure)
-          @output.puts "# * #{name} [#{counter} - FAILED]"
-        end
-        
-        def example_not_implemented(name)
-          @output.puts "# * #{name} [NOT IMPLEMENTED]"
-        end
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/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 '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/spec/rails/vendor/plugins/rspec/lib/spec/runner/formatter/specdoc_formatter.rb

@@ -1,28 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      class SpecdocFormatter < BaseTextFormatter      
-        def add_behaviour(name)
-          @output.puts
-          @output.puts name
-          @output.flush
-        end
-      
-        def example_failed(name, counter, failure)
-          @output.puts failure.expectation_not_met? ? red("- #{name} (FAILED - #{counter})") : magenta("- #{name} (ERROR - #{counter})")
-          @output.flush
-        end
-      
-        def example_passed(name)
-          @output.puts green("- #{name}")
-          @output.flush
-        end
-        
-        def example_not_implemented(name)
-          @output.puts yellow("- #{name} (NOT IMPLEMENTED)")
-          @output.flush
-        end
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/heckle_runner.rb

@@ -1,72 +0,0 @@
-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 contexts held by +behaviour_runner+ once for each of the 
-      # methods in the matched classes.
-      def heckle_with(behaviour_runner)
-        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, behaviour_runner)
-        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, behaviour_runner)
-            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, behaviour_runner)
-        super(klass_name, method_name)
-        @behaviour_runner = behaviour_runner
-      end
-
-      def tests_pass?
-        paths = [] # We can pass an empty array of paths - our specs are already loaded.
-        failure_count = @behaviour_runner.run(paths, false)
-        failure_count == 0
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/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 not supported on Windows"
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/option_parser.rb

@@ -1,226 +0,0 @@
-require 'optparse'
-require 'stringio'
-
-module Spec
-  module Runner
-    class OptionParser
-      BUILT_IN_FORMATTERS = {
-        'specdoc'  => Formatter::SpecdocFormatter,
-        's'        => Formatter::SpecdocFormatter,
-        'html'     => Formatter::HtmlFormatter,
-        'h'        => Formatter::HtmlFormatter,
-        'rdoc'     => Formatter::RdocFormatter,
-        'r'        => Formatter::RdocFormatter,
-        'progress' => Formatter::ProgressBarFormatter,
-        'p'        => Formatter::ProgressBarFormatter,
-        'failing_examples' => Formatter::FailingExamplesFormatter,
-        'e'        => Formatter::FailingExamplesFormatter,
-        'failing_behaviours' => Formatter::FailingBehavioursFormatter,
-        'b'        => Formatter::FailingBehavioursFormatter
-      }
-
-      COMMAND_LINE = {
-        :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            : Behaviour doc as text",
-                                                    "rdoc|r               : Behaviour 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
-        @spec_parser = SpecParser.new
-        @file_factory = File
-      end
-
-      def create_behaviour_runner(args, err, out, warn_if_no_files)
-        options = parse(args, err, out, warn_if_no_files)
-        # Some exit points in parse (--generate-options, --drb) don't return the options, 
-        # but hand over control. In that case we don't want to continue.
-        return nil unless options.is_a?(Options)
-        options.create_behaviour_runner
-      end
-
-      def parse(args, err, out, warn_if_no_files)
-        options_file = nil
-        args_copy = args.dup
-        options = Options.new
-
-        opts = ::OptionParser.new do |opts|
-          opts.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
-          opts.separator ""
-
-          def opts.rspec_on(name, &block)
-            on(*COMMAND_LINE[name], &block)
-          end
-
-          opts.rspec_on(:diff) {|diff| options.parse_diff(diff, out, err)}
-
-          opts.rspec_on(:colour) {options.colour = true}
-
-          opts.rspec_on(:example) {|example| options.parse_example(example)}
-
-          opts.rspec_on(:specification) {|example| options.parse_example(example)}
-
-          opts.rspec_on(:line) {|line_number| options.line_number = line_number.to_i}
-
-          opts.rspec_on(:format) {|format| options.parse_format(format, out, err)}
-
-          opts.rspec_on(:require) {|req| options.parse_require(req)}
-
-          opts.rspec_on(:backtrace) {options.backtrace_tweaker = NoisyBacktraceTweaker.new}
-
-          opts.rspec_on(:loadby) {|loadby| options.loadby = loadby}
-
-          opts.rspec_on(:reverse) {options.reverse = true}
-
-          opts.rspec_on(:timeout) {|timeout| options.timeout = timeout.to_f}
-
-          opts.rspec_on(:heckle) {|heckle| options.parse_heckle(heckle)}
-          
-          opts.rspec_on(:dry_run) {options.dry_run = true}
-
-          opts.rspec_on(:options_file) do |options_file|
-            return parse_options_file(options_file, out, err, args_copy, warn_if_no_files)
-          end
-
-          opts.rspec_on(:generate_options) do |options_file|
-            options.parse_generate_options(options_file, args_copy, out)
-          end
-
-          opts.rspec_on(:runner) do |runner|
-            options.parse_runner(runner, out, err)
-          end
-
-          opts.rspec_on(:drb) do
-            return parse_drb(args_copy, out, err, warn_if_no_files)
-          end
-
-          opts.rspec_on(:version) {parse_version(out)}
-
-          opts.on_tail(*COMMAND_LINE[:help]) {parse_help(opts, out)}
-        end
-        opts.parse!(args)
-
-        if args.empty? && warn_if_no_files
-          err.puts "No files specified."
-          err.puts opts
-          exit(6) if err == $stderr
-        end
-
-        if options.line_number
-          set_spec_from_line_number(options, args, err)
-        end
-
-        if options.formatters.empty?
-          options.formatters << Formatter::ProgressBarFormatter.new(out)
-        end
-
-        options
-      end
-
-      def parse_options_file(options_file, out_stream, error_stream, args_copy, warn_if_no_files)
-        # Remove the --options option and the argument before writing to file
-        index = args_copy.index("-O") || args_copy.index("--options")
-        args_copy.delete_at(index)
-        args_copy.delete_at(index)
-
-        new_args = args_copy + IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
-        return CommandLine.run(new_args, error_stream, out_stream, true, warn_if_no_files)
-      end
-
-      def parse_drb(args_copy, out_stream, error_stream, warn_if_no_files)
-        # Remove the --drb option
-        index = args_copy.index("-X") || args_copy.index("--drb")
-        args_copy.delete_at(index)
-
-        return DrbCommandLine.run(args_copy, error_stream, out_stream, true, warn_if_no_files)
-      end
-
-      def parse_version(out_stream)
-        out_stream.puts ::Spec::VERSION::DESCRIPTION
-        exit if out_stream == $stdout
-      end
-
-      def parse_help(opts, out_stream)
-        out_stream.puts opts
-        exit if out_stream == $stdout
-      end      
-
-      def set_spec_from_line_number(options, args, err)
-        if options.examples.empty?
-          if args.length == 1
-            if @file_factory.file?(args[0])
-              source = @file_factory.open(args[0])
-              example = @spec_parser.spec_name_for(source, options.line_number)
-              options.parse_example(example)
-            elsif @file_factory.directory?(args[0])
-              err.puts "You must specify one file, not a directory when using the --line option"
-              exit(1) if err == $stderr
-            else
-              err.puts "#{args[0]} does not exist"
-              exit(2) if err == $stderr
-            end
-          else
-            err.puts "Only one file can be specified when using the --line option: #{args.inspect}"
-            exit(3) if err == $stderr
-          end
-        else
-          err.puts "You cannot use both --line and --example"
-          exit(4) if err == $stderr
-        end
-      end
-    end
-  end
-end