cucumber 2.1.0 → 2.2.0

data/features/docs/wire_protocol/table_diffing.feature

@@ -1,126 +0,0 @@
-@wire
-Feature: Wire protocol table diffing
-
-  In order to use the amazing functionality in the Cucumber table object
-  As a wire server
-  I want to be able to ask for a table diff during a step definition invocation
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: Hello
-        Scenario: Wired
-          Given we're all wired
-
-      """
-    And a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-
-  @spawn
-  Scenario: Invoke a step definition tries to diff the table and fails
-    Given there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                                                                                             |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]]                                                                  |
-      | ["begin_scenario"]                                   | ["success"]                                                                                          |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a","b"],["c","d"]],[["x","y"],["z","z"]]]]                                               |
-      | ["diff_failed"]                                      | ["fail",{"message":"Not same", "exception":"DifferentException", "backtrace":["a.cs:12","b.cs:34"]}] |
-      | ["end_scenario"]                                     | ["success"]                                                                                          |
-    When I run `cucumber -f progress --backtrace`
-    Then the stderr should not contain anything
-    And it should fail with:
-      """
-      F
-
-      (::) failed steps (::)
-
-      Not same (DifferentException from localhost:54321)
-      a.cs:12
-      b.cs:34
-      features/wired.feature:3:in `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """
-
-  Scenario: Invoke a step definition tries to diff the table and passes
-    Given there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                               |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]]    |
-      | ["begin_scenario"]                                   | ["success"]                            |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]] |
-      | ["diff_ok"]                                          | ["success"]                            |
-      | ["end_scenario"]                                     | ["success"]                            |
-    When I run `cucumber -f progress`
-    Then it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  @spawn
-  Scenario: Invoke a step definition which successfully diffs a table but then fails
-    Given there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                                                      |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]]                           |
-      | ["begin_scenario"]                                   | ["success"]                                                   |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]]                        |
-      | ["diff_ok"]                                          | ["fail",{"message":"I wanted things to be different for us"}] |
-      | ["end_scenario"]                                     | ["success"]                                                   |
-    When I run `cucumber -f progress`
-    Then it should fail with:
-      """
-      F
-
-      (::) failed steps (::)
-
-      I wanted things to be different for us (Cucumber::WireSupport::WireException)
-      features/wired.feature:3:in `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """
-
-  @spawn
-  Scenario: Invoke a step definition which asks for an immediate diff that fails
-    Given there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                            |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
-      | ["begin_scenario"]                                   | ["success"]                         |
-      | ["invoke",{"id":"1","args":[]}]                      | ["diff!",[[["a"]],[["b"]]]]         |
-      | ["end_scenario"]                                     | ["success"]                         |
-    When I run `cucumber -f progress`
-    And it should fail with exactly:
-      """
-      F
-
-      (::) failed steps (::)
-
-      Tables were not identical:
-      
-        | (-) a | (+) b |
-       (Cucumber::MultilineArgument::DataTable::Different)
-      features/wired.feature:3:in `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-      0m0.012s
-
-      """

data/features/docs/wire_protocol/tags.feature

@@ -1,87 +0,0 @@
-@wire
-Feature: Wire protocol tags
-
-  In order to use Before and After hooks in a wire server, we send tags with the 
-  scenario in the begin_scenario and end_scenario messages
-
-  Background:
-    And a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-
-  Scenario: Run a scenario
-    Given a file named "features/wired.feature" with:
-      """
-        @foo @bar
-        Feature: Wired
-        
-          @baz
-          Scenario: Everybody's Wired
-            Given we're all wired
-
-      """
-    And there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                            |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
-      | ["begin_scenario", {"tags":["bar","baz","foo"]}]     | ["success"]                         |
-      | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
-      | ["end_scenario", {"tags":["bar","baz","foo"]}]       | ["success"]                         |
-    When I run `cucumber -f pretty -q`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      @foo @bar
-      Feature: Wired
-      
-        @baz
-        Scenario: Everybody's Wired
-          Given we're all wired
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Run a scenario outline example
-  Given a file named "features/wired.feature" with:
-    """
-      @foo @bar
-      Feature: Wired
-      
-        @baz
-        Scenario Outline: Everybody's Wired
-          Given we're all <something>
-          
-        Examples:
-          | something |
-          | wired     |
-
-    """
-  And there is a wire server running on port 54321 which understands the following protocol:
-    | request                                              | response                            |
-    | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
-    | ["begin_scenario", {"tags":["bar","baz","foo"]}]     | ["success"]                         |
-    | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
-    | ["end_scenario", {"tags":["bar","baz","foo"]}]       | ["success"]                         |
-  When I run `cucumber -f pretty -q`
-  Then the stderr should not contain anything
-  And it should pass with:
-    """
-    @foo @bar
-    Feature: Wired
-    
-      @baz
-      Scenario Outline: Everybody's Wired
-        Given we're all <something>
-
-        Examples: 
-          | something |
-          | wired     |
-
-    1 scenario (1 passed)
-    1 step (1 passed)
-
-    """

data/features/docs/wire_protocol/timeouts.feature

@@ -1,64 +0,0 @@
-@wire
-Feature: Wire protocol timeouts
-
-  We don't want Cucumber to hang forever on a wire server that's not even there,
-  but equally we need to give the user the flexibility to allow step definitions
-  to take a while to execute, if that's what they need.
-
-  Background:
-    And a file named "features/wired.feature" with:
-      """
-      Feature: Telegraphy
-        Scenario: Wired
-          Given we're all wired
-
-      """
-
-  Scenario: Try to talk to a server that's not there
-    Given a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-    When I run `cucumber -f progress`
-    Then the stderr should contain:
-      """
-      Unable to contact the wire server at localhost:54321
-      """
-
-  @spawn
-  Scenario: Invoke a step definition that takes longer than its timeout
-    Given a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-      timeout:
-        invoke: 0.1
-
-      """
-    And there is a wire server on port 54321 which understands the following protocol:
-      | request                                              | response                                                     |
-      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[{"val":"wired", "pos":10}]}]] |
-      | ["begin_scenario"]                                   | ["success"]                                                  |
-      | ["invoke",{"id":"1","args":["wired"]}]               | ["success"]                                                  |
-      | ["end_scenario"]                                     | ["success"]                                                  |
-    And the wire server takes 0.2 seconds to respond to the invoke message
-    When I run `cucumber -f pretty`
-    Then the stderr should not contain anything
-    And it should fail with:
-      """
-      Feature: Telegraphy
-
-        Scenario: Wired         # features/wired.feature:2
-          Given we're all wired # Unknown
-            Timed out calling wire server with message 'invoke' (Timeout::Error)
-            features/wired.feature:3:in `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2 # Scenario: Wired
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """

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/gherkin/formatter/argument.rb

@@ -1,17 +0,0 @@
-require 'cucumber/gherkin/formatter/hashable'
-
-module Cucumber
-module Gherkin
-  module Formatter
-    class Argument < Hashable
-      #native_impl('gherkin')
-      attr_reader :offset, :val
-
-      # Creates a new Argument that starts at character offset +offset+ with value +val+
-      def initialize(offset, val)
-        @offset, @val = offset, val
-      end
-    end
-  end
-end
-end

data/lib/cucumber/gherkin/formatter/hashable.rb

@@ -1,27 +0,0 @@
-module Cucumber
-module Gherkin
-  module Formatter
-    class Hashable
-      def to_hash
-        ivars = instance_variables
-        # When tests are runn with therubyracer (JavaScript), an extra field might
-        # exist - added by Ref::WeakReference
-        # https://github.com/bdurand/ref/blob/master/lib/ref/weak_reference/pure_ruby.rb
-        # Remove it - we don't want it in the JSON.
-        ivars.delete(:@__weak_backreferences__)
-        ivars.inject({}) do |hash, ivar|
-          value = instance_variable_get(ivar)
-          value = value.to_hash if value.respond_to?(:to_hash)
-          if Array === value
-            value = value.map do |e|
-              e.respond_to?(:to_hash) ? e.to_hash : e
-            end
-          end
-          hash[ivar[1..-1]] = value unless [[], nil].index(value)
-          hash
-        end
-      end
-    end
-  end
-end
-end

data/lib/cucumber/language_support.rb

@@ -1,30 +0,0 @@
-module Cucumber
-  # This module defines the API for programming language support in Cucumber.
-  # While Cucumber itself is written in Ruby, any programming language can
-  # be supported by implementing this API.
-  #
-  # For the sake of illustration we'll consider an imaginary language called
-  # _why. _why files have the .why extension, so we need to put support for
-  # this language in the <tt>Cucumber::WhySupport::WhyLanguage</tt>. This
-  # class must be defined in a file called <tt>cucumber/why_support/why_language.rb</tt>
-  # and be available on Ruby's <tt>$LOAD_PATH</tt>:
-  #
-  #   module Cucumber
-  #     module WhySupport
-  #       class WhyLanguage
-  #
-  #         # Uses whatever available language bridge to load
-  #         # +why_file+ and returns an Array of StepDefinition.
-  #         def load_code_file(why_file)
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  # Each language implementation manages its own hooks, and must execute them
-  # at appropriate times.
-  #
-  #
-  module LanguageSupport
-  end
-end

data/lib/cucumber/language_support/language_methods.rb

@@ -1,72 +0,0 @@
-require 'cucumber/step_match'
-require 'cucumber/step_definition_light'
-
-module Cucumber
-  module LanguageSupport
-    module LanguageMethods
-
-      def after_configuration(cli_configuration)
-        configuration = Configuration.new(cli_configuration)
-        hooks[:after_configuration].each do |hook|
-          hook.invoke('AfterConfiguration', configuration)
-        end
-      end
-
-      def execute_transforms(args)
-        args.map do |arg|
-          matching_transform = transforms.detect {|transform| transform.match(arg) }
-          matching_transform ? matching_transform.invoke(arg) : arg
-        end
-      end
-
-      def add_hook(phase, hook)
-        hooks[phase.to_sym] << hook
-        hook
-      end
-
-      def clear_hooks
-        @hooks = nil
-      end
-
-      def add_transform(transform)
-        transforms.unshift transform
-        transform
-      end
-
-      def hooks_for(phase, scenario) #:nodoc:
-        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
-      end
-
-      def unmatched_step_definitions
-        available_step_definition_hash.keys - invoked_step_definition_hash.keys
-      end
-
-      def available_step_definition(regexp_source, location)
-        available_step_definition_hash[StepDefinitionLight.new(regexp_source, location)] = nil
-      end
-
-      def invoked_step_definition(regexp_source, location)
-        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, location)] = nil
-      end
-
-      private
-
-      def available_step_definition_hash
-        @available_step_definition_hash ||= {}
-      end
-
-      def invoked_step_definition_hash
-        @invoked_step_definition_hash ||= {}
-      end
-
-      def hooks
-        @hooks ||= Hash.new{|h,k| h[k] = []}
-      end
-
-      def transforms
-        @transforms ||= []
-      end
-
-    end
-  end
-end