cucumber 3.1.2 → 5.1.3

data/lib/cucumber/events/test_step_created.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Event fired when a TestStep is created from a PickleStep
+    class TestStepCreated < Core::Event.new(:test_step, :pickle_step)
+      attr_reader :test_step
+      attr_reader :pickle_step
+    end
+  end
+end

data/lib/cucumber/events/undefined_parameter_type.rb

@@ -0,0 +1,10 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    class UndefinedParameterType < Core::Event.new(:type_name, :expression)
+      attr_reader :type_name
+      attr_reader :expression
+    end
+  end
+end

data/lib/cucumber/file_specs.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'cucumber'
-require 'cucumber/core/ast/location'
+require 'cucumber/core/test/location'
 
 module Cucumber
   class FileSpecs
@@ -9,7 +9,7 @@ module Cucumber
 
     def initialize(file_specs)
       Cucumber.logger.debug("Features:\n")
-      @file_specs = file_specs.map { |s| FileSpec.new(s) }
+      @file_specs = file_specs.map { |spec| FileSpec.new(spec) }
       Cucumber.logger.debug("\n")
     end
 
@@ -22,8 +22,8 @@ module Cucumber
     end
 
     class FileSpec
-      def initialize(s)
-        @file, @lines = *FILE_COLON_LINE_PATTERN.match(s).captures
+      def initialize(spec)
+        @file, @lines = *FILE_COLON_LINE_PATTERN.match(spec).captures
         Cucumber.logger.debug("  * #{@file}\n")
         @lines = String(@lines).split(':').map { |line| Integer(line) }
       end
@@ -31,8 +31,8 @@ module Cucumber
       attr_reader :file
 
       def locations
-        return [Core::Ast::Location.new(@file)] if @lines.empty?
-        @lines.map { |line| Core::Ast::Location.new(@file, line) }
+        return [Core::Test::Location.new(@file)] if @lines.empty?
+        @lines.map { |line| Core::Test::Location.new(@file, line) }
       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/filters/activate_steps.rb

@@ -26,7 +26,7 @@ module Cucumber
         private
 
         def new_test_steps
-          @original_test_case.test_steps.map(&self.method(:attempt_to_activate))
+          @original_test_case.test_steps.map(&method(:attempt_to_activate))
         end
 
         def attempt_to_activate(test_step)
@@ -39,12 +39,14 @@ module Cucumber
 
         class FindMatch
           def initialize(step_match_search, configuration, test_step)
-            @step_match_search, @configuration, @test_step = step_match_search, configuration, test_step
+            @step_match_search = step_match_search
+            @configuration = configuration
+            @test_step = test_step
           end
 
           def result
             begin
-              return NoStepMatch.new(test_step.source.last, test_step.text) unless matches.any?
+              return NoStepMatch.new(test_step, test_step.text) unless matches.any?
             rescue Cucumber::Ambiguous => e
               return AmbiguousStepMatch.new(e)
             end

data/lib/cucumber/filters/broadcast_test_case_ready_event.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Filters
+    class BroadcastTestCaseReadyEvent < Core::Filter.new(:config)
+      def test_case(test_case)
+        config.notify :test_case_ready, test_case
+        test_case.describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/prepare_world.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'cucumber/core/filter'
-require 'cucumber/core/ast/location'
+require 'cucumber/core/test/location'
 require 'cucumber/running_test_case'
 
 module Cucumber
@@ -13,23 +13,19 @@ module Cucumber
 
       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
 
-          empty_hook = proc {} # no op - legacy format adapter expects a before hooks
-          empty_hook_location = Cucumber::Core::Ast::Location.from_source_location(*empty_hook.source_location)
-          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source, empty_hook_location, &empty_hook)
-          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

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

data/lib/cucumber/formatter/ansicolor.rb

@@ -55,20 +55,18 @@ module Cucumber
       include Cucumber::Term::ANSIColor
 
       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'
-                })
+        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|
@@ -89,45 +87,42 @@ 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
 

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?
+        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
+
+        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,23 @@ 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
-    )
+    ]
 
-    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_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
 
@@ -31,7 +32,7 @@ module Cucumber
       def exception
         return @exception if ::Cucumber.use_full_backtrace
 
-        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m
+        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|
@@ -41,7 +42,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