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

data/features/docs/formatters/debug_formatter.feature

@@ -1,47 +0,0 @@
-Feature: Debug formatter
-
-  In order to help you easily visualise the listener API, you can use
-  the `debug` formatter that prints the calls to the listener as a
-  feature is run.
-
-  Background:
-    Given the standard step definitions
-
-  Scenario: title
-    Given a file named "features/test.feature" with:
-      """
-      Feature:
-        Scenario:
-          Given this step passes
-      """
-    When I run `cucumber -f debug`
-    Then the stderr should not contain anything
-    Then it should pass with:
-      """
-      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
-      """

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,59 +0,0 @@
-# frozen_string_literal: true
-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,26 +0,0 @@
-# frozen_string_literal: true
-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/core_ext/instance_exec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-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/formatter/debug.rb

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-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,132 +0,0 @@
-# frozen_string_literal: true
-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