cucumber 3.0.0.pre.1 → 3.0.0.pre.2

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 module Cucumber
-  module RbSupport
+  module Glue
     module Snippet
 
       ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
@@ -10,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
 
@@ -37,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('/', '\/')
@@ -58,32 +64,62 @@ module Cucumber
 
         def do_block
           do_block = String.new
-          do_block << "do#{arguments}\n"
+          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
 
@@ -93,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
 
@@ -103,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
@@ -122,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
 
@@ -136,7 +173,7 @@ module Cucumber
         end
 
         class DocString
-          def append_block_argument_to(array)
+          def append_block_parameter_to(array)
             array << 'string'
           end
 
@@ -149,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

@@ -23,7 +23,7 @@ module Cucumber
         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
 
@@ -44,7 +44,7 @@ module Cucumber
       end
 
       def name
-        "After hook"
+        'After hook'
       end
 
       def match_locations?(queried_locations)
@@ -64,7 +64,7 @@ module Cucumber
       end
 
       def name
-        "Before hook"
+        'Before hook'
       end
 
       def match_locations?(queried_locations)
@@ -84,7 +84,7 @@ module Cucumber
       end
 
       def name
-        "AfterStep hook"
+        'AfterStep hook'
       end
 
       def match_locations?(queried_locations)

data/lib/cucumber/multiline_argument.rb

@@ -49,11 +49,11 @@ module Cucumber
           @result
         end
 
-        def doc_string(node, *args)
+        def doc_string(node, *_args)
           @result = DocString.new(node)
         end
 
-        def data_table(node, *args)
+        def data_table(node, *_args)
           @result = DataTable.new(node)
         end
       end

data/lib/cucumber/multiline_argument/data_table.rb

@@ -3,6 +3,7 @@ require 'forwardable'
 require 'cucumber/gherkin/data_table_parser'
 require 'cucumber/gherkin/formatter/escaping'
 require 'cucumber/core/ast/describes_itself'
+require 'cucumber/multiline_argument/data_table/diff_matrices'
 
 module Cucumber
   module MultilineArgument
@@ -26,38 +27,10 @@ module Cucumber
     # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
     #
     class DataTable
-      class Different < StandardError
-        def initialize(table)
-          super("Tables were not identical:\n#{table}")
-        end
-      end
-
-      class Builder
-        attr_reader :rows
-
-        def initialize
-          @rows = []
-        end
-
-        def row(row)
-          @rows << row
-        end
-
-        def eof
-        end
-      end
-
-      include Enumerable
       include Core::Ast::DescribesItself
-      extend Forwardable
-
-      NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
-
-      attr_accessor :file
-      def_delegator :@ast_table, :location
 
       def self.default_arg_name #:nodoc:
-        "table"
+        'table'
       end
 
       class << self
@@ -68,11 +41,12 @@ module Cucumber
           when String
             parse(data, location)
           else
-            raise ArgumentError, "expected data to be a String or an Array."
+            raise ArgumentError, 'expected data to be a String or an Array.'
           end
         end
 
         private
+
         def parse(text, location = Core::Ast::Location.of_caller)
           builder = Builder.new
           parser = Cucumber::Gherkin::DataTableParser.new(builder)
@@ -85,13 +59,30 @@ module Cucumber
         end
       end
 
+      class Builder
+        attr_reader :rows
+
+        def initialize
+          @rows = []
+        end
+
+        def row(row)
+          @rows << row
+        end
+
+        def eof
+        end
+      end
+
+
+      NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
 
       # @param data [Core::Ast::DataTable] the data for the table
       # @param conversion_procs [Hash] see map_columns!
       # @param header_mappings [Hash] see map_headers!
       # @param header_conversion_proc [Proc] see map_headers!
       def initialize(data, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil)
-        raise ArgumentError, "data must be a Core::Ast::DataTable" unless data.kind_of? Core::Ast::DataTable
+        raise ArgumentError, 'data must be a Core::Ast::DataTable' unless data.kind_of? Core::Ast::DataTable
         ast_table = data
         # Verify that it's square
         ast_table.transpose
@@ -110,6 +101,12 @@ module Cucumber
         dup
       end
 
+      attr_accessor :file
+
+      def location
+        @ast_table.location
+      end
+
       # Creates a copy of this table, inheriting any column and header mappings
       # registered with #map_column! and #map_headers!.
       #
@@ -337,80 +334,22 @@ module Cucumber
       # a Table argument, if you want to compare that table to some actual values.
       #
       def diff!(other_table, options={})
-        options = {
-          :missing_row   => true,
-          :surplus_row   => true,
-          :missing_col   => true,
-          :surplus_col   => false,
-          :misplaced_col => false
-        }.merge(options)
-
         other_table = ensure_table(other_table)
         other_table.convert_headers!
         other_table.convert_columns!
-        ensure_green!
 
         convert_headers!
         convert_columns!
 
-        original_width = cell_matrix[0].length
-        @cell_matrix, other_table_cell_matrix = pad_and_match(@cell_matrix, other_table.cell_matrix)
-        padded_width = cell_matrix[0].length
-
-        missing_col = cell_matrix[0].detect{|cell| cell.status == :undefined}
-        surplus_col = padded_width > original_width
-        misplaced_col = cell_matrix[0] != other_table.cell_matrix[0]
-
-        require_diff_lcs
-        cell_matrix.extend(Diff::LCS)
-        changes = cell_matrix.diff(other_table_cell_matrix).flatten
-
-        inserted = 0
-        missing  = 0
-
-        row_indices = Array.new(other_table_cell_matrix.length) {|n| n}
-
-        last_change = nil
-        missing_row_pos = nil
-        insert_row_pos  = 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 && last_change.action == '-'
-            inserted += 1
-          end
-          last_change = change
-        end
+        DiffMatrices.new(cell_matrix, other_table.cell_matrix, options).call
+      end
 
-        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
-          if 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
+      class Different < StandardError
+        attr_reader :table
+        def initialize(table)
+          @table = table
+          super("Tables were not identical:\n#{table}")
         end
-
-        clear_cache!
-        should_raise =
-          missing_row_pos && options[:missing_row] ||
-          insert_row_pos  && options[:surplus_row] ||
-          missing_col     && options[:missing_col] ||
-          surplus_col     && options[:surplus_col] ||
-          misplaced_col   && options[:misplaced_col]
-        raise Different.new(self) if should_raise
       end
 
       def to_hash(cells) #:nodoc:
@@ -453,9 +392,7 @@ module Cucumber
         cells_rows[0][col]
       end
 
-      def cell_matrix #:nodoc:
-        @cell_matrix
-      end
+      attr_reader :cell_matrix
 
       def col_width(col) #:nodoc:
         columns[col].__send__(:width)
@@ -476,7 +413,7 @@ module Cucumber
         Formatter::LegacyApi::Ast::MultilineArg.for(self).accept(Formatter::Fanout.new([formatter]))
         Cucumber::Term::ANSIColor.coloring = c
         io.rewind
-        s = "\n" + io.read + (" " * (options[:indent] - 2))
+        s = "\n" + io.read + (' ' * (options[:indent] - 2))
         s
       end
 
@@ -494,11 +431,10 @@ module Cucumber
         raw.to_json(*args)
       end
 
-      private
-
       TO_S_PREFIXES = Hash.new('    ')
       TO_S_PREFIXES[:comment]   = '(+) '
       TO_S_PREFIXES[:undefined] = '(-) '
+      private_constant :TO_S_PREFIXES
 
       protected
 
@@ -510,16 +446,6 @@ module Cucumber
         end
       end
 
-      def inspect_rows(missing_row, inserted_row) #:nodoc:
-        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 create_cell_matrix(ast_table) #:nodoc:
         ast_table.raw.map do |raw_row|
           line = raw_row.line rescue -1
@@ -556,85 +482,21 @@ module Cucumber
           raise "No headers matched #{pre.inspect}" if mapped_cells.empty?
           raise "#{mapped_cells.length} headers matched #{pre.inspect}: #{mapped_cells.map { |c| c.value }.inspect}" if mapped_cells.length > 1
           mapped_cells[0].value = post
-          if @conversion_procs.has_key?(pre)
+          if @conversion_procs.key?(pre)
             @conversion_procs[post] = @conversion_procs.delete(pre)
           end
         end
       end
 
-      def require_diff_lcs #:nodoc:
-        begin
-          require 'diff/lcs'
-        rescue LoadError => e
-          e.message << "\n Please gem install diff-lcs\n"
-          raise e
-        end
-      end
-
       def clear_cache! #:nodoc:
         @hashes = @rows_hash = @col_names = @rows = @columns = nil
       end
 
-      # Pads two cell matrices to same column width and matches columns according to header value.
-      # The first cell matrix is the reference matrix with the second matrix matched against it.
-      def pad_and_match(a_cell_matrix, other_cell_matrix) #:nodoc:
-        clear_cache!
-        cols = a_cell_matrix.transpose
-        unmatched_cols = other_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 = other_cell_matrix.collect {SurplusCell.new(nil, self, -1)}
-            empty_col.first.value = v
-            matched_cols << empty_col
-          end
-        end
-
-
-        empty_col = cell_matrix.collect {SurplusCell.new(nil, self, -1)}
-        unmatched_cols.each do
-          cols << empty_col
-        end
-
-        return cols.transpose, (matched_cols + unmatched_cols).transpose
-      end
-
       def ensure_table(table_or_array) #:nodoc:
         return table_or_array if DataTable === table_or_array
         DataTable.from(table_or_array)
       end
 
-      def ensure_array_of_array(array)
-        Hash === array[0] ? hashes_to_array(array) : array
-      end
-
-      def hashes_to_array(hashes) #:nodoc:
-        header = hashes[0].keys.sort
-        [header] + hashes.map{|hash| header.map{|key| hash[key]}}
-      end
-
-      def ensure_green! #:nodoc:
-        each_cell{|cell| cell.status = :passed}
-      end
-
-      def each_cell(&proc) #:nodoc:
-        cell_matrix.each{|row| row.each(&proc)}
-      end
-
-      def mark_as_missing(col) #:nodoc:
-        col.each do |cell|
-          cell.status = :undefined
-        end
-      end
-
       def symbolize_key(key)
         key.downcase.tr(' ', '_').to_sym
       end
@@ -733,7 +595,7 @@ module Cucumber
           :comment
         end
 
-        def ==(o)
+        def ==(_o)
           true
         end