cucumber 2.99.0 → 3.0.0

data/lib/cucumber/{rb_support → glue}/snippet.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Cucumber
-  module RbSupport
+  module Glue
     module Snippet
 
       ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
@@ -9,22 +11,27 @@ module Cucumber
           configuration.snippet_generators << new
         end
 
-        def call(code_keyword, step_name, multiline_arg, snippet_type = :regexp)
+        def initialize(cucumber_expression_generator)
+          @cucumber_expression_generator = cucumber_expression_generator
+        end
+
+        def call(code_keyword, step_name, multiline_arg, snippet_type)
           snippet_class = typed_snippet_class(snippet_type)
-          snippet_class.new(code_keyword, step_name, multiline_arg).to_s
+          snippet_class.new(@cucumber_expression_generator, code_keyword, step_name, multiline_arg).to_s
         end
 
         def typed_snippet_class(type)
-          SNIPPET_TYPES.fetch(type || :regexp)
+          SNIPPET_TYPES.fetch(type || :cucumber_expression)
         end
       end
 
       class BaseSnippet
 
-        def initialize(code_keyword, pattern, multiline_argument)
+        def initialize(cucumber_expression_generator, code_keyword, step_name, multiline_argument)
           @number_of_arguments = 0
           @code_keyword = code_keyword
-          @pattern = replace_and_count_capturing_groups(pattern)
+          @pattern = replace_and_count_capturing_groups(step_name)
+          @generated_expressions = cucumber_expression_generator.generate_expressions(step_name)
           @multiline_argument = MultilineArgumentSnippet.new(multiline_argument)
         end
 
@@ -36,13 +43,13 @@ module Cucumber
           "#{code_keyword}#{typed_pattern}"
         end
 
-        def self.cli_option_string(type)
-          "%-7s: %-28s e.g. %s" % [type, description, example]
+        def self.cli_option_string(type, cucumber_expression_generator)
+          format('%-7s: %-28s e.g. %s', type, description, example(cucumber_expression_generator))
         end
 
         private
 
-        attr_reader :code_keyword, :pattern, :multiline_argument, :number_of_arguments
+        attr_reader :code_keyword, :pattern, :generated_expressions, :multiline_argument, :number_of_arguments
 
         def replace_and_count_capturing_groups(pattern)
           modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
@@ -56,33 +63,63 @@ module Cucumber
         end
 
         def do_block
-          do_block = ""
-          do_block << "do#{arguments}\n"
+          do_block = String.new
+          do_block << "do#{parameters}\n"
           multiline_argument.append_comment_to(do_block)
           do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
-          do_block << "end"
+          do_block << 'end'
           do_block
         end
 
-        def arguments
+        def parameters
           block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
-          multiline_argument.append_block_argument_to(block_args)
-          block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+          multiline_argument.append_block_parameter_to(block_args)
+          block_args.empty? ? '' : " |#{block_args.join(", ")}|"
         end
 
-        def self.example
-          new("Given", "missing step", MultilineArgument::None.new).step
+        def self.example(cucumber_expression_generator)
+          new(cucumber_expression_generator, 'Given', 'I have 2 cukes', MultilineArgument::None.new).step
         end
 
       end
 
+      class CucumberExpression < BaseSnippet
+        def typed_pattern
+          "(\"#{generated_expressions[0].source}\")"
+        end
+
+        def to_s
+          header = generated_expressions.each_with_index.map do |expr, i|
+            prefix = i == 0 ? '' : '# '
+            "#{prefix}#{code_keyword}(\"#{expr.source}\") do#{parameters(expr)}"
+          end.join("\n")
+
+          body = String.new
+          multiline_argument.append_comment_to(body)
+          body << "  pending # Write code here that turns the phrase above into concrete actions\n"
+          body << 'end'
+
+          "#{header}\n#{body}"
+        end
+
+        def parameters(expr)
+          parameter_names = expr.parameter_names
+          multiline_argument.append_block_parameter_to(parameter_names)
+          parameter_names.empty? ? '' : " |#{parameter_names.join(", ")}|"
+        end
+
+        def self.description
+          'Cucumber Expressions'
+        end
+      end
+
       class Regexp < BaseSnippet
         def typed_pattern
           "(/^#{pattern}$/)"
         end
 
         def self.description
-          "Snippets with parentheses"
+          'Snippets with parentheses'
         end
       end
 
@@ -92,7 +129,7 @@ module Cucumber
         end
 
         def self.description
-          "Snippets without parentheses. Note that these cause a warning from modern versions of Ruby."
+          'Snippets without parentheses. Note that these cause a warning from modern versions of Ruby.'
         end
       end
 
@@ -102,11 +139,12 @@ module Cucumber
         end
 
         def self.description
-          "Snippets with percent regexp"
+          'Snippets with percent regexp'
         end
       end
 
       SNIPPET_TYPES = {
+        :cucumber_expression => CucumberExpression,
         :regexp => Regexp,
         :classic => Classic,
         :percent => Percent
@@ -121,11 +159,11 @@ module Cucumber
         end
 
         class Builder
-          def doc_string(*args)
+          def doc_string(*_args)
             @result = DocString.new
           end
 
-          def data_table(table, *args)
+          def data_table(table, *_args)
             @result = DataTable.new(table)
           end
 
@@ -135,7 +173,7 @@ module Cucumber
         end
 
         class DocString
-          def append_block_argument_to(array)
+          def append_block_parameter_to(array)
             array << 'string'
           end
 
@@ -148,17 +186,17 @@ module Cucumber
             @table = table
           end
 
-          def append_block_argument_to(array)
+          def append_block_parameter_to(array)
             array << 'table'
           end
 
           def append_comment_to(string)
-            string << "  # table is a #{Cucumber::MultilineArgument::DataTable.to_s}\n"
+            string << "  # table is a #{Cucumber::MultilineArgument::DataTable}\n"
           end
         end
 
         class None
-          def append_block_argument_to(array)
+          def append_block_parameter_to(array)
           end
 
           def append_comment_to(string)

data/lib/cucumber/glue/step_definition.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+require 'cucumber/step_match'
+require 'cucumber/step_argument'
+require 'cucumber/core_ext/string'
+require 'cucumber/glue/invoke_in_world'
+
+module Cucumber
+  module Glue
+    # A Step Definition holds a Regexp pattern and a Proc, and is
+    # typically created by calling {Dsl#register_rb_step_definition Given, When or Then}
+    # in the step_definitions Ruby files.
+    #
+    # Example:
+    #
+    #   Given /I have (\d+) cucumbers in my belly/ do
+    #     # some code here
+    #   end
+    #
+    class StepDefinition
+
+      class MissingProc < StandardError
+        def message
+          'Step definitions must always have a proc or symbol'
+        end
+      end
+
+      class << self
+        def new(registry, string_or_regexp, proc_or_sym, options)
+          raise MissingProc if proc_or_sym.nil?
+          super registry, registry.create_expression(string_or_regexp), create_proc(proc_or_sym, options)
+        end
+
+        private
+
+        def create_proc(proc_or_sym, options)
+          return proc_or_sym if proc_or_sym.is_a?(Proc)
+          raise ArgumentError unless proc_or_sym.is_a?(Symbol)
+          message = proc_or_sym
+          target_proc = parse_target_proc_from(options)
+          patch_location_onto lambda { |*args|
+            target = instance_exec(&target_proc)
+            target.send(message, *args)
+          }
+        end
+
+        def patch_location_onto(block)
+          location = Core::Ast::Location.of_caller(5)
+          block.define_singleton_method(:source_location) { [location.file, location.line] }
+          block
+        end
+
+        def parse_target_proc_from(options)
+          return lambda { self } unless options.key?(:on)
+          target = options[:on]
+          case target
+          when Proc
+            target
+          when Symbol
+            lambda { self.send(target) }
+          else
+            lambda { raise ArgumentError, 'Target must be a symbol or a proc' }
+          end
+        end
+      end
+
+      attr_reader :expression
+
+      def initialize(registry, expression, proc)
+        raise 'No regexp' if expression.is_a?(Regexp)
+        @registry, @expression, @proc = registry, expression, proc
+        # @registry.available_step_definition(regexp_source, location)
+      end
+
+      # @api private
+      def to_hash
+        type = expression.is_a?(CucumberExpressions::RegularExpression) ? 'regular expression' : 'cucumber expression'
+        regexp = expression.regexp
+        flags = ''
+        flags += 'm' if (regexp.options & Regexp::MULTILINE) != 0
+        flags += 'i' if (regexp.options & Regexp::IGNORECASE) != 0
+        flags += 'x' if (regexp.options & Regexp::EXTENDED) != 0
+        {
+          source: {
+            type: type,
+            expression: expression.source
+          },
+          regexp: {
+            source: regexp.source,
+            flags: flags
+          }
+        }
+      end
+
+      # @api private
+      def ==(step_definition)
+        expression.source == step_definition.expression.source
+      end
+
+      # @api private
+      def arguments_from(step_name)
+        args = @expression.match(step_name)
+        # @registry.invoked_step_definition(regexp_source, location) if args
+        args
+      end
+
+      # @api private
+      # TODO: inline this and step definition just be a value object
+      def invoke(args)
+        begin
+          InvokeInWorld.cucumber_instance_exec_in(@registry.current_world, true, @expression.to_s, *args, &@proc)
+        rescue ArityMismatchError => e
+          e.backtrace.unshift(self.backtrace_line)
+          raise e
+        end
+      end
+
+      # @api private
+      def backtrace_line
+        "#{location}:in `#{@expression}'"
+      end
+
+      # @api private
+      def file_colon_line
+        case @proc
+        when Proc
+          location.to_s
+        when Symbol
+          ":#{@proc}"
+        end
+      end
+
+      # The source location where the step defintion can be found
+      def location
+        @location ||= Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
+      end
+
+      # @api private
+      def file
+        @file ||= location.file
+      end
+    end
+  end
+end

data/lib/cucumber/glue/world_factory.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Glue
+
+    class WorldFactory
+      def initialize(proc)
+        @proc = proc || -> { Object.new }
+      end
+
+      def create_world
+        @proc.call || raise_nil_world
+      end
+
+      def raise_nil_world
+        raise NilWorld.new
+      rescue NilWorld => e
+        e.backtrace.clear
+        e.backtrace.push(Glue.backtrace_line(@proc, 'World'))
+        raise e
+      end
+    end
+
+  end
+end

data/lib/cucumber/hooks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'pathname'
 require 'cucumber/core/ast/location'
 require 'cucumber/core/test/around_hook'
@@ -18,11 +19,11 @@ module Cucumber
       end
 
       def after_step_hook(source, location, &block)
-        raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
+        raise ArgumentError unless source.last.is_a?(Core::Ast::Step)
         build_hook_step(source, location, block, AfterStepHook, Core::Test::Action)
       end
 
-      def around_hook(source, &block)
+      def around_hook(_source, &block)
         Core::Test::AroundHook.new(&block)
       end
 
@@ -42,8 +43,8 @@ module Cucumber
         @location = location
       end
 
-      def name
-        "After hook"
+      def text
+        'After hook'
       end
 
       def match_locations?(queried_locations)
@@ -62,8 +63,8 @@ module Cucumber
         @location = location
       end
 
-      def name
-        "Before hook"
+      def text
+        'Before hook'
       end
 
       def match_locations?(queried_locations)
@@ -82,8 +83,8 @@ module Cucumber
         @location = location
       end
 
-      def name
-        "AfterStep hook"
+      def text
+        'AfterStep hook'
       end
 
       def match_locations?(queried_locations)

data/lib/cucumber/load_path.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Cucumber
   module LoadPath
     def add_dirs(*dirs)

data/lib/cucumber/multiline_argument/data_table/diff_matrices.rb

@@ -0,0 +1,158 @@
+module Cucumber
+  module MultilineArgument
+    class DataTable
+      class DiffMatrices #:nodoc:
+        attr_accessor :cell_matrix, :other_table_cell_matrix, :options
+
+        def initialize(cell_matrix, other_table_cell_matrix, options)
+          @cell_matrix = cell_matrix
+          @other_table_cell_matrix = other_table_cell_matrix
+          @options = options
+        end
+
+        def call
+          prepare_diff
+          perform_diff
+          fill_in_missing_values
+          raise_error if should_raise?
+        end
+
+        private
+
+        attr_reader :row_indices, :original_width, :original_header, :padded_width, :missing_row_pos, :insert_row_pos
+
+        def prepare_diff
+          @original_width = cell_matrix[0].length
+          @original_header = other_table_cell_matrix[0]
+          pad_and_match
+          @padded_width = cell_matrix[0].length
+          @row_indices = Array.new(other_table_cell_matrix.length) {|n| n}
+        end
+
+        # Pads two cell matrices to same column width and matches columns according to header value.
+        def pad_and_match
+          cols = cell_matrix.transpose
+          unmatched_cols = other_table_cell_matrix.transpose
+
+          header_values = cols.map(&:first)
+          matched_cols = []
+
+          header_values.each_with_index do |v, i|
+            mapped_index = unmatched_cols.index{|unmapped_col| unmapped_col.first == v}
+            if mapped_index
+              matched_cols << unmatched_cols.delete_at(mapped_index)
+            else
+              mark_as_missing(cols[i])
+              empty_col = ensure_2d(other_table_cell_matrix).collect {SurplusCell.new(nil, self, -1)}
+              empty_col.first.value = v
+              matched_cols << empty_col
+            end
+          end
+
+          unmatched_cols.each do
+            empty_col = cell_matrix.collect {SurplusCell.new(nil, self, -1)}
+            cols << empty_col
+          end
+
+          self.cell_matrix = ensure_2d(cols.transpose)
+          self.other_table_cell_matrix = ensure_2d((matched_cols + unmatched_cols).transpose)
+        end
+
+        def mark_as_missing(col)
+          col.each do |cell|
+            cell.status = :undefined
+          end
+        end
+
+        def ensure_2d(array)
+          array[0].is_a?(Array) ? array : [array]
+        end
+
+
+        def perform_diff
+          inserted    = 0
+          missing     = 0
+          last_change = nil
+
+          changes.each do |change|
+            if change.action == '-'
+              @missing_row_pos = change.position + inserted
+              cell_matrix[missing_row_pos].each{|cell| cell.status = :undefined}
+              row_indices.insert(missing_row_pos, nil)
+              missing += 1
+            else # '+'
+              @insert_row_pos = change.position + missing
+              inserted_row = change.element
+              inserted_row.each{|cell| cell.status = :comment}
+              cell_matrix.insert(insert_row_pos, inserted_row)
+              row_indices[insert_row_pos] = nil
+              inspect_rows(cell_matrix[missing_row_pos], inserted_row) if last_change == '-'
+              inserted += 1
+            end
+            last_change = change.action
+          end
+        end
+
+        def changes
+          require 'diff/lcs'
+          diffable_cell_matrix = cell_matrix.dup.extend(::Diff::LCS)
+          diffable_cell_matrix.diff(other_table_cell_matrix).flatten
+        end
+
+        def inspect_rows(missing_row, inserted_row)
+          missing_row.each_with_index do |missing_cell, col|
+            inserted_cell = inserted_row[col]
+            if missing_cell.value != inserted_cell.value && missing_cell.value.to_s == inserted_cell.value.to_s
+              missing_cell.inspect!
+              inserted_cell.inspect!
+            end
+          end
+        end
+
+
+        def fill_in_missing_values
+          other_table_cell_matrix.each_with_index do |other_row, i|
+            row_index = row_indices.index(i)
+            row = cell_matrix[row_index] if row_index
+            next unless row
+            (original_width..padded_width).each do |col_index|
+              surplus_cell = other_row[col_index]
+              row[col_index].value = surplus_cell.value if row[col_index]
+            end
+          end
+        end
+
+        def missing_col
+          cell_matrix[0].find{|cell| cell.status == :undefined}
+        end
+
+        def surplus_col
+          padded_width > original_width
+        end
+
+        def misplaced_col
+          cell_matrix[0] != original_header
+        end
+
+
+        def raise_error
+          table = DataTable.from([[]])
+          table.instance_variable_set :@cell_matrix, cell_matrix
+          raise Different.new(table) if should_raise?
+        end
+
+        def should_raise?
+          [
+            missing_row_pos && options.fetch(:missing_row, true),
+            insert_row_pos  && options.fetch(:surplus_row, true),
+            missing_col     && options.fetch(:missing_col, true),
+            surplus_col     && options.fetch(:surplus_col, false),
+            misplaced_col   && options.fetch(:misplaced_col, false)
+          ].any?
+        end
+      end
+      private_constant :DiffMatrices
+    end
+  end
+end
+