cucumber 2.0.0.beta.2 → 2.0.0.beta.3

data/lib/cucumber/multiline_argument/doc_string.rb

@@ -0,0 +1,10 @@
+module Cucumber
+  module MultilineArgument
+    class DocString < SimpleDelegator
+      def append_to(array)
+        array << self
+      end
+    end
+  end
+end
+

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0.beta.2'
+    VERSION       = '2.0.0.beta.3'
     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_world.rb

@@ -36,10 +36,8 @@ module Cucumber
       # @param [String] name The name of the step
       # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
       def step(name, raw_multiline_arg=nil)
-        # TODO: this argument parsing should move up out of core
-        location = Core::Ast::Location.new(*caller[0].split(':')[0..1])
-        core_multiline_arg = Core::Ast::MultilineArgument.from(raw_multiline_arg, location)
-        @__cucumber_runtime.invoke(name, MultilineArgument.from(core_multiline_arg), location)
+        location = Core::Ast::Location.of_caller
+        @__cucumber_runtime.invoke(name, MultilineArgument.from(raw_multiline_arg, location))
       end
 
       # Run a snippet of Gherkin

data/lib/cucumber/reports/legacy_formatter.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 require 'delegate'
 require 'cucumber/errors'
+require 'cucumber/multiline_argument'
 
 module Cucumber
   module Reports
@@ -220,29 +221,41 @@ module Cucumber
         def after_test_case(*args)
           if current_test_step_source.step_result.nil?
             switch_step_container
-            @delayed_messages = []
-            @delayed_embeddings = []
           end
+
+          # messages and embedding should already have been handled, but just in case...
+          @delayed_messages.each { |message| formatter.puts(message) }
+          @delayed_embeddings.each { |embedding| embedding.send_to_formatter(formatter) }
+          @delayed_messages = []
+          @delayed_embeddings = []
+
           @child.after_test_case
           @previous_test_case_background = @current_test_case_background
           @previous_test_case_scenario_outline = current_test_step_source.scenario_outline
         end
 
         def before_hook(location, result)
-          @before_hook_results << Legacy::Ast::HookResult.new(LegacyResultBuilder.new(result))
+          @before_hook_results << Legacy::Ast::HookResult.new(LegacyResultBuilder.new(result), @delayed_messages, @delayed_embeddings)
+          @delayed_messages = []
+          @delayed_embeddings = []
         end
 
         def after_hook(location, result)
           # if the scenario has no steps, we can hit this before we've created the scenario printer
           # ideally we should call switch_step_container in before_step_step
           switch_step_container if !@child 
-          @child.after_hook Legacy::Ast::HookResult.new(LegacyResultBuilder.new(result))
+          @child.after_hook Legacy::Ast::HookResult.new(LegacyResultBuilder.new(result), @delayed_messages, @delayed_embeddings)
+          @delayed_messages = []
+          @delayed_embeddings = []
         end
 
         def after_step_hook(hook, result)
           line = StepBacktraceLine.new(current_test_step_source.step)
-          @child.after_step_hook LegacyResultBuilder.new(result).
-            append_to_exception_backtrace(line)
+          @child.after_step_hook Legacy::Ast::HookResult.new(LegacyResultBuilder.new(result).
+            append_to_exception_backtrace(line), @delayed_messages, @delayed_embeddings)
+          @delayed_messages = []
+          @delayed_embeddings = []
+
         end
 
         def background(node, *)
@@ -417,7 +430,7 @@ module Cucumber
         end
 
         def after_step_hook(result)
-          result.describe_exception_to formatter
+          result.accept formatter
         end
 
         def step_invocation(step_invocation, source)
@@ -485,7 +498,7 @@ module Cucumber
         end
 
         def after_step_hook(result)
-          result.describe_exception_to formatter
+          result.accept formatter
         end
 
         def after_test_case(*args)
@@ -726,7 +739,8 @@ module Cucumber
         include PrintsAfterHooks
 
         def after_step_hook(result)
-          @after_step_hook_result = result
+          @after_step_hook_result ||= []
+          @after_step_hook_result.push result
         end
 
         def after_test_case(*args)
@@ -791,7 +805,7 @@ module Cucumber
             formatter.after_table_cell(value)
           end
           formatter.after_table_row(legacy_table_row)
-          @after_step_hook_result.describe_exception_to formatter if @after_step_hook_result
+          @after_step_hook_result.each { |result| result.accept formatter } if @after_step_hook_result
           after_hook_results.accept(formatter)
           @done = true
           self
@@ -826,7 +840,7 @@ module Cucumber
         def after
           return if @done
           @child.after if @child
-          @after_step_hook_result.describe_exception_to formatter if @after_step_hook_result
+          @after_step_hook_result.each { |result| result.accept formatter } if @after_step_hook_result
           after_hook_results.accept(formatter)
           @done = true
           self
@@ -977,7 +991,7 @@ module Cucumber
 
     class StepBacktraceLine < Struct.new(:step)
       def to_s
-        "#{step.location}:in `#{step.keyword}#{step.gherkin_statement.name}'"
+        step.backtrace_line
       end
     end
 
@@ -1057,13 +1071,15 @@ module Cucumber
         end
 
         class HookResult
-          def initialize(result)
-            @result = result
+          def initialize(result, messages, embeddings)
+            @result, @messages, @embeddings = result, messages, embeddings
             @already_accepted = false
           end
 
           def accept(formatter)
             unless @already_accepted
+              @messages.each { |message| formatter.puts(message) }
+              @embeddings.each { |embedding| embedding.send_to_formatter(formatter) }
               @result.describe_exception_to(formatter)
               @already_accepted = true
             end
@@ -1179,9 +1195,9 @@ module Cucumber
         end
 
         class DataTableRow
-          def initialize(row)
-            @values = row.map(&:value)
-            @line = row.line
+          def initialize(row, line)
+            @values = row
+            @line = line
           end
 
           def dom_id
@@ -1210,6 +1226,18 @@ module Cucumber
           private :values, :line
         end
 
+        class LegacyTableRow < DataTableRow
+          def accept(formatter)
+            formatter.before_table_row(self)
+            values.each do |value|
+              formatter.before_table_cell(value.value)
+              formatter.table_cell_value(value.value, value.status)
+              formatter.after_table_cell(value.value)
+            end
+            formatter.after_table_row(self)
+          end
+        end
+
         Tags = Struct.new(:tags) do
           def accept(formatter)
             formatter.before_tags tags
@@ -1268,6 +1296,10 @@ module Cucumber
               @result = DataTable.new(node)
             end
 
+            def legacy_table(node)
+              @result = LegacyTable.new(node)
+            end
+
             def result
               @result || Node.new(nil)
             end
@@ -1281,16 +1313,31 @@ module Cucumber
             end
           end
 
-          class DataTable < Node
+          class DataTable < Cucumber::MultilineArgument::DataTable
+            def node
+              @ast_table
+            end
+
             def accept(formatter)
-              formatter.before_multiline_arg node
-              node.cells_rows.each do |row|
-                Legacy::Ast::DataTableRow.new(row).accept(formatter)
+              formatter.before_multiline_arg self
+              node.raw.each_with_index do |row, index|
+                line = node.location.line + index
+                Legacy::Ast::DataTableRow.new(row, line).accept(formatter)
               end
-              formatter.after_multiline_arg node
+              formatter.after_multiline_arg self
             end
           end
+        end
 
+        class LegacyTable < SimpleDelegator
+          def accept(formatter)
+            formatter.before_multiline_arg self
+            cells_rows.each_with_index do |row, index|
+              line = location.line + index
+              Legacy::Ast::LegacyTableRow.new(row, line).accept(formatter)
+            end
+            formatter.after_multiline_arg self
+          end
         end
 
         Features = Struct.new(:duration)

data/lib/cucumber/runtime.rb

@@ -35,7 +35,6 @@ module Cucumber
 
   require 'cucumber/core'
   require 'cucumber/runtime/user_interface'
-  require 'cucumber/runtime/features_loader'
   require 'cucumber/runtime/results'
   require 'cucumber/runtime/support_code'
   require 'cucumber/runtime/tag_limits'
@@ -157,44 +156,6 @@ module Cucumber
       @support_code.unknown_programming_language?
     end
 
-    # TODO: this code is untested
-    def write_stepdefs_json
-      if(@configuration.dotcucumber)
-        stepdefs = []
-        @support_code.step_definitions.sort{|a,b| a.to_hash['source'] <=> a.to_hash['source']}.each do |stepdef|
-          stepdef_hash = stepdef.to_hash
-          steps = []
-          features.each do |feature|
-            feature.feature_elements.each do |feature_element|
-              feature_element.raw_steps.each do |step|
-                args = stepdef.arguments_from(step.name)
-                if(args)
-                  steps << {
-                    'name' => step.name,
-                    'args' => args.map do |arg|
-                      {
-                        'offset' => arg.offset,
-                        'val' => arg.val
-                      }
-                    end
-                  }
-                end
-              end
-            end
-          end
-          stepdef_hash['file_colon_line'] = stepdef.file_colon_line
-          stepdef_hash['steps'] = steps.uniq.sort {|a,b| a['name'] <=> b['name']}
-          stepdefs << stepdef_hash
-        end
-        if !File.directory?(@configuration.dotcucumber)
-          FileUtils.mkdir_p(@configuration.dotcucumber)
-        end
-        File.open(File.join(@configuration.dotcucumber, 'stepdefs.json'), 'w') do |io|
-          io.write(MultiJson.dump(stepdefs, :pretty => true))
-        end
-      end
-    end
-
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
     def doc_string(string_without_triple_quotes, content_type='', line_offset=0)

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -27,7 +27,7 @@ module Cucumber
         :invoke,
         :load_programming_language
 
-      # Returns a Cucumber::Core::Ast::DataTable for +text_or_table+, which can either
+      # Returns a Cucumber::MultilineArgument::DataTable for +text_or_table+, which can either
       # be a String:
       #
       #   table(%{
@@ -45,21 +45,23 @@ module Cucumber
       #   ])
       #
       def table(text_or_table, file=nil, line_offset=0)
-        file, line = *caller[0].split(':')[0..1]
-        location = Core::Ast::Location.new(file, line)
+        if !file
+          location = Core::Ast::Location.of_caller
+        else
+          location = Core::Ast::Location.new(file, line)
+        end
         if Array === text_or_table
-          Core::Ast::DataTable.new(text_or_table, location)
+          MultilineArgument::DataTable.new(text_or_table, location)
         else
-          Core::Ast::DataTable.parse(text_or_table, file, location)
+          MultilineArgument::DataTable.parse(text_or_table, file, location)
         end
       end
 
-      # Returns Ast::DocString for +string_without_triple_quotes+.
+      # Returns a Cucumber::MultilineArgument::DocString for +body+.
       #
-      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-        file, line = *caller[0].split(':')[0..1]
-        location = Core::Ast::Location.new(file, line)
-        Core::Ast::DocString.new(string_without_triple_quotes,content_type, location)
+      def doc_string(body, content_type='', line_offset=0)
+        location = Core::Ast::Location.of_caller
+        MultilineArgument.doc_string(body, content_type, location)
       end
     end
   end

data/lib/cucumber/runtime/support_code.rb

@@ -1,5 +1,4 @@
 require 'cucumber/constantize'
-require 'cucumber/core/ast/multiline_argument'
 require 'cucumber/runtime/for_programming_languages'
 
 module Cucumber
@@ -8,6 +7,7 @@ module Cucumber
 
     class SupportCode
 
+      # TODO: figure out a way to move this to the core. We'd need to have access to the mappings to pass those in.
       require 'forwardable'
       class StepInvoker
         include Gherkin::Rubify
@@ -20,13 +20,20 @@ module Cucumber
         end
 
         def step(step)
-          location = Cucumber::Core::Ast::Location.new(*caller[0].split(':')[0..1])
-          core_multiline_arg = Core::Ast::MultilineArgument.from(step.doc_string || step.rows, location)
-          @support_code.invoke(step.name, MultilineArgument.from(core_multiline_arg), location)
+          location = Core::Ast::Location.of_caller
+          @support_code.invoke(step.name, multiline_arg(step, location))
         end
 
         def eof
         end
+
+        def multiline_arg(step, location)
+          if argument = step.doc_string
+            MultilineArgument.doc_string(argument.value, argument.content_type, location.on_line(argument.line_range))
+          else
+            MultilineArgument.from(step.rows, location)
+          end
+        end
       end
 
       include Constantize

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -69,7 +69,7 @@ module Cucumber
 
           def handle_diff!(tables)
             # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
-            location = Core::Ast::Location.new('??', '??')
+            location = Core::Ast::Location.new(__FILE__, __LINE__)
             table1 = table(tables[0], location)
             table2 = table(tables[1], location)
             table1.diff!(table2)
@@ -89,7 +89,7 @@ module Cucumber
           private
 
           def table(data, location)
-            Cucumber::MultilineArgument.from(Core::Ast::DataTable.new(data, location))
+            Cucumber::MultilineArgument.from_core(Core::Ast::DataTable.new(data, location))
           end
         end
 

data/spec/cucumber/formatter/pretty_spec.rb

@@ -531,14 +531,14 @@ OUTPUT
                 Given there are <Things>                    # spec.feature:4
                 Examples: Fruit
                   Scenario: | apples |                          # spec.feature:8
-                    Given there are apples                      # spec.feature:4
+                    Given there are apples                      # spec.feature:8
                   Scenario: | bananas |                         # spec.feature:9
-                    Given there are bananas                     # spec.feature:4
+                    Given there are bananas                     # spec.feature:9
                 Examples: Vegetables
                   Scenario: | broccoli |                        # spec.feature:12
-                    Given there are broccoli                    # spec.feature:4
+                    Given there are broccoli                    # spec.feature:12
                   Scenario: | carrots |                         # spec.feature:13
-                    Given there are carrots                     # spec.feature:4
+                    Given there are carrots                     # spec.feature:13
               OUTPUT
               lines.split("\n").each do |line|
                 expect(@out.string).to include line.strip
@@ -561,7 +561,7 @@ OUTPUT
                 lines = <<-OUTPUT
               Examples:
                  Scenario: | Hominidae | Very long cell content | # spec.feature:8
-                   Given there are Hominidae                      # spec.feature:4
+                   Given there are Hominidae                      # spec.feature:8
 
                 OUTPUT
                 lines.split("\n").each do |line|

data/spec/cucumber/mappings_spec.rb

@@ -10,7 +10,7 @@ module Cucumber
       let(:ruby)      { double.as_null_object }
       let(:runtime)   do
         double(
-          load_programming_language: ruby, 
+          load_programming_language: ruby,
           step_match: double
         )
       end
@@ -18,16 +18,129 @@ module Cucumber
       let(:report)    { double.as_null_object }
 
       it "responds to #source_tag_names" do
-        gherkin_docs = [
-          gherkin do
-            feature 'test', tags: '@foo @bar' do
-              scenario 'test', tags: '@baz' do
+        define_gherkin do
+          feature 'test', tags: '@foo @bar' do
+            scenario 'test', tags: '@baz' do
+              step 'passing'
+            end
+          end
+        end
+
+        before do |scenario|
+          expect(scenario.source_tag_names).to eq %w(@foo @bar @baz)
+        end
+      end
+
+      describe "#failed?" do
+
+        it "is true if the test case is in a failed state" do
+          define_gherkin do
+            feature do
+              scenario do
+                step 'failing'
+              end
+            end
+          end
+
+          allow(runtime).to receive(:step_match) do |step_name|
+            if step_name == 'failing'
+              step_match = double
+              allow(step_match).to receive(:invoke) { fail }
+              step_match
+            else
+              raise Cucumber::Undefined
+            end
+          end
+
+          after do |test_case|
+            expect(test_case).to be_failed
+          end
+        end
+
+      end
+
+      describe "#scenario_outline" do
+
+        # TODO: is this actually desired behaviour?
+        it "throws a NoMethodError when the test case is from a scenario" do
+          define_gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+
+          before do |test_case|
+            expect{ test_case.scenario_outline }.to raise_error(NoMethodError)
+          end
+        end
+
+        it "points to self when the test case is from a scenario outline" do
+          define_gherkin do
+            feature do
+              scenario_outline 'outline' do
+                step 'passing'
+
+                examples 'examples' do
+                  row 'a'
+                  row '1'
+                end
+              end
+            end
+          end
+
+          before do |test_case|
+            expect(test_case.scenario_outline).to_not be_nil
+            expect(test_case.scenario_outline.name).to eq "Scenario Outline: outline, examples (row 1)"
+          end
+        end
+
+      end
+
+      describe "#outline?" do
+
+        it "returns false when the test case is from a scenario" do
+          define_gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+
+          before do |test_case|
+            expect(test_case).to_not be_an_outline
+          end
+        end
+
+        it "returns true when the test case is from a scenario" do
+          define_gherkin do
+            feature do
+              scenario_outline do
                 step 'passing'
+
+                examples 'examples' do
+                  row 'a'
+                  row '1'
+                end
               end
             end
           end
-        ]
 
+          before do |test_case|
+            expect(test_case).to be_an_outline
+          end
+        end
+
+      end
+      attr_accessor :gherkin_docs
+
+      def define_gherkin(&block)
+        self.gherkin_docs = [gherkin(&block)]
+      end
+
+      def before
         # TODO: the complexity of this stubbing shows we need to clean up the interface
         scenario_spy = nil
         allow(ruby).to receive(:hooks_for) do |phase, scenario|
@@ -41,10 +154,26 @@ module Cucumber
             []
           end
         end
-
         execute gherkin_docs, mappings, report
+        yield scenario_spy
+      end
 
-        expect(scenario_spy.source_tag_names).to eq %w(@foo @bar @baz)
+      def after
+        # TODO: the complexity of this stubbing shows we need to clean up the interface
+        scenario_spy = nil
+        allow(ruby).to receive(:hooks_for) do |phase, scenario|
+          if phase == :after
+            hook = double
+            expect(hook).to receive(:invoke) do |phase, scenario|
+              scenario_spy = scenario
+            end
+            [hook]
+          else
+            []
+          end
+        end
+        execute gherkin_docs, mappings, report
+        yield scenario_spy
       end
     end
   end