cucumber 2.0.0 → 2.0.1

data/lib/cucumber/formatter/legacy_api/ast.rb

@@ -60,6 +60,7 @@ module Cucumber
             comments.each do |comment|
               formatter.comment_line comment.to_s.strip
             end
+            formatter.after_comment comments
           end
         end
 
@@ -107,6 +108,7 @@ module Cucumber
 
           def accept(formatter)
             formatter.before_step(self)
+            Ast::Comments.new(step.comments).accept(formatter)
             messages.each { |message| formatter.puts(message) }
             embeddings.each { |embedding| embedding.send_to_formatter(formatter) }
             formatter.before_step_result *step_result_attributes
@@ -370,6 +372,17 @@ module Cucumber
 
         Features = Struct.new(:duration)
 
+        class Background < SimpleDelegator
+          def initialize(feature, node)
+            super node
+            @feature = feature
+          end
+
+          def feature
+            @feature
+          end
+        end
+
       end
     end
   end

data/lib/cucumber/formatter/legacy_api/runtime_facade.rb

@@ -23,6 +23,10 @@ module Cucumber
         def steps(status = nil)
           results.steps(status)
         end
+
+        def step_match(step_name, name_to_report=nil)
+          support_code.step_match(step_name, name_to_report)
+        end
       end
 
     end

data/lib/cucumber/formatter/pretty.rb

@@ -240,7 +240,8 @@ module Cucumber
       end
 
       def print_summary(features)
-        print_stats(features, @options)
+        duration = features ? features.duration : nil
+        print_stats(duration, @options)
         print_snippets(@options)
         print_passing_wip(@options)
       end

data/lib/cucumber/formatter/progress.rb

@@ -1,5 +1,7 @@
 require 'cucumber/formatter/console'
 require 'cucumber/formatter/io'
+require 'cucumber/formatter/duration_extractor'
+require 'cucumber/formatter/hook_query_visitor'
 
 module Cucumber
   module Formatter
@@ -13,73 +15,38 @@ module Cucumber
         @runtime, @io, @options = runtime, ensure_io(path_or_io, "progress"), options
         @previous_step_keyword = nil
         @snippets_input = []
+        @total_duration = 0
       end
 
-      def before_features(features)
-        print_profile_information
-      end
-
-      def after_features(features)
-        @io.puts
-        @io.puts
-        print_summary(features)
-      end
-
-      def before_feature_element(*args)
-        @exception_raised = false
-      end
-
-      def after_feature_element(*args)
-        progress(:failed) if (defined? @exception_raised) and (@exception_raised)
-        @exception_raised = false
-      end
-
-      def before_steps(*args)
-        progress(:failed) if (defined? @exception_raised) and (@exception_raised)
-        @exception_raised = false
-      end
-
-      def after_steps(*args)
-        @exception_raised = false
-      end
-
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-        progress(status)
-        @status = status
-      end
-
-      def before_outline_table(outline_table)
-        @outline_table = outline_table
-      end
-
-      def after_outline_table(outline_table)
-        @outline_table = nil
-      end
-
-      def table_cell_value(value, status)
-        return unless @outline_table
-        status ||= @status
-        progress(status) unless table_header_cell?(status)
+      def before_test_case(_test_case)
+        unless @profile_information_printed
+          print_profile_information
+          @profile_information_printed = true
+        end
+        @previous_step_keyword = nil
       end
 
-      def exception(*args)
-        @exception_raised = true
+      def after_test_step(test_step, result)
+        progress(result.to_sym) if !HookQueryVisitor.new(test_step).hook? || result.failed?
+        collect_snippet_data(test_step, result) unless HookQueryVisitor.new(test_step).hook?
       end
 
-      def before_test_case(test_case)
-        @previous_step_keyword = nil
+      def after_test_case(_test_case, result)
+        @total_duration += DurationExtractor.new(result).result_duration
       end
 
-      def after_test_step(test_step, result)
-        collect_snippet_data(test_step, result)
+      def done
+        @io.puts
+        @io.puts
+        print_summary
       end
 
       private
 
-      def print_summary(features)
+      def print_summary
         print_steps(:pending)
         print_steps(:failed)
-        print_stats(features, @options)
+        print_stats(@total_duration, @options)
         print_snippets(@options)
         print_passing_wip(@options)
       end

data/lib/cucumber/formatter/rerun.rb

@@ -8,10 +8,11 @@ module Cucumber
       def initialize(runtime, path_or_io, options)
         @io = ensure_io(path_or_io, "rerun")
         @failures = {}
+        @options = options
       end
 
       def after_test_case(test_case, result)
-        return if result.passed?
+        return if result.ok?(@options[:strict])
         @failures[test_case.location.file] ||= []
         @failures[test_case.location.file] << test_case.location.line
       end

data/lib/cucumber/formatter/usage.rb

@@ -14,39 +14,33 @@ module Cucumber
         @runtime = runtime
         @io = ensure_io(path_or_io, "usage")
         @options = options
-        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
+        @stepdef_to_match = Hash.new { |h, stepdef_key| h[stepdef_key] = [] }
+        @total_duration = 0
       end
 
-      def before_features(features)
-        print_profile_information
-      end
-
-      def before_step(step)
-        @step = step
-        @start_time = Time.now
-      end
+      def after_test_step(test_step, result)
+        return if HookQueryVisitor.new(test_step).hook?
 
-      def before_step_result(*args)
-        @duration = Time.now - @start_time
-      end
-
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        step_match = @runtime.step_match(test_step.source.last.name)
         step_definition = step_match.step_definition
-        unless step_definition.nil? # nil if it's from a scenario outline
-          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+        stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+        unless @stepdef_to_match[stepdef_key].map { |key| key[:file_colon_line] }.include? test_step.location
+          duration = DurationExtractor.new(result).result_duration
 
           @stepdef_to_match[stepdef_key] << {
-            :keyword => keyword,
-            :step_match => step_match,
-            :status => status,
-            :file_colon_line => @step.file_colon_line,
-            :duration => @duration
+            keyword: test_step.source.last.keyword,
+            step_match: step_match,
+            status: result.to_sym,
+            file_colon_line: test_step.location,
+            duration: duration
           }
         end
         super
       end
 
-      def print_summary(features)
+      private
+
+      def print_summary
         add_unused_stepdefs
         aggregate_info
 

data/lib/cucumber/hooks.rb

@@ -1,33 +1,42 @@
+require 'pathname'
+require 'cucumber/core/ast/location'
 require 'cucumber/core/test/around_hook'
 
 module Cucumber
 
-  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as 
+  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as
   # source for test steps
   module Hooks
 
     class << self
-      def before_hook(source, &block)
-        build_hook_step(source, block, BeforeHook, Core::Test::UnskippableAction)
+      def before_hook(source, location, &block)
+        build_hook_step(source, location, block, BeforeHook, Core::Test::UnskippableAction)
       end
 
-      def after_hook(source, &block)
-        build_hook_step(source, block, AfterHook, Core::Test::UnskippableAction)
+      def after_hook(source, location, &block)
+        build_hook_step(source, location, block, AfterHook, Core::Test::UnskippableAction)
       end
 
-      def after_step_hook(source, &block)
+      def after_step_hook(source, location, &block)
         raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
-        build_hook_step(source, block, AfterStepHook, Core::Test::Action)
+        build_hook_step(source, location, block, AfterStepHook, Core::Test::Action)
       end
 
       def around_hook(source, &block)
         Core::Test::AroundHook.new(&block)
       end
 
+      def location(hook)
+        filepath, line = *hook.source_location
+        Core::Ast::Location.new(
+          Pathname.new(filepath).relative_path_from(Pathname.new(Dir.pwd)).to_path,
+          line)
+      end
+
       private
 
-      def build_hook_step(source, block, hook_type, action_type)
-        action = action_type.new(&block)
+      def build_hook_step(source, location, block, hook_type, action_type)
+        action = action_type.new(location, &block)
         hook = hook_type.new(action.location)
         Core::Test::Step.new(source + [hook], action)
       end

data/lib/cucumber/multiline_argument/data_table.rb

@@ -148,6 +148,22 @@ module Cucumber
         @hashes ||= build_hashes
       end
 
+      # Converts this table into an Array of Hashes where the keys are symbols.
+      # For example, a Table built from the following plain text:
+      #
+      #   | foo | Bar | Foo Bar |
+      #   | 2   | 3   | 5       |
+      #   | 7   | 9   | 16      |
+      #
+      # Gets converted into the following:
+      #
+      #   [{:foo => '2', :bar => '3', :foo_bar => '5'}, {:foo => '7', :bar => '9', :foo_bar => '16'}]
+      #
+      def symbolic_hashes
+        @header_conversion_proc = lambda { |h| symbolize_key(h) }
+        @symbolic_hashes ||= build_hashes
+      end
+
       # Converts this table into a Hash where the first column is
       # used as keys and the second column is used as values
       #
@@ -336,7 +352,7 @@ module Cucumber
         convert_columns!
 
         original_width = cell_matrix[0].length
-        other_table_cell_matrix = pad!(other_table.cell_matrix)
+        @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}
@@ -556,44 +572,36 @@ module Cucumber
         @hashes = @rows_hash = @col_names = @rows = @columns = nil
       end
 
-      # Pads our own cell_matrix and returns a cell matrix of same
-      # column width that can be used for diffing
-      def pad!(other_cell_matrix) #:nodoc:
+      # 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 = cell_matrix.transpose
-        unmapped_cols = other_cell_matrix.transpose
+        cols = a_cell_matrix.transpose
+        unmatched_cols = other_cell_matrix.transpose
 
-        mapped_cols = []
 
-        cols.each_with_index do |col, col_index|
-          header = col[0]
-          candidate_cols, unmapped_cols = unmapped_cols.partition do |other_col|
-            other_col[0] == header
-          end
-          raise "More than one column has the header #{header}" if candidate_cols.size > 2
+        header_values = cols.map(&:first)
+        matched_cols = []
 
-          other_padded_col = if candidate_cols.size == 1
-            # Found a matching column
-            candidate_cols[0]
+        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[col_index])
-            (0...other_cell_matrix.length).map do |row|
-              val = row == 0 ? header.value : nil
-              SurplusCell.new(val, self, -1)
-            end
+            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
-          mapped_cols.insert(col_index, other_padded_col)
         end
 
-        unmapped_cols.each_with_index do |col, col_index|
-          empty_col = (0...cell_matrix.length).map do |row|
-            SurplusCell.new(nil, self, -1)
-          end
+
+        empty_col = cell_matrix.collect {SurplusCell.new(nil, self, -1)}
+        unmatched_cols.each do
           cols << empty_col
         end
 
-        @cell_matrix = cols.transpose
-        (mapped_cols + unmapped_cols).transpose
+        return cols.transpose, (matched_cols + unmatched_cols).transpose
       end
 
       def ensure_table(table_or_array) #:nodoc:
@@ -624,6 +632,10 @@ module Cucumber
         end
       end
 
+      def symbolize_key(key)
+        key.downcase.tr(' ', '_').to_sym
+      end
+
       # Represents a row of cells or columns of cells
       class Cells #:nodoc:
         include Enumerable

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0'
+    VERSION       = '2.0.1'
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     JRUBY         = defined?(JRUBY_VERSION)

data/lib/cucumber/rb_support/rb_hook.rb

@@ -10,6 +10,10 @@ module Cucumber
         @proc = proc
       end
 
+      def source_location
+        @proc.source_location
+      end
+
       def invoke(pseudo_method, arguments, &block)
         @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].compact, &@proc)
       end

data/lib/cucumber/running_test_case.rb

@@ -2,7 +2,7 @@ require 'delegate'
 
 module Cucumber
   # Represents the current status of a running test case.
-  # 
+  #
   # This wraps a `Cucumber::Core::Test::Case` and delegates
   # many methods to that object.
   #
@@ -15,11 +15,11 @@ module Cucumber
   #
   # The test case might come from a regular Scenario or
   # a Scenario outline. You can call the `#outline?`
-  # predicate to find out. If it's from an outline, 
+  # predicate to find out. If it's from an outline,
   # you get a couple of extra methods.
   module RunningTestCase
     def self.new(test_case)
-      Builder.new(test_case).result
+      Builder.new(test_case).running_test_case
     end
 
     class Builder
@@ -45,7 +45,7 @@ module Cucumber
       def examples_table_row(row)
       end
 
-      def result
+      def running_test_case
         @factory.new(@test_case)
       end
     end
@@ -62,6 +62,15 @@ module Cucumber
         hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
       end
 
+      def exception
+        return unless @result.failed?
+        @result.exception
+      end
+
+      def status
+        @result.to_sym
+      end
+
       def failed?
         @result.failed?
       end