cucumber-core 3.2.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dca5c34098216100e0a9ff047bc2d42b9e8dda47
-  data.tar.gz: aa847f085e1019a5a453ffb7b1a6d9a024694489
+SHA256:
+  metadata.gz: 82c21261d3bd32b6f07c066ffc1fc87559b54c80adedacb1b219dc5a6fa607dc
+  data.tar.gz: 2b11fd0ed43ca9b8aa3b5fc0041c5c341bd2ba2f16324319bde2e0c010fdc308
 SHA512:
-  metadata.gz: d3a9110d17664518200a78fd4671ba89118e1b6513f7c0bdccdbd8706e40a31278e1f5e364e07d60c981fdc6aa7fbe21f1e59264b1c647be8afb3f2103087922
-  data.tar.gz: b3bca052952a7b249c76bd6e3890cba35ea05390a775656920828447721c84182c2b36fe8ce548c1f53c0b24e68e701a169f606c1c196eef366ca2f71a0c679b
+  metadata.gz: b39751c63f5fda3cbaa4d66fe634e86eadbdbb9efb92b6c4f8bf5bde36259a374c9a41c313a10db9ebc849564e97374c9af715f71a74ec64820b4630c789d256
+  data.tar.gz: 06c3dc949a7a213e661ac021a793d4177dde521887a538ed291a4031200562ddb8f96ab70c2598ac78cbbcb68b6eee8c0fe67a61f72a894fc396b887b3150e7a

data/CHANGELOG.md

@@ -1,5 +1,57 @@
 Please see [CONTRIBUTING.md](https://github.com/cucumber/cucumber/blob/master/CONTRIBUTING.md) on how to contribute to Cucumber.
 
+## [In Git](https://github.com/cucumber/cucumber-ruby-core/compare/v4.0.0...master)
+
+### Changed
+
+* N/A
+
+### Added
+
+* N/A
+
+### Fixed
+
+* N/A
+
+### Removed
+
+* N/A
+
+### Improved
+
+* N/A
+
+## [4.0.0](https://github.com/cucumber/cucumber-ruby-core/compare/v3.2.0...v4.0.0)
+
+### Changed
+
+* Update to use Gherkin v6 ([#158](https://github.com/cucumber/cucumber-ruby-core/pull/158) @brasmusson)
+* Let Scenarios with no Steps get the result status Undefined ([#157](https://github.com/cucumber/cucumber-ruby-core/pull/157) @brasmusson)
+* Convert to use the Gherkin compiler and Pickles ([#156](https://github.com/cucumber/cucumber-ruby-core/pull/156) @brasmusson)
+
+### Added
+
+* N/A
+
+### Fixed
+
+* N/A
+
+### Removed
+
+* Remove the support for old style tag expressions ([#159](https://github.com/cucumber/cucumber-ruby-core/pull/159) @brasmusson)
+
+### Improved
+
+* N/A
+
+## [3.2.1](https://github.com/cucumber/cucumber-ruby-core/compare/v3.2.0...v3.2.1)
+
+### Fixed
+
+* Switched `gherkin` in Gemspec to use _pessimistic_ versioning. (These two commits aren't merged into `master`, as they already exist in newer commits. This is a 'backported' patch to resolve [#160](https://github.com/cucumber/cucumber-ruby-core/issues/160)).
+
 ## [3.2.0](https://github.com/cucumber/cucumber-ruby-core/compare/v3.1.0...v3.2.0)
 
 ### Added

data/lib/cucumber/core/compiler.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
+
 require 'cucumber/core/test/case'
 require 'cucumber/core/test/step'
+require 'cucumber/core/test/tag'
+require 'cucumber/core/test/doc_string'
+require 'cucumber/core/test/data_table'
+require 'cucumber/core/test/empty_multiline_argument'
 
 module Cucumber
   module Core
-
-    # Compiles the AST into test cases
+    # Compiles the Pickles into test cases
     class Compiler
       attr_reader :receiver
       private     :receiver
@@ -14,10 +18,9 @@ module Cucumber
         @receiver = receiver
       end
 
-      def feature(feature)
-        compiler = FeatureCompiler.new(TestCaseBuilder.new(receiver))
-        feature.describe_to(compiler)
-        self
+      def pickle(pickle)
+        test_case = create_test_case(pickle)
+        test_case.describe_to(receiver)
       end
 
       def done
@@ -25,152 +28,41 @@ module Cucumber
         self
       end
 
-      # @private
-      class TestCaseBuilder
-        attr_reader :receiver
-        private     :receiver
-
-        def initialize(receiver)
-          @receiver = receiver
-        end
-
-        def on_background_step(source)
-          background_test_steps << Test::Step.new(source)
-          self
-        end
-
-        def on_step(source)
-          test_steps << Test::Step.new(source)
-          self
-        end
-
-        def on_test_case(source)
-          Test::Case.new(test_steps, source).describe_to(receiver) if test_steps.count > 0
-          @test_steps = nil
-          self
-        end
-
-        private
-
-        def background_test_steps
-          @background_test_steps ||= []
-        end
-
-        def test_steps
-          @test_steps ||= background_test_steps.dup
-        end
-      end
-
-      # @private
-      class FeatureCompiler
-        attr_reader :receiver
-        private     :receiver
-
-        def initialize(receiver)
-          @receiver = receiver
-        end
-
-        def feature(feature, &descend)
-          @feature = feature
-          descend.call(self)
-          self
-        end
-
-        def background(background, &descend)
-          source = [@feature, background]
-          compiler = BackgroundCompiler.new(source, receiver)
-          descend.call(compiler)
-          self
-        end
-
-        def scenario(scenario, &descend)
-          source = [@feature, scenario]
-          scenario_compiler = ScenarioCompiler.new(source, receiver)
-          descend.call(scenario_compiler)
-          receiver.on_test_case(source)
-          self
-        end
-
-        def scenario_outline(scenario_outline, &descend)
-          source = [@feature, scenario_outline]
-          compiler = ScenarioOutlineCompiler.new(source, receiver)
-          descend.call(compiler)
-          self
-        end
-      end
-
-      # @private
-      class ScenarioOutlineCompiler
-        attr_reader :source, :receiver
-        private     :source, :receiver
-
-        def initialize(source, receiver)
-          @source   = source
-          @receiver = receiver
-        end
-
-        def outline_step(outline_step)
-          outline_steps << outline_step
-          self
-        end
-
-        def examples_table(examples_table, &descend)
-          @examples_table = examples_table
-          descend.call(self)
-          self
-        end
-
-        def examples_table_row(row)
-          steps(row).each do |step|
-            receiver.on_step(source + [@examples_table, row, step])
-          end
-          receiver.on_test_case(source + [@examples_table, row])
-          self
-        end
+      private
 
-        private
-
-        def steps(row)
-          outline_steps.map { |s| s.to_step(row) }
-        end
-
-        def outline_steps
-          @outline_steps ||= []
-        end
+      def create_test_case(pickle)
+        uri = pickle[:uri]
+        test_steps = pickle[:steps].map { |step| create_test_step(step, uri) }
+        lines = pickle[:locations].map { |location| location[:line] }.sort.reverse
+        tags = pickle[:tags].map { |tag| Test::Tag.new(Test::Location.new(uri, tag[:location][:line]), tag[:name]) }
+        Test::Case.new(pickle[:name], test_steps, Test::Location.new(uri, lines), tags, pickle[:language])
       end
 
-      # @private
-      class ScenarioCompiler
-        attr_reader :source, :receiver
-        private     :source, :receiver
-
-        def initialize(source, receiver)
-          @source   = source
-          @receiver = receiver
-        end
-
-        def step(step)
-          receiver.on_step(source + [step])
-          self
-        end
+      def create_test_step(pickle_step, uri)
+        lines = pickle_step[:locations].map { |location| location[:line] }.sort.reverse
+        multiline_arg = create_multiline_arg(pickle_step, uri)
+        Test::Step.new(pickle_step[:text], Test::Location.new(uri, lines), multiline_arg)
       end
 
-      # @private
-      class BackgroundCompiler
-        attr_reader :source, :receiver
-        private     :source, :receiver
-
-        def initialize(source, receiver)
-          @source   = source
-          @receiver = receiver
-        end
-
-        def step(step)
-          receiver.on_background_step(source + [step])
-          self
+      def create_multiline_arg(pickle_step, uri)
+        if !pickle_step[:doc_string].nil?
+          argument = pickle_step[:doc_string]
+          Test::DocString.new(
+            argument[:content],
+            argument[:content_type],
+            Test::Location.new(uri, argument[:location][:line])
+          )
+        elsif !pickle_step[:data_table].nil?
+          argument = pickle_step[:data_table]
+          first_cell = argument[:rows].first[:cells].first
+          Test::DataTable.new(
+            argument[:rows].map { |row| row[:cells].map { |cell| cell[:value] } },
+            Test::Location.new(uri, first_cell[:location][:line])
+          )
+        else
+          Test::EmptyMultilineArgument.new
         end
       end
-
     end
   end
 end

data/lib/cucumber/core/events.rb

@@ -6,10 +6,7 @@ module Cucumber
     module Events
 
       # Signals that a gherkin source has been parsed
-      class GherkinSourceParsed < Event.new(:uri, :gherkin_document)
-        # The uri of the file
-        attr_reader :uri
-
+      class GherkinSourceParsed < Event.new(:gherkin_document)
         # @return [GherkinDocument] the GherkinDocument Ast Node
         attr_reader :gherkin_document
 

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

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
-require 'gherkin/parser'
-require 'gherkin/token_scanner'
-require 'gherkin/errors'
-require 'cucumber/core/gherkin/ast_builder'
-require 'cucumber/core/ast'
+require 'gherkin/gherkin'
 
 module Cucumber
   module Core
@@ -20,30 +16,26 @@ module Cucumber
         end
 
         def document(document)
-          parser        = ::Gherkin::Parser.new
-          scanner       = ::Gherkin::TokenScanner.new(document.body)
-          token_matcher = ::Gherkin::TokenMatcher.new(document.language)
-          core_builder  = AstBuilder.new(document.uri)
-
-          begin
-            result = parser.parse(scanner, token_matcher)
-            event_bus.gherkin_source_parsed(document.uri, result.dup)
-
-            receiver.feature core_builder.feature(result)
-          rescue *PARSER_ERRORS => e
-            raise Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
+          messages = ::Gherkin::Gherkin.from_source(document.uri, document.body, {default_dialect: document.language, include_source: false})
+          messages.each do |message|
+            if !message.gherkinDocument.nil?
+              event_bus.gherkin_source_parsed(message.gherkinDocument.to_hash)
+            elsif !message.pickle.nil?
+              receiver.pickle(message.pickle.to_hash)
+            elsif !message.attachment.nil?
+              raise message.attachment.data
+            else
+              raise "Unknown message: #{message.to_hash}"
+            end
           end
+        rescue RuntimeError => e
+          raise Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
         end
 
         def done
           receiver.done
           self
         end
-
-        private
-
-        PARSER_ERRORS = ::Gherkin::ParserError
-
       end
     end
   end

data/lib/cucumber/core/report/summary.rb

@@ -29,32 +29,10 @@ module Cucumber
             end
           end
           event_bus.on(:test_step_finished) do |event|
-            event.result.describe_to test_steps if is_step?(event.test_step)
+            event.result.describe_to test_steps unless event.test_step.hook?
           end
           self
         end
-
-        def is_step?(test_step)
-          StepQueryVisitor.new(test_step).is_step?
-        end
-      end
-
-      class StepQueryVisitor
-        def initialize(test_step)
-          @step = false
-          test_step.source.last.describe_to(self)
-        end
-
-        def is_step?
-          @step
-        end
-
-        def step(*)
-          @step = true
-        end
-        
-        def method_missing(*)
-        end
       end
     end
   end

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

@@ -2,7 +2,7 @@
 require 'cucumber/core/test/result'
 require 'cucumber/core/test/timer'
 require 'cucumber/core/test/result'
-require 'cucumber/core/ast/location'
+require 'cucumber/core/test/location'
 
 module Cucumber
   module Core
@@ -10,7 +10,7 @@ module Cucumber
       class Action
         def initialize(location = nil, &block)
           raise ArgumentError, "Passing a block to execute the action is mandatory." unless block
-          @location = location ? location : Ast::Location.new(*block.source_location)
+          @location = location ? location : Test::Location.new(*block.source_location)
           @block = block
           @timer = Timer.new
         end

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

@@ -12,6 +12,10 @@ module Cucumber
           visitor.around_hook(self, *args, &continue)
         end
 
+        def hook?
+          true
+        end
+
         def execute(*args, &continue)
           @timer.start
           @block.call(continue)

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

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
+
 require 'cucumber/core/test/result'
 require 'cucumber/tag_expressions'
-require 'cucumber/core/gherkin/tag_expression'
-require 'cucumber/core/ast/location'
 
 module Cucumber
   module Core
     module Test
       class Case
-        attr_reader :source, :test_steps, :around_hooks
+        attr_reader :name, :test_steps, :location, :tags, :language, :around_hooks
 
-        def initialize(test_steps, source, around_hooks = [])
-          raise ArgumentError.new("test_steps should be an Array but is a #{test_steps.class}") unless test_steps.kind_of?(Array)
+        def initialize(name, test_steps, location, tags, language, around_hooks = [])
+          raise ArgumentError.new("test_steps should be an Array but is a #{test_steps.class}") unless test_steps.is_a?(Array)
+          @name = name
           @test_steps = test_steps
-          @source = source
+          @location = location
+          @tags = tags
+          @language = language
           @around_hooks = around_hooks
         end
 
@@ -32,31 +34,12 @@ module Cucumber
           self
         end
 
-        def describe_source_to(visitor, *args)
-          source.reverse.each do |node|
-            node.describe_to(visitor, *args)
-          end
-          self
-        end
-
         def with_steps(test_steps)
-          self.class.new(test_steps, source, around_hooks)
+          self.class.new(name, test_steps, location, tags, language, around_hooks)
         end
 
         def with_around_hooks(around_hooks)
-          self.class.new(test_steps, source, around_hooks)
-        end
-
-        def name
-          @name ||= NameBuilder.new(self).result
-        end
-        
-        def keyword
-          @keyword ||= NameBuilder.new(self).keyword
-        end
-
-        def tags
-          @tags ||= TagCollector.new(self).result
+          self.class.new(name, test_steps, location, tags, language, around_hooks)
         end
 
         def match_tags?(*expressions)
@@ -64,43 +47,19 @@ module Cucumber
         end
 
         def match_name?(name_regexp)
-          source.any? { |node| node.respond_to?(:name) && node.name =~ name_regexp }
-        end
-
-        def language
-          feature.language
-        end
-
-        def location
-          source.last.location
+          name =~ name_regexp
         end
 
         def match_locations?(queried_locations)
-          queried_locations.any? { |queried_location|
-            all_source.any? { |node|
-              node.all_locations.any? { |location|
-                queried_location.match? location
-              }
-            }
-          }
-        end
-
-        def all_locations
-          @all_locations ||= Ast::Location.merge(all_source.map(&:all_locations).flatten)
-        end
-
-        def all_source
-          @all_source ||= (source + test_steps.map(&:source)).flatten.uniq
+          queried_locations.any? do |queried_location|
+            queried_location.match? location
+          end
         end
 
         def inspect
           "#<#{self.class}: #{location}>"
         end
 
-        def feature
-          source.first
-        end
-
         def hash
           location.hash
         end
@@ -122,73 +81,8 @@ module Cucumber
         end
 
         def match_single_tag_expression?(expression)
-          if old_style_tag_expression?(expression)
-            Cucumber::Core::Gherkin::TagExpression.new([expression]).evaluate(tags)
-          else
-            Cucumber::TagExpressions::Parser.new.parse(expression).evaluate(tags.map(&:name))
-          end
-        end
-
-        def old_style_tag_expression?(expression)
-          expression.include?(',') || expression.include?('~')
+          Cucumber::TagExpressions::Parser.new.parse(expression).evaluate(tags.map(&:name))
         end
-
-        class NameBuilder
-          attr_reader :result
-          attr_reader :keyword
-
-          def initialize(test_case)
-            test_case.describe_source_to self
-          end
-
-          def feature(*)
-            self
-          end
-
-          def scenario(scenario)
-            @result = scenario.name
-            @keyword = scenario.keyword
-            self
-          end
-
-          def scenario_outline(outline)
-            @result = outline.name + @result
-            @keyword = outline.keyword
-            self
-          end
-
-          def examples_table(table)
-            name = table.name.strip
-            name = table.keyword if name.length == 0
-            @result = ", #{name}" + @result
-            self
-          end
-
-          def examples_table_row(row)
-            @result = " (##{row.number})"
-            self
-          end
-        end
-
-        class TagCollector
-          attr_reader :result
-
-          def initialize(test_case)
-            @result = []
-            test_case.describe_source_to self
-          end
-
-          [:feature, :scenario, :scenario_outline, :examples_table].each do |node_name|
-            define_method(node_name) do |node|
-              @result = node.tags + @result
-              self
-            end
-          end
-
-          def examples_table_row(*)
-          end
-        end
-
       end
     end
   end