cucumber-core 1.2.0 → 1.3.0

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

@@ -1,5 +1,8 @@
+require 'gherkin3/parser'
+require 'gherkin3/token_scanner'
+require 'gherkin3/errors'
 require 'cucumber/core/gherkin/ast_builder'
-require 'gherkin/parser/parser'
+require 'cucumber/core/ast'
 
 module Cucumber
   module Core
@@ -15,13 +18,18 @@ module Cucumber
         end
 
         def document(document)
-          builder = AstBuilder.new(document.uri)
-          parser = ::Gherkin::Parser::Parser.new(builder, true, "root", false)
+          parser  = ::Gherkin3::Parser.new
+          scanner = ::Gherkin3::TokenScanner.new(document.body)
+          core_builder = AstBuilder.new(document.uri)
+
+          if document.body.strip.empty?
+            return receiver.feature Ast::NullFeature.new
+          end
 
           begin
-            parser.parse(document.body, document.uri, 0)
-            builder.language = parser.i18n_language
-            receiver.feature builder.result
+            result = parser.parse(scanner)
+
+            receiver.feature core_builder.feature(result)
           rescue *PARSER_ERRORS => e
             raise Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
           end
@@ -34,16 +42,8 @@ module Cucumber
 
         private
 
-        PARSER_ERRORS = if Cucumber::JRUBY
-                          [
-                            ::Java::GherkinLexer::LexingError
-                          ]
-                        else
-                          [
-                            ::Gherkin::Lexer::LexingError,
-                            ::Gherkin::Parser::ParseError,
-                          ]
-                        end
+        PARSER_ERRORS = ::Gherkin3::ParserError
+
       end
     end
   end

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

@@ -0,0 +1,64 @@
+module Cucumber
+module Core
+module Gherkin
+  class TagExpression
+
+    attr_reader :limits
+
+    def initialize(tag_expressions)
+      @ands = []
+      @limits = {}
+      tag_expressions.each do |expr|
+        add(expr.strip.split(/\s*,\s*/))
+      end
+    end
+
+    def empty?
+      @ands.empty?
+    end
+
+    def evaluate(tags)
+      return true if @ands.flatten.empty?
+      vars = Hash[*tags.map{|tag| [tag.name, true]}.flatten]
+      raise "No vars" if vars.nil? # Useless statement to prevent ruby warnings about unused var
+      !!Kernel.eval(ruby_expression)
+    end
+
+  private
+
+    def add(tags_with_negation_and_limits)
+      negatives, positives = tags_with_negation_and_limits.partition{|tag| tag =~ /^~/}
+      @ands << (store_and_extract_limits(negatives, true) + store_and_extract_limits(positives, false))
+    end
+
+    def store_and_extract_limits(tags_with_negation_and_limits, negated)
+      tags_with_negation = []
+      tags_with_negation_and_limits.each do |tag_with_negation_and_limit|
+        tag_with_negation, limit = tag_with_negation_and_limit.split(':')
+        tags_with_negation << tag_with_negation
+        if limit
+          tag_without_negation = negated ? tag_with_negation[1..-1] : tag_with_negation
+          if @limits[tag_without_negation] && @limits[tag_without_negation] != limit.to_i
+            raise "Inconsistent tag limits for #{tag_without_negation}: #{@limits[tag_without_negation]} and #{limit.to_i}"
+          end
+          @limits[tag_without_negation] = limit.to_i
+        end
+      end
+      tags_with_negation
+    end
+
+    def ruby_expression
+      "(" + @ands.map do |ors|
+        ors.map do |tag|
+          if tag =~ /^~(.*)/
+            "!vars['#{$1}']"
+          else
+            "vars['#{tag}']"
+          end
+        end.join("||")
+      end.join(")&&(") + ")"
+    end
+  end
+end
+end
+end

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

@@ -1,4 +1,5 @@
 require 'cucumber/core/test/result'
+require 'cucumber/core/gherkin/tag_expression'
 
 module Cucumber
   module Core
@@ -55,9 +56,8 @@ module Cucumber
           @tags ||= TagCollector.new(self).result
         end
 
-        require 'gherkin/tag_expression'
         def match_tags?(*expressions)
-          ::Gherkin::TagExpression.new(expressions.flatten).evaluate(tags.map {|t| ::Gherkin::Formatter::Model::Tag.new(t.name, t.line) })
+          Cucumber::Core::Gherkin::TagExpression.new(expressions.flatten).evaluate(tags)
         end
 
         def match_name?(name_regexp)

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

@@ -4,8 +4,8 @@ module Cucumber
   module Core
     module Test
       class Runner
-        attr_reader :report, :running_test_case
-        private :report, :running_test_case
+        attr_reader :report, :running_test_case, :running_test_step
+        private :report, :running_test_case, :running_test_step
 
         def initialize(report)
           @report = report
@@ -13,6 +13,7 @@ module Cucumber
 
         def test_case(test_case, &descend)
           @running_test_case = RunningTestCase.new
+          @running_test_step = nil
           report.before_test_case(test_case)
           descend.call(self)
           report.after_test_case(test_case, running_test_case.result)
@@ -20,14 +21,18 @@ module Cucumber
         end
 
         def test_step(test_step)
+          @running_test_step = test_step
           report.before_test_step test_step
           step_result = running_test_case.execute(test_step)
           report.after_test_step test_step, step_result
+          @running_test_step = nil
           self
         end
 
         def around_hook(hook, &continue)
-          running_test_case.execute(hook, &continue)
+          result = running_test_case.execute(hook, &continue)
+          report.after_test_step running_test_step, result if running_test_step
+          @running_test_step = nil
           self
         end
 
@@ -98,7 +103,7 @@ module Cucumber
               def execute(test_step, monitor, &continue)
                 result = test_step.execute(monitor.result, &continue)
                 result = result.with_message(%(Undefined step: "#{test_step.name}")) if result.undefined?
-                result = result.with_appended_backtrace(test_step.source.last) if test_step.respond_to?(:source)
+                result = result.with_appended_backtrace(test_step.source.last) if IsStepVisitor.new(test_step).step?
                 result.describe_to(monitor, result)
               end
 

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

@@ -57,6 +57,25 @@ module Cucumber
         end
 
       end
+
+      class IsStepVisitor
+        def initialize(test_step)
+          @is_step = false
+          test_step.describe_to(self)
+        end
+
+        def step?
+          @is_step
+        end
+
+        def test_step(*)
+          @is_step = true
+        end
+
+        def method_missing(*)
+          self
+        end
+      end
     end
   end
 end

data/lib/cucumber/core/version.rb

@@ -2,7 +2,7 @@ module Cucumber
   module Core
     class Version
       def self.to_s
-        "1.2.0"
+        "1.3.0"
       end
     end
   end

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

@@ -3,7 +3,7 @@ module Cucumber::Core::Ast
   describe Background do
     it "has a useful inspect" do
       location = Location.new("features/a_feature.feature", 3)
-      background = Background.new(double, double, location, double, "Background", "the name", double, [])
+      background = Background.new(location, double, "Background", "the name", double, [])
       expect(background.inspect).to eq(%{#<Cucumber::Core::Ast::Background "Background: the name" (#{location})>})
     end
   end

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

@@ -1,6 +1,12 @@
 require 'cucumber/core/ast/location'
 
 module Cucumber::Core::Ast
+  RSpec::Matchers.define :be_included_in do |expected|
+    match do |actual|
+      expected.include? actual
+    end
+  end  
+
   describe Location do
     let(:line) { 12 }
     let(:file) { "foo.feature" }
@@ -115,6 +121,45 @@ module Cucumber::Core::Ast
         end
       end
     end
+
+    describe "created from source location" do
+      context "when the location is in the tree below pwd" do
+        it "create a relative path from pwd" do
+          expect( Location.from_source_location(Dir.pwd + "/path/file.rb", 1).file ).to eq "path/file.rb"
+        end
+      end
+
+      context "when the location is in an installed gem" do
+        it "create a relative path from the gem directory" do
+          expect( Location.from_source_location("/path/gems/gem-name/path/file.rb", 1).file ).to eq "gem-name/path/file.rb"
+        end
+      end
+
+      context "when the location is neither below pwd nor in an installed gem" do
+        it "use the absolute path to the file" do
+          expect( Location.from_source_location("/path/file.rb", 1).file ).to eq "/path/file.rb"
+        end
+      end
+    end
+
+    describe "created from file-colon-line" do
+      it "handles also Windows paths" do
+        expect( Location.from_file_colon_line("c:\path\file.rb:123").file ).to eq "c:\path\file.rb"
+      end
+    end
+
+    describe "created of caller" do
+      it "use the location of the caller" do
+        expect( Location.of_caller.to_s ).to be_included_in caller[0]
+      end
+
+      context "when specifying additional caller depth"do      
+        it "use the location of the n:th caller" do
+          expect( Location.of_caller(1).to_s ).to be_included_in caller[1]
+        end
+      end
+    end
+
   end
 end
 

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

@@ -8,8 +8,7 @@ module Cucumber
   module Core
     module Ast
       describe OutlineStep do
-        let(:outline_step) { OutlineStep.new(node, language, location, comments, keyword, name, multiline_arg) }
-        let(:node) { double }
+        let(:outline_step) { OutlineStep.new(language, location, comments, keyword, name, multiline_arg) }
         let(:language) { double }
         let(:location) { double }
         let(:comments)  { double }
@@ -46,7 +45,7 @@ module Cucumber
           end
 
           context "when the step has a DataTable" do
-            let(:outline_step) { OutlineStep.new(node, language, location, comments, keyword, name, table) }
+            let(:outline_step) { OutlineStep.new(language, location, comments, keyword, name, table) }
             let(:name)  { "anything" }
             let(:table) { DataTable.new([['x', 'y'],['a', 'a <arg>']], Location.new('foo.feature', 23)) }
 
@@ -64,7 +63,7 @@ module Cucumber
 
           context "when the step has a DocString" do
             let(:location) { double }
-            let(:outline_step) { OutlineStep.new(node, language, location, comments, keyword, name, doc_string) }
+            let(:outline_step) { OutlineStep.new(language, location, comments, 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

@@ -1,14 +1,16 @@
 require 'cucumber/core/ast/step'
-require 'gherkin/i18n'
+require 'cucumber/core/ast/outline_step'
+require 'cucumber/core/ast/empty_multiline_argument'
+require 'gherkin3/dialect'
 
 module Cucumber
   module Core
     module Ast
       describe Step do
         let(:step) do
-          node, language, location, comments, keyword, name = *double
+          language, location, comments, keyword, name = *double
           multiline_arg = EmptyMultilineArgument.new
-          Step.new(node, language, location, comments, keyword, name, multiline_arg)
+          Step.new(language, location, comments, keyword, name, multiline_arg)
         end
 
         describe "describing itself" do
@@ -27,7 +29,7 @@ module Cucumber
           end
 
           context "with a multiline argument" do
-            let(:step) { Step.new(double, double, 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
@@ -46,7 +48,7 @@ module Cucumber
         end
 
         describe "backtrace line" do
-          let(:step) { Step.new(double, double, "path/file.feature:10", double, "Given ", "this step passes", double) }
+          let(:step) { Step.new(double, "path/file.feature:10", double, "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'")
@@ -55,12 +57,12 @@ module Cucumber
         end
 
         describe "actual keyword" do
-          let(:language) { ::Gherkin::I18n.get('en') }
+          let(:language) { ::Gherkin3::Dialect.for('en') }
 
           context "for keywords 'given', 'when' and 'then'" do
-            let(:given_step) { Step.new(double, language, double, double, "Given ", double, double) }
-            let(:when_step) { Step.new(double, language, double, double, "When ", double, double) }
-            let(:then_step) { Step.new(double, language, double, double, "Then ", double, double) }
+            let(:given_step) { Step.new(language, double, double, "Given ", double, double) }
+            let(:when_step) { Step.new(language, double, double, "When ", double, double) }
+            let(:then_step) { Step.new(language, double, double, "Then ", double, double) }
 
             it "returns the keyword itself" do
               expect( given_step.actual_keyword(nil) ).to eq("Given ")
@@ -70,9 +72,9 @@ module Cucumber
           end
 
           context "for keyword 'and', 'but', and '*'" do
-            let(:and_step) { Step.new(double, language, double, double, "And ", double, double) }
-            let(:but_step) { Step.new(double, language, double, double, "But ", double, double) }
-            let(:asterisk_step) { Step.new(double, language, double, double, "* ", double, double) }
+            let(:and_step) { Step.new(language, double, double, "And ", double, double) }
+            let(:but_step) { Step.new(language, double, double, "But ", double, double) }
+            let(:asterisk_step) { Step.new(language, double, double, "* ", double, double) }
 
             context "when the previous step keyword exist" do
               it "returns the previous step keyword" do
@@ -93,8 +95,8 @@ module Cucumber
           end
 
           context "for i18n languages" do
-            let(:language) { ::Gherkin::I18n.get('en-lol') }
-            let(:and_step) { Step.new(double, language, double, double, "AN ", double, double) }
+            let(:language) { ::Gherkin3::Dialect.for('en-lol') }
+            let(:and_step) { Step.new(language, double, double, "AN ", double, double) }
 
             it "returns the keyword in the correct language" do
               expect( and_step.actual_keyword(nil) ).to eq("I CAN HAZ ")
@@ -106,10 +108,10 @@ module Cucumber
       describe ExpandedOutlineStep do
         let(:outline_step) { double }
         let(:step) do
-          node, language, location, keyword, name = *double
-          comments = []
+          language, location, keyword, name = *double
           multiline_arg = EmptyMultilineArgument.new
-          ExpandedOutlineStep.new(outline_step, node, language, location, comments, keyword, name, multiline_arg)
+          comments = []
+          ExpandedOutlineStep.new(outline_step, language, location, comments, keyword, name, multiline_arg)
         end
 
         describe "describing itself" do
@@ -128,7 +130,7 @@ module Cucumber
           end
 
           context "with a multiline argument" do
-            let(:step) { ExpandedOutlineStep.new(double, double, double, 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
@@ -157,8 +159,8 @@ module Cucumber
         end
 
         describe "backtrace line" do
-          let(:outline_step) { OutlineStep.new(double, double, "path/file.feature:5", double, "Given ", "this step <state>", double) }
-          let(:step) { ExpandedOutlineStep.new(outline_step, double, double, "path/file.feature:10", double, "Given ", "this step passes", double) }
+          let(:outline_step) { OutlineStep.new(double, "path/file.feature:5", double, "Given ", "this step <state>", double) }
+          let(:step) { ExpandedOutlineStep.new(outline_step, double, "path/file.feature:10", double, "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" +

data/spec/cucumber/core/gherkin/parser_spec.rb

@@ -15,7 +15,7 @@ module Cucumber
         end
 
         context "for invalid gherkin" do
-          let(:source) { Gherkin::Document.new(path, 'not gherkin') }
+          let(:source) { Gherkin::Document.new(path, "\nnot gherkin\n\nFeature: \n") }
           let(:path)   { 'path_to/the.feature' }
 
           it "raises an error" do
@@ -116,19 +116,48 @@ module Cucumber
           end
         end
 
-        context "a Scenario with a Comment" do
+        context "a feature file with a comments on different levels" do
           source do
+            comment 'feature comment'
             feature do
-              comment 'wow'
-              scenario
+              comment 'scenario comment'
+              scenario do
+                comment 'step comment'
+                step
+              end
+              comment 'scenario outline comment'
+              scenario_outline do
+                comment 'outline step comment'
+                step
+                comment 'examples comment'
+                examples do
+                  row
+                  row
+                end
+              end
             end
           end
 
-          it "parses the comment into the AST" do
+          it "the comments are distibuted to down the ast tree from the feature" do
             visitor = double
-            allow( visitor ).to receive(:feature).and_yield(visitor)
+            expect( visitor ).to receive(:feature) do |feature|
+              expect( feature.comments.join ).to eq "# feature comment"
+              visitor
+            end.and_yield(visitor)
             expect( visitor ).to receive(:scenario) do |scenario|
-              expect( scenario.comments.join ).to eq "# wow"
+              expect( scenario.comments.join ).to eq "  # scenario comment"
+            end.and_yield(visitor)
+            expect( visitor ).to receive(:step) do |step|
+              expect( step.comments.join ).to eq "    # step comment"
+            end.and_yield(visitor)
+            expect( visitor ).to receive(:scenario_outline) do |scenario_outline|
+              expect( scenario_outline.comments.join ).to eq "  # scenario outline comment"
+            end.and_yield(visitor)
+            expect( visitor ).to receive(:outline_step) do |outline_step|
+              expect( outline_step.comments.join ).to eq "    # outline step comment"
+            end.and_yield(visitor)
+            expect( visitor ).to receive(:examples_table) do |examples_table|
+              expect( examples_table.comments.join ).to eq "    # examples comment"
             end
             feature.describe_to(visitor)
           end