cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/lib/cucumber/filters/apply_after_hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Filters
     class ApplyAfterHooks < Core::Filter.new(:hooks)

data/lib/cucumber/filters/apply_after_step_hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/core/filter'
 
 module Cucumber

data/lib/cucumber/filters/apply_around_hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/core/filter'
 
 module Cucumber

data/lib/cucumber/filters/apply_before_hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Filters
     class ApplyBeforeHooks < Core::Filter.new(:hooks)

data/lib/cucumber/filters/broadcast_test_run_started_event.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Filters
+    # Added at the end of the filter chain to broadcast a list of
+    # all of the test cases that have made it through the filters.
+    class BroadcastTestRunStartedEvent < Core::Filter.new(:config)
+      def initialize(config, receiver = nil)
+        super
+        @test_cases = []
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        config.notify :test_run_started, @test_cases
+        @test_cases.map do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        super
+        self
+      end
+    end
+  end
+end

data/lib/cucumber/filters/gated_receiver.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Filters
-
     class GatedReceiver
       def initialize(receiver)
         @receiver = receiver
@@ -20,6 +21,5 @@ module Cucumber
         self
       end
     end
-
   end
 end

data/lib/cucumber/filters/prepare_world.rb

@@ -1,35 +1,31 @@
+# frozen_string_literal: true
+
 require 'cucumber/core/filter'
+require 'cucumber/core/test/location'
 require 'cucumber/running_test_case'
-require 'cucumber/hooks'
 
 module Cucumber
   module Filters
-
     class PrepareWorld < Core::Filter.new(:runtime)
-
       def test_case(test_case)
         CaseFilter.new(runtime, test_case).test_case.describe_to receiver
       end
 
       class CaseFilter
         def initialize(runtime, original_test_case)
-          @runtime, @original_test_case = runtime, original_test_case
+          @runtime = runtime
+          @original_test_case = original_test_case
         end
 
         def test_case
-          init_scenario = Cucumber::Hooks.around_hook(@original_test_case.source) do |continue|
+          init_scenario = Cucumber::Hooks.around_hook do |continue|
             @runtime.begin_scenario(scenario)
             continue.call
             @runtime.end_scenario(scenario)
           end
           around_hooks = [init_scenario] + @original_test_case.around_hooks
 
-          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source) do
-            #no op - legacy format adapter expects a before hooks
-          end
-          steps = [default_hook] + @original_test_case.test_steps
-
-          @original_test_case.with_around_hooks(around_hooks).with_steps(steps)
+          @original_test_case.with_around_hooks(around_hooks).with_steps(@original_test_case.test_steps)
         end
 
         private
@@ -38,8 +34,6 @@ module Cucumber
           @scenario ||= RunningTestCase.new(test_case)
         end
       end
-
     end
-
   end
 end

data/lib/cucumber/filters/quit.rb

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Filters
-
     class Quit
-      def initialize(receiver=nil)
+      def initialize(receiver = nil)
         @receiver = receiver
       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
 
@@ -22,7 +21,5 @@ module Cucumber
         self.class.new(receiver)
       end
     end
-
   end
 end
-

data/lib/cucumber/filters/randomizer.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
 module Cucumber
   module Filters
-
-    # Batches up all test cases, randomizes them, and then sends them on
+    # Batches up all test cases, randomizes them, and then sends them on
     class Randomizer
-      def initialize(seed, receiver=nil)
+      def initialize(seed, receiver = nil)
         @receiver = receiver
         @test_cases = []
         @seed = seed
@@ -29,12 +32,14 @@ module Cucumber
       private
 
       def shuffled_test_cases
-        @test_cases.shuffle(random: Random.new(seed))
+        digester = Digest::SHA2.new(256)
+        @test_cases.map.with_index
+                   .sort_by { |_, index| digester.digest((@seed + index).to_s) }
+                   .map { |test_case, _| test_case }
       end
 
       attr_reader :seed
       private :seed
     end
-
   end
 end

data/lib/cucumber/filters/retry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/filter'
+require 'cucumber/running_test_case'
+require 'cucumber/events'
+
+module Cucumber
+  module Filters
+    class Retry < Core::Filter.new(:configuration)
+      def test_case(test_case)
+        configuration.on_event(:test_case_finished) do |event|
+          next unless retry_required?(test_case, event)
+
+          test_case_counts[test_case] += 1
+          test_case.describe_to(receiver)
+        end
+
+        super
+      end
+
+      private
+
+      def retry_required?(test_case, event)
+        event.test_case == test_case && event.result.failed? && test_case_counts[test_case] < configuration.retry_attempts
+      end
+
+      def test_case_counts
+        @test_case_counts ||= Hash.new { |h, k| h[k] = 0 }
+      end
+    end
+  end
+end

data/lib/cucumber/filters/tag_limits.rb

@@ -1,6 +1,8 @@
-require "cucumber/filters/gated_receiver"
-require "cucumber/filters/tag_limits/test_case_index"
-require "cucumber/filters/tag_limits/verifier"
+# frozen_string_literal: true
+
+require 'cucumber/filters/gated_receiver'
+require 'cucumber/filters/tag_limits/test_case_index'
+require 'cucumber/filters/tag_limits/verifier'
 
 module Cucumber
   module Filters
@@ -11,7 +13,7 @@ module Cucumber
     end
 
     class TagLimits
-      def initialize(tag_limits, receiver=nil)
+      def initialize(tag_limits, receiver = nil)
         @tag_limits = tag_limits
         @gated_receiver = GatedReceiver.new(receiver)
         @test_case_index = TestCaseIndex.new
@@ -40,6 +42,5 @@ module Cucumber
       attr_reader :test_case_index
       attr_reader :verifier
     end
-
   end
 end

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Filters
     class TagLimits
-
       class TestCaseIndex
         def initialize
           @index = Hash.new { |hash, key| hash[key] = [] }
@@ -25,7 +26,6 @@ module Cucumber
 
         attr_accessor :index
       end
-
     end
   end
 end

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Filters
     class TagLimits
-
       class Verifier
         def initialize(tag_limits)
           @tag_limits = tag_limits
@@ -16,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
@@ -27,7 +26,7 @@ module Cucumber
         attr_reader :tag_limits
 
         class Breach
-          INDENT = (" " * 2).freeze
+          INDENT = (' ' * 2).freeze
 
           def initialize(tag_name, limit, locations)
             @tag_name = tag_name
@@ -52,7 +51,6 @@ module Cucumber
           attr_reader :limit
           attr_reader :locations
         end
-
       end
     end
   end

data/lib/cucumber/formatter/ansicolor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/platform'
 require 'cucumber/term/ansicolor'
 
@@ -8,7 +10,7 @@ if Cucumber::WINDOWS_MRI
   end
 end
 
-Cucumber::Term::ANSIColor.coloring = false if !STDOUT.tty? && !ENV.has_key?("AUTOTEST")
+Cucumber::Term::ANSIColor.coloring = false if !STDOUT.tty? && !ENV.key?('AUTOTEST')
 
 module Cucumber
   module Formatter
@@ -52,20 +54,19 @@ module Cucumber
     module ANSIColor
       include Cucumber::Term::ANSIColor
 
-      ALIASES = Hash.new do |h,k|
-        if k.to_s =~ /(.*)_param/
-          h[$1] + ',bold'
-        end
-      end.merge({
+      ALIASES = Hash.new do |h, k|
+        h[Regexp.last_match(1)] + ',bold' if k.to_s =~ /(.*)_param/
+      end.merge(
         'undefined' => 'yellow',
         'pending'   => 'yellow',
+        'flaky'     => 'yellow',
         'failed'    => 'red',
         'passed'    => 'green',
         'outline'   => 'cyan',
         'skipped'   => 'cyan',
         'comment'   => 'grey',
         'tag'       => 'cyan'
-      })
+      )
 
       if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"
         ENV['CUCUMBER_COLORS'].split(':').each do |pair|
@@ -86,62 +87,55 @@ module Cucumber
       #     red(bold(string, &proc)) + red
       #   end
       ALIASES.each_key do |method_name|
-        unless method_name =~ /.*_param/
-          code = <<-EOF
+        next if method_name =~ /.*_param/
+        code = <<-COLOR
           def #{method_name}(string=nil, &proc)
-            #{ALIASES[method_name].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name].split(",").length}
+            #{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(' + ')}
+            #{ALIASES[method_name + '_param'].split(',').join('(') + '(string, &proc' + ')' * ALIASES[method_name + '_param'].split(',').length} + #{ALIASES[method_name].split(',').join(' + ')}
           end
-          EOF
-          eval(code)
-        end
+        COLOR
+        eval(code) # rubocop:disable Security/Eval
       end
 
       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
+        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_method :grey, :white
+        when 2..8
+          alias_method :grey, :white # rubocop:disable Lint/DuplicateMethods
+        else
+          define_real_grey
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        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_method :grey, :white
+        else
+          define_real_grey
         end
       end
 
       def self.define_real_grey #:nodoc:
-        def grey(string) #:nodoc:
-          if ::Cucumber::Term::ANSIColor.coloring?
-            "\e[90m#{string}\e[0m"
-          else
-            string
-          end
+        define_method :grey do |string|
+          ::Cucumber::Term::ANSIColor.coloring? ? "\e[90m#{string}\e[0m" : string
         end
       end
 
       define_grey
 
       def cukes(n)
-        ("(::) " * n).strip
+        ('(::) ' * n).strip
       end
 
       def green_cukes(n)

data/lib/cucumber/formatter/ast_lookup.rb

@@ -0,0 +1,165 @@
+# 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?
+        keyword = Cucumber::Gherkin::I18n.code_keyword_for(keyword)
+        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
+
+        # rubocop:disable Metrics/PerceivedComplexity
+        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
+        # rubocop:enable Metrics/PerceivedComplexity
+      end
+    end
+  end
+end