rspec-core 2.0.0.a1

data/lib/rspec/core/formatters.rb

@@ -0,0 +1,16 @@
+require 'rspec/core/formatters/base_formatter'
+require 'rspec/core/formatters/base_text_formatter'
+require 'rspec/core/formatters/documentation_formatter'
+require 'rspec/core/formatters/progress_formatter'
+
+module Rspec
+
+  module Core
+
+    module Formatters
+
+    end
+
+  end
+
+end

data/lib/rspec/core/formatters/base_formatter.rb

@@ -0,0 +1,123 @@
+module Rspec
+
+  module Core
+
+    module Formatters
+
+      class BaseFormatter
+        attr_accessor :behaviour
+        attr_reader :example_count, :duration, :examples
+
+        def initialize
+          @example_count = 0
+          @examples = []
+          @behaviour = nil
+        end
+
+        def configuration
+          Rspec::Core.configuration
+        end
+
+        def output
+          Rspec::Core.configuration.output
+        end
+
+        def profile_examples?
+          Rspec::Core.configuration.profile_examples
+        end
+
+        def color_enabled?
+          configuration.color_enabled?
+        end
+
+        def pending_examples
+          @pending_examples ||= ::Rspec::Core.world.find(examples, :positive, :execution_result => { :status => 'pending' })
+        end
+
+        def failed_examples
+          @failed_examples ||= ::Rspec::Core.world.find(examples, :positive, :execution_result => { :status => 'failed' })
+        end
+
+        # This method is invoked before any examples are run, right after
+        # they have all been collected. This can be useful for special
+        # formatters that need to provide progress on feedback (graphical ones)
+        #
+        # This method will only be invoked once, and the next one to be invoked
+        # is #add_behaviour
+        def start(example_count)
+          @example_count = example_count
+        end
+
+        def example_finished(example)
+          examples << example
+        end
+
+        # This method is invoked at the beginning of the execution of each behaviour.
+        # +behaviour+ is the behaviour.
+        #
+        # The next method to be invoked after this is #example_failed or #example_finished
+        def add_behaviour(behaviour)
+          @behaviour = behaviour
+        end
+
+        # This method is invoked after all of the examples have executed. The next method
+        # to be invoked after this one is #dump_failure (once for each failed example),
+        def start_dump(duration)
+          @duration = duration
+        end
+
+        # Dumps detailed information about each example failure.
+        def dump_failures
+        end
+
+        # This method is invoked after the dumping of examples and failures.
+        def dump_summary
+        end
+
+        # This gets invoked after the summary if option is set to do so.
+        def dump_pending
+        end
+
+        # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
+        def close
+        end
+
+        def format_backtrace(backtrace, example)
+          return "" unless backtrace
+          return backtrace if example.metadata[:full_backtrace] == true
+
+          cleansed = backtrace.select { |line| backtrace_line(line) }
+          # Kick the describe stack info off the list, just keep the line the problem happened on from that file
+          # cleansed = [cleansed.detect { |line| line.split(':').first == example.metadata[:caller].split(':').first }] if cleansed.size > 1 
+          cleansed.empty? ? backtrace : cleansed
+        end
+
+        protected
+
+        def backtrace_line(line)
+          return nil if configuration.cleaned_from_backtrace?(line)
+          line.sub!(/\A([^:]+:\d+)$/, '\\1')
+          return nil if line == '-e:1'
+          line
+        end
+
+        def read_failed_line(exception, example)
+          original_file = example.file_path.to_s.downcase
+          matching_line = exception.backtrace.detect { |line| line.split(':').first.downcase == original_file.downcase }
+
+          return "Unable to find matching line from backtrace" if matching_line.nil?
+
+          file_path, line_number = matching_line.split(':')
+          if File.exist?(file_path)
+            open(file_path, 'r') { |f| f.readlines[line_number.to_i - 1] }
+          else
+            "Unable to find #{file_path} to read failed line"
+          end
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/rspec/core/formatters/base_text_formatter.rb

@@ -0,0 +1,139 @@
+module Rspec
+
+  module Core
+
+    module Formatters
+
+      class BaseTextFormatter < BaseFormatter
+
+        def dump_failures
+          output.puts
+          failed_examples.each_with_index do |failed_example, index|
+            exception = failed_example.execution_result[:exception_encountered]
+            padding = '    '
+
+            output.puts "#{index.next}) #{failed_example}"
+            output.puts "#{padding}Failure/Error: #{read_failed_line(exception, failed_example).strip}"
+
+            exception.message.split("\n").each do |line|
+              output.puts "#{padding}#{colorise(line, exception).strip}"
+            end
+
+            format_backtrace(exception.backtrace, failed_example).each do |backtrace_info|
+              output.puts grey("#{padding}# #{backtrace_info}")
+            end
+
+            output.puts 
+            output.flush
+          end
+        end
+
+        def colorise(s, failure)
+          red(s)
+        end
+
+        def dump_summary
+          failure_count = failed_examples.size
+          pending_count = pending_examples.size
+
+          output.puts "\nFinished in #{duration} seconds\n"
+
+          summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failures"
+          summary << ", #{pending_count} pending" if pending_count > 0  
+
+          if failure_count == 0
+            if pending_count > 0
+              output.puts yellow(summary)
+            else
+              output.puts green(summary)
+            end
+          else
+            output.puts red(summary)
+          end
+
+          # Don't print out profiled info if there are failures, it just clutters the output
+          if profile_examples? && failure_count == 0
+            sorted_examples = examples.sort_by { |example| example.execution_result[:run_time] }.reverse.first(10)
+            output.puts "\nTop #{sorted_examples.size} slowest examples:\n"        
+            sorted_examples.each do |example|
+              output.puts "  (#{sprintf("%.7f", example.execution_result[:run_time])} seconds) #{example}"
+              output.puts grey("   # #{format_caller(example.metadata[:caller])}")
+            end
+          end
+
+          output.flush
+        end
+
+        # def textmate_link_backtrace(path)
+        #   file, line = path.split(':')
+        #   "txmt://open/?url=file://#{File.expand_path(file)}&line=#{line}"
+        # end
+
+        def format_caller(caller_info)
+          caller_info.to_s.split(':in `block').first
+        end
+
+        def dump_pending
+          unless pending_examples.empty?
+            output.puts
+            output.puts "Pending:"
+            pending_examples.each do |pending_example, message|
+              output.puts "  #{pending_example}"
+              output.puts grey("   # #{format_caller(pending_example.metadata[:caller])}")
+            end
+          end
+          output.flush
+        end
+
+        def close
+          if IO === output && output != $stdout
+            output.close 
+          end
+        end
+
+        protected
+
+        def color(text, color_code)
+          return text unless color_enabled?
+          "#{color_code}#{text}\e[0m"
+        end
+
+        def bold(text)
+          color(text, "\e[1m")
+        end
+
+        def white(text)
+          color(text, "\e[37m")
+        end
+
+        def green(text)
+          color(text, "\e[32m")
+        end
+
+        def red(text)
+          color(text, "\e[31m")
+        end
+
+        def magenta(text)
+          color(text, "\e[35m")
+        end
+
+        def yellow(text)
+          color(text, "\e[33m")
+        end
+
+        def blue(text)
+          color(text, "\e[34m")
+        end
+
+        def grey(text)
+          color(text, "\e[90m")
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/rspec/core/formatters/documentation_formatter.rb

@@ -0,0 +1,84 @@
+module Rspec
+
+  module Core
+
+    module Formatters
+
+      class DocumentationFormatter < BaseTextFormatter
+
+        attr_reader :previous_nested_behaviours
+
+        def initialize
+          super
+          @previous_nested_behaviours = []
+        end
+
+        def add_behaviour(behaviour)
+          super
+
+          described_behaviour_chain.each_with_index do |nested_behaviour, i|
+            unless nested_behaviour == previous_nested_behaviours[i]
+              at_root_level = (i == 0)
+              desc_or_name = at_root_level ? nested_behaviour.name : nested_behaviour.description
+              output.puts if at_root_level
+              output.puts "#{'  ' * i}#{desc_or_name}"
+            end
+          end
+
+          @previous_nested_behaviours = described_behaviour_chain
+        end
+
+        def output_for(example)
+          case example.execution_result[:status]
+          when 'failed'
+            failure_output(example, example.execution_result[:exception_encountered])
+          when 'pending'
+            pending_output(example, example.execution_result[:pending_message])
+          when 'passed'
+            passed_output(example)
+          else
+            red(example.execution_result[:status])
+          end
+        end
+
+        def example_finished(example)
+          super
+          output.puts output_for(example)
+          output.flush
+        end
+
+        def failure_output(example, exception)
+          expectation_not_met = exception.is_a?(::Rspec::Expectations::ExpectationNotMetError)
+
+          message = if expectation_not_met
+            "#{current_indentation}#{example.description} (FAILED)"
+          else
+            "#{current_indentation}#{example.description} (ERROR)"
+          end
+
+          expectation_not_met ? red(message) : magenta(message)
+        end
+
+        def passed_output(example)
+          green("#{current_indentation}#{example.description}")
+        end
+
+        def pending_output(example, message)
+          yellow("#{current_indentation}#{example.description} (PENDING: #{message})")
+        end
+
+        def current_indentation
+          '  ' * previous_nested_behaviours.size
+        end
+
+        def described_behaviour_chain
+          behaviour.ancestors
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/rspec/core/formatters/progress_formatter.rb

@@ -0,0 +1,36 @@
+module Rspec
+
+  module Core
+
+    module Formatters
+
+      class ProgressFormatter < BaseTextFormatter
+
+        def output_for(example)
+          case example.execution_result[:status]
+          when 'failed' then colorise('F', example.execution_result[:exception_encountered])
+          when 'pending' then yellow('*')
+          when 'passed' then green('.')
+          else
+            red(example.execution_result[:status])
+          end
+        end
+
+        def example_finished(example)
+          super
+          output.print output_for(example)
+        end
+
+        def start_dump(duration)
+          super
+          output.puts
+          output.flush
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/rspec/core/kernel_extensions.rb

@@ -0,0 +1,15 @@
+module Rspec
+  module Core
+    module KernelExtensions
+
+      def describe(*args, &behaviour_block)
+        Rspec::Core::ExampleGroup.describe(*args, &behaviour_block)
+      end
+      
+      alias :context :describe
+
+    end
+  end
+end
+
+include Rspec::Core::KernelExtensions

data/lib/rspec/core/mocking/with_absolutely_nothing.rb

@@ -0,0 +1,13 @@
+module Rspec
+  module Core
+    module Mocking
+      module WithAbsolutelyNothing
+
+        def _setup_mocks; end
+        def _verify_mocks; end
+        def _teardown_mocks; end
+
+      end
+    end
+  end
+end

data/lib/rspec/core/mocking/with_flexmock.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#
+#  Created by Jim Weirich on 2007-04-10.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'flexmock/rspec'
+
+module Rspec
+  module Core
+    module Mocking
+      module WithFlexmock
+        include FlexMock::MockContainer
+        def setup_mocks_for_rspec
+          # No setup required
+        end
+        def verify_mocks_for_rspec
+          flexmock_verify
+        end
+        def teardown_mocks_for_rspec
+          flexmock_close
+        end
+      end
+    end
+  end
+end