cucumber 2.99.0 → 3.0.0

data/lib/cucumber/rb_support/rb_transform.rb

@@ -1,59 +0,0 @@
-module Cucumber
-  module RbSupport
-    # A Ruby Transform holds a Regexp and a Proc, and is created
-    # by calling <tt>Transform in the <tt>support</tt> ruby files.
-    # See also RbDsl.
-    #
-    # Example:
-    #
-    #   Transform /^(\d+) cucumbers$/ do |cucumbers_string|
-    #     cucumbers_string.to_i
-    #   end
-    #
-    class RbTransform
-      class MissingProc < StandardError
-        def message
-          "Transforms must always have a proc with at least one argument"
-        end
-      end
-
-      def initialize(rb_language, pattern, proc)
-        raise MissingProc if proc.nil? || proc.arity < 1
-        @rb_language, @regexp, @proc = rb_language, Regexp.new(pattern), proc
-      end
-
-      def match(arg)
-        arg ? arg.match(@regexp) : nil
-      end
-
-      def invoke(arg)
-        if matched = match(arg)
-          args = matched.captures.empty? ? [arg] : matched.captures
-          @rb_language.current_world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
-        end
-      end
-
-      def to_s
-         convert_captures(strip_anchors(@regexp.source))
-      end
-
-    private
-      def convert_captures(regexp_source)
-        regexp_source
-          .gsub(/(\()(?!\?[<:=!])/,'(?:')
-          .gsub(/(\(\?<)(?![=!])/,'(?:<')
-      end
-
-      def strip_captures(regexp_source)
-        regexp_source.
-          gsub(/(\()/, '').
-          gsub(/(\))/, '')
-      end
-
-      def strip_anchors(regexp_source)
-        regexp_source.
-          gsub(/(^\^|\$$)/, '')
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_world.rb

@@ -1,149 +0,0 @@
-require 'cucumber/gherkin/formatter/ansi_escapes'
-
-module Cucumber
-  module RbSupport
-    # Defines the basic DSL methods availlable in all Cucumber step definitions.
-    #
-    # You can, and probably should, extend this DSL with your own methods that
-    # make sense in your domain. For more on that, see {Cucumber::RbSupport::RbDsl#World}
-    module RbWorld
-
-      # @private
-      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
-
-      # Call a Transform with a string from another Transform definition
-      def Transform(arg)
-        rb = @__cucumber_runtime.support_code.ruby
-        rb.execute_transforms([arg]).first
-      end
-
-      # @private
-      attr_writer :__cucumber_runtime, :__natural_language
-
-      # Run a single Gherkin step
-      # @example Call another step
-      #   step "I am logged in"
-      # @example Call a step with quotes in the name
-      #   step %{the user "Dave" is logged in}
-      # @example Passing a table
-      #   step "the following users exist:", table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @example Passing a multiline string
-      #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
-      # @param [String] name The name of the step
-      # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
-      def step(name, raw_multiline_arg=nil)
-        location = Core::Ast::Location.of_caller
-        @__cucumber_runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
-      end
-
-      # Run a snippet of Gherkin
-      # @example
-      #   steps %{
-      #     Given the user "Susan" exists
-      #     And I am logged in as "Susan"
-      #   }
-      # @param [String] steps_text The Gherkin snippet to run
-      def steps(steps_text)
-        location = Core::Ast::Location.of_caller
-        @__cucumber_runtime.invoke_dynamic_steps(steps_text, @__natural_language, location)
-      end
-
-      # Parse Gherkin into a {Cucumber::Ast::Table} object.
-      #
-      # Useful in conjunction with the #step method.
-      # @example Create a table
-      #   users = table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @param [String] text_or_table The Gherkin string that represents the table
-      def table(text_or_table, file=nil, line_offset=0)
-        @__cucumber_runtime.table(text_or_table, file, line_offset)
-      end
-
-      # Create an {Cucumber::Ast::DocString} object
-      #
-      # Useful in conjunction with the #step method, when
-      # want to specify a content type.
-      # @example Create a multiline string
-      #   code = multiline_string(%{
-      #     puts "this is ruby code"
-      #   %}, 'ruby')
-      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-        STDERR.puts AnsiEscapes.failed + "WARNING: #doc_string is deprecated. Just pass a regular String instead:" + caller[0] + AnsiEscapes.reset
-        # TODO: rename this method to multiline_string
-        @__cucumber_runtime.doc_string(string_without_triple_quotes, content_type, line_offset)
-      end
-
-      # @deprecated Use {#puts} instead.
-      def announce(*messages)
-        STDERR.puts AnsiEscapes.failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + AnsiEscapes.reset
-        puts(*messages)
-      end
-
-      # Print a message to the output.
-      #
-      # @note Cucumber might surprise you with the behaviour of this method. Instead
-      #   of sending the output directly to STDOUT, Cucumber will intercept and cache
-      #   the message until the current step has finished, and then display it.
-      #
-      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
-      def puts(*messages)
-        # Even though they won't be output until later, converting the messages to
-        # strings right away will protect them from modifications to their original
-        # objects in the mean time
-        messages.collect! { |message| "#{message}" }
-
-        @__cucumber_runtime.puts(*messages)
-      end
-
-      # Pause the tests and ask the operator for input
-      def ask(question, timeout_seconds=60)
-        @__cucumber_runtime.ask(question, timeout_seconds)
-      end
-
-      # Embed an image in the output
-      def embed(file, mime_type, label='Screenshot')
-        @__cucumber_runtime.embed(file, mime_type, label)
-      end
-
-      # Mark the matched step as pending.
-      def pending(message = "TODO")
-        if block_given?
-          begin
-            yield
-          rescue Exception
-            raise Pending, message
-          end
-          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
-        else
-          raise Pending, message
-        end
-      end
-
-      # Skips this step and the remaining steps in the scenario
-      def skip_this_scenario(message = "Scenario skipped")
-        raise Core::Test::Result::Skipped, message
-      end
-
-      # Prints the list of modules that are included in the World
-      def inspect
-        modules = [self.class]
-        (class << self; self; end).instance_eval do
-          modules += included_modules
-        end
-        sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
-      end
-
-      # see {#inspect}
-      def to_s
-        inspect
-      end
-    end
-  end
-end

data/spec/cucumber/core_ext/instance_exec_spec.rb

@@ -1,4 +0,0 @@
-require 'cucumber/core_ext/instance_exec'
-
-describe 'cucumber_instance_exec' do
-end

data/spec/cucumber/events/bus_spec.rb

@@ -1,94 +0,0 @@
-require "cucumber/events/bus"
-
-module Cucumber
-  module Events
-    class TestEvent
-    end
-
-    class AnotherTestEvent
-    end
-
-    describe Bus do
-      let(:bus) { Bus.new(Cucumber::Events) }
-      let(:test_event) { TestEvent.new }
-      let(:another_test_event) { AnotherTestEvent.new }
-
-      it "calls subscriber with event payload" do
-        received_payload = nil
-        bus.register(TestEvent) do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "does not call subscribers for other events" do
-        handler_called = false
-        bus.register(TestEvent) do |event|
-          handler_called = true
-        end
-
-        bus.notify another_test_event
-
-        expect(handler_called).to eq(false)
-      end
-
-      it "broadcasts to multiple subscribers" do
-        received_events = []
-        bus.register(TestEvent) do |event|
-          received_events << event
-        end
-        bus.register(TestEvent) do |event|
-          received_events << event
-        end
-
-        bus.notify test_event
-
-        expect(received_events.length).to eq 2
-        expect(received_events).to all eq test_event
-      end
-
-      it "allows subscription by string" do
-        received_payload = nil
-        bus.register('Cucumber::Events::TestEvent') do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "allows subscription by symbol (for events in the Cucumber::Events namespace)" do
-        received_payload = nil
-        bus.register(:test_event) do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      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
-        bus.register(TestEvent, handler)
-
-        bus.notify test_event
-
-        expect(handler.received_payload).to eq test_event
-      end
-
-    end
-  end
-end

data/spec/cucumber/formatter/debug_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/debug'
-require 'cucumber/cli/options'
-
-module Cucumber
-  module Formatter
-    describe Debug do
-      extend SpecHelperDsl
-      include SpecHelper
-
-        before(:each) do
-          Cucumber::Term::ANSIColor.coloring = false
-          @out = StringIO.new
-          @formatter = Debug.new(runtime, @out, {})
-        end
-
-        describe "given a single feature" do
-          before(:each) { run_defined_feature }
-
-          describe "with a scenario" do
-            define_feature <<-FEATURE
-          Feature: Banana party
-
-            Scenario: Monkey eats banana
-              Given there are bananas
-            FEATURE
-
-            it "outputs the events as expected" do
-              expect(@out.string).to eq(<<EXPECTED)
-before_test_case
-before_features
-before_feature
-before_tags
-after_tags
-feature_name
-before_test_step
-after_test_step
-before_test_step
-before_feature_element
-before_tags
-after_tags
-scenario_name
-before_steps
-before_step
-before_step_result
-step_name
-after_step_result
-after_step
-after_test_step
-after_steps
-after_feature_element
-after_test_case
-after_feature
-after_features
-done
-EXPECTED
-            end
-          end
-        end
-    end
-
-  end
-end

data/spec/cucumber/formatter/event_bus_report_spec.rb

@@ -1,88 +0,0 @@
-require 'cucumber/configuration'
-require 'cucumber/runtime'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/event_bus_report'
-
-module Cucumber
-  module Formatter
-    describe EventBusReport do
-      extend SpecHelperDsl
-      include SpecHelper
-
-      context "With no options" do
-        let(:config) { Cucumber::Configuration.new }
-
-        before(:each) do
-          @formatter = EventBusReport.new(config)
-        end
-
-        describe "given a single feature" do
-
-          describe "a scenario with a single passing step" do
-            define_feature <<-FEATURE
-          Feature:
-            Scenario: Test Scenario
-              Given passing
-            FEATURE
-
-            define_steps do
-              Given(/pass/) {}
-            end
-
-            it "emits a BeforeTestCase event" do
-              received_event = nil
-              config.on_event Cucumber::Events::BeforeTestCase do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-            end
-
-            it "emits a BeforeTestStep event" do
-              received_event = nil
-              config.on_event Cucumber::Events::BeforeTestStep do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-              expect(received_event.test_step.name).to eq "passing"
-            end
-
-            it "emits an AfterTestStep event with a passed result" do
-              received_event = nil
-              config.on_event Cucumber::Events::AfterTestStep do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-              expect(received_event.test_step.name).to eq "passing"
-              expect(received_event.result).to be_passed
-            end
-
-            it "emits an AfterTestCase event with a passed result" do
-              received_event = nil
-              config.on_event Cucumber::Events::AfterTestCase do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-              expect(received_event.result).to be_passed
-            end
-
-            it "emits a Done event when the test run is finished" do
-              received_event = nil
-              config.on_event Cucumber::Events::FinishedTesting do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event).not_to be_nil
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-
-

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-require 'cucumber/rb_support/rb_language'
-
-module Cucumber
-  module RbSupport
-    describe RbStepDefinition do
-      let(:user_interface) { double('user interface') }
-      let(:rb)             { support_code.ruby }
-      let(:support_code) do
-        Cucumber::Runtime::SupportCode.new(user_interface)
-      end
-      let(:dsl) do
-        rb
-        Object.new.extend(RbSupport::RbDsl)
-      end
-
-      describe "#load_code_file" do
-        after do
-          FileUtils.rm_rf('tmp.rb')
-        end
-
-        def a_file_called(name)
-          File.open('tmp.rb', 'w') do |f|
-            f.puts yield
-          end
-        end
-
-        it "re-loads the file when called multiple times" do
-          a_file_called('tmp.rb') do
-            "$foo = 1"
-          end
-
-          rb.load_code_file('tmp.rb')
-          expect($foo).to eq 1
-
-          a_file_called('tmp.rb') do
-            "$foo = 2"
-          end
-
-          rb.load_code_file('tmp.rb')
-
-          expect($foo).to eq 2
-        end
-
-        it "only loads ruby files" do
-          a_file_called("readme.md") do
-            "yo"
-          end
-          rb.load_code_file('readme.md')
-        end
-      end
-
-      describe "Handling the World" do
-        it "raises an error if the world is nil" do
-          dsl.World {}
-
-          begin
-            rb.begin_scenario(nil)
-            raise "Should fail"
-          rescue RbSupport::NilWorld => e
-            expect(e.message).to eq "World procs should never return nil"
-            expect(e.backtrace.length).to eq 1
-            expect(e.backtrace[0]).to match(/spec\/cucumber\/rb_support\/rb_language_spec\.rb\:\d+\:in `World'/)
-          end
-        end
-
-        module ModuleOne
-        end
-
-        module ModuleTwo
-        end
-
-        class ClassOne
-        end
-
-        it "implicitlys extend world with modules" do
-          dsl.World(ModuleOne, ModuleTwo)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-
-            expect(included_modules.inspect).to match(/ModuleOne/) # Workaround for RSpec/Ruby 1.9 issue with namespaces
-            expect(included_modules.inspect).to match(/ModuleTwo/)
-          end
-          expect(rb.current_world.class).to eq Object
-        end
-
-        it "raises error when we try to register more than one World proc" do
-          expected_error = %{You can only pass a proc to #World once, but it's happening
-in 2 places:
-
-spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
-spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
-
-Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
-or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
-
-}
-          dsl.World { Hash.new }
-
-          expect(-> {
-            dsl.World { Array.new }
-          }).to raise_error(RbSupport::MultipleWorld, /#{expected_error}/)
-        end
-      end
-
-      describe "step argument transformations" do
-        describe "without capture groups" do
-          it "complains when registering with a with no transform block" do
-            expect(-> {
-              dsl.Transform('^abc$')
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a zero-arg transform block" do
-            expect(-> {
-              dsl.Transform('^abc$') {42}
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a splat-arg transform block" do
-            expect(-> {
-              dsl.Transform('^abc$') {|*splat| 42 }
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when transforming with an arity mismatch" do
-            expect(-> {
-              dsl.Transform('^abc$') {|one, two| 42 }
-              rb.execute_transforms(['abc'])
-            }).to raise_error(Cucumber::ArityMismatchError)
-          end
-
-          it "allows registering a regexp pattern that yields the step_arg matched" do
-            dsl.Transform(/^ab*c$/) {|arg| 42}
-
-            expect(rb.execute_transforms(['ab'])).to eq ['ab']
-            expect(rb.execute_transforms(['ac'])).to eq [42]
-            expect(rb.execute_transforms(['abc'])).to eq [42]
-            expect(rb.execute_transforms(['abbc'])).to eq [42]
-          end
-
-          it "transforms times" do
-            require 'time'
-            dsl.Transform(/^(\d\d-\d\d-\d\d\d\d)$/) do |arg|
-              Time.parse(arg)
-            end
-            expect(rb.execute_transforms(['10-0E-1971'])).to eq ['10-0E-1971']
-            expect(rb.execute_transforms(['10-03-1971'])).to eq [Time.parse('10-03-1971')]
-          end
-        end
-
-        describe "with capture groups" do
-          it "complains when registering with a with no transform block" do
-            expect(-> {
-              dsl.Transform('^a(.)c$')
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a zero-arg transform block" do
-            expect(-> {
-              dsl.Transform('^a(.)c$') { 42 }
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when registering with a splat-arg transform block" do
-            expect(-> {
-              dsl.Transform('^a(.)c$') {|*splat| 42 }
-            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-          end
-
-          it "complains when transforming with an arity mismatch" do
-            expect(-> {
-              dsl.Transform('^a(.)c$') {|one, two| 42 }
-              rb.execute_transforms(['abc'])
-            }).to raise_error(Cucumber::ArityMismatchError)
-          end
-
-          it "allows registering a regexp pattern that yields capture groups" do
-            dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
-              {shape.to_sym => color.to_sym}
-            end
-
-            expect(rb.execute_transforms(['shape: circle, color: blue'])).to eq [{:circle => :blue}]
-            expect(rb.execute_transforms(['shape: square, color: red'])).to eq [{:square => :red}]
-            expect(rb.execute_transforms(['not shape: square, not color: red'])).to eq ['not shape: square, not color: red']
-          end
-        end
-
-        it "allows registering a string pattern" do
-          dsl.Transform('^ab*c$') {|arg| 42}
-
-          expect(rb.execute_transforms(['ab'])).to eq ['ab']
-          expect(rb.execute_transforms(['ac'])).to eq [42]
-          expect(rb.execute_transforms(['abc'])).to eq [42]
-          expect(rb.execute_transforms(['abbc'])).to eq [42]
-        end
-
-        it "gives match priority to transforms defined last" do
-          dsl.Transform(/^transform_me$/) {|arg| :foo }
-          dsl.Transform(/^transform_me$/) {|arg| :bar }
-          dsl.Transform(/^transform_me$/) {|arg| :baz }
-
-          expect(rb.execute_transforms(['transform_me'])).to eq [:baz]
-        end
-
-        it "allows registering a transform which returns nil" do
-          dsl.Transform('^ac$') {|arg| nil}
-
-          expect(rb.execute_transforms(['ab'])).to eq ['ab']
-          expect(rb.execute_transforms(['ac'])).to eq [nil]
-        end
-      end
-
-      describe "hooks" do
-        it "finds before hooks" do
-          fish = dsl.Before('@fish'){}
-          meat = dsl.Before('@meat'){}
-
-          scenario = double('Scenario')
-
-          expect(scenario).to receive(:accept_hook?).with(fish) { true }
-          expect(scenario).to receive(:accept_hook?).with(meat) { false }
-          expect(rb.hooks_for(:before, scenario)).to eq [fish]
-        end
-
-        it "finds around hooks" do
-          a = dsl.Around do |scenario, block|
-          end
-
-          b = dsl.Around('@tag') do |scenario, block|
-          end
-
-          scenario = double('Scenario')
-
-          expect(scenario).to receive(:accept_hook?).with(a) { true }
-          expect(scenario).to receive(:accept_hook?).with(b) { false }
-          expect(rb.hooks_for(:around, scenario)).to eq [a]
-        end
-      end
-    end
-  end
-end