cucumber 3.0.0.pre.1 → 3.0.0.pre.2

data/lib/cucumber/rb_support/rb_transform.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-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,171 +0,0 @@
-# frozen_string_literal: true
-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
-
-      # Extend the World with user-defined modules
-      def add_modules!(world_modules, namespaced_world_modules)
-        add_world_modules!(world_modules)
-        add_namespaced_modules!(namespaced_world_modules)
-      end
-
-      # 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
-
-      # 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
-        modules << stringify_namespaced_modules
-        sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
-      end
-
-      # see {#inspect}
-      def to_s
-        inspect
-      end
-
-      private
-
-      # @private
-      def add_world_modules!(modules)
-        modules.each do |world_module|
-          extend(world_module)
-        end
-      end
-
-      # @private
-      def add_namespaced_modules!(modules)
-        @__namespaced_modules = modules
-        modules.each do |namespace, world_modules|
-          world_modules.each do |world_module|
-            variable_name = "@__#{namespace}_world"
-
-            inner_world = if self.class.respond_to?(namespace)
-                            instance_variable_get(variable_name)
-                          else
-                            Object.new
-                          end
-            instance_variable_set(variable_name,
-                                  inner_world.extend(world_module))
-            self.class.send(:define_method, namespace) do
-              instance_variable_get(variable_name)
-            end
-          end
-        end
-      end
-
-      def stringify_namespaced_modules
-        @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
-      end
-    end
-  end
-end

data/spec/cucumber/core_ext/instance_exec_spec.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core_ext/instance_exec'
-
-describe 'cucumber_instance_exec' do
-end

data/spec/cucumber/formatter/debug_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-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/rb_support/rb_language_spec.rb

@@ -1,321 +0,0 @@
-# frozen_string_literal: true
-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')
-          FileUtils.rm_rf('docs.md')
-        end
-
-        def a_file_called(name)
-          File.open(name, '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("docs.md") do
-            "yo"
-          end
-          rb.load_code_file('docs.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 'Handling namespaced World' do
-        module ModuleOne
-          def method_one
-            1
-          end
-        end
-
-        module ModuleMinusOne
-          def method_one
-            -1
-          end
-        end
-
-        module ModuleTwo
-          def method_two
-            2
-          end
-        end
-
-        module ModuleThree
-          def method_three
-            3
-          end
-        end
-
-        it 'extends the world with namespaces' do
-          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-            expect(included_modules.inspect).to match(/ModuleOne/)
-          end
-          expect(rb.current_world.class).to eq Object
-          expect(rb.current_world).to respond_to(:method_one)
-
-          expect(rb.current_world.module_two.class).to eq Object
-          expect(rb.current_world.module_two).to respond_to(:method_two)
-
-          expect(rb.current_world.module_three.class).to eq Object
-          expect(rb.current_world.module_three).to respond_to(:method_three)
-        end
-
-        it 'allows to inspect the included modules' do
-          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-          end
-          expect(rb.current_world.inspect).to match(/ModuleOne/)
-          expect(rb.current_world.inspect).to include('ModuleTwo (as module_two)')
-          expect(rb.current_world.inspect).to include('ModuleThree (as module_three)')
-        end
-
-        it 'merges methods when assigning different modules to the same namespace' do
-          dsl.World(namespace: ModuleOne)
-          dsl.World(namespace: ModuleTwo)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-          end
-          expect(rb.current_world.namespace).to respond_to(:method_one)
-          expect(rb.current_world.namespace).to respond_to(:method_two)
-        end
-
-        it 'resolves conflicts when assigning different modules to the same namespace' do
-          dsl.World(namespace: ModuleOne)
-          dsl.World(namespace: ModuleMinusOne)
-          rb.begin_scenario(double('scenario').as_null_object)
-          class << rb.current_world
-            extend RSpec::Matchers
-          end
-          expect(rb.current_world.namespace).to respond_to(:method_one)
-          expect(rb.current_world.namespace.method_one).to eql(-1)
-        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