cucumber-core 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 82c21261d3bd32b6f07c066ffc1fc87559b54c80adedacb1b219dc5a6fa607dc
-  data.tar.gz: 2b11fd0ed43ca9b8aa3b5fc0041c5c341bd2ba2f16324319bde2e0c010fdc308
+SHA1:
+  metadata.gz: a5ba16d6f3fc1772d232afd8159f009c8464e586
+  data.tar.gz: 69531a546edaa1bd2d51cb66510451043f32e87a
 SHA512:
-  metadata.gz: b39751c63f5fda3cbaa4d66fe634e86eadbdbb9efb92b6c4f8bf5bde36259a374c9a41c313a10db9ebc849564e97374c9af715f71a74ec64820b4630c789d256
-  data.tar.gz: 06c3dc949a7a213e661ac021a793d4177dde521887a538ed291a4031200562ddb8f96ab70c2598ac78cbbcb68b6eee8c0fe67a61f72a894fc396b887b3150e7a
+  metadata.gz: ee28cc3b48def98ad79cae99e5b8eb4ded00dd08e550235d2289a89ad2d4a46a2ef58709294089289adb4aed9a69b60093f655879aa1a9e66164e23dba0942f2
+  data.tar.gz: 1809cd9af683812a02b68fd82ef97a858bc5529dd9951718cfff8dd940fe8eef2a43eb6d5f78d62148588fe5c2698db031888b382928a64fdc1acbc351ca5685

data/CHANGELOG.md

@@ -1,6 +1,6 @@
 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)
+## [In Git](https://github.com/cucumber/cucumber-ruby-core/compare/v5.0.0...master)
 
 ### Changed
 
@@ -22,6 +22,12 @@ Please see [CONTRIBUTING.md](https://github.com/cucumber/cucumber/blob/master/CO
 
 * N/A
 
+## [5.0.0](https://github.com/cucumber/cucumber-ruby-core/compare/v4.0.0...v5.0.0)
+
+### Changed
+
+* Update to use Gherkin v7
+
 ## [4.0.0](https://github.com/cucumber/cucumber-ruby-core/compare/v3.2.0...v4.0.0)
 
 ### Changed

data/README.md

@@ -1,10 +1,9 @@
 # cucumber-core
 
 [![Chat with us](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cucumber/cucumber-ruby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Build Status](https://secure.travis-ci.org/cucumber/cucumber-ruby-core.svg)](http://travis-ci.org/cucumber/cucumber-ruby-core)
+[![Build Status](https://travis-ci.org/cucumber/cucumber-ruby-core.svg?branch=master)](https://travis-ci.org/cucumber/cucumber-ruby-core)
 [![Code Climate](https://codeclimate.com/github/cucumber/cucumber-ruby-core.svg)](https://codeclimate.com/github/cucumber/cucumber-ruby-core)
 [![Coverage Status](https://coveralls.io/repos/cucumber/cucumber-ruby-core/badge.svg?branch=master)](https://coveralls.io/r/cucumber/cucumber-ruby-core?branch=master)
-[![Dependency Status](https://gemnasium.com/cucumber/cucumber-ruby-core.svg)](https://gemnasium.com/cucumber/cucumber-ruby-core)
 
 Cucumber Core is the [inner hexagon](http://alistair.cockburn.us/Hexagonal+architecture) for the [Ruby flavour of Cucumber](https://github.com/cucumber/cucumber-ruby).
 

data/lib/cucumber/core/compiler.rb

@@ -31,34 +31,36 @@ module Cucumber
       private
 
       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])
+        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
 
       def create_test_step(pickle_step, uri)
-        lines = pickle_step[:locations].map { |location| location[:line] }.sort.reverse
+        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)
+        Test::Step.new(pickle_step.text, Test::Location.new(uri, lines), multiline_arg)
       end
 
       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])
-          )
+        if pickle_step.argument
+          if pickle_step.argument.doc_string
+            doc_string = pickle_step.argument.doc_string
+            Test::DocString.new(
+              doc_string.content,
+              doc_string.contentType,
+              Test::Location.new(uri, doc_string.location.line)
+            )
+          elsif pickle_step.argument.data_table
+            data_table = pickle_step.argument.data_table
+            first_cell = data_table.rows.first.cells.first
+            Test::DataTable.new(
+              data_table.rows.map { |row| row.cells.map { |cell| cell.value } },
+              Test::Location.new(uri, first_cell.location.line)
+            )
+          end
         else
           Test::EmptyMultilineArgument.new
         end

data/lib/cucumber/core/event_bus.rb

@@ -11,7 +11,7 @@ module Cucumber
     class EventBus
       attr_reader :event_types
 
-      # @param [Hash{Symbol => Class}] a hash of event types to use on the bus
+      # @param registry [Hash{Symbol => Class}] a hash of event types to use on the bus
       def initialize(registry = Events.registry)
         @event_types = registry.freeze
         @handlers = {}

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

@@ -19,17 +19,16 @@ module Cucumber
           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)
+              event_bus.gherkin_source_parsed(message.gherkinDocument)
             elsif !message.pickle.nil?
-              receiver.pickle(message.pickle.to_hash)
+              receiver.pickle(message.pickle)
             elsif !message.attachment.nil?
-              raise message.attachment.data
+              # Parse error
+              raise Core::Gherkin::ParseError.new("#{document.uri}: #{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

data/lib/cucumber/core/version.rb

@@ -3,7 +3,7 @@ module Cucumber
   module Core
     class Version
       def self.to_s
-        "4.0.0"
+        "5.0.0"
       end
     end
   end

data/spec/capture_warnings.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+# With thanks to @myronmarston
+# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
+
+module CaptureWarnings
+  def report_warnings(&block)
+    current_dir = Dir.pwd
+    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
+    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
+
+    if errors.any?
+      puts errors.join("\n")
+    end
+
+    if other_warnings.any?
+      puts "#{ other_warnings.count } non-cucumber-core warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
+      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
+    end
+
+    # Until they fix https://bugs.ruby-lang.org/issues/10661
+    if RUBY_VERSION == "2.2.0"
+      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
+    end
+
+    if project_warnings.any?
+      puts "#{ project_warnings.count } cucumber-core warnings detected"
+      print_warnings('cucumber-core', project_warnings)
+      fail "Please remove all cucumber-core warnings."
+    end
+
+    ensure_system_exit_if_required
+  end
+
+  def capture_error(&block)
+    old_stderr = STDERR.clone
+    pipe_r, pipe_w = IO.pipe
+    pipe_r.sync    = true
+    error         = String.new
+    reader = Thread.new do
+      begin
+        loop do
+          error << pipe_r.readpartial(1024)
+        end
+      rescue EOFError
+      end
+    end
+    STDERR.reopen(pipe_w)
+    block.call
+  ensure
+    capture_system_exit
+    STDERR.reopen(old_stderr)
+    pipe_w.close
+    reader.join
+    return error.split("\n")
+  end
+
+  def print_warnings(type, warnings)
+    puts
+    puts "-" * 30 + " #{type} warnings: " + "-" * 30
+    puts
+    puts warnings.join("\n")
+    puts
+    puts "-" * 75
+    puts
+  end
+
+  def ensure_system_exit_if_required
+    raise @system_exit if @system_exit
+  end
+
+  def capture_system_exit
+    @system_exit = $!
+  end
+end

data/spec/coverage.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'simplecov'
+formatters = [ SimpleCov::Formatter::HTMLFormatter ]
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  formatters << Coveralls::SimpleCov::Formatter
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatters)
+SimpleCov.start

data/spec/cucumber/core/compiler_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+require 'cucumber/core'
+require 'cucumber/core/compiler'
+require 'cucumber/core/gherkin/writer'
+
+module Cucumber::Core
+  describe Compiler do
+    include Gherkin::Writer
+    include Cucumber::Core
+
+    def self.stubs(*names)
+      names.each do |name|
+        let(name) { double(name.to_s) }
+      end
+    end
+
+    it "compiles a feature with a single scenario" do
+      gherkin_documents = [
+        gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      ]
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered.and_yield(visitor)
+        expect( visitor ).to receive(:test_step).once.ordered
+        expect( visitor ).to receive(:done).once.ordered
+      end
+    end
+
+    it "compiles a feature with a background" do
+      gherkin_documents = [
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      ]
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered.and_yield(visitor)
+        expect( visitor ).to receive(:test_step).exactly(2).times.ordered
+        expect( visitor ).to receive(:done).once.ordered
+      end
+    end
+
+    it "compiles multiple features" do
+      gherkin_documents = [
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end,
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      ]
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered
+        expect( visitor ).to receive(:test_step).twice.ordered
+        expect( visitor ).to receive(:test_case).once.ordered
+        expect( visitor ).to receive(:test_step).twice.ordered
+        expect( visitor ).to receive(:done).once
+      end
+    end
+
+    context "compiling scenario outlines" do
+      it "compiles a scenario outline to test cases" do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              background do
+                step 'passing'
+              end
+
+              scenario_outline do
+                step 'passing <arg>'
+                step 'passing'
+
+                examples 'examples 1' do
+                  row 'arg'
+                  row '1'
+                  row '2'
+                end
+
+                examples 'examples 2' do
+                  row 'arg'
+                  row 'a'
+                end
+              end
+            end
+          end
+        ]
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_case).exactly(3).times.and_yield(visitor)
+          expect( visitor ).to receive(:test_step).exactly(9).times
+          expect( visitor ).to receive(:done).once
+        end
+      end
+
+      it 'replaces arguments correctly when generating test steps' do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              scenario_outline do
+                step 'passing <arg1> with <arg2>'
+                step 'as well as <arg3>'
+
+                examples do
+                  row 'arg1', 'arg2', 'arg3'
+                  row '1',    '2',    '3'
+                end
+              end
+            end
+          end
+        ]
+
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_step) do |test_step|
+            expect(test_step.text).to eq 'passing 1 with 2'
+          end.once.ordered
+
+          expect( visitor ).to receive(:test_step) do |test_step|
+            expect(test_step.text).to eq 'as well as 3'
+          end.once.ordered
+
+          expect( visitor ).to receive(:done).once.ordered
+        end
+      end
+    end
+
+    context 'empty scenarios' do
+      it 'does create test cases for them' do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              scenario do
+              end
+            end
+          end
+        ]
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_case).once.ordered
+          expect( visitor ).to receive(:done).once.ordered
+        end
+      end
+    end
+
+    def compile(gherkin_documents)
+      visitor = double
+      allow( visitor ).to receive(:test_suite).and_yield(visitor)
+      allow( visitor ).to receive(:test_case).and_yield(visitor)
+      yield visitor
+      super(gherkin_documents, visitor)
+    end
+
+  end
+end

data/spec/cucumber/core/event_bus_spec.rb

@@ -0,0 +1,163 @@
+require "cucumber/core/event_bus"
+
+module Cucumber
+  module Core
+    module Events
+
+      class TestEvent < Core::Event.new(:some_attribute)
+      end
+
+      AnotherTestEvent = Core::Event.new
+
+      UnregisteredEvent = Core::Event.new
+    end
+
+    describe EventBus do
+      let(:event_bus) { EventBus.new(registry) }
+      let(:registry) { { test_event: Events::TestEvent, another_test_event: Events::AnotherTestEvent } }
+
+      context "broadcasting events" do
+
+        it "can broadcast by calling a method named after the event ID" do
+          called = false
+          event_bus.on(:test_event) {called = true }
+          event_bus.test_event
+          expect(called).to be true
+        end
+
+        it "can broadcast by calling the `broadcast` method with an instance of the event type" do
+          called = false
+          event_bus.on(:test_event) {called = true }
+          event_bus.broadcast(Events::TestEvent.new(:some_attribute))
+          expect(called).to be true
+        end
+
+        it "calls a subscriber for an event, passing details of the event" do
+          received_payload = nil
+          event_bus.on :test_event do |event|
+            received_payload = event
+          end
+
+          event_bus.test_event :some_attribute
+
+          expect(received_payload.some_attribute).to eq(:some_attribute)
+        end
+
+        it "does not call subscribers for other events" do
+          handler_called = false
+          event_bus.on :test_event do
+            handler_called = true
+          end
+
+          event_bus.another_test_event
+
+          expect(handler_called).to eq(false)
+        end
+
+        it "broadcasts to multiple subscribers" do
+          received_events = []
+          event_bus.on :test_event do
+            received_events << :event
+          end
+          event_bus.on :test_event do
+            received_events << :event
+          end
+
+          event_bus.test_event(:some_attribute)
+
+          expect(received_events.length).to eq 2
+        end
+
+        it "raises an error when given an event to broadcast that it doesn't recognise" do
+          expect { event_bus.some_unknown_event }.to raise_error(NameError)
+        end
+
+        context "#broadcast method" do
+          it "must be passed an instance of a registered event type" do
+            expect { 
+              event_bus.broadcast Events::UnregisteredEvent
+            }.to raise_error(ArgumentError)
+          end
+        end
+
+      end
+
+      context "subscribing to events" do
+        it "allows subscription by symbol (Event ID)" do
+          received_payload = nil
+          event_bus.on(:test_event) do |event|
+            received_payload = event
+          end
+
+          event_bus.test_event :some_attribute
+
+          expect(received_payload.some_attribute).to eq(:some_attribute)
+        end
+
+        it "raises an error if you use an unknown Event ID" do
+          expect { 
+            event_bus.on(:some_unknown_event) { :whatever }
+          }.to raise_error(ArgumentError)
+        end
+
+        it "allows handlers that are objects with a `call` method" do
+          class MyHandler
+            attr_reader :received_payload
+
+            def call(event)
+              @received_payload = event
+            end
+          end
+
+          handler = MyHandler.new
+          event_bus.on(:test_event, handler)
+
+          event_bus.test_event :some_attribute
+
+          expect(handler.received_payload.some_attribute).to eq :some_attribute
+        end
+
+        it "allows handlers that are procs" do
+          class MyProccyHandler
+            attr_reader :received_payload
+
+            def initialize(event_bus)
+              event_bus.on :test_event, &method(:on_test_event)
+            end
+
+            def on_test_event(event)
+              @received_payload = event
+            end
+          end
+
+          handler = MyProccyHandler.new(event_bus)
+
+          event_bus.test_event :some_attribute
+          expect(handler.received_payload.some_attribute).to eq :some_attribute
+        end
+
+        it "sends events that were broadcast before you subscribed" do
+          event_bus.test_event :some_attribute
+          event_bus.another_test_event
+
+          received_payload = nil
+          event_bus.on(:test_event) do |event|
+            received_payload = event
+          end
+
+          expect(received_payload.some_attribute).to eq(:some_attribute)
+        end
+
+      end
+
+      it "will let you inspect the registry" do
+        expect(event_bus.event_types[:test_event]).to eq Events::TestEvent
+      end
+
+      it "won't let you modify the registry" do
+        expect { event_bus.event_types[:foo] = :bar }.to raise_error(RuntimeError)
+      end
+
+    end
+  end
+end