cucumber 2.0.0.rc.4 → 4.0.0.rc.2

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

@@ -0,0 +1,154 @@
+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, 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

data/lib/cucumber/multiline_argument/doc_string.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Cucumber
   module MultilineArgument
     class DocString < SimpleDelegator
       def append_to(array)
-        array << self
+        array << to_s
       end
     end
   end
 end
-

data/lib/cucumber/platform.rb

@@ -1,28 +1,25 @@
+# frozen_string_literal: true
+
 # Detect the platform we're running on so we can tweak behaviour
 # in various places.
 require 'rbconfig'
+require 'cucumber/core/platform'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0.rc.4'
+    VERSION       = File.read(File.expand_path('version', __dir__))
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
-    JRUBY         = defined?(JRUBY_VERSION)
-    WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-    OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
-    WINDOWS_MRI   = WINDOWS && !JRUBY
     RAILS         = defined?(Rails)
     RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-    RUBY_2_1      = RUBY_VERSION =~ /^2\.1/
-    RUBY_2_0      = RUBY_VERSION =~ /^2\.0/
-    RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+    RUBY          = defined? RUBY_VERSION
 
     class << self
       attr_accessor :use_full_backtrace
 
       # @private
-      def file_mode(m, encoding="UTF-8")
-        "#{m}:#{encoding}"
+      def file_mode(mode, encoding = 'UTF-8')
+        "#{mode}:#{encoding}"
       end
     end
     self.use_full_backtrace = false

data/lib/cucumber/project_initializer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Cucumber
+  # Generates generic file structure for a cucumber project
+  class ProjectInitializer
+    def run
+      create_directory('features')
+      create_directory('features/step_definitions')
+      create_directory('features/support')
+      create_file('features/support/env.rb')
+    end
+
+    private
+
+    def create_directory(dir_name)
+      create_directory_or_file dir_name, true
+    end
+
+    def create_file(file_name)
+      create_directory_or_file file_name, false
+    end
+
+    def create_directory_or_file(file_name, directory)
+      file_type = if directory
+                    :mkdir_p
+                  else
+                    :touch
+                  end
+
+      report_exists(file_name) || return if File.exist?(file_name)
+
+      report_creating(file_name)
+      FileUtils.send file_type, file_name
+    end
+
+    def report_exists(file)
+      puts "   exist   #{file}"
+    end
+
+    def report_creating(file)
+      puts "  create   #{file}"
+    end
+  end
+end

data/lib/cucumber/rake/task.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require 'cucumber/platform'
-require 'gherkin/formatter/ansi_escapes'
+require 'cucumber/gherkin/formatter/ansi_escapes'
 begin
   # Support Rake > 0.8.7
   require 'rake/dsl_definition'
+  # rubocop:disable Lint/HandleExceptions
 rescue LoadError
+  # rubocop:enable Lint/HandleExceptions
 end
 
 module Cucumber
@@ -25,7 +29,7 @@ module Cucumber
     #
     # See the attributes for additional configuration possibilities.
     class Task
-      include Gherkin::Formatter::AnsiEscapes
+      include Cucumber::Gherkin::Formatter::AnsiEscapes
       include ::Rake::DSL if defined?(::Rake::DSL)
 
       class InProcessCucumberRunner #:nodoc:
@@ -34,8 +38,8 @@ module Cucumber
         attr_reader :args
 
         def initialize(libs, cucumber_opts, feature_files)
-          raise "libs must be an Array when running in-process" unless Array === libs
-          libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
+          raise 'libs must be an Array when running in-process' unless Array == libs.class
+          libs.reverse_each { |lib| $LOAD_PATH.unshift(lib) }
           @args = (
             cucumber_opts +
             feature_files
@@ -45,7 +49,7 @@ module Cucumber
         def run
           require 'cucumber/cli/main'
           failure = Cucumber::Cli::Main.execute(args)
-          raise "Cucumber failed" if failure
+          raise 'Cucumber failed' if failure
         end
       end
 
@@ -60,16 +64,16 @@ module Cucumber
           @feature_files = feature_files
         end
 
-        def load_path(libs)
-          ['"%s"' % @libs.join(File::PATH_SEPARATOR)]
+        def load_path
+          [format('"%<path>s"', path: @libs.join(File::PATH_SEPARATOR))]
         end
 
         def quoted_binary(cucumber_bin)
-          ['"%s"' % cucumber_bin]
+          [format('"%<path>s"', path: cucumber_bin)]
         end
 
         def use_bundler
-          @bundler.nil? ? File.exist?("./Gemfile") && bundler_gem_available? : @bundler
+          @bundler.nil? ? File.exist?('./Gemfile') && bundler_gem_available? : @bundler
         end
 
         def bundler_gem_available?
@@ -80,19 +84,21 @@ module Cucumber
 
         def cmd
           if use_bundler
-            [ Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'cucumber', @cucumber_opts,
-            @feature_files ].flatten
+            [
+              Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'cucumber',
+              @cucumber_opts, @feature_files
+            ].flatten
           else
-            [ Cucumber::RUBY_BINARY, '-I', load_path(@libs), quoted_binary(@cucumber_bin),
-            @cucumber_opts, @feature_files ].flatten
+            [
+              Cucumber::RUBY_BINARY, '-I', load_path,
+              quoted_binary(@cucumber_bin), @cucumber_opts, @feature_files
+            ].flatten
           end
         end
 
         def run
-          sh cmd.join(" ") do |ok, res|
-            if !ok
-              exit res.exitstatus
-            end
+          sh cmd.join(' ') do |ok, res|
+            exit res.exitstatus unless ok
           end
         end
       end
@@ -105,9 +111,9 @@ module Cucumber
 
       # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
       # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
-      attr_accessor :cucumber_opts
+      attr_reader :cucumber_opts
       def cucumber_opts=(opts) #:nodoc:
-        @cucumber_opts = String === opts ? opts.split(' ') : opts
+        @cucumber_opts = String == opts.class ? opts.split(' ') : opts
       end
 
       # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
@@ -126,12 +132,16 @@ module Cucumber
       # Note that this attribute has no effect if you don't run in forked mode.
       attr_accessor :bundler
 
+      # Name of the running task
+      attr_reader :task_name
+
       # Define Cucumber Rake task
-      def initialize(task_name = "cucumber", desc = "Run Cucumber features")
-        @task_name, @desc = task_name, desc
+      def initialize(task_name = 'cucumber', desc = 'Run Cucumber features')
+        @task_name = task_name
+        @desc = desc
         @fork = true
         @libs = ['lib']
-        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+        @rcov_opts = %w[--rails --exclude osx\/objc,gems\/]
         yield self if block_given?
         @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
         define_task
@@ -144,24 +154,22 @@ module Cucumber
         end
       end
 
-      def runner(task_args = nil) #:nodoc:
+      def runner(_task_args = nil) #:nodoc:
         cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
-        if(@fork)
-          return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
-        end
+        return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files) if @fork
         InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
       end
 
       def cucumber_opts_with_profile #:nodoc:
-        @profile ? [cucumber_opts, '--profile', @profile] : cucumber_opts
+        Array(cucumber_opts).concat(Array(@profile).flat_map { |p| ['--profile', p] })
       end
 
       def feature_files #:nodoc:
-        make_command_line_safe(FileList[ ENV['FEATURE'] || [] ])
+        make_command_line_safe(FileList[ENV['FEATURE'] || []])
       end
 
       def make_command_line_safe(list)
-        list.map{|string| string.gsub(' ', '\ ')}
+        list.map { |string| string.gsub(' ', '\ ') }
       end
     end
   end

data/lib/cucumber/rspec/disable_option_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 module Spec #:nodoc:
@@ -7,16 +9,17 @@ module Spec #:nodoc:
     # will fail when running cucumber)
     class OptionParser < ::OptionParser #:nodoc:
       NEUTERED_RSPEC = Object.new
-      def NEUTERED_RSPEC.method_missing(m, *args); self; end
+      def NEUTERED_RSPEC.method_missing(_method, *_args) # rubocop:disable Style/MissingRespondToMissing
+        self || super
+      end
 
-      def self.method_added(m)
-        unless @__neutering_rspec
-          @__neutering_rspec = true
-          define_method(m) do |*a|
-            NEUTERED_RSPEC
-          end
-          @__neutering_rspec = false
+      def self.method_added(method)
+        return if @__neutering_rspec
+        @__neutering_rspec = true
+        define_method(method) do |*_a|
+          NEUTERED_RSPEC
         end
+        @__neutering_rspec = false
       end
     end
   end

data/lib/cucumber/rspec/doubles.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'rspec/mocks'
 
 World(RSpec::Mocks::ExampleMethods)
 
 Before do
-  if RSpec::Mocks::Version::STRING.split('.').first.to_i > 2
+  if RSpec::Mocks::Version::STRING >= '2.9.9'
     RSpec::Mocks.setup
   else
     RSpec::Mocks.setup(self)