cucumber 2.99.0 → 3.0.0

data/spec/cucumber/step_match_spec.rb

@@ -1,18 +1,19 @@
 # encoding: utf-8
+# frozen_string_literal: true
 require 'spec_helper'
-require 'cucumber/rb_support/rb_step_definition'
-require 'cucumber/rb_support/rb_language'
+require 'cucumber/glue/step_definition'
+require 'cucumber/glue/registry_and_more'
 
 module Cucumber
   describe StepMatch do
     WORD = '[[:word:]]'
 
     before do
-      @rb_language = RbSupport::RbLanguage.new(nil, Configuration.new)
+      @registry = Glue::RegistryAndMore.new(nil, Configuration.new)
     end
 
-    def stepdef(regexp)
-      RbSupport::RbStepDefinition.new(@rb_language, regexp, lambda{}, {})
+    def stepdef(string_or_regexp)
+      Glue::StepDefinition.new(@registry, string_or_regexp, lambda{}, {})
     end
 
     def step_match(regexp, name)
@@ -20,66 +21,66 @@ module Cucumber
       StepMatch.new(stepdef, name, stepdef.arguments_from(name))
     end
 
-    it "formats step names" do
-      m = step_match(/it (.*) in (.*)/, "it snows in april")
-      format = m.format_args("[%s]")
-      expect(format).to eq "it [snows] in [april]"
+    it 'formats step names' do
+      m = step_match(/it (.*) in (.*)/, 'it snows in april')
+      format = m.format_args('[%s]')
+      expect(format).to eq 'it [snows] in [april]'
     end
 
-    it "formats one group when we use Unicode" do
+    it 'formats one group when we use Unicode' do
       m = step_match(/I (#{WORD}+) ok/, "I æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ ok")
 
-      expect(m.format_args("<span>%s</span>")).to eq "I <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> ok"
+      expect(m.format_args('<span>%s</span>')).to eq "I <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> ok"
     end
 
-    it "formats several groups when we use Unicode" do
+    it 'formats several groups when we use Unicode' do
       m = step_match(/I (#{WORD}+) (#{WORD}+) (#{WORD}+) this (#{WORD}+)/, "I ate æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ egg this morning")
 
-      expect(m.format_args("<span>%s</span>")).to eq "I <span>ate</span> <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> <span>egg</span> this <span>morning</span>"
+      expect(m.format_args('<span>%s</span>')).to eq "I <span>ate</span> <span>æøåÆØÅæøåÆØÅæøåÆØÅæøåÆØÅ</span> <span>egg</span> this <span>morning</span>"
     end
 
-    it "deals with Unicode both inside and outside arguments" do
-      expect("Jæ vø ålsker døtte løndet").to match /Jæ (.+) ålsker (.+) løndet/
+    it 'deals with Unicode both inside and outside arguments' do
+      expect("Jæ vø ålsker døtte løndet").to match(/Jæ (.+) ålsker (.+) løndet/)
 
       m = step_match(/Jæ (#{WORD}+) ålsker (#{WORD}+) løndet/, "Jæ vø ålsker døtte løndet")
 
-      expect(m.format_args("<span>%s</span>")).to eq "Jæ <span>vø</span> ålsker <span>døtte</span> løndet"
+      expect(m.format_args('<span>%s</span>')).to eq "Jæ <span>vø</span> ålsker <span>døtte</span> løndet"
     end
 
-    it "formats groups with format string" do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I ate 1 egg this morning")
+    it 'formats groups with format string' do
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I ate 1 egg this morning')
 
-      expect(m.format_args("<span>%s</span>")).to eq "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+      expect(m.format_args('<span>%s</span>')).to eq 'I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>'
     end
 
-    it "formats groups with format string when there are dupes" do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I bob 1 bo this bobs")
+    it 'formats groups with format string when there are dupes' do
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I bob 1 bo this bobs')
 
-      expect(m.format_args("<span>%s</span>")).to eq "I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>"
+      expect(m.format_args('<span>%s</span>')).to eq 'I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>'
     end
 
-    it "formats groups with block" do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I ate 1 egg this morning")
+    it 'formats groups with block' do
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I ate 1 egg this morning')
 
-      expect(m.format_args(&lambda{|m| "<span>#{m}</span>"})).to eq "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+      expect(m.format_args(&lambda{|m| "<span>#{m}</span>"})).to eq 'I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>'
     end
 
-    it "formats groups with proc object" do
-      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, "I ate 1 egg this morning")
+    it 'formats groups with proc object' do
+      m = step_match(/I (#{WORD}+) (\d+) (#{WORD}+) this (#{WORD}+)/, 'I ate 1 egg this morning')
 
-      expect(m.format_args(lambda{|m| "<span>#{m}</span>"})).to eq "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
+      expect(m.format_args(lambda{|m| "<span>#{m}</span>"})).to eq 'I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>'
     end
 
-    it "formats groups even when first group is optional and not matched" do
+    it 'formats groups even when first group is optional and not matched' do
       m = step_match(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
 
-      expect(m.format_args("<span>%s</span>")).to eq "I should be flashed '<span>Login failed.</span>'"
+      expect(m.format_args('<span>%s</span>')).to eq "I should be flashed '<span>Login failed.</span>'"
     end
 
-    it "formats embedded groups" do
-      m = step_match(/running( (\d+) times)? (\d+) meters/, "running 5 times 10 meters")
+    it 'formats embedded groups' do
+      m = step_match(/running( (\d+) times)? (\d+) meters/, 'running 5 times 10 meters')
 
-      expect(m.format_args("<span>%s</span>")).to eq "running<span> 5 times</span> <span>10</span> meters"
+      expect(m.format_args('<span>%s</span>')).to eq 'running<span> 5 times</span> <span>10</span> meters'
     end
   end
 end

data/spec/cucumber/world/pending_spec.rb

@@ -1,45 +1,46 @@
+# frozen_string_literal: true
 require 'spec_helper'
-require 'cucumber/rb_support/rb_language'
+require 'cucumber/glue/registry_and_more'
 require 'cucumber/configuration'
 
 module Cucumber
   describe 'Pending' do
     before(:each) do
-      l = RbSupport::RbLanguage.new(Runtime.new, Configuration.new)
-      l.begin_rb_scenario(double('scenario').as_null_object)
-      @world = l.current_world
+      registry = Glue::RegistryAndMore.new(Runtime.new, Configuration.new)
+      registry.begin_scenario(double('scenario').as_null_object)
+      @world = registry.current_world
     end
 
     it 'raises a Pending if no block is supplied' do
       expect(-> {
-        @world.pending "TODO"
+        @world.pending 'TODO'
       }).to raise_error(Cucumber::Pending, /TODO/)
     end
 
     it 'raises a Pending if a supplied block fails as expected' do
       expect(-> {
-        @world.pending "TODO" do
-        raise "oops"
+        @world.pending 'TODO' do
+        raise 'oops'
         end
       }).to raise_error(Cucumber::Pending, /TODO/)
     end
 
     it 'raises a Pending if a supplied block fails as expected with a double' do
       expect do
-        @world.pending "TODO" do
+        @world.pending 'TODO' do
           m = double('thing')
           expect(m).to receive(:foo)
           RSpec::Mocks.verify
         end
       end.to raise_error(Cucumber::Pending, /TODO/)
       # The teardown is needed so that the message expectation does not bubble up.
-      RSpec::Mocks.teardown 
+      RSpec::Mocks.teardown
     end
 
     it 'raises a Pending if a supplied block starts working' do
       expect(-> {
-        @world.pending "TODO" do
-        # success!
+        @world.pending 'TODO' do
+          # success!
         end
       }).to raise_error(Cucumber::Pending, /TODO/)
     end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 ENV['CUCUMBER_COLORS'] = nil
 $:.unshift(File.dirname(__FILE__))
 

data/spec/support/standard_step_actions.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 # Filter that activates steps with obvious pass / fail behaviour
 class StandardStepActions < Cucumber::Core::Filter.new
   def test_case(test_case)
     test_steps = test_case.test_steps.map do |step|
-      case step.name
+      case step.text
       when /fail/
         step.with_action { raise Failure }
       when /pass/