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

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
+

data/lib/cucumber/platform.rb

@@ -6,20 +6,18 @@ require 'cucumber/core/platform'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = File.read(File.expand_path("../version", __FILE__))
+    VERSION       = File.read(File.expand_path('../version', __FILE__))
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     RAILS         = defined?(Rails)
     RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-    RUBY_2_2      = RUBY_VERSION =~ /^2\.2/
-    RUBY_2_1      = RUBY_VERSION =~ /^2\.1/
-    RUBY_2_3      = RUBY_VERSION =~ /^2\.3/
+    RUBY          = defined? RUBY_VERSION
 
     class << self
       attr_accessor :use_full_backtrace
 
       # @private
-      def file_mode(m, encoding="UTF-8")
+      def file_mode(m, encoding='UTF-8')
         "#{m}:#{encoding}"
       end
     end

data/lib/cucumber/rake/task.rb

@@ -35,7 +35,7 @@ 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
+          raise 'libs must be an Array when running in-process' unless Array === libs
           libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
           @args = (
             cucumber_opts +
@@ -46,7 +46,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
 
@@ -61,16 +61,16 @@ module Cucumber
           @feature_files = feature_files
         end
 
-        def load_path(libs)
-          ['"%s"' % @libs.join(File::PATH_SEPARATOR)]
+        def load_path
+          [format('"%s"', @libs.join(File::PATH_SEPARATOR))]
         end
 
         def quoted_binary(cucumber_bin)
-          ['"%s"' % cucumber_bin]
+          [format('"%s"', 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?
@@ -84,13 +84,13 @@ module Cucumber
             [ 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::RUBY_BINARY, '-I', load_path, quoted_binary(@cucumber_bin),
             @cucumber_opts, @feature_files ].flatten
           end
         end
 
         def run
-          sh cmd.join(" ") do |ok, res|
+          sh cmd.join(' ') do |ok, res|
             if !ok
               exit res.exitstatus
             end
@@ -128,7 +128,7 @@ module Cucumber
       attr_accessor :bundler
 
       # Define Cucumber Rake task
-      def initialize(task_name = "cucumber", desc = "Run Cucumber features")
+      def initialize(task_name = 'cucumber', desc = 'Run Cucumber features')
         @task_name, @desc = task_name, desc
         @fork = true
         @libs = ['lib']
@@ -145,7 +145,7 @@ 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)
@@ -154,7 +154,7 @@ module Cucumber
       end
 
       def cucumber_opts_with_profile #:nodoc:
-        Array(cucumber_opts).concat Array(@profile).flat_map {|p| ["--profile", p] }
+        Array(cucumber_opts).concat Array(@profile).flat_map {|p| ['--profile', p] }
       end
 
       def feature_files #:nodoc:

data/lib/cucumber/rspec/disable_option_parser.rb

@@ -8,7 +8,7 @@ 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(_m, *_args); self; end
 
       def self.method_added(m)
         unless @__neutering_rspec

data/lib/cucumber/rspec/doubles.rb

@@ -4,7 +4,7 @@ require 'rspec/mocks'
 World(RSpec::Mocks::ExampleMethods)
 
 Before do
-  if RSpec::Mocks::Version::STRING >= "2.9.9"
+  if RSpec::Mocks::Version::STRING >= '2.9.9'
     RSpec::Mocks.setup
   else
     RSpec::Mocks.setup(self)

data/lib/cucumber/running_test_case.rb

@@ -32,11 +32,11 @@ module Cucumber
       def feature(feature)
       end
 
-      def scenario(scenario)
+      def scenario(_scenario)
         @factory = Scenario
       end
 
-      def scenario_outline(scenario)
+      def scenario_outline(_scenario)
         @factory = ScenarioOutlineExample
       end
 

data/lib/cucumber/runtime.rb

@@ -14,7 +14,7 @@ require 'cucumber/step_match_search'
 module Cucumber
   module FixRuby21Bug9285
     def message
-      String(super).gsub("@ rb_sysopen ", "")
+      String(super).gsub('@ rb_sysopen ', '')
     end
   end
 
@@ -30,8 +30,14 @@ module Cucumber
   class FileNotFoundException < FileException
   end
 
-  class FeatureFolderNotFoundException < FileException
-    include FixRuby21Bug9285 if Cucumber::RUBY_2_1 || Cucumber::RUBY_2_2 || Cucumber::RUBY_2_3
+  class FeatureFolderNotFoundException < Exception
+    def initialize(path)
+      @path = path
+    end
+
+    def message
+      "No such file or directory - #{@path}"
+    end
   end
 
   require 'cucumber/core'
@@ -58,11 +64,10 @@ module Cucumber
 
     require 'cucumber/wire/plugin'
     def run!
+      load_step_definitions
       install_wire_plugin
-      load_support_files
       fire_after_configuration_hook
-      formatters
-      load_step_definitions
+      # TODO: can we remove this state?
       self.visitor = report
 
       receiver = Test::Runner.new(@configuration.event_bus)
@@ -90,22 +95,22 @@ module Cucumber
       @support_code.unmatched_step_definitions
     end
 
-    def begin_scenario(scenario)
-      @support_code.fire_hook(:begin_scenario, scenario)
+    def begin_scenario(test_case)
+      @support_code.fire_hook(:begin_scenario, test_case)
     end
 
-    def end_scenario(scenario)
+    def end_scenario(_scenario)
       @support_code.fire_hook(:end_scenario)
     end
 
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
-    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+    def doc_string(string_without_triple_quotes, content_type='', _line_offset=0)
       location = Core::Ast::Location.of_caller
       Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
     end
 
-  private
+    private
 
     def fire_after_configuration_hook #:nodoc
       @support_code.fire_hook(:after_configuration, @configuration)
@@ -115,6 +120,7 @@ module Cucumber
     def features
       @features ||= feature_files.map do |path|
         source = NormalisedEncodingFile.read(path)
+        @configuration.notify :gherkin_source_read, path, source
         Cucumber::Core::Gherkin::Document.new(path, source)
       end
     end
@@ -141,13 +147,13 @@ module Cucumber
           set_encoding
         rescue Errno::EACCES => e
           raise FileNotFoundException.new(e, File.expand_path(path))
-        rescue Errno::ENOENT => e
-          raise FeatureFolderNotFoundException.new(e, path)
+        rescue Errno::ENOENT
+          raise FeatureFolderNotFoundException.new(path)
         end
       end
 
       def read
-        @file.read.encode("UTF-8")
+        @file.read.encode('UTF-8')
       end
 
       private
@@ -186,34 +192,44 @@ module Cucumber
     end
 
     def formatters
-      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
-        create_formatter(factory, path_or_io, options)
-      }
+      @formatters ||=
+        @configuration.formatter_factories do |factory, formatter_options, path_or_io, options|
+          create_formatter(factory, formatter_options, path_or_io, options)
+        end
     end
 
-    def create_formatter(factory, path_or_io, options)
+    def create_formatter(factory, formatter_options, path_or_io, cli_options)
       if !legacy_formatter?(factory)
-        return factory.new(@configuration) if path_or_io.nil?
-        return factory.new(@configuration.with_options(out_stream: path_or_io))
+        if accept_options?(factory)
+          return factory.new(@configuration, formatter_options) if path_or_io.nil?
+          return factory.new(@configuration.with_options(out_stream: path_or_io),
+                             formatter_options)
+        else
+          return factory.new(@configuration) if path_or_io.nil?
+          return factory.new(@configuration.with_options(out_stream: path_or_io))
+        end
       end
       results = Formatter::LegacyApi::Results.new
       runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
-      formatter = factory.new(runtime_facade, path_or_io, options)
+      formatter = factory.new(runtime_facade, path_or_io, cli_options)
       Formatter::LegacyApi::Adapter.new(
         Formatter::IgnoreMissingMessages.new(formatter),
         results, @configuration)
     end
 
-    def legacy_formatter?(factory)
+    def accept_options?(factory)
       factory.instance_method(:initialize).arity > 1
     end
 
+    def legacy_formatter?(factory)
+      factory.instance_method(:initialize).arity > 2
+    end
+
     def failure?
       if @configuration.wip?
         summary_report.test_cases.total_passed > 0
       else
-        summary_report.test_cases.total_failed > 0 || summary_report.test_steps.total_failed > 0 ||
-          (@configuration.strict? && (summary_report.test_steps.total_undefined > 0 || summary_report.test_steps.total_pending > 0))
+        !summary_report.ok?(@configuration.strict?)
       end
     end
     public :failure?
@@ -229,10 +245,8 @@ module Cucumber
         filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
         filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
         filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
-        filters << Filters::Quit.new
-        filters << Filters::Retry.new(@configuration)
-        # TODO: can we just use RbLanguages's step definitions directly?
-        step_match_search = StepMatchSearch.new(@support_code.ruby.method(:step_matches), @configuration)
+        # TODO: can we just use Glue::RegistryAndMore's step definitions directly?
+        step_match_search = StepMatchSearch.new(@support_code.registry.method(:step_matches), @configuration)
         filters << Filters::ActivateSteps.new(step_match_search, @configuration)
         @configuration.filters.each do |filter|
           filters << filter
@@ -242,19 +256,17 @@ module Cucumber
           filters << Filters::ApplyBeforeHooks.new(@support_code)
           filters << Filters::ApplyAfterHooks.new(@support_code)
           filters << Filters::ApplyAroundHooks.new(@support_code)
+          filters << Filters::BroadcastTestRunStartingEvent.new(@configuration)
+          filters << Filters::Quit.new
+          filters << Filters::Retry.new(@configuration)
           # need to do this last so it becomes the first test step
           filters << Filters::PrepareWorld.new(self)
         end
       end
     end
 
-    def load_support_files
-      files = @configuration.support_to_load
-      @support_code.load_files!(files)
-    end
-
     def load_step_definitions
-      files = @configuration.step_defs_to_load
+      files = @configuration.support_to_load + @configuration.step_defs_to_load
       @support_code.load_files!(files)
     end