cucumber 2.0.0.beta.3 → 2.0.0.beta.4

data/lib/cucumber/formatter/pretty.rb

@@ -72,6 +72,7 @@ module Cucumber
       end
 
       def after_feature_element(feature_element)
+        print_messages
         @io.puts
         @io.flush
       end
@@ -83,6 +84,7 @@ module Cucumber
       end
 
       def after_background(background)
+        print_messages
         @in_background = nil
         @io.puts
         @io.flush
@@ -125,6 +127,7 @@ module Cucumber
       def before_step(step)
         @current_step = step
         @indent = 6
+        print_messages
       end
 
       def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
@@ -161,6 +164,7 @@ module Cucumber
 
       def exception(exception, status)
         return if @hide_this_step
+        print_messages
         print_exception(exception, status, @indent)
         @io.flush
       end

data/lib/cucumber/formatter/rerun.rb

@@ -2,106 +2,32 @@ require 'cucumber/formatter/io'
 
 module Cucumber
   module Formatter
-    # The formatter used for <tt>--format rerun</tt>
-    #
-    # This formatter keeps track of all failing features and print out their location.
-    # Example:
-    #
-    #   features/foo.feature:34 features/bar.feature:11:76:81
-    #
-    # This formatter is used by AutoTest - it will use the output to decide what
-    # to run the next time, simply passing the output string on the command line.
-    #
     class Rerun
-      include Io
+      include Formatter::Io
 
       def initialize(runtime, path_or_io, options)
         @io = ensure_io(path_or_io, "rerun")
-        @options = options
-        @file_names = []
-        @file_colon_lines = Hash.new{|h,k| h[k] = []}
+        @failures = {}
       end
 
-      def before_feature(feature_element)
-        @lines = []
-        @file = feature_element.file
-        # See https://github.com/cucumber/cucumber/issues/629
-        if @file.include?(' ')
-          warn("Filenames with spaces like '#{@file}' cause unexpected behaviour from the rerun formatter.")
-        end
+      def after_test_case(test_case, result)
+        return if result.passed?
+        @failures[test_case.location.file] ||= []
+        @failures[test_case.location.file] << test_case.location.line
       end
 
-      def after_feature(*)
-        unless @lines.empty?
-          after_first_time do
-            @io.print ' '
-          end
-          @io.print "#{@file}:#{@lines.join(':')}"
-          @io.flush
-        end
+      def done
+        return if @failures.empty?
+        @io.print file_failures.join(' ')
       end
 
-      def after_features(features)
-        @io.close
+      [:before_test_case, :before_test_step, :after_test_step].each do |method|
+        define_method(method) { |*| }
       end
 
-      def before_feature_element(feature_element)
-        @rerun = false
-      end
-
-      def after_feature_element(feature_element)
-        if (@rerun || feature_element.failed? || feature_element.status == :skipped) && !(Cucumber::Reports::Legacy::Ast::ScenarioOutline === feature_element)
-          @lines << feature_element.line
-        end
-      end
-
-      def after_table_row(table_row)
-        return unless @in_examples and Cucumber::Reports::LegacyExampleTableRow === table_row
-        unless @header_row
-          if table_row.failed? || table_row.status == :skipped
-            @rerun = true
-            @lines << table_row.line
-          end
-        end
-
-        @header_row = false if @header_row
-      end
-
-      def before_examples(*args)
-        @header_row = true
-        @in_examples = true
-        @current_example_line = nil
-      end
-
-      def after_examples(*args)
-        @in_examples = false
-        if @current_example_line and @rerun
-          @lines << @current_example_line
-        end
-      end
-
-      def before_table_row(table_row)
-        return unless @in_examples
-      end
-
-      def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
-        @rerun = true if [:failed, :pending, :undefined].index(status)
-      end
-
-      def scenario_name(keyword, name, file_colon_line, source_indent)
-        return unless @in_examples
-        if @current_example_line and @rerun
-          @lines << @current_example_line
-        end
-        @rerun = false
-        @current_example_line = file_colon_line.split(':')[1]
-      end
-
-    private
-
-      def after_first_time
-        yield if @not_first_time
-        @not_first_time = true
+      private
+      def file_failures
+        @failures.map { |file, lines| [file, lines].join(':') }
       end
     end
   end

data/lib/cucumber/language_support/language_methods.rb

@@ -4,21 +4,6 @@ require 'cucumber/step_definition_light'
 module Cucumber
   module LanguageSupport
     module LanguageMethods
-      def around(scenario)
-        execute_around(scenario) do
-          yield
-        end
-      end
-
-      def before(scenario)
-        begin_scenario(scenario)
-        execute_before(scenario)
-      end
-
-      def after(scenario)
-        execute_after(scenario)
-        end_scenario
-      end
 
       def after_configuration(configuration)
         hooks[:after_configuration].each do |hook|
@@ -26,12 +11,6 @@ module Cucumber
         end
       end
 
-      def execute_after_step(scenario)
-        hooks_for(:after_step, scenario).each do |hook|
-          invoke(hook, 'AfterStep', scenario)
-        end
-      end
-
       def execute_transforms(args)
         args.map do |arg|
           matching_transform = transforms.detect {|transform| transform.match(arg) }
@@ -87,39 +66,6 @@ module Cucumber
         @transforms ||= []
       end
 
-      def execute_around(scenario, &block)
-        hooks_for(:around, scenario).reverse.inject(block) do |blk, hook|
-          proc do
-            invoke(hook, 'Around', scenario, true) do
-              blk.call(scenario)
-            end
-          end
-        end.call
-      end
-
-      def execute_before(scenario)
-        hooks_for(:before, scenario).each do |hook|
-          invoke(hook, 'Before', scenario, true)
-        end
-      end
-
-      def execute_after(scenario)
-        hooks_for(:after, scenario).reverse_each do |hook|
-          invoke(hook, 'After', scenario, true)
-        end
-      end
-
-      def invoke(hook, location, scenario, exception_fails_scenario, &block)
-        begin
-          hook.invoke(location, scenario, &block)
-        rescue Exception => exception
-          if exception_fails_scenario
-            scenario.fail!(exception)
-          else
-            raise
-          end
-        end
-      end
     end
   end
 end

data/lib/cucumber/multiline_argument/data_table.rb

@@ -427,8 +427,9 @@ module Cucumber
       end
 
       def to_s(options = {}) #:nodoc:
+        # TODO: factor out this code so we don't depend on such a big lump of old cruft
         require 'cucumber/formatter/pretty'
-        require 'cucumber/reports/legacy_formatter'
+        require 'cucumber/formatter/legacy_api/adapter'
         options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
         io = StringIO.new
 
@@ -436,9 +437,7 @@ module Cucumber
         Cucumber::Term::ANSIColor.coloring = options[:color]
         formatter = Formatter::Pretty.new(nil, io, options)
         formatter.instance_variable_set('@indent', options[:indent])
-
-        Reports::Legacy::Ast::MultilineArg.for(self).accept(Reports::FormatterWrapper.new([formatter]))
-
+        Formatter::LegacyApi::Ast::MultilineArg.for(self).accept(Formatter::Fanout.new([formatter]))
         Cucumber::Term::ANSIColor.coloring = c
         io.rewind
         s = "\n" + io.read + (" " * (options[:indent] - 2))

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0.beta.3'
+    VERSION       = '2.0.0.beta.4'
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     JRUBY         = defined?(JRUBY_VERSION)

data/lib/cucumber/runtime.rb

@@ -9,6 +9,10 @@ require 'cucumber/load_path'
 require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
 require 'cucumber/file_specs'
+require 'cucumber/filters/quit'
+require 'cucumber/filters/randomizer'
+require 'cucumber/filters/tag_limits'
+require 'cucumber/formatter/fanout'
 
 module Cucumber
   module FixRuby21Bug9285
@@ -35,9 +39,7 @@ module Cucumber
 
   require 'cucumber/core'
   require 'cucumber/runtime/user_interface'
-  require 'cucumber/runtime/results'
   require 'cucumber/runtime/support_code'
-  require 'cucumber/runtime/tag_limits'
   class Runtime
     attr_reader :results, :support_code, :configuration
 
@@ -46,17 +48,15 @@ module Cucumber
     include Runtime::UserInterface
 
     def initialize(configuration = Configuration.default)
-      @current_scenario = nil
       @configuration = Configuration.parse(configuration)
       @support_code = SupportCode.new(self, @configuration)
-      @results = Results.new(@configuration)
+      @results = Formatter::LegacyApi::Results.new
     end
 
-    # Allows you to take an existing runtime and change it's configuration
+    # Allows you to take an existing runtime and change its configuration
     def configure(new_configuration)
       @configuration = Configuration.parse(new_configuration)
       @support_code.configure(@configuration)
-      @results.configure(@configuration)
     end
 
     def load_programming_language(language)
@@ -79,10 +79,6 @@ module Cucumber
       @configuration.dry_run?
     end
 
-    def step_visited(step) #:nodoc:
-      @results.step_visited(step)
-    end
-
     def scenarios(status = nil)
       @results.scenarios(status)
     end
@@ -103,55 +99,10 @@ module Cucumber
       @support_code.snippet_text(::Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg)
     end
 
-    def with_hooks(scenario, skip_hooks=false)
-      around(scenario, skip_hooks) do
-        before_and_after(scenario, skip_hooks) do
-          yield scenario
-        end
-      end
-    end
-
-    def around(scenario, skip_hooks=false, &block) #:nodoc:
-      if skip_hooks
-        yield
-        return
-      end
-
-      @support_code.around(scenario, block)
-    end
-
-    def before_and_after(scenario, skip_hooks=false) #:nodoc:
-      before(scenario) unless skip_hooks
-      yield scenario
-      after(scenario) unless skip_hooks
-      record_result scenario
-    end
-
-    def record_result(scenario)
-      @results.scenario_visited(scenario)
-    end
-
     def begin_scenario(scenario)
       @support_code.fire_hook(:begin_scenario, scenario)
     end
 
-    def before(scenario) #:nodoc:
-      return if dry_run? || @current_scenario
-      @current_scenario = scenario
-      @support_code.fire_hook(:before, scenario)
-    end
-
-    def after(scenario) #:nodoc:
-      @current_scenario = nil
-      return if dry_run?
-      @support_code.fire_hook(:after, scenario)
-    end
-
-    def after_step #:nodoc:
-      return if dry_run?
-      @support_code.fire_hook(:execute_after_step, @current_scenario)
-    end
-
     def unknown_programming_language?
       @support_code.unknown_programming_language?
     end
@@ -159,8 +110,7 @@ module Cucumber
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
     def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-      file, line = *caller[0].split(':')[0..1]
-      location = Core::Ast::Location.new(file, line)
+      location = Core::Ast::Location.of_caller
       Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
     end
 
@@ -228,68 +178,52 @@ module Cucumber
       @mappings = Mappings.for(self)
     end
 
-    require 'cucumber/reports/legacy_formatter'
+    require 'cucumber/formatter/legacy_api/adapter'
+    require 'cucumber/formatter/legacy_api/runtime_facade'
+    require 'cucumber/formatter/legacy_api/results'
+    require 'cucumber/formatter/ignore_missing_messages'
+    require 'cucumber/core/report/summary'
     def report
-      @report ||= Cucumber::Reports::LegacyFormatter.new(self, @configuration.formatters(self))
+      @report ||= Formatter::Fanout.new([summary_report] + formatters)
+    end
+
+    def summary_report
+      @summary_report ||= Core::Report::Summary.new
+    end
+
+    def formatters
+      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
+        results = Formatter::LegacyApi::Results.new
+        runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
+        formatter = factory.new(runtime_facade, path_or_io, options)
+        Formatter::LegacyApi::Adapter.new(
+          Formatter::IgnoreMissingMessages.new(formatter),
+          results, @support_code, @configuration)
+      }
     end
 
+    def failure?
+      if @configuration.wip?
+        summary_report.test_cases.total_passed > 0
+      else
+        summary_report.test_cases.total_failed > 0 || summary_report.test_steps.total_failed > 0 ||
+          (@configuration.strict? && (summary_report.test_steps.total_undefined > 0 || summary_report.test_steps.total_skipped > 0))
+      end
+    end
+    public :failure?
+
     require 'cucumber/core/test/filters'
     def filters
       tag_expressions = @configuration.tag_expressions
       name_regexps = @configuration.name_regexps
       tag_limits = @configuration.tag_limits
       [].tap do |filters|
-        filters << [Cucumber::Runtime::Randomizer, [@configuration.seed]] if @configuration.randomize?
-        filters << [Cucumber::Runtime::TagLimits::Filter, [tag_limits]] if tag_limits.any?
+        filters << [Filters::Randomizer, [@configuration.seed]] if @configuration.randomize?
+        filters << [Filters::TagLimits, [tag_limits]] if tag_limits.any?
         filters << [Cucumber::Core::Test::TagFilter, [tag_expressions]]
         filters << [Cucumber::Core::Test::NameFilter, [name_regexps]]
         filters << [Cucumber::Core::Test::LocationsFilter, [filespecs.locations]]
-        filters << [Quit, []]
-      end
-    end
-
-    class Randomizer
-      def initialize(seed, receiver)
-        @receiver = receiver
-        @test_cases = []
-        @seed = seed
-      end
-
-      def test_case(test_case)
-        @test_cases << test_case
-      end
-
-      def done
-        shuffled_test_cases.each do |test_case|
-          test_case.describe_to(@receiver)
-        end
-        @receiver.done
-      end
-
-      private
-
-      def shuffled_test_cases
-        @test_cases.shuffle(random: Random.new(seed))
-      end
-
-      attr_reader :seed
-      private :seed
-    end
-
-    class Quit
-      def initialize(receiver)
-        @receiver = receiver
-      end
-
-      def test_case(test_case)
-        unless Cucumber.wants_to_quit
-          test_case.describe_to @receiver
-        end
-      end
-
-      def done
-        @receiver.done
-        self
+        filters << [Filters::Quit, []]
       end
     end