cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'cucumber/platform'
+
+module Cucumber
+  module Formatter
+    @backtrace_filters = %w[
+      /vendor/rails
+      lib/cucumber
+      bin/cucumber:
+      lib/rspec
+      gems/
+      site_ruby/
+      minitest
+      test/unit
+      .gem/ruby
+      bin/bundle
+    ]
+
+    @backtrace_filters << RbConfig::CONFIG['rubyarchdir'] if RbConfig::CONFIG['rubyarchdir']
+    @backtrace_filters << RbConfig::CONFIG['rubylibdir'] if RbConfig::CONFIG['rubylibdir']
+
+    @backtrace_filters << 'org/jruby/' if ::Cucumber::JRUBY
+
+    BACKTRACE_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
+
+    class BacktraceFilter
+      def initialize(exception)
+        @exception = exception
+      end
+
+      def exception
+        return @exception if ::Cucumber.use_full_backtrace
+
+        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m # rubocop:disable Style/RegexpLiteral
+        backtrace = @exception.backtrace.map { |line| line.gsub(pwd_pattern, './') }
+
+        filtered = (backtrace || []).reject do |line|
+          line =~ BACKTRACE_FILTER_PATTERNS
+        end
+
+        if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']
+          # Strip off file locations
+          filtered = filtered.map do |line|
+            line =~ /(.*):in `/ ? Regexp.last_match(1) : line
+          end
+        end
+
+        @exception.set_backtrace(filtered)
+        @exception
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/console.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
-require 'cucumber/formatter/summary'
+require 'cucumber/gherkin/i18n'
 
 module Cucumber
   module Formatter
-
     # This module contains helper methods that are used by formatters that
     # print output to the terminal.
     #
@@ -28,15 +29,14 @@ module Cucumber
     module Console
       extend ANSIColor
       include Duration
-      include Summary
 
       def format_step(keyword, step_match, status, source_indent)
         comment = if source_indent
-          c = ('# ' + step_match.file_colon_line).indent(source_indent)
-          format_string(c, :comment)
-        else
-          ''
-        end
+                    c = ('# ' + step_match.location.to_s).indent(source_indent)
+                    format_string(c, :comment)
+                  else
+                    ''
+                  end
 
         format = format_for(status, :param)
         line = keyword + step_match.format_args(format) + comment
@@ -46,7 +46,7 @@ module Cucumber
       def format_string(o, status)
         fmt = format_for(status)
         o.to_s.split("\n").map do |line|
-          if Proc === fmt
+          if Proc == fmt.class
             fmt.call(line)
           else
             fmt % line
@@ -54,101 +54,81 @@ module Cucumber
         end.join("\n")
       end
 
-      def print_steps(status)
-        print_elements(runtime.steps(status), status, 'steps')
+      def print_elements(elements, status, kind)
+        return if elements.empty?
+
+        element_messages = element_messages(elements, status)
+        print_element_messages(element_messages, status, kind)
       end
 
-      def print_elements(elements, status, kind)
-        if elements.any?
+      def print_element_messages(element_messages, status, kind)
+        if element_messages.any?
           @io.puts(format_string("(::) #{status} #{kind} (::)", status))
           @io.puts
           @io.flush
         end
 
-        elements.each_with_index do |element, i|
-          if status == :failed
-            print_exception(element.exception, status, 0)
-          else
-            @io.puts(format_string(element.backtrace_line, status))
-          end
+        element_messages.each do |message|
+          @io.puts(format_string(message, status))
           @io.puts
           @io.flush
         end
       end
 
-      def print_stats(features, options)
-        failures = collect_failing_scenarios(runtime)
-        if !failures.empty?
-          print_failing_scenarios(failures, options.custom_profiles, options[:source])
+      def print_statistics(duration, config, counts, issues)
+        if issues.any?
+          @io.puts issues.to_s
+          @io.puts
         end
 
-        @io.puts scenario_summary(runtime) {|status_count, status| format_string(status_count, status)}
-        @io.puts step_summary(runtime) {|status_count, status| format_string(status_count, status)}
+        @io.puts counts.to_s
+        @io.puts(format_duration(duration)) if duration && config.duration?
 
-        @io.puts(format_duration(features.duration)) if features && features.duration
-
-        if runtime.configuration.randomize?
+        if config.randomize?
           @io.puts
-          @io.puts "Randomized with seed #{runtime.configuration.seed}"
+          @io.puts "Randomized with seed #{config.seed}"
         end
 
         @io.flush
       end
 
-      def collect_failing_scenarios(runtime)
-        # TODO: brittle - stop coupling to types
-        scenario_class = LegacyApi::Ast::Scenario
-        example_table_class = Core::Ast::ExamplesTable
-
-        runtime.scenarios(:failed).select do |s|
-          [scenario_class, example_table_class].include?(s.class)
-        end.map do |s|
-          s.is_a?(example_table_class)? s.scenario_outline : s
-        end
+      def print_exception(e, status, indent)
+        string = exception_message_string(e, indent)
+        @io.puts(format_string(string, status))
       end
 
-      def print_failing_scenarios(failures, custom_profiles, given_source)
-        @io.puts format_string("Failing Scenarios:", :failed)
-        failures.each do |failure|
-          profiles_string = custom_profiles.empty? ? '' : (custom_profiles.map{|profile| "-p #{profile}" }).join(' ') + ' '
-          source = given_source ? format_string(" # " + failure.name, :comment) : ''
-          @io.puts format_string("cucumber #{profiles_string}" + failure.location, :failed) + source
-        end
-        @io.puts
-      end
+      def exception_message_string(e, indent)
+        message = "#{e.message} (#{e.class})".dup.force_encoding('UTF-8')
+        message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
 
-      def print_exception(e, status, indent)
-        message = "#{e.message} (#{e.class})"
-        if ENV['CUCUMBER_TRUNCATE_OUTPUT']
-          message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
-        end
-
-        string = "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
-        @io.puts(format_string(string, status))
+        "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
       end
 
       # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655
-      def linebreaks(s, max)
-        s.gsub(/.{1,#{max}}(?:\s|\Z)/){($& + 5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")}.rstrip
+      def linebreaks(msg, max)
+        return msg unless max && max > 0
+        msg.gsub(/.{1,#{max}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }.rstrip
       end
 
-      def collect_snippet_data(test_step, result)
+      def collect_snippet_data(test_step, ast_lookup)
         # collect snippet data for undefined steps
-        unless hook?(test_step)
-          keyword = test_step.source.last.actual_keyword(@previous_step_keyword)
-          @previous_step_keyword = keyword
-          if result.undefined?
-            @snippets_input << Console::SnippetData.new(keyword, test_step.source.last)
-          end
-        end
+        keyword = ast_lookup.snippet_step_keyword(test_step)
+        @snippets_input << Console::SnippetData.new(keyword, test_step)
       end
 
       def print_snippets(options)
         return unless options[:snippets]
-        return if runtime.steps(:undefined).empty?
+        return if @snippets_input.empty?
 
+        snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
+          snippet_text(step_keyword, step_name, multiline_arg)
+        end
+        do_print_snippets(snippet_text_proc)
+      end
+
+      def do_print_snippets(snippet_text_proc)
         snippets = @snippets_input.map do |data|
-          @runtime.snippet_text(data.actual_keyword, data.step.name, data.step.multiline_arg)
+          snippet_text_proc.call(data.actual_keyword, data.step.text, data.step.multiline_arg)
         end.uniq
 
         text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
@@ -159,12 +139,20 @@ module Cucumber
         @io.flush
       end
 
-      def print_passing_wip(options)
-        return unless options[:wip]
-        passed = runtime.scenarios(:passed)
-        if passed.any?
+      def print_passing_wip(config, passed_test_cases, ast_lookup)
+        return unless config.wip?
+        messages = passed_test_cases.map do |test_case|
+          scenario_source = ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          linebreaks("#{test_case.location.on_line(test_case.location.lines.max)}:in `#{keyword}: #{test_case.name}'", ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+        end
+        do_print_passing_wip(messages)
+      end
+
+      def do_print_passing_wip(passed_messages)
+        if passed_messages.any?
           @io.puts format_string("\nThe --wip switch was used, so I didn't expect anything to pass. These scenarios passed:", :failed)
-          print_elements(passed, :passed, "scenarios")
+          print_element_messages(passed_messages, :passed, 'scenarios')
         else
           @io.puts format_string("\nThe --wip switch was used, so the failures were expected. All is good.\n", :passed)
         end
@@ -174,56 +162,33 @@ module Cucumber
         # no-op
       end
 
-      #define @delayed_messages = [] in your Formatter if you want to
-      #activate this feature
       def puts(*messages)
-        if @delayed_messages
-          @delayed_messages += messages
-        else
-          if @io
-            @io.puts
-            messages.each do |message|
-              @io.puts(format_string(message, :tag))
-            end
-            @io.flush
-          end
+        return unless @io
+        @io.puts
+        messages.each do |message|
+          @io.puts(format_string(message, :tag))
         end
-      end
-
-      def print_messages
-        @delayed_messages.each {|message| print_message(message)}
-        empty_messages
-      end
-
-      def print_table_row_messages
-        return if @delayed_messages.empty?
-        @io.print(format_string(@delayed_messages.join(', '), :tag).indent(2))
-        @io.flush
-        empty_messages
-      end
-
-      def print_message(message)
-        @io.puts(format_string(message, :tag).indent(@indent))
         @io.flush
       end
 
-      def empty_messages
-        @delayed_messages = []
-      end
-
       def print_profile_information
         return if @options[:skip_profile_information] || @options[:profiles].nil? || @options[:profiles].empty?
-        profiles = @options[:profiles]
-        profiles_sentence = ''
-        profiles_sentence = profiles.size == 1 ? profiles.first :
-          "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+        do_print_profile_information(@options[:profiles])
+      end
 
-        @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size> 1}..."
+      def do_print_profile_information(profiles)
+        profiles_sentence = if profiles.size == 1
+                              profiles.first
+                            else
+                              "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+                            end
+
+        @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size > 1}..."
       end
 
       private
 
-      FORMATS = Hash.new{ |hash, format| hash[format] = method(format).to_proc }
+      FORMATS = Hash.new { |hash, format| hash[format] = method(format).to_proc }
 
       def format_for(*keys)
         key = keys.join('_').to_sym
@@ -232,17 +197,30 @@ module Cucumber
         fmt
       end
 
-      def hook?(test_step)
-        not test_step.source.last.respond_to?(:actual_keyword)
+      def element_messages(elements, status)
+        elements.map do |element|
+          if status == :failed
+            exception_message_string(element.exception, 0)
+          else
+            linebreaks(element.backtrace_line, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+          end
+        end
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg)
+        keyword = Cucumber::Gherkin::I18n.code_keyword_for(step_keyword).strip
+        config.snippet_generators.map do |generator|
+          generator.call(keyword, step_name, multiline_arg, config.snippet_type)
+        end.join("\n")
       end
 
       class SnippetData
         attr_reader :actual_keyword, :step
         def initialize(actual_keyword, step)
-          @actual_keyword, @step = actual_keyword, step
+          @actual_keyword = actual_keyword
+          @step = step
         end
       end
-
     end
   end
 end

data/lib/cucumber/formatter/console_counts.rb

@@ -0,0 +1,39 @@
+require 'cucumber/formatter/console'
+
+module Cucumber
+  module Formatter
+    class ConsoleCounts
+      include Console
+
+      def initialize(config)
+        @summary = Core::Report::Summary.new(config.event_bus)
+      end
+
+      def to_s
+        [
+          [scenario_count, status_counts(@summary.test_cases)].compact.join(' '),
+          [step_count, status_counts(@summary.test_steps)].compact.join(' ')
+        ].join("\n")
+      end
+
+      private
+
+      def scenario_count
+        count = @summary.test_cases.total
+        "#{count} scenario" + (count == 1 ? '' : 's')
+      end
+
+      def step_count
+        count = @summary.test_steps.total
+        "#{count} step" + (count == 1 ? '' : 's')
+      end
+
+      def status_counts(summary)
+        counts = Core::Test::Result::TYPES.map { |status| [status, summary.total(status)] }
+        counts = counts.select { |_status, count| count > 0 }
+        counts = counts.map { |status, count| format_string("#{count} #{status}", status) }
+        "(#{counts.join(', ')})" if counts.any?
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/console_issues.rb

@@ -0,0 +1,61 @@
+require 'cucumber/formatter/console'
+
+module Cucumber
+  module Formatter
+    class ConsoleIssues
+      include Console
+
+      def initialize(config, ast_lookup = AstLookup.new(config))
+        @previous_test_case = nil
+        @issues = Hash.new { |h, k| h[k] = [] }
+        @config = config
+        @config.on_event(:test_case_finished) do |event|
+          if event.test_case != @previous_test_case
+            @previous_test_case = event.test_case
+            @issues[event.result.to_sym] << event.test_case unless event.result.ok?(@config.strict)
+          elsif event.result.passed?
+            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(@config.strict.strict?(:flaky))
+            @issues[:failed].delete(event.test_case)
+          end
+        end
+        @ast_lookup = ast_lookup
+      end
+
+      def to_s
+        return if @issues.empty?
+        result = Core::Test::Result::TYPES.map { |type| scenario_listing(type, @issues[type]) }
+        result.flatten.join("\n")
+      end
+
+      def any?
+        @issues.any?
+      end
+
+      private
+
+      def scenario_listing(type, test_cases)
+        return [] if test_cases.empty?
+        [format_string("#{type_heading(type)} Scenarios:", type)] + test_cases.map do |test_case|
+          scenario_source = @ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          source = @config.source? ? format_string(" # #{keyword}: #{test_case.name}", :comment) : ''
+          format_string("cucumber #{profiles_string}#{test_case.location.file}:#{test_case.location.lines.max}", type) + source
+        end
+      end
+
+      def type_heading(type)
+        case type
+        when :failed
+          'Failing'
+        else
+          type.to_s.slice(0, 1).capitalize + type.to_s.slice(1..-1)
+        end
+      end
+
+      def profiles_string
+        return if @config.custom_profiles.empty?
+        @config.custom_profiles.map { |profile| "-p #{profile}" }.join(' ') + ' '
+      end
+    end
+  end
+end