has_finder 0.1.1

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

@@ -0,0 +1,158 @@
+module Spec
+  module Runner
+    class Options
+      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
+      }
+      
+      attr_accessor(
+        :backtrace_tweaker,
+        :colour,
+        :context_lines,
+        :diff_format,
+        :differ_class,
+        :dry_run,
+        :examples,
+        :failure_file,
+        :formatters,
+        :generate,
+        :heckle_runner,
+        :line_number,
+        :loadby,
+        :reporter,
+        :reverse,
+        :runner_type,
+        :timeout,
+        :verbose
+      )
+
+      def initialize
+        @backtrace_tweaker = QuietBacktraceTweaker.new
+        @examples = []
+        @formatters = []
+        @colour = false
+        @dry_run = false
+      end
+
+      def create_behaviour_runner
+        @formatters.each do |formatter|
+          formatter.colour = @colour if formatter.respond_to?(:colour=)
+          formatter.dry_run = @dry_run if formatter.respond_to?(:dry_run=)
+        end
+        @reporter = Reporter.new(@formatters, @backtrace_tweaker)
+
+        # this doesn't really belong here.
+        # it should, but the way things are coupled, it doesn't
+        if @differ_class
+          Spec::Expectations.differ = @differ_class.new(@diff_format, @context_lines, @colour)
+        end
+
+        return nil if @generate
+
+        if @runner_type
+          @runner_type.new(self)
+        else
+          BehaviourRunner.new(self)
+        end
+      end
+
+      def parse_diff(format, out_stream, error_stream)
+        @context_lines = 3
+        case format
+          when :context, 'context', 'c'
+            @diff_format  = :context
+          when :unified, 'unified', 'u', '', nil
+            @diff_format  = :unified
+        end
+
+        if [:context,:unified].include? @diff_format
+          require 'spec/expectations/differs/default'
+          @differ_class = Spec::Expectations::Differs::Default
+        else
+          begin
+            @diff_format  = :custom
+            @differ_class = eval(format)
+          rescue NameError
+            error_stream.puts "Couldn't find differ class #{format}"
+            error_stream.puts "Make sure the --require option is specified *before* --diff"
+            exit if out_stream == $stdout
+          end
+        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, out_stream, error_stream)
+        where = out_stream
+        # This funky regexp checks whether we have a FILE_NAME or not
+        if (format =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/) && ($2 != '')
+          format = $1
+          where = $2
+        else
+          raise "When using several --format options only one of them can be without a file" if @out_used
+          @out_used = true
+        end
+
+        begin
+          formatter_type = BUILT_IN_FORMATTERS[format] || eval(format)
+          @formatters << formatter_type.new(where)
+        rescue NameError
+          error_stream.puts "Couldn't find formatter class #{format}"
+          error_stream.puts "Make sure the --require option is specified *before* --format"
+          exit if out_stream == $stdout
+        end
+      end
+
+      def parse_require(req)
+        req.split(",").each{|file| require file}
+      end
+
+      def parse_heckle(heckle)
+        heckle_require = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? 'spec/runner/heckle_runner_unsupported' : 'spec/runner/heckle_runner'
+        require heckle_require
+        @heckle_runner = HeckleRunner.new(heckle)
+      end
+
+      def parse_generate_options(options_file, args_copy, out_stream)
+        # Remove the --generate-options option and the argument before writing to file
+        index = args_copy.index("-G") || args_copy.index("--generate-options")
+        args_copy.delete_at(index)
+        args_copy.delete_at(index)
+
+        File.open(options_file, 'w') do |io|
+          io.puts args_copy.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}"
+        @generate = true
+      end
+
+      def parse_runner(runner, out_stream, error_stream)
+        begin
+          @runner_type = eval(runner)
+        rescue NameError
+          error_stream.puts "Couldn't find behaviour runner class #{runner}"
+          error_stream.puts "Make sure the --require option is specified."
+          exit if out_stream == $stdout
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Spec
+  module Runner
+    class Reporter
+      
+      def initialize(formatters, backtrace_tweaker)
+        @formatters = formatters
+        @backtrace_tweaker = backtrace_tweaker
+        clear!
+      end
+      
+      def add_behaviour(name)
+        @formatters.each{|f| f.add_behaviour(name)}
+        @behaviour_names << name
+      end
+      
+      def example_started(name)
+        @formatters.each{|f| f.example_started(name)}
+      end
+      
+      def example_finished(name, error=nil, failure_location=nil, not_implemented = false)
+        @example_names << name
+        
+        if not_implemented
+          example_not_implemented(name)
+        elsif error.nil?
+          example_passed(name)
+        else
+          example_failed(name, error, failure_location)
+        end
+      end
+
+      def start(number_of_examples)
+        clear!
+        @start_time = Time.new
+        @formatters.each{|f| f.start(number_of_examples)}
+      end
+  
+      def end
+        @end_time = Time.new
+      end
+  
+      # Dumps the summary and returns the total number of failures
+      def dump
+        @formatters.each{|f| f.start_dump}
+        dump_failures
+        @formatters.each{|f| f.dump_summary(duration, @example_names.length, @failures.length, @not_implemented_count)}
+        @failures.length
+      end
+
+    private
+  
+      def clear!
+        @behaviour_names = []
+        @failures = []
+        @not_implemented_count = 0
+        @example_names = []
+        @start_time = nil
+        @end_time = nil
+      end
+  
+      def dump_failures
+        return if @failures.empty?
+        @failures.inject(1) do |index, failure|
+          @formatters.each{|f| f.dump_failure(index, failure)}
+          index + 1
+        end
+      end
+
+      def duration
+        return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
+        return "0.0"
+      end
+      
+      def example_passed(name)
+        @formatters.each{|f| f.example_passed(name)}
+      end
+
+      def example_failed(name, error, failure_location)
+        @backtrace_tweaker.tweak_backtrace(error, failure_location)
+        example_name = "#{@behaviour_names.last} #{name}"
+        failure = Failure.new(example_name, error)
+        @failures << failure
+        @formatters.each{|f| f.example_failed(name, @failures.length, failure)}
+      end
+      
+      def example_not_implemented(name)
+        @not_implemented_count += 1
+        @formatters.each{|f| f.example_not_implemented(name)}
+      end
+      
+      class Failure
+        attr_reader :exception
+        
+        def initialize(example_name, exception)
+          @example_name = example_name
+          @exception = exception
+        end
+
+        def header
+          if expectation_not_met?
+            "'#{@example_name}' FAILED"
+          else
+            "#{@exception.class.name} in '#{@example_name}'"
+          end
+        end
+        
+        def expectation_not_met?
+          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Spec
+  module Runner
+    # Parses a spec file and finds the nearest example for a given line number.
+    class SpecParser
+      def spec_name_for(io, line_number)
+        source  = io.read
+        behaviour, behaviour_line = behaviour_at_line(source, line_number)
+        example, example_line = example_at_line(source, line_number)
+        if behaviour && example && (behaviour_line < example_line)
+          "#{behaviour} #{example}"
+        elsif behaviour
+          behaviour
+        else
+          nil
+        end
+      end
+
+    protected
+
+      def behaviour_at_line(source, line_number)
+        find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/)
+      end
+
+      def example_at_line(source, line_number)
+        find_above(source, line_number, /^\s*(specify|it)\s+(.*)\s+do/)
+      end
+
+      # Returns the context/describe or specify/it name and the line number
+      def find_above(source, line_number, pattern)
+        lines_above_reversed(source, line_number).each_with_index do |line, n|
+          return [parse_description($2), line_number-n] if line =~ pattern
+        end
+        nil
+      end
+
+      def lines_above_reversed(source, line_number)
+        lines = source.split("\n")
+      	lines[0...line_number].reverse
+      end
+      
+      def parse_description(str)
+        return str[1..-2] if str =~ /^['"].*['"]$/
+        if matches = /^(.*)\s*,\s*['"](.*)['"]$/.match(str)
+          return ::Spec::DSL::Description.generate_description(matches[1], matches[2])
+        end
+        return str
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/test_case_adapter.rb

@@ -0,0 +1,10 @@
+require 'spec/expectations'
+require 'spec/matchers'
+
+module Test
+  module Unit
+    class TestCase
+      include Spec::Matchers
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/translator.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+module Spec
+  class Translator
+    def translate(from, to)
+      from = File.expand_path(from)
+      to = File.expand_path(to)
+      if File.directory?(from)
+        translate_dir(from, to)
+      elsif(from =~ /\.rb$/)
+        translate_file(from, to)
+      end
+    end
+    
+    def translate_dir(from, to)
+      FileUtils.mkdir_p(to) unless File.directory?(to)
+      Dir["#{from}/*"].each do |sub_from|
+        path = sub_from[from.length+1..-1]
+        sub_to = File.join(to, path)
+        translate(sub_from, sub_to)
+      end
+    end
+
+    def translate_file(from, to)
+      translation = ""
+      File.open(from) do |io|
+        io.each_line do |line|
+          translation << translate_line(line)
+        end
+      end
+      File.open(to, "w") do |io|
+        io.write(translation)
+      end
+    end
+
+    def translate_line(line)
+      return line if line =~ /(should_not|should)_receive/
+      
+      line.gsub!(/(^\s*)context([\s*|\(]['|"|A-Z])/, '\1describe\2')
+      line.gsub!(/(^\s*)specify([\s*|\(]['|"|A-Z])/, '\1it\2')
+      line.gsub!(/(^\s*)context_setup(\s*[do|\{])/, '\1before(:all)\2')
+      line.gsub!(/(^\s*)context_teardown(\s*[do|\{])/, '\1after(:all)\2')
+      line.gsub!(/(^\s*)setup(\s*[do|\{])/, '\1before(:each)\2')
+      line.gsub!(/(^\s*)teardown(\s*[do|\{])/, '\1after(:each)\2')
+      
+      if line =~ /(.*\.)(should_not|should)(?:_be)(?!_)(.*)/m
+        pre = $1
+        should = $2
+        post = $3
+        be_or_equal = post =~ /(<|>)/ ? "be" : "equal"
+        
+        return "#{pre}#{should} #{be_or_equal}#{post}"
+      end
+      
+      if line =~ /(.*\.)(should_not|should)_(?!not)\s*(.*)/m
+        pre = $1
+        should = $2
+        post = $3
+        
+        post.gsub!(/^raise/, 'raise_error')
+        post.gsub!(/^throw/, 'throw_symbol')
+        
+        unless standard_matcher?(post)
+          post = "be_#{post}"
+        end
+        
+        # Add parenthesis
+        post.gsub!(/^(\w+)\s+([\w|\.|\,|\(.*\)|\'|\"|\:|@| ]+)(\})/, '\1(\2)\3') # inside a block
+        post.gsub!(/^(redirect_to)\s+(.*)/, '\1(\2)') # redirect_to, which often has http:
+        post.gsub!(/^(\w+)\s+([\w|\.|\,|\(.*\)|\{.*\}|\'|\"|\:|@| ]+)/, '\1(\2)')
+        post.gsub!(/(\s+\))/, ')')
+        post.gsub!(/\)\}/, ') }')
+        post.gsub!(/^(\w+)\s+(\/.*\/)/, '\1(\2)') #regexps
+        line = "#{pre}#{should} #{post}"
+      end
+
+      line
+    end
+    
+    def standard_matcher?(matcher)
+      patterns = [
+        /^be/, 
+        /^be_close/,
+        /^eql/, 
+        /^equal/, 
+        /^has/, 
+        /^have/, 
+        /^change/, 
+        /^include/,
+        /^match/, 
+        /^raise_error/, 
+        /^respond_to/, 
+        /^redirect_to/, 
+        /^satisfy/, 
+        /^throw_symbol/,
+        # Extra ones that we use in spec_helper
+        /^pass/,
+        /^fail/,
+        /^fail_with/,
+      ]
+      matched = patterns.detect{ |p| matcher =~ p }
+      !matched.nil?
+    end
+    
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/version.rb

@@ -0,0 +1,22 @@
+module Spec
+  module VERSION
+    unless defined? MAJOR
+      MAJOR  = 1
+      MINOR  = 0
+      TINY   = 5
+      RELEASE_CANDIDATE = nil
+
+      # RANDOM_TOKEN: 0.956731547671535
+      REV = "$LastChangedRevision: 2081 $".match(/LastChangedRevision: (\d+)/)[1]
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+      TAG = "REL_#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('_')}".upcase.gsub(/\.|-/, '_')
+      FULL_VERSION = "#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('.')} (r#{REV})"
+
+      NAME   = "RSpec"
+      URL    = "http://rspec.rubyforge.org/"  
+    
+      DESCRIPTION = "#{NAME}-#{FULL_VERSION} - BDD for Ruby\n#{URL}"
+    end
+  end
+end