cucumber 3.1.2 → 8.0.0

data/lib/cucumber/filters/quit.rb

@@ -8,9 +8,7 @@ module Cucumber
       end
 
       def test_case(test_case)
-        unless Cucumber.wants_to_quit
-          test_case.describe_to @receiver
-        end
+        test_case.describe_to @receiver unless Cucumber.wants_to_quit
         self
       end
 

data/lib/cucumber/filters/tag_limits/verifier.rb

@@ -17,10 +17,8 @@ module Cucumber
 
         def collect_breaches(test_case_index)
           tag_limits.reduce([]) do |breaches, (tag_name, limit)|
-            breaches.tap do |breaches|
-              if test_case_index.count_by_tag_name(tag_name) > limit
-                breaches << Breach.new(tag_name, limit, test_case_index.locations_of_tag_name(tag_name))
-              end
+            breaches.tap do |breach|
+              breach << Breach.new(tag_name, limit, test_case_index.locations_of_tag_name(tag_name)) if test_case_index.count_by_tag_name(tag_name) > limit
             end
           end
         end
@@ -49,9 +47,7 @@ module Cucumber
             locations.count
           end
 
-          attr_reader :tag_name
-          attr_reader :limit
-          attr_reader :locations
+          attr_reader :tag_name, :limit, :locations
         end
       end
     end

data/lib/cucumber/filters/tag_limits.rb

@@ -38,9 +38,7 @@ module Cucumber
 
       private
 
-      attr_reader :gated_receiver
-      attr_reader :test_case_index
-      attr_reader :verifier
+      attr_reader :gated_receiver, :test_case_index, :verifier
     end
   end
 end

data/lib/cucumber/filters.rb

@@ -11,3 +11,4 @@ require 'cucumber/filters/quit'
 require 'cucumber/filters/randomizer'
 require 'cucumber/filters/retry'
 require 'cucumber/filters/tag_limits'
+require 'cucumber/filters/broadcast_test_case_ready_event'

data/lib/cucumber/formatter/ansicolor.rb

@@ -3,28 +3,48 @@
 require 'cucumber/platform'
 require 'cucumber/term/ansicolor'
 
-if Cucumber::WINDOWS_MRI
-  unless ENV['ANSICON']
-    STDERR.puts %{*** WARNING: You must use ANSICON 1.31 or higher (https://github.com/adoxa/ansicon/) to get coloured output on Windows}
-    Cucumber::Term::ANSIColor.coloring = false
-  end
-end
-
-Cucumber::Term::ANSIColor.coloring = false if !STDOUT.tty? && !ENV.key?('AUTOTEST')
+Cucumber::Term::ANSIColor.coloring = false if !$stdout.tty? && !ENV.key?('AUTOTEST')
 
 module Cucumber
   module Formatter
-    # Defines aliases for coloured output. You don't invoke any methods from this
-    # module directly, but you can change the output colours by defining
-    # a <tt>CUCUMBER_COLORS</tt> variable in your shell, very much like how you can
-    # tweak the familiar POSIX command <tt>ls</tt> with
-    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    # This module allows to format cucumber related outputs using ANSI escape sequences.
+    #
+    # For example, it provides a `passed` method which returns the string with
+    # the ANSI escape sequence to format it green per default.
+    #
+    # To use this, include or extend it in your class.
+    #
+    # Example:
+    #
+    #   require 'cucumber/formatter/ansicolor'
+    #
+    #   class MyFormatter
+    #     extend Cucumber::Term::ANSIColor
+    #
+    #     def on_test_step_finished(event)
+    #       $stdout.puts undefined(event.test_step) if event.result.undefined?
+    #       $stdout.puts passed(event.test_step) if event.result.passed?
+    #     end
+    #   end
+    #
+    # This module also allows the user to customize the format of cucumber outputs
+    # using environment variables.
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green.
+    #
+    # Example:
+    #
+    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
     #
     # The colours that you can change are:
     #
     # * <tt>undefined</tt>     - defaults to <tt>yellow</tt>
     # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
     # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>flaky</tt>         - defaults to <tt>yellow</tt>
+    # * <tt>flaky_param</tt>   - defaults to <tt>yellow,bold</tt>
     # * <tt>failed</tt>        - defaults to <tt>red</tt>
     # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
     # * <tt>passed</tt>        - defaults to <tt>green</tt>
@@ -36,48 +56,45 @@ module Cucumber
     # * <tt>comment</tt>       - defaults to <tt>grey</tt>
     # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
     #
-    # For instance, if your shell has a black background and a green font (like the
-    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
-    # steps to be white instead of green.
-    #
-    # Although not listed, you can also use <tt>grey</tt>.
-    #
-    # Examples: (On Windows, use SET instead of export.)
-    #
-    #   export CUCUMBER_COLORS="passed=white"
-    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
-    #
     # To see what colours and effects are available, just run this in your shell:
     #
-    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Cucumber::Term::ANSIColor.attributes"
+    #   ruby -e "require 'rubygems'; require 'cucumber/term/ansicolor'; puts Cucumber::Term::ANSIColor.attributes"
     #
     module ANSIColor
       include Cucumber::Term::ANSIColor
 
+      # :stopdoc:
       ALIASES = Hash.new do |h, k|
-        if k.to_s =~ /(.*)_param/
-          h[$1] + ',bold'
-        end
-      end.merge({
-                  'undefined' => 'yellow',
-                  'pending'   => 'yellow',
-                  'flaky'     => 'yellow',
-                  'failed'    => 'red',
-                  'passed'    => 'green',
-                  'outline'   => 'cyan',
-                  'skipped'   => 'cyan',
-                  'comment'   => 'grey',
-                  'tag'       => 'cyan'
-                })
+        next unless k.to_s =~ /(.*)_param/
 
-      if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"
-        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+        "#{h[Regexp.last_match(1)]},bold"
+      end.merge(
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'flaky'     => 'yellow',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comment'   => 'grey',
+        'tag'       => 'cyan'
+      )
+      # :startdoc:
+
+      # Apply the custom color scheme
+      #
+      # example:
+      #
+      #   apply_custom_colors('passed=white')
+      def apply_custom_colors(colors)
+        colors.split(':').each do |pair|
           a = pair.split('=')
           ALIASES[a[0]] = a[1]
         end
       end
+      apply_custom_colors(ENV['CUCUMBER_COLORS']) if ENV['CUCUMBER_COLORS']
 
-      # Eval to define the color-named methods required by Term::ANSIColor.
+      # Define the color-named methods required by Term::ANSIColor.
       #
       # Examples:
       #
@@ -89,56 +106,18 @@ module Cucumber
       #     red(bold(string, &proc)) + red
       #   end
       ALIASES.each_key do |method_name|
-        unless method_name =~ /.*_param/
-          code = <<-EOF
-          def #{method_name}(string=nil, &proc)
-            #{ALIASES[method_name].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name].split(",").length}
-          end
-          # This resets the colour to the non-param colour
-          def #{method_name}_param(string=nil, &proc)
-            #{ALIASES[method_name + '_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name + '_param'].split(",").length} + #{ALIASES[method_name].split(",").join(' + ')}
-          end
-          EOF
-          eval(code)
-        end
-      end
+        next if method_name.end_with?('_param')
 
-      def self.define_grey #:nodoc:
-        begin
-          gem 'genki-ruby-terminfo'
-          require 'terminfo'
-          case TermInfo.default_object.tigetnum('colors')
-          when 0
-            raise "Your terminal doesn't support colours."
-          when 1
-            ::Cucumber::Term::ANSIColor.coloring = false
-            alias grey white
-          when 2..8
-            alias grey white
-          else
-            define_real_grey
-          end
-        rescue Exception => e
-          if e.class.name == 'TermInfo::TermInfoError'
-            STDERR.puts '*** WARNING ***'
-            STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
-            STDERR.puts 'Try setting it to TERM=xterm-256color to get grey colour in output.'
-            STDERR.puts "\n"
-            alias grey white
-          else
-            define_real_grey
-          end
+        define_method(method_name) do |text = nil, &proc|
+          apply_styles(ALIASES[method_name], text, &proc)
         end
-      end
 
-      def self.define_real_grey #:nodoc:
-        define_method :grey do |string|
-          ::Cucumber::Term::ANSIColor.coloring? ? "\e[90m#{string}\e[0m" : string
+        define_method("#{method_name}_param") do |text = nil, &proc|
+          apply_styles(ALIASES["#{method_name}_param"], text, &proc) + apply_styles(ALIASES[method_name])
         end
       end
 
-      define_grey
-
+      # :stopdoc:
       def cukes(n)
         ('(::) ' * n).strip
       end
@@ -154,6 +133,15 @@ module Cucumber
       def yellow_cukes(n)
         blink(yellow(cukes(n)))
       end
+      # :startdoc:
+
+      private
+
+      def apply_styles(styles, text = nil, &proc)
+        styles.split(',').reverse.reduce(text) do |result, method_name|
+          send(method_name, result, &proc)
+        end
+      end
     end
   end
 end

data/lib/cucumber/formatter/ast_lookup.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Formatter
+    class AstLookup
+      def initialize(config)
+        @gherkin_documents = {}
+        @test_case_lookups = {}
+        @test_step_lookups = {}
+        @step_keyword_lookups = {}
+        config.on_event :gherkin_source_parsed, &method(:on_gherkin_source_parsed)
+      end
+
+      def on_gherkin_source_parsed(event)
+        @gherkin_documents[event.gherkin_document.uri] = event.gherkin_document
+      end
+
+      def gherkin_document(uri)
+        @gherkin_documents[uri]
+      end
+
+      def scenario_source(test_case)
+        uri = test_case.location.file
+        @test_case_lookups[uri] ||= TestCaseLookupBuilder.new(gherkin_document(uri)).lookup_hash
+        @test_case_lookups[uri][test_case.location.lines.max]
+      end
+
+      def step_source(test_step)
+        uri = test_step.location.file
+        @test_step_lookups[uri] ||= TestStepLookupBuilder.new(gherkin_document(uri)).lookup_hash
+        @test_step_lookups[uri][test_step.location.lines.min]
+      end
+
+      def snippet_step_keyword(test_step)
+        uri = test_step.location.file
+        document = gherkin_document(uri)
+        dialect = ::Gherkin::Dialect.for(document.feature.language)
+        given_when_then_keywords = [dialect.given_keywords, dialect.when_keywords, dialect.then_keywords].flatten.uniq.reject { |kw| kw == '* ' }
+        keyword_lookup = step_keyword_lookup(uri)
+        keyword = nil
+        node = keyword_lookup[test_step.location.lines.min]
+        while keyword.nil?
+          if given_when_then_keywords.include?(node.keyword)
+            keyword = node.keyword
+            break
+          end
+          break if node.previous_node.nil?
+
+          node = node.previous_node
+        end
+        keyword = dialect.given_keywords.reject { |kw| kw == '* ' }[0] if keyword.nil?
+        Cucumber::Gherkin::I18n.code_keyword_for(keyword)
+      end
+
+      ScenarioSource = Struct.new(:type, :scenario)
+
+      ScenarioOutlineSource = Struct.new(:type, :scenario_outline, :examples, :row)
+
+      StepSource = Struct.new(:type, :step)
+
+      private
+
+      def step_keyword_lookup(uri)
+        @step_keyword_lookups[uri] ||= KeywordLookupBuilder.new(gherkin_document(uri)).lookup_hash
+      end
+
+      class TestCaseLookupBuilder
+        attr_reader :lookup_hash
+
+        def initialize(gherkin_document)
+          @lookup_hash = {}
+          process_scenario_container(gherkin_document.feature)
+        end
+
+        private
+
+        def process_scenario_container(container)
+          container.children.each do |child|
+            if child.respond_to?(:rule) && child.rule
+              process_scenario_container(child.rule)
+            elsif child.respond_to?(:scenario) && child.scenario
+              process_scenario(child)
+            end
+          end
+        end
+
+        def process_scenario(child)
+          if child.scenario.examples.empty?
+            @lookup_hash[child.scenario.location.line] = ScenarioSource.new(:Scenario, child.scenario)
+          else
+            child.scenario.examples.each do |examples|
+              examples.table_body.each do |row|
+                @lookup_hash[row.location.line] = ScenarioOutlineSource.new(:ScenarioOutline, child.scenario, examples, row)
+              end
+            end
+          end
+        end
+      end
+
+      class TestStepLookupBuilder
+        attr_reader :lookup_hash
+
+        def initialize(gherkin_document)
+          @lookup_hash = {}
+          process_scenario_container(gherkin_document.feature)
+        end
+
+        private
+
+        def process_scenario_container(container)
+          container.children.each do |child|
+            if child.respond_to?(:rule) && child.rule
+              process_scenario_container(child.rule)
+            elsif child.respond_to?(:scenario) && child.scenario
+              child.scenario.steps.each do |step|
+                @lookup_hash[step.location.line] = StepSource.new(:Step, step)
+              end
+            elsif !child.background.nil?
+              child.background.steps.each do |step|
+                @lookup_hash[step.location.line] = StepSource.new(:Step, step)
+              end
+            end
+          end
+        end
+      end
+
+      KeywordSearchNode = Struct.new(:keyword, :previous_node)
+
+      class KeywordLookupBuilder
+        attr_reader :lookup_hash
+
+        def initialize(gherkin_document)
+          @lookup_hash = {}
+          process_scenario_container(gherkin_document.feature, nil)
+        end
+
+        private
+
+        def process_scenario_container(container, original_previous_node)
+          container.children.each do |child|
+            previous_node = original_previous_node
+            if child.respond_to?(:rule) && child.rule
+              process_scenario_container(child.rule, original_previous_node)
+            elsif child.respond_to?(:scenario) && child.scenario
+              child.scenario.steps.each do |step|
+                node = KeywordSearchNode.new(step.keyword, previous_node)
+                @lookup_hash[step.location.line] = node
+                previous_node = node
+              end
+            elsif child.respond_to?(:background) && child.background
+              child.background.steps.each do |step|
+                node = KeywordSearchNode.new(step.keyword, previous_node)
+                @lookup_hash[step.location.line] = node
+                previous_node = node
+                original_previous_node = previous_node
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -4,22 +4,25 @@ require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-    @backtrace_filters = %w(
+    @backtrace_filters = %w[
       /vendor/rails
       lib/cucumber
       bin/cucumber:
       lib/rspec
       gems/
+      site_ruby/
       minitest
       test/unit
       .gem/ruby
-      lib/ruby/
       bin/bundle
-    )
+      rdebug-ide
+    ]
 
-    if ::Cucumber::JRUBY
-      @backtrace_filters << 'org/jruby/'
-    end
+    @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_filters << '<internal:' if RUBY_ENGINE == 'truffleruby'
 
     BACKTRACE_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
 
@@ -41,7 +44,7 @@ module Cucumber
         if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']
           # Strip off file locations
           filtered = filtered.map do |line|
-            line =~ /(.*):in `/ ? $1 : line
+            line =~ /(.*):in `/ ? Regexp.last_match(1) : line
           end
         end