rspec 0.8.2 → 0.9.0

data/lib/spec/runner/options.rb

@@ -0,0 +1,26 @@
+module Spec
+  module Runner
+    class Options
+      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
+      )
+    end
+  end
+end

data/lib/spec/runner/reporter.rb

@@ -2,36 +2,38 @@ module Spec
   module Runner
     class Reporter
       
-      def initialize(formatter, backtrace_tweaker)
-        @formatter = formatter
+      def initialize(formatters, backtrace_tweaker)
+        @formatters = formatters
         @backtrace_tweaker = backtrace_tweaker
         clear!
       end
       
-      def add_context(name)
-        #TODO - @context_names.empty? tells the formatter whether this is the first context or not - that's a little slippery
-        @formatter.add_context(name, @context_names.empty?)
-        @context_names << name
+      def add_behaviour(name)
+        @formatters.each{|f| f.add_behaviour(name)}
+        @behaviour_names << name
+        STDOUT.flush
       end
       
-      def spec_started(name)
-        @spec_names << name
-        @formatter.spec_started(name)
+      def example_started(name)
+        @formatters.each{|f| f.example_started(name)}
+        STDOUT.flush
       end
       
-      def spec_finished(name, error=nil, failure_location=nil)
+      def example_finished(name, error=nil, failure_location=nil)
+        @example_names << name
         if error.nil?
-          spec_passed(name)
+          example_passed(name)
         else
-          @backtrace_tweaker.tweak_backtrace(error, failure_location)
-          spec_failed(name, Failure.new(@context_names.last, name, error))
+          example_failed(name, error, failure_location)
         end
+        STDOUT.flush
       end
 
-      def start(number_of_specs)
+      def start(number_of_examples)
         clear!
         @start_time = Time.new
-        @formatter.start(number_of_specs)
+        @formatters.each{|f| f.start(number_of_examples)}
+        STDOUT.flush
       end
   
       def end
@@ -40,18 +42,19 @@ module Spec
   
       # Dumps the summary and returns the total number of failures
       def dump
-        @formatter.start_dump
+        @formatters.each{|f| f.start_dump}
         dump_failures
-        @formatter.dump_summary(duration, @spec_names.length, @failures.length)
+        @formatters.each{|f| f.dump_summary(duration, @example_names.length, @failures.length)}
+        STDOUT.flush
         @failures.length
       end
 
-      private
+    private
   
       def clear!
-        @context_names = []
+        @behaviour_names = []
         @failures = []
-        @spec_names = []
+        @example_names = []
         @start_time = nil
         @end_time = nil
       end
@@ -59,7 +62,7 @@ module Spec
       def dump_failures
         return if @failures.empty?
         @failures.inject(1) do |index, failure|
-          @formatter.dump_failure(index, failure)
+          @formatters.each{|f| f.dump_failure(index, failure)}
           index + 1
         end
       end
@@ -69,29 +72,33 @@ module Spec
         return "0.0"
       end
 
-      def spec_passed(name)
-        @formatter.spec_passed(name)
+      def example_passed(name)
+        @formatters.each{|f| f.example_passed(name)}
       end
 
-      def spec_failed(name, failure)
+      def example_failed(name, error, failure_location)
+        @backtrace_tweaker.tweak_backtrace(error, failure_location)
+        example_name = "#{@behaviour_names.last} #{name}"
+        @failure_io.puts(example_name) unless @failure_io.nil?
+        failure = Failure.new(example_name, error)
         @failures << failure
-        @formatter.spec_failed(name, @failures.length, failure)
+        @formatters.each{|f| f.example_failed(name, @failures.length, failure)}
+        STDOUT.flush
       end
-
+      
       class Failure
         attr_reader :exception
         
-        def initialize(context_name, spec_name, exception)
-          @context_name = context_name
-          @spec_name = spec_name
+        def initialize(example_name, exception)
+          @example_name = example_name
           @exception = exception
         end
 
         def header
           if expectation_not_met?
-            "'#{@context_name} #{@spec_name}' FAILED"
+            "'#{@example_name}' FAILED"
           else
-            "#{@exception.class.name} in '#{@context_name} #{@spec_name}'"
+            "#{@exception.class.name} in '#{@example_name}'"
           end
         end
         

data/lib/spec/runner/spec_parser.rb

@@ -1,15 +1,15 @@
 module Spec
   module Runner
-    # Parses a spec file and finds the nearest spec for a given line number.
+    # 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
-        context = context_at_line(source, line_number)
-        spec    = spec_at_line(source, line_number)
-        if context && spec
-          "#{context} #{spec}"
-        elsif context
-          context
+        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
@@ -17,17 +17,18 @@ module Spec
 
     protected
 
-      def context_at_line(source, line_number)
-        find_above(source, line_number, /^\s*context\s+['|"](.*)['|"]/)
+      def behaviour_at_line(source, line_number)
+        find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/)
       end
 
-      def spec_at_line(source, line_number)
-        find_above(source, line_number, /^\s*specify\s+['|"](.*)['|"]/)
+      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 do |line| 
-          return $1 if line =~ 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
@@ -36,6 +37,14 @@ module Spec
         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 "#{matches[1]}#{matches[2]}"
+        end
+        return str
+      end
     end
   end
 end

data/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/lib/spec/translator.rb

@@ -1,87 +1,104 @@
-require 'fileutils'
-
-module Spec
-  class Translator
-    def translate_dir(from, to)
-      from = File.expand_path(from)
-      to = File.expand_path(to)
-      if File.directory?(from)
-        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_dir(sub_from, sub_to)
-        end
-      else
-        translate_file(from, to)
-      end
-    end
-    
-    def translate_file(from, to)
-      translation = ""
-      File.open(from) do |io|
-        io.each_line do |line|
-          translation << translate(line)
-        end
-      end
-      File.open(to, "w") do |io|
-        io.write(translation)
-      end
-    end
-
-    def translate(line)
-      return line if line =~ /(should_not|should)_receive/
-      
-      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)(.*)/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
-        
-        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/, 
-        /^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
+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!(/^(\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/, 
+        /^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/lib/spec/version.rb

@@ -1,25 +1,17 @@
 module Spec
   module VERSION
-    def self.build_tag
-      tag = "REL_" + [MAJOR, MINOR, TINY].join('_')
-      if defined?(RELEASE_CANDIDATE)
-        tag << "_" << RELEASE_CANDIDATE
-      end
-      tag
-    end
-
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 8
-      TINY   = 2
-      # RELEASE_CANDIDATE = "RC1"
+      MINOR  = 9
+      TINY   = 0
+      RELEASE_CANDIDATE = nil # "beta-1"
       
-      # RANDOM_TOKEN: 0.375509844656552
-      REV = "$LastChangedRevision: 1560 $".match(/LastChangedRevision: (\d+)/)[1]
+      # RANDOM_TOKEN: 0.909189653221202
+      REV = "$LastChangedRevision: 1874 $".match(/LastChangedRevision: (\d+)/)[1]
 
       STRING = [MAJOR, MINOR, TINY].join('.')
-      FULL_VERSION = "#{STRING} (r#{REV})"
-      TAG = build_tag
+      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/"