cucumber 2.99.0 → 3.0.0

data/features/docs/writing_support_code/transforms.feature

@@ -1,98 +0,0 @@
-Feature: Transforms
-
-  Transforms allow you to convert primitive string arguments captured in step definitions
-  into more meaningful data types.
-
-  Background:
-    Let's just create a simple feature for testing out Transforms.
-    We also have a Person class that we need to be able to build.
-
-    Given a file named "features/foo.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given a Person aged 15 with blonde hair
-      """
-    And a file named "features/support/person.rb" with:
-      """
-      class Person
-        attr_accessor :age
-      
-        def to_s
-          "I am #{age} years old"
-        end
-      end
-      """
-
-  Scenario: Basic Transform
-    This is the most basic way to use a transform. Notice that the regular
-    expression is pretty much duplicated between the step defintion and the 
-    transform itself.
-
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Transform(/a Person aged (\d+)/) do |age|
-        person = Person.new
-        person.age = age.to_i
-        person
-      end
-      
-      Given /^(a Person aged \d+) with blonde hair$/ do |person|
-        expect(person.age).to eq 15
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass
-
-  Scenario: Re-use Transform's Regular Expression
-    If you keep a reference to the transform, you can use it in your
-    regular expressions to avoid repeating the regular expression.
-
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      A_PERSON = Transform(/a Person aged (\d+)/) do |age|
-        person = Person.new
-        person.age = age.to_i
-        person
-      end
-
-      Given /^(#{A_PERSON}) with blonde hair$/ do |person|
-        expect(person.age).to eq 15
-      end
-      """
-    When I run `cucumber features/foo.feature`
-    Then it should pass
-
-  Scenario: Use Transform from code
-    You can also call the `Transform` method from within a step definition to
-    dynamically run a tranform.
-
-    Note that this is rather useless at present, unless the transform itself has a side-effect, since the `Transform`
-    function still returns the regular expression pattern.
-
-    Given a file named "features/people.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given people with these ages:
-            | name  | age |
-            | sue   | 25  |
-            | sally | 77  |
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """
-      Transform(/a Person aged (\d+)/) do |age|
-        $person = Person.new
-        $person.age = age.to_i
-        $person
-      end
-
-      Given(/^people with these ages:$/) do |table|
-        table.rows.each do |name, age|
-          Transform("a Person aged #{age}")
-          expect($person.age).to eq age.to_i
-        end
-      end
-      """
-    When I run `cucumber features/people.feature`
-    Then it should pass

data/features/lib/step_definitions/wire_steps.rb

@@ -1,58 +0,0 @@
-Given /^there is a wire server (running |)on port (\d+) which understands the following protocol:$/ do |running, port, table|
-  protocol = table.hashes.map do |table_hash|
-    table_hash['response'] = table_hash['response'].gsub(/\n/, '\n')
-    table_hash
-  end
-
-  @server = FakeWireServer.new(port.to_i, protocol)
-  start_wire_server if running.strip == "running"
-end
-
-Given /^the wire server takes (.*) seconds to respond to the invoke message$/ do |timeout|
-  @server.delay_response(:invoke, timeout.to_f)
-  start_wire_server
-end
-
-Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value|
-  set_env(variable, value)
-end
-
-Then(/^the wire server should have received the following messages:$/) do |expected_messages|
-  expect(messages_received).to eq expected_messages.raw.flatten
-end
-
-module WireHelper
-  attr_reader :messages_received
-
-  def start_wire_server
-    @messages_received = []
-    reader, writer = IO.pipe
-    @wire_pid = fork { 
-      reader.close
-      @server.run(writer)
-    }
-    writer.close
-    Thread.new do
-      while message = reader.gets
-        @messages_received << message.strip
-      end
-    end
-    at_exit { stop_wire_server }
-  end
-
-  def stop_wire_server
-    return unless @wire_pid
-    Process.kill('KILL', @wire_pid)
-    Process.wait(@wire_pid)
-  rescue Errno::ESRCH
-    # No such process - wire server has already been stopped by the After hook
-  end
-end
-
-Before('@wire') do
-  extend(WireHelper)
-end
-
-After('@wire') do
-  stop_wire_server
-end

data/gem_tasks/cucumber.rake

@@ -1,25 +0,0 @@
-require 'cucumber/rake/task'
-require 'cucumber/platform'
-
-class Cucumber::Rake::Task
-  def set_profile_for_current_ruby
-    self.profile = if Cucumber::JRUBY
-      Cucumber::WINDOWS ? 'jruby_win' : 'jruby'
-    elsif Cucumber::WINDOWS_MRI
-      'windows_mri'
-    elsif Cucumber::RUBY_1_9
-      'ruby_1_9'
-    elsif Cucumber::RUBY_2_0
-      'ruby_2_0'
-    elsif Cucumber::RUBY_2_1
-      'ruby_2_1'
-    end
-  end
-end
-
-Cucumber::Rake::Task.new(:features) do |t|
-  t.fork = true
-  t.set_profile_for_current_ruby
-end
-
-task :cucumber => :features

data/lib/cucumber/ast.rb

@@ -1,13 +0,0 @@
-require 'cucumber/multiline_argument'
-
-module Cucumber
-  module Ast
-    def self.const_missing(const_name)
-      if const_name == :Table
-        warn "`Cucumber::Ast::Table` has been deprecated. Use `Cucumber::MultilineArgument::DataTable` instead."
-        return Cucumber::MultilineArgument::DataTable
-      end
-      raise "`Cucumber::Ast` no longer exists. These classes have moved into the `Cucumber::Core::Ast` namespace, but may not have the same API."
-    end
-  end
-end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -1,70 +0,0 @@
-require 'cucumber/platform'
-
-module Cucumber
-  # Raised if the number of a StepDefinition's Regexp match groups
-  # is different from the number of Proc arguments.
-  class ArityMismatchError < StandardError
-  end
-end
-
-class Object #:nodoc:
-  # TODO: Move most of this stuff out to an InstanceExecutor class.
-  def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
-    cucumber_run_with_backtrace_filtering(pseudo_method) do
-      if check_arity && !cucumber_compatible_arity?(args, block)
-        instance_exec do
-          ari = block.arity
-          ari = ari < 0 ? (ari.abs-1).to_s+"+" : ari
-          s1 = ari == 1 ? "" : "s"
-          s2 = args.length == 1 ? "" : "s"
-          raise Cucumber::ArityMismatchError.new(
-            "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
-          )
-        end
-      else
-        instance_exec(*args, &block)
-      end
-    end
-  end
-
-  private
-
-  def cucumber_compatible_arity?(args, block)
-    return true if block.arity == args.length
-    if block.arity < 0
-      return true if args.length >= (block.arity.abs - 1)
-    end
-    false
-  end
-
-  def cucumber_run_with_backtrace_filtering(pseudo_method)
-    begin
-      yield
-    rescue Exception => e
-      instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
-      replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
-      raise e
-    end
-  end
-
-  INSTANCE_EXEC_OFFSET = -3
-
-  def replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
-    return if Cucumber.use_full_backtrace
-
-    instance_exec_pos = backtrace.index(instance_exec_invocation_line)
-    if instance_exec_pos
-      replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
-      backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
-
-      depth = backtrace.count { |line| line == instance_exec_invocation_line }
-      end_pos = depth > 1 ? instance_exec_pos : -1
-
-      backtrace[replacement_line+1..end_pos] = nil
-      backtrace.compact!
-    else
-      # This happens with rails, because they screw up the backtrace
-      # before we get here (injecting erb stacktrace and such)
-    end
-  end
-end

data/lib/cucumber/events/after_test_case.rb

@@ -1,25 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event fired after a test case has finished executing
-    class AfterTestCase
-
-      # The test case that was just executed.
-      #
-      # @return [Cucumber::Core::Test::Case]
-      attr_reader :test_case
-
-      # The result of executing the test case.
-      #
-      # @return [Cucumber::Core::Test::Result]
-      attr_reader :result
-
-      # @private
-      def initialize(test_case, result)
-        @test_case, @result = test_case, result
-      end
-
-    end
-
-  end
-end

data/lib/cucumber/events/after_test_step.rb

@@ -1,30 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event fired after each test step has been executed
-    class AfterTestStep
-
-      # The test case currently being executed.
-      #
-      # @return [Cucumber::Core::Test::Case]
-      attr_reader :test_case
-
-      # The test step that was just executed.
-      #
-      # @return [Cucumber::Core::Test::Step]
-      attr_reader :test_step
-
-      # The result of executing the test step.
-      #
-      # @return [Cucumber::Core::Test::Result]
-      attr_reader :result
-
-      # @private
-      def initialize(test_case, test_step, result)
-        @test_case, @test_step, @result = test_case, test_step, result
-      end
-
-    end
-
-  end
-end

data/lib/cucumber/events/before_test_case.rb

@@ -1,18 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event fired before a test case is executed
-    class BeforeTestCase
-
-      # The test case about to be executed.
-      #
-      # @return [Cucumber::Core::Test::Case]
-      attr_reader :test_case
-
-      # @private
-      def initialize(test_case)
-        @test_case = test_case
-      end
-    end
-  end
-end

data/lib/cucumber/events/before_test_step.rb

@@ -1,23 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event fired before a test step is executed
-    class BeforeTestStep
-
-      # The test case currently being executed.
-      #
-      # @return [Cucumber::Core::Test::Case]
-      attr_reader :test_case
-
-      # The test step about to be executed.
-      #
-      # @return [Cucumber::Core::Test::Step]
-      attr_reader :test_step
-
-      # @private
-      def initialize(test_case, test_step)
-        @test_case, @test_step = test_case, test_step
-      end
-    end
-  end
-end

data/lib/cucumber/events/bus.rb

@@ -1,86 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event bus
-    #
-    # Implements and in-process pub-sub events broadcaster allowing multiple observers
-    # to subscribe to different events that fire as your tests are executed.
-    #
-    # @private
-    class Bus
-
-      def initialize(default_namespace)
-        @default_namespace = default_namespace.to_s
-        @handlers = {}
-      end
-
-      # Register for an event
-      def register(event_id, handler_object = nil, &handler_proc)
-        handler = handler_proc || handler_object
-        raise ArgumentError.new("Please pass either an object or a handler block") unless handler
-        event_class = parse_event_id(event_id)
-        handlers_for(event_class) << handler
-      end
-
-      # Broadcast an event
-      def notify(event)
-        handlers_for(event.class).each { |handler| handler.call(event) }
-      end
-
-      private
-
-      def handlers_for(event_class)
-        @handlers[event_class.to_s] ||= []
-      end
-
-      def parse_event_id(event_id)
-        case event_id
-        when Class
-          return event_id
-        when String
-          constantize(event_id)
-        else
-          constantize("#{@default_namespace}::#{camel_case(event_id)}")
-        end
-      end
-
-      def camel_case(underscored_name)
-        underscored_name.to_s.split("_").map { |word| word.upcase[0] + word[1..-1] }.join
-      end
-
-      # Thanks ActiveSupport
-      # (Only needed to support Ruby 1.9.3 and JRuby)
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-
-        # Trigger a built-in NameError exception including the ill-formed constant in the message.
-        Object.const_get(camel_cased_word) if names.empty?
-
-        # Remove the first blank element in case of '::ClassName' notation.
-        names.shift if names.size > 1 && names.first.empty?
-
-        names.inject(Object) do |constant, name|
-          if constant == Object
-            constant.const_get(name)
-          else
-            candidate = constant.const_get(name)
-            next candidate if constant.const_defined?(name, false)
-            next candidate unless Object.const_defined?(name)
-
-            # Go down the ancestors to check if it is owned directly. The check
-            # stops when we reach Object or the end of ancestors tree.
-            constant = constant.ancestors.inject do |const, ancestor|
-              break const    if ancestor == Object
-              break ancestor if ancestor.const_defined?(name, false)
-              const
-            end
-
-            # owner is in Object, so raise
-            constant.const_get(name, false)
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/cucumber/events/finished_testing.rb

@@ -1,9 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event fired after aall test cases have finished executing
-    class FinishedTesting
-    end
-
-  end
-end

data/lib/cucumber/formatter/debug.rb

@@ -1,35 +0,0 @@
-require 'cucumber/formatter/progress'
-require 'cucumber/step_definition_light'
-
-module Cucumber
-  module Formatter
-    class Debug
-      def initialize(runtime, io, options)
-        @io = io
-      end
-
-      def log(message)
-        return unless ENV['DEBUG']
-        @io.puts "* #{message}"
-      end
-
-      def respond_to?(*args)
-        true
-      end
-
-      def method_missing(name, *args)
-        print(name)
-      end
-
-      def puts(*args)
-        print("puts")
-      end
-
-    private
-
-      def print(text)
-        @io.puts text
-      end
-    end
-  end
-end

data/lib/cucumber/formatter/event_bus_report.rb

@@ -1,38 +0,0 @@
-module Cucumber
-  module Formatter
-
-    # Adapter between Cucumber::Core::Test::Runner's Report API and 
-    # Cucumber's event bus
-    class EventBusReport
-      attr_reader :config
-      private :config
-
-      def initialize(config)
-        @config = config
-      end
-
-      def before_test_case(test_case)
-        @config.notify Events::BeforeTestCase.new(test_case)
-        @test_case = test_case
-      end
-
-      def before_test_step(test_step)
-        @config.notify Events::BeforeTestStep.new(@test_case, test_step)
-      end
-
-      def after_test_step(test_step, result)
-        @config.notify Events::AfterTestStep.new(@test_case, test_step, result)
-      end
-
-      def after_test_case(test_case, result)
-        @config.notify Events::AfterTestCase.new(test_case, result)
-      end
-
-      def done
-        @config.notify Events::FinishedTesting.new
-      end
-    end
-
-  end
-end
-

data/lib/cucumber/rb_support/rb_hook.rb

@@ -1,19 +0,0 @@
-module Cucumber
-  module RbSupport
-    # Wrapper for Before, After and AfterStep hooks
-    class RbHook
-      attr_reader :tag_expressions, :location
-
-      def initialize(rb_language, tag_expressions, proc)
-        @rb_language = rb_language
-        @tag_expressions = tag_expressions
-        @proc = proc
-        @location = Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
-      end
-
-      def invoke(pseudo_method, arguments, &block)
-        @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].flatten.compact, &@proc)
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -1,131 +0,0 @@
-require 'cucumber/step_match'
-require 'cucumber/step_argument'
-require 'cucumber/core_ext/string'
-
-module Cucumber
-  module RbSupport
-    # A Ruby Step Definition holds a Regexp and a Proc, and is created
-    # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
-    # in the <tt>step_definitions</tt> ruby files. See also RbDsl.
-    #
-    # Example:
-    #
-    #   Given /I have (\d+) cucumbers in my belly/ do
-    #     # some code here
-    #   end
-    #
-    class RbStepDefinition
-
-      class MissingProc < StandardError
-        def message
-          "Step definitions must always have a proc or symbol"
-        end
-      end
-
-      class << self
-        def new(rb_language, pattern, proc_or_sym, options)
-          raise MissingProc if proc_or_sym.nil?
-          super rb_language, parse_pattern(pattern), create_proc(proc_or_sym, options)
-        end
-
-        private
-
-        def parse_pattern(pattern)
-          return pattern if pattern.is_a?(Regexp)
-          raise ArgumentError unless pattern.is_a?(String)
-          p = Regexp.escape(pattern)
-          p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
-          Regexp.new("^#{p}$")
-        end
-
-        def create_proc(proc_or_sym, options)
-          return proc_or_sym if proc_or_sym.is_a?(Proc)
-          raise ArgumentError unless proc_or_sym.is_a?(Symbol)
-          message = proc_or_sym
-          target_proc = parse_target_proc_from(options)
-          patch_location_onto lambda { |*args|
-            target = instance_exec(&target_proc)
-            target.send(message, *args)
-          }
-        end
-
-        def patch_location_onto(block)
-          location = Core::Ast::Location.of_caller(5)
-          block.define_singleton_method(:source_location) { [location.file, location.line] }
-          block
-        end
-
-        def parse_target_proc_from(options)
-          return lambda { self } unless options.key?(:on)
-          target = options[:on]
-          case target
-          when Proc
-            target
-          when Symbol
-            lambda { self.send(target) }
-          else
-            lambda { raise ArgumentError, "Target must be a symbol or a proc" }
-          end
-        end
-      end
-
-      def initialize(rb_language, regexp, proc)
-        @rb_language, @regexp, @proc = rb_language, regexp, proc
-        @rb_language.available_step_definition(regexp_source, location)
-      end
-
-      def regexp_source
-        @regexp.inspect
-      end
-
-      def to_hash
-        flags = ''
-        flags += 'm' if (@regexp.options & Regexp::MULTILINE) != 0
-        flags += 'i' if (@regexp.options & Regexp::IGNORECASE) != 0
-        flags += 'x' if (@regexp.options & Regexp::EXTENDED) != 0
-        {'source' => @regexp.source, 'flags' => flags}
-      end
-
-      def ==(step_definition)
-        regexp_source == step_definition.regexp_source
-      end
-
-      def arguments_from(step_name)
-        args = StepArgument.arguments_from(@regexp, step_name)
-        @rb_language.invoked_step_definition(regexp_source, location) if args
-        args
-      end
-
-      def invoke(args)
-        begin
-          args = @rb_language.execute_transforms(args)
-          @rb_language.current_world.cucumber_instance_exec(true, regexp_source, *args, &@proc)
-        rescue Cucumber::ArityMismatchError => e
-          e.backtrace.unshift(self.backtrace_line)
-          raise e
-        end
-      end
-
-      def backtrace_line
-        "#{location.to_s}:in `#{regexp_source}'"
-      end
-
-      def file_colon_line
-        case @proc
-        when Proc
-          location.to_s
-        when Symbol
-          ":#{@proc}"
-        end
-      end
-
-      def location
-        @location ||= Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
-      end
-
-      def file
-        @file ||= location.file
-      end
-    end
-  end
-end