cucumber 2.0.0.beta.3 → 2.0.0

data/lib/cucumber/formatter/legacy_api/ast.rb

@@ -0,0 +1,376 @@
+module Cucumber
+  module Formatter
+    module LegacyApi
+      # Adapters to pass to the legacy API formatters that provide the interface
+      # of the old AST classes
+      module Ast
+
+        # Acts as a null object, or a base class
+        class Node
+          def initialize(node = nil)
+            @node = node
+          end
+
+          def accept(formatter)
+          end
+
+          attr_reader :node
+          private :node
+        end
+
+        # Null object for HeaderRow language.
+        # ExampleTableRow#keyword is never called on them,
+        # but this will pass silently if it happens anyway
+        class NullLanguage
+          def method_missing(*args, &block)
+            self
+          end
+
+          def to_ary
+            ['']
+          end
+        end
+
+        class HookResultCollection
+          def initialize
+            @children = []
+          end
+
+          def accept(formatter)
+            @children.each { |child| child.accept(formatter) }
+          end
+
+          def send_output_to(formatter)
+            @children.each { |child| child.send_output_to(formatter) }
+          end
+
+          def describe_exception_to(formatter)
+            @children.each { |child| child.describe_exception_to(formatter) }
+          end
+
+          def <<(child)
+            @children << child
+          end
+        end
+
+        Comments = Struct.new(:comments) do
+          def accept(formatter)
+            return if comments.empty?
+            formatter.before_comment comments
+            comments.each do |comment|
+              formatter.comment_line comment.to_s.strip
+            end
+          end
+        end
+
+        class HookResult
+          def initialize(result, messages, embeddings)
+            @result, @messages, @embeddings = result, messages, embeddings
+            @already_accepted = false
+          end
+
+          def accept(formatter)
+            unless @already_accepted
+              send_output_to(formatter)
+              describe_exception_to(formatter)
+            end
+            self
+          end
+
+          def send_output_to(formatter)
+            unless @already_accepted
+              @messages.each { |message| formatter.puts(message) }
+              @embeddings.each { |embedding| embedding.send_to_formatter(formatter) }
+            end
+          end
+
+          def describe_exception_to(formatter)
+            unless @already_accepted
+              @result.describe_exception_to(formatter)
+              @already_accepted = true
+            end
+          end
+        end
+
+        StepInvocation = Struct.new(:step_match,
+                                    :status,
+                                    :duration,
+                                    :exception,
+                                    :indent,
+                                    :background,
+                                    :step,
+                                    :messages,
+                                    :embeddings) do
+          extend Forwardable
+
+          def_delegators :step, :keyword, :name, :multiline_arg, :location, :gherkin_statement
+
+          def accept(formatter)
+            formatter.before_step(self)
+            messages.each { |message| formatter.puts(message) }
+            embeddings.each { |embedding| embedding.send_to_formatter(formatter) }
+            formatter.before_step_result *step_result_attributes
+            print_step_name(formatter)
+            Ast::MultilineArg.for(multiline_arg).accept(formatter)
+            print_exception(formatter)
+            formatter.after_step_result *step_result_attributes
+            formatter.after_step(self)
+          end
+
+          def step_result_attributes
+            legacy_multiline_arg = if multiline_arg.kind_of?(Core::Ast::EmptyMultilineArgument)
+              nil
+            else
+              step.multiline_arg
+            end
+            [keyword, step_match, legacy_multiline_arg, status, exception, source_indent, background, file_colon_line]
+          end
+
+          def failed?
+            status != :passed
+          end
+
+          def passed?
+            status == :passed
+          end
+
+          def dom_id
+
+          end
+
+          def actual_keyword(previous_step_keyword = nil)
+            step.actual_keyword(previous_step_keyword)
+          end
+
+          def file_colon_line
+            location.to_s
+          end
+
+          def backtrace_line
+            step_match.backtrace_line
+          end
+
+          def step_invocation
+            self
+          end
+
+          private
+
+          def source_indent
+            indent.of(self)
+          end
+
+          def print_step_name(formatter)
+            formatter.step_name(
+              keyword,
+              step_match,
+              status,
+              source_indent,
+              background,
+              location.to_s)
+          end
+
+          def print_exception(formatter)
+            return unless exception
+            raise exception if ENV['FAIL_FAST']
+            formatter.exception(exception, status)
+          end
+        end
+
+        class StepInvocations < Array
+          def failed?
+            any?(&:failed?)
+          end
+
+          def passed?
+            all?(&:passed?)
+          end
+
+          def status
+            return :passed if passed?
+            failed_step.status
+          end
+
+          def exception
+            failed_step.exception if failed_step
+          end
+
+          private
+
+          def failed_step
+            detect(&:failed?)
+          end
+        end
+
+        class DataTableRow
+          def initialize(row, line)
+            @values = row
+            @line = line
+          end
+
+          def dom_id
+            "row_#{line}"
+          end
+
+          def accept(formatter)
+            formatter.before_table_row(self)
+            values.each do |value|
+              formatter.before_table_cell(value)
+              formatter.table_cell_value(value, status)
+              formatter.after_table_cell(value)
+            end
+            formatter.after_table_row(self)
+          end
+
+          def status
+            :skipped
+          end
+
+          def exception
+            nil
+          end
+
+          attr_reader :values, :line
+          private :values, :line
+        end
+
+        ExampleTableRow = Struct.new(:exception, :status, :cells, :location, :language) do
+          def name
+            '| ' + cells.join(' | ') + ' |'
+          end
+
+          def failed?
+            status == :failed
+          end
+
+          def line
+            location.line
+          end
+
+          def keyword
+            # This method is only called when used for the scenario name line with
+            # the expand option, and on that line the keyword is "Scenario"
+            language.keywords('scenario')[0]
+          end
+        end
+
+        class LegacyTableRow < DataTableRow
+          def accept(formatter)
+            formatter.before_table_row(self)
+            values.each do |value|
+              formatter.before_table_cell(value.value)
+              formatter.table_cell_value(value.value, value.status)
+              formatter.after_table_cell(value.value)
+            end
+            formatter.after_table_row(self)
+          end
+        end
+
+        Tags = Struct.new(:tags) do
+          def accept(formatter)
+            formatter.before_tags tags
+            tags.each do |tag|
+              formatter.tag_name tag.name
+            end
+            formatter.after_tags tags
+          end
+        end
+
+        Scenario = Struct.new(:status, :name, :location) do
+          def backtrace_line(step_name = "#{name}", line = self.location.line)
+            "#{location.on_line(line)}:in `#{step_name}'"
+          end
+
+          def failed?
+            :failed == status
+          end
+
+          def line
+            location.line
+          end
+        end
+
+        ScenarioOutline = Struct.new(:status, :name, :location) do
+          def backtrace_line(step_name = "#{name}", line = self.location.line)
+            "#{location.on_line(line)}:in `#{step_name}'"
+          end
+
+          def failed?
+            :failed == status
+          end
+
+          def line
+            location.line
+          end
+        end
+
+        module MultilineArg
+          class << self
+            def for(node)
+              Builder.new(node).result
+            end
+          end
+
+          class Builder
+            def initialize(node)
+              node.describe_to(self)
+            end
+
+            def doc_string(node)
+              @result = DocString.new(node)
+            end
+
+            def data_table(node)
+              @result = DataTable.new(node)
+            end
+
+            def legacy_table(node)
+              @result = LegacyTable.new(node)
+            end
+
+            def result
+              @result || Node.new(nil)
+            end
+          end
+
+          class DocString < Node
+            def accept(formatter)
+              formatter.before_multiline_arg node
+              formatter.doc_string(node)
+              formatter.after_multiline_arg node
+            end
+          end
+
+          class DataTable < Cucumber::MultilineArgument::DataTable
+            def node
+              @ast_table
+            end
+
+            def accept(formatter)
+              formatter.before_multiline_arg self
+              node.raw.each_with_index do |row, index|
+                line = node.location.line + index
+                DataTableRow.new(row, line).accept(formatter)
+              end
+              formatter.after_multiline_arg self
+            end
+          end
+        end
+
+        class LegacyTable < SimpleDelegator
+          def accept(formatter)
+            formatter.before_multiline_arg self
+            cells_rows.each_with_index do |row, index|
+              line = location.line + index
+              LegacyTableRow.new(row, line).accept(formatter)
+            end
+            formatter.after_multiline_arg self
+          end
+        end
+
+        Features = Struct.new(:duration)
+
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/legacy_api/results.rb

@@ -0,0 +1,51 @@
+module Cucumber
+  module Formatter
+    module LegacyApi
+
+      class Results
+        def initialize
+          # Optimization - quicker lookup.
+          @inserted_steps = {}
+          @inserted_scenarios = {}
+        end
+
+        def step_visited(step) #:nodoc:
+          step_id = step.object_id
+
+          unless @inserted_steps.has_key?(step_id)
+            @inserted_steps[step_id] = step
+            steps.push(step)
+          end
+        end
+
+        def scenario_visited(scenario) #:nodoc:
+          scenario_id = scenario.object_id
+
+          unless @inserted_scenarios.has_key?(scenario_id)
+            @inserted_scenarios[scenario_id] = scenario
+            scenarios.push(scenario)
+          end
+        end
+
+        def steps(status = nil) #:nodoc:
+          @steps ||= []
+          if(status)
+            @steps.select{|step| step.status == status}
+          else
+            @steps
+          end
+        end
+
+        def scenarios(status = nil) #:nodoc:
+          @scenarios ||= []
+          if(status)
+            @scenarios.select{|scenario| scenario.status == status}
+          else
+            @scenarios
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/legacy_api/runtime_facade.rb

@@ -0,0 +1,30 @@
+module Cucumber
+  module Formatter
+    module LegacyApi
+
+      # This is what's passed to the constructor of the formatters
+      class RuntimeFacade < Struct.new(:results, :support_code, :configuration)
+        def unmatched_step_definitions
+          support_code.unmatched_step_definitions
+        end
+
+        def snippet_text(step_keyword, step_name, multiline_arg) #:nodoc:
+          support_code.snippet_text(::Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg)
+        end
+
+        def unknown_programming_language?
+          support_code.unknown_programming_language?
+        end
+
+        def scenarios(status = nil)
+          results.scenarios(status)
+        end
+
+        def steps(status = nil)
+          results.steps(status)
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/pretty.rb

@@ -26,6 +26,8 @@ module Cucumber
         @indent = 0
         @prefixes = options[:prefixes] || {}
         @delayed_messages = []
+        @previous_step_keyword = nil
+        @snippets_input = []
       end
 
       def before_features(features)
@@ -72,6 +74,7 @@ module Cucumber
       end
 
       def after_feature_element(feature_element)
+        print_messages
         @io.puts
         @io.flush
       end
@@ -83,6 +86,7 @@ module Cucumber
       end
 
       def after_background(background)
+        print_messages
         @in_background = nil
         @io.puts
         @io.flush
@@ -125,6 +129,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 +166,7 @@ module Cucumber
 
       def exception(exception, status)
         return if @hide_this_step
+        print_messages
         print_exception(exception, status, @indent)
         @io.flush
       end
@@ -205,6 +211,14 @@ module Cucumber
         @io.flush
       end
 
+      def before_test_case(test_case)
+        @previous_step_keyword = nil
+      end
+
+      def after_test_step(test_step, result)
+        collect_snippet_data(test_step, result)
+      end
+
       private
 
       def print_feature_element_name(keyword, name, file_colon_line, source_indent)

data/lib/cucumber/formatter/progress.rb

@@ -11,6 +11,8 @@ module Cucumber
 
       def initialize(runtime, path_or_io, options)
         @runtime, @io, @options = runtime, ensure_io(path_or_io, "progress"), options
+        @previous_step_keyword = nil
+        @snippets_input = []
       end
 
       def before_features(features)
@@ -64,6 +66,14 @@ module Cucumber
         @exception_raised = true
       end
 
+      def before_test_case(test_case)
+        @previous_step_keyword = nil
+      end
+
+      def after_test_step(test_step, result)
+        collect_snippet_data(test_step, result)
+      end
+
       private
 
       def print_summary(features)

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