cucumber-core 1.0.0.beta.2 → 1.0.0.beta.3

data/lib/cucumber/core/gherkin/ast_builder.rb

@@ -1,6 +1,7 @@
 require 'cucumber/initializer'
 require 'cucumber/core/ast'
 require 'cucumber/core/platform'
+require 'gherkin/rubify'
 
 module Cucumber
   module Core
@@ -70,11 +71,7 @@ module Cucumber
         end
 
         def file
-          if Cucumber::WINDOWS && !ENV['CUCUMBER_FORWARD_SLASH_PATHS']
-            @path.gsub(/\//, '\\')
-          else
-            @path
-          end
+          @path
         end
 
         class Builder
@@ -115,7 +112,9 @@ module Cucumber
 
           def result(language)
             background = background(language)
-            feature = Ast::Feature.new(
+            Ast::Feature.new(
+              node,
+              language,
               location,
               background,
               comments,
@@ -125,9 +124,6 @@ module Cucumber
               node.description.rstrip,
               children.map { |builder| builder.result(background, language, tags) }
             )
-            feature.gherkin_statement(node)
-            feature.language = language
-            feature
           end
 
           def add_child(child)
@@ -209,15 +205,15 @@ module Cucumber
 
           class StepBuilder < Builder
             def result(language)
-              step = Ast::Step.new(
+              Ast::Step.new(
+                node,
                 language,
                 location,
                 node.keyword,
                 node.name,
-                Ast::MultilineArgument.from(node.doc_string || node.rows, location)
+                
+                MultilineArgument.from(node.doc_string || node.rows, location)
               )
-              step.gherkin_statement(node)
-              step
             end
           end
         end
@@ -225,7 +221,8 @@ module Cucumber
         class ScenarioOutlineBuilder < Builder
           def result(background, language, feature_tags)
             raise ParseError.new("Missing Examples section for Scenario Outline at #{location}") if examples_tables.empty?
-            scenario_outline = Ast::ScenarioOutline.new(
+            Ast::ScenarioOutline.new(
+              node,
               language,
               location,
               background,
@@ -238,8 +235,6 @@ module Cucumber
               steps(language),
               examples_tables
             )
-            scenario_outline.gherkin_statement(node)
-            scenario_outline
           end
 
           def add_examples(file, node)
@@ -267,7 +262,8 @@ module Cucumber
           class ExamplesTableBuilder < Builder
 
             def result
-              examples_table = Ast::ExamplesTable.new(
+              Ast::ExamplesTable.new(
+                node,
                 location,
                 comments,
                 tags,
@@ -277,8 +273,6 @@ module Cucumber
                 header,
                 example_rows
               )
-              examples_table.gherkin_statement(node)
-              examples_table
             end
 
             private
@@ -299,15 +293,34 @@ module Cucumber
 
           class StepBuilder < Builder
             def result(language)
-              step = Ast::OutlineStep.new(
+              Ast::OutlineStep.new(
+                node,
                 language,
                 location,
                 node.keyword,
                 node.name,
-                Ast::MultilineArgument.from(node.doc_string || node.rows, location)
+                MultilineArgument.from(node.doc_string || node.rows, location)
               )
-              step.gherkin_statement(node)
-              step
+            end
+          end
+        end
+
+        module MultilineArgument
+          class << self
+            include ::Gherkin::Rubify
+
+            def from(argument, parent_location)
+              return Ast::EmptyMultilineArgument.new unless argument
+              argument = rubify(argument)
+              case argument
+              when ::Gherkin::Formatter::Model::DocString
+                Ast::DocString.new(argument.value, argument.content_type, parent_location.on_line(argument.line_range))
+              when Array
+                location = parent_location.on_line(argument.first.line..argument.last.line)
+                Ast::DataTable.new(argument.map{|row| row.cells}, location)
+              else
+                raise ArgumentError, "Don't know how to convert #{argument.inspect} into a MultilineArgument"
+              end
             end
           end
         end

data/lib/cucumber/core/test/{mapping.rb → action.rb}

@@ -6,21 +6,20 @@ require 'cucumber/core/ast/location'
 module Cucumber
   module Core
     module Test
-
-      class Mapping
+      class Action
         def initialize(&block)
           raise ArgumentError, "Passing a block to execute the mapping is mandatory." unless block
           @block = block
           @timer = Timer.new
         end
 
-        def skip
+        def skip(last_result)
           skipped
         end
 
-        def execute
+        def execute(last_result)
           @timer.start
-          @block.call
+          @block.call(last_result)
           passed
         rescue Result::Raisable => exception
           exception.with_duration(@timer.duration)
@@ -51,18 +50,18 @@ module Cucumber
         end
       end
 
-      class UnskippableMapping < Mapping
-        def skip
-          execute
+      class UnskippableAction < Action
+        def skip(last_result)
+          execute(last_result)
         end
       end
 
-      class UndefinedMapping
-        def execute
+      class UndefinedAction
+        def execute(last_result)
           undefined
         end
 
-        def skip
+        def skip(last_result)
           undefined
         end
 

data/lib/cucumber/core/test/mapper.rb

@@ -110,15 +110,15 @@ module Cucumber
           include Cucumber.initializer(:source)
 
           def after(block)
-            build_hook_step(block, Hooks::AfterHook, Test::UnskippableMapping)
+            build_hook_step(block, Hooks::AfterHook, Test::UnskippableAction)
           end
 
           def before(block)
-            build_hook_step(block, Hooks::BeforeHook, Test::UnskippableMapping)
+            build_hook_step(block, Hooks::BeforeHook, Test::UnskippableAction)
           end
 
           def after_step(block)
-            build_hook_step(block, Hooks::AfterStepHook, Test::Mapping)
+            build_hook_step(block, Hooks::AfterStepHook, Test::Action)
           end
 
           private

data/lib/cucumber/core/test/runner.rb

@@ -60,7 +60,7 @@ module Cucumber
               include Cucumber.initializer(:step_result)
 
               def execute(test_step, monitor)
-                result = test_step.execute
+                result = test_step.execute(monitor.result)
                 result.describe_to(monitor, result)
               end
 
@@ -83,7 +83,7 @@ module Cucumber
 
             class Failing < Base
               def execute(test_step, monitor)
-                test_step.skip
+                test_step.skip(monitor.result)
               end
 
               def result(duration)

data/lib/cucumber/core/test/step.rb

@@ -1,6 +1,6 @@
 require 'cucumber/initializer'
 require 'cucumber/core/test/result'
-require 'cucumber/core/test/mapping'
+require 'cucumber/core/test/action'
 
 module Cucumber
   module Core
@@ -9,7 +9,7 @@ module Cucumber
         include Cucumber.initializer(:source)
         attr_reader :source
 
-        def initialize(source, mapping = Test::UndefinedMapping.new)
+        def initialize(source, mapping = Test::UndefinedAction.new)
           raise ArgumentError if source.any?(&:nil?)
           @mapping = mapping
           super(source)
@@ -26,16 +26,16 @@ module Cucumber
           self
         end
 
-        def skip
-          @mapping.skip
+        def skip(last_result)
+          @mapping.skip(last_result)
         end
 
-        def execute
-          @mapping.execute
+        def execute(last_result)
+          @mapping.execute(last_result)
         end
 
         def with_mapping(&block)
-          self.class.new(source, Test::Mapping.new(&block))
+          self.class.new(source, Test::Action.new(&block))
         end
 
         def name

data/lib/cucumber/core/version.rb

@@ -2,7 +2,7 @@ module Cucumber
   module Core
     class Version
       def self.to_s
-        "1.0.0.beta.2"
+        "1.0.0.beta.3"
       end
     end
   end

data/spec/cucumber/core/ast/data_table_spec.rb

@@ -12,43 +12,6 @@ module Cucumber
             %w{one four seven},
             %w{4444 55555 666666}
           ], location)
-          def @table.cells_rows; super; end
-          def @table.columns; super; end
-        end
-
-        it "should have rows" do
-          expect( @table.cells_rows[0].map{|cell| cell.value} ).to eq %w{one four seven}
-        end
-
-        it "should have columns" do
-          expect( @table.columns[1].map{|cell| cell.value} ).to eq %w{four 55555}
-        end
-
-        it "should have headers" do
-          expect( @table.headers ).to eq %w{one four seven}
-        end
-
-        it "should have same cell objects in rows and columns" do
-          # 666666
-          expect( @table.cells_rows[1].__send__(:[], 2) ).to eq @table.columns[2].__send__(:[], 1)
-        end
-
-        it "should know about max width of a row" do
-          expect( @table.columns[1].__send__(:width) ).to eq 5
-        end
-
-        it "should be convertible to an array of hashes" do
-          expect( @table.hashes ).to eq [
-            {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
-          ]
-        end
-
-        it "should accept symbols as keys for the hashes" do
-          expect( @table.hashes.first[:one] ).to eq '4444'
-        end
-
-        it "should return the row values in order" do
-          expect( @table.rows.first ).to eq %w{4444 55555 666666}
         end
 
         describe "equality" do
@@ -86,62 +49,12 @@ module Cucumber
             ], location)
           end
 
-          it "should be convertible in to an array where each row is a hash" do
-            expect( @table.transpose.hashes[0] ).to eq({'one' => '1111', 'two' => '22222'})
-          end
-        end
-
-        describe "#rows_hash" do
-
-          it "should return a hash of the rows" do
-            table = DataTable.new([
-              %w{one 1111},
-              %w{two 22222}
-            ], location)
-            expect( table.rows_hash ).to eq({'one' => '1111', 'two' => '22222'})
-          end
-
-          it "should fail if the table doesn't have two columns" do
-            faulty_table = DataTable.new([
-              %w{one 1111 abc},
-              %w{two 22222 def}
+          it "should transpose the table" do
+            transposed = DataTable.new([
+              %w{one two},
+              %w{1111 22222}
             ], location)
-            expect { faulty_table.rows_hash }.to raise_error('The table must have exactly 2 columns')
-          end
-        end
-
-        describe "#new" do
-          it "should allow Array of Hash" do
-            t1 = DataTable.new([{'name' => 'aslak', 'male' => 'true'}], location)
-            expect( t1.hashes ).to eq [{'name' => 'aslak', 'male' => 'true'}]
-          end
-        end
-
-        it "should convert to sexp" do
-          sexp_value =      
-            [:table,
-              [:row, -1,
-                [:cell, "one"],
-                [:cell, "four"],
-                [:cell, "seven"]
-              ],
-              [:row, -1,
-                [:cell, "4444"],
-                [:cell, "55555"],
-                [:cell, "666666"]
-              ]
-            ]
-          expect( @table.to_sexp ).to eq sexp_value
-        end
-
-        describe "#each_cell" do
-          it "runs the given block on each cell in the table" do
-            table = DataTable.new([[1,2],[3,4]], location)
-            values = []
-            table.each_cell do |cell|
-              values << cell.value
-            end
-            expect( values ).to eq [1,2,3,4]
+            expect( @table.transpose ).to eq( transposed )
           end
         end
 

data/spec/cucumber/core/ast/location_spec.rb

@@ -24,6 +24,14 @@ module Cucumber::Core::Ast
       end
     end
 
+    describe "line" do
+      it "is an integer" do
+        expect(Location.new(file, line).line).to be_kind_of(Integer)
+        expect(Location.new(file, 1..2).line).to be_kind_of(Integer)
+        expect(Location.of_caller.line).to be_kind_of(Integer)
+      end
+    end
+
     describe "to_s" do
       it "is file:line for a precise location" do
         expect( Location.new("foo.feature", 12).to_s ).to eq "foo.feature:12"

data/spec/cucumber/core/ast/outline_step_spec.rb

@@ -8,7 +8,8 @@ module Cucumber
   module Core
     module Ast
       describe OutlineStep do
-        let(:outline_step) { OutlineStep.new(language, location, keyword, name, multiline_arg) }
+        let(:outline_step) { OutlineStep.new(node, language, location, keyword, name, multiline_arg) }
+        let(:node) { double }
         let(:language) { double }
         let(:location) { double }
         let(:keyword)  { double }
@@ -35,16 +36,10 @@ module Cucumber
               expect( outline_step.to_step(row).name ).to eq 'a green cucumber'
             end
 
-            it "knows the name of the outline step" do
-              row = ExamplesTable::Row.new({'color' => 'green'}, 1, location)
-              outline_step.gherkin_statement(double(:name => name))
-              expect( outline_step.to_step(row).gherkin_statement.name ).to eq name
-            end
-
           end
 
           context "when the step has a DataTable" do
-            let(:outline_step) { OutlineStep.new(language, location, keyword, name, table) }
+            let(:outline_step) { OutlineStep.new(node, language, location, keyword, name, table) }
             let(:name)  { "anything" }
             let(:table) { DataTable.new([['x', 'y'],['a', 'a <arg>']], Location.new('foo.feature', 23)) }
 
@@ -62,7 +57,7 @@ module Cucumber
 
           context "when the step has a DocString" do
             let(:location) { double }
-            let(:outline_step) { OutlineStep.new(language, location, keyword, name, doc_string) }
+            let(:outline_step) { OutlineStep.new(node, language, location, keyword, name, doc_string) }
             let(:doc_string) { DocString.new('a <arg> that needs replacing', '', location) }
             let(:name) { 'anything' }
 

data/spec/cucumber/core/ast/step_spec.rb

@@ -5,9 +5,9 @@ module Cucumber
     module Ast
       describe Step do
         let(:step) do
-          language, location, keyword, name = *double
+          node, language, location, keyword, name = *double
           multiline_arg = EmptyMultilineArgument.new
-          Step.new(language, location, keyword, name, multiline_arg)
+          Step.new(node, language, location, keyword, name, multiline_arg)
         end
 
         describe "describing itself" do
@@ -26,7 +26,7 @@ module Cucumber
           end
 
           context "with a multiline argument" do
-            let(:step) { Step.new(double, double, double, double, multiline_arg) }
+            let(:step) { Step.new(double, double, double, double, double, multiline_arg) }
             let(:multiline_arg) { double }
 
             it "tells its multiline argument to describe itself" do
@@ -38,6 +38,73 @@ module Cucumber
 
         end
 
+        describe "backtrace line" do
+          let(:step) { Step.new(double, double, "path/file.feature:10", "Given ", "this step passes", double) }
+
+          it "knows how to form the backtrace line" do
+            expect( step.backtrace_line ).to eq("path/file.feature:10:in `Given this step passes'")
+          end
+
+        end
+
+      end
+
+      describe ExpandedOutlineStep do
+        let(:outline_step) { double }
+        let(:step) do
+          node, language, location, keyword, name = *double
+          multiline_arg = EmptyMultilineArgument.new
+          ExpandedOutlineStep.new(outline_step, node, language, location, keyword, name, multiline_arg)
+        end
+
+        describe "describing itself" do
+          let(:visitor) { double }
+
+          it "describes itself as a step" do
+            expect( visitor ).to receive(:step).with(step)
+            step.describe_to(visitor)
+          end
+
+          context "with no multiline argument" do
+            it "does not try to describe any children" do
+              allow( visitor ).to receive(:step).with(step).and_yield(visitor)
+              step.describe_to(visitor)
+            end
+          end
+
+          context "with a multiline argument" do
+            let(:step) { Step.new(double, double, double, double, double, multiline_arg) }
+            let(:multiline_arg) { double }
+
+            it "tells its multiline argument to describe itself" do
+              allow( visitor ).to receive(:step).with(step).and_yield(visitor)
+              expect( multiline_arg ).to receive(:describe_to).with(visitor)
+              step.describe_to(visitor)
+            end
+          end
+
+        end
+
+        describe "matching location" do
+          let(:location) { double }
+
+          it "also match the outline steps location" do
+            allow( location).to receive(:any?).and_return(nil)
+            expect( outline_step ).to receive(:match_locations?).with(location)
+            step.match_locations?(location)
+          end
+        end
+
+        describe "backtrace line" do
+          let(:outline_step) { OutlineStep.new(double, double, "path/file.feature:5", "Given ", "this step <state>", double) }
+          let(:step) { ExpandedOutlineStep.new(outline_step, double, double, "path/file.feature:10", "Given ", "this step passes", double) }
+
+          it "includes the outline step in the backtrace line" do
+            expect( step.backtrace_line ).to eq("path/file.feature:10:in `Given this step passes'\n" +
+                                                "path/file.feature:5:in `Given this step <state>'")
+          end
+
+        end
       end
     end
   end