开源软件构建与测试

_service:tar_scm:rubygem-cucumber-wire.spec Changed

@@ -1,14 +1,13 @@
 %global gem_name cucumber-wire
 %{?_with_bootstrap: %global bootstrap 1}
 Name:                rubygem-%{gem_name}
-Version:             0.0.1
-Release:             2
+Version:             6.2.0
+Release:             1
 Summary:             Wire protocol for Cucumber
 License:             MIT
 URL:                 http://cucumber.io
 Source0:             https://rubygems.org/gems/%{gem_name}-%{version}.gem
-Patch0:              rubygem-cucumber-wire-0.0.1-Adapt-to-the-move-of-Location-to-Cucumber-Core-Test.patch
-Patch1:		     0001-fix-features-incompative.patch
+Source1:             https://github.com/cucumber/cucumber-ruby-wire/archive/refs/tags/v%{version}.tar.gz
 BuildRequires:       ruby(release) rubygems-devel ruby
 %if ! 0%{?bootstrap}
 BuildRequires:       rubygem(aruba) rubygem(cucumber) rubygem(rspec) rubygem(did_you_mean)
@@ -27,10 +26,13 @@
 Documentation for %{name}.
 
 %prep
-%setup -q -n %{gem_name}-%{version}
-%patch0 -p1
-%patch1 -p1
-%gemspec_add_file 'lib/cucumber/wire/step_argument.rb'
+%setup -q -n %{gem_name}-%{version} -b1
+
+%gemspec_remove_dep -g cucumber-cucumber-expressions "~> 14.0", ">= 14.0.0"
+%gemspec_add_dep -g cucumber-cucumber-expressions ">= 14.0"
+
+%gemspec_remove_dep -g  cucumber-messages "~> 17.1", ">= 17.1.1"
+%gemspec_add_dep -g cucumber-messages ">= 17.0"
 
 %build
 gem build ../%{gem_name}-%{version}.gemspec
@@ -44,8 +46,13 @@
 
 %check
 pushd .%{gem_instdir}
-LANG=C.UTF-8 rspec spec
-RUBYOPT="-I$(pwd)/lib" cucumber
+
+rspec -Ilib spec
+
+ln -s %{_builddir}/cucumber-ruby-wire-6.2.0/features features
+
+RUBYOPT="-I$(pwd)/lib" cucumber --format progress --publish-quiet
+
 popd
 %endif
 
@@ -55,17 +62,19 @@
 %{gem_libdir}
 %exclude %{gem_cache}
 %{gem_spec}
+%license %{gem_instdir}/LICENSE
 
 %files help
 %doc %{gem_docdir}
-%{gem_instdir}/Gemfile
 %doc %{gem_instdir}/README.md
-%{gem_instdir}/Rakefile
-%{gem_instdir}/cucumber-wire.gemspec
-%{gem_instdir}/features
+%doc %{gem_instdir}/CHANGELOG.md
+%doc %{gem_instdir}/CONTRIBUTING.md
 %{gem_instdir}/spec
 
 %changelog
+* Mon Jan 9 2023 liyanan <liyanan32@h-partners.com> - 6.2.0-1
+- Update to 6.2.0
+
 * Wed Mar 02 2022 baizhonggui <baizhonggui@huawei.com> - 0.0.1-2
 - Add support ruby 3.0 for fixing build error

_service:tar_scm:0001-fix-features-incompative.patch Deleted

_service:tar_scm:rubygem-cucumber-wire-0.0.1-Adapt-to-the-move-of-Location-to-Cucumber-Core-Test.patch Deleted

@@ -1,206 +0,0 @@
-From 51ff0156094757ad21b8f380e2427d5b366924fa Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Bj=C3=B6rn=20Rasmusson?= <B.Rasmusson@computer.org>
-Date: Sun, 22 Jul 2018 21:23:34 +0200
-Subject: PATCH Fixes to work with modern Cucucmber-Ruby
-
-* Pass the registry all the way down to the step definitions.
-* Move the class StepArgument from Cucumber-Ruby and update it to match
-  the expectations of Cucumber-Ruby when using cucumber-expressions.
----
- features/step_matches_message.feature  |  2 +-
- lib/cucumber/wire/connections.rb       |  5 +++--
- lib/cucumber/wire/plugin.rb            |  9 +++++----
- lib/cucumber/wire/protocol.rb          |  4 ++--
- lib/cucumber/wire/protocol/requests.rb |  4 ++--
- lib/cucumber/wire/request_handler.rb   |  3 ++-
- lib/cucumber/wire/step_argument.rb     | 24 ++++++++++++++++++++++++
- lib/cucumber/wire/step_definition.rb   |  6 ++++--
- spec/cucumber/wire/connections_spec.rb |  4 ++--
- 9 files changed, 45 insertions(+), 16 deletions(-)
- create mode 100644 lib/cucumber/wire/step_argument.rb
-
-diff --git a/features/step_matches_message.feature b/features/step_matches_message.feature
-index b0051f8..afa70be 100644
---- a/features/step_matches_message.feature
-+++ b/features/step_matches_message.feature
-@@ -70,7 +70,7 @@ Feature: Step matches message
-       """
-       -
- 
--      we.*   # MyApp.MyClass:123
-+      "we.*"   # MyApp.MyClass:123
- 
-       1 scenario (1 skipped)
-       1 step (1 skipped)
-diff --git a/lib/cucumber/wire/connections.rb b/lib/cucumber/wire/connections.rb
-index 7856fea..4e57a22 100644
---- a/lib/cucumber/wire/connections.rb
-+++ b/lib/cucumber/wire/connections.rb
-@@ -16,10 +16,11 @@ class Connections
-       attr_reader :connections
-       private :connections
- 
--      def initialize(connections, configuration)
-+      def initialize(connections, configuration, registry)
-         raise ArgumentError unless connections
-         @connections = connections
-         @configuration = configuration
-+        @registry = registry
-       end
- 
-       def find_match(test_step)
-@@ -30,7 +31,7 @@ def find_match(test_step)
-       end
- 
-       def step_matches(step_name)
--        connections.map{ |c| c.step_matches(step_name)}.flatten
-+        connections.map{ |c| c.step_matches(step_name, @registry)}.flatten
-       end
- 
-       def begin_scenario(test_case)
-diff --git a/lib/cucumber/wire/plugin.rb b/lib/cucumber/wire/plugin.rb
-index d1d6277..79843cd 100644
---- a/lib/cucumber/wire/plugin.rb
-+++ b/lib/cucumber/wire/plugin.rb
-@@ -5,15 +5,16 @@
- module Cucumber
-   module Wire
-     class Plugin
--      attr_reader :config
--      private :config
-+      attr_reader :config, :registry
-+      private :config, :registry
- 
--      def initialize(config)
-+      def initialize(config, registry)
-         @config = config
-+        @registry = registry
-       end
- 
-       def install
--        connections = Connections.new(wire_files.map { |f| create_connection(f) }, @config)
-+        connections = Connections.new(wire_files.map { |f| create_connection(f) }, config, registry)
-         config.filters << Filters::ActivateSteps.new(StepMatchSearch.new(connections.method(:step_matches), @config), @config)
-         config.filters << AddHooksFilter.new(connections) unless @config.dry_run?
-         config.register_snippet_generator Snippet::Generator.new(connections)
-diff --git a/lib/cucumber/wire/protocol.rb b/lib/cucumber/wire/protocol.rb
-index 328c728..738577e 100644
---- a/lib/cucumber/wire/protocol.rb
-+++ b/lib/cucumber/wire/protocol.rb
-@@ -3,8 +3,8 @@
- module Cucumber
-   module Wire
-     module Protocol
--      def step_matches(name_to_match)
--        handler = Requests::StepMatches.new(self)
-+      def step_matches(name_to_match, registry)
-+        handler = Requests::StepMatches.new(self, registry)
-         handler.execute(name_to_match)
-       end
- 
-diff --git a/lib/cucumber/wire/protocol/requests.rb b/lib/cucumber/wire/protocol/requests.rb
-index eff80b0..5e32d11 100644
---- a/lib/cucumber/wire/protocol/requests.rb
-+++ b/lib/cucumber/wire/protocol/requests.rb
-@@ -1,5 +1,5 @@
- require 'cucumber/wire/request_handler'
--require 'cucumber/step_argument'
-+require 'cucumber/wire/step_argument'
- 
- module Cucumber
-   module Wire
-@@ -25,7 +25,7 @@ def handle_success(params)
-           private
- 
-           def create_step_match(raw_step_match)
--            step_definition = StepDefinition.new(@connection, raw_step_match)
-+            step_definition = StepDefinition.new(@connection, raw_step_match, @registry)
-             step_args = raw_step_match'args'.map do |raw_arg|
-               StepArgument.new(raw_arg'pos', raw_arg'val')
-             end
-diff --git a/lib/cucumber/wire/request_handler.rb b/lib/cucumber/wire/request_handler.rb
-index ee8f2f1..118f9cd 100644
---- a/lib/cucumber/wire/request_handler.rb
-+++ b/lib/cucumber/wire/request_handler.rb
-@@ -1,9 +1,10 @@
- module Cucumber
-   module Wire
-     class RequestHandler
--      def initialize(connection)
-+      def initialize(connection, registry = nil)
-         @connection = connection
-         @message = underscore(self.class.name.split('::').last)
-+        @registry = registry
-       end
- 
-       def execute(request_params = nil)
-diff --git a/lib/cucumber/wire/step_argument.rb b/lib/cucumber/wire/step_argument.rb
-new file mode 100644
-index 0000000..116ee3a
---- /dev/null
-+++ b/lib/cucumber/wire/step_argument.rb
-@@ -0,0 +1,24 @@
-+# frozen_string_literal: true
-+require 'cucumber/cucumber_expressions/group'
-+
-+module Cucumber
-+  module Wire
-+    # Defines the location and value of a captured argument from the step
-+    # text
-+    class StepArgument
-+      attr_reader :offset
-+
-+      def initialize(offset, val)
-+        @offset, @value = offset, val
-+      end
-+
-+      def value(_current_world)
-+        @value
-+      end
-+
-+      def group
-+        CucumberExpressions::Group.new(@value, @offset, @offset + @value.length, )
-+      end
-+    end
-+  end
-+end
-diff --git a/lib/cucumber/wire/step_definition.rb b/lib/cucumber/wire/step_definition.rb
-index 09a4f1d..b453cdc 100644
---- a/lib/cucumber/wire/step_definition.rb
-+++ b/lib/cucumber/wire/step_definition.rb
-@@ -3,12 +3,14 @@
- module Cucumber
-   module Wire
-     class StepDefinition
--      attr_reader :regexp_source, :location
-+      attr_reader :regexp_source, :location, :registry, :expression
- 
--      def initialize(connection, data)
-+      def initialize(connection, data, registry)
-         @connection = connection
-+        @registry   = registry
-         @id              = data'id'
-         @regexp_source   = data'regexp' || "Unknown"
-+        @expression      = registry.create_expression(@regexp_source)
-         @location        = Core::Ast::Location.from_file_colon_line(data'source' || "unknown:0")
-       end
- 
-diff --git a/spec/cucumber/wire/connections_spec.rb b/spec/cucumber/wire/connections_spec.rb
-index 449e19f..62c9f1a 100644
---- a/spec/cucumber/wire/connections_spec.rb
-+++ b/spec/cucumber/wire/connections_spec.rb
-@@ -9,12 +9,12 @@ module Wire
-           connection1 = double(step_matches: :a, :b)
-           connection2 = double(step_matches: :c)
- 
--          connections = Connections.new(connection1, connection2, double)
-+          connections = Connections.new(connection1, connection2, double, double)
-           expect(connections.step_matches('')).to eq :a, :b, :c
-         end
- 
-         it "copes with no connections" do
--          connections = Connections.new(, double)
-+          connections = Connections.new(, double, double)
-           expect(connections.step_matches('')).to eq 
-         end
-       end

_service Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/.rspec Deleted

_service:tar_scm:cucumber-wire-0.0.1.gem/data/.travis.yml Deleted

_service:tar_scm:cucumber-wire-0.0.1.gem/data/Gemfile Deleted

_service:tar_scm:cucumber-wire-0.0.1.gem/data/Rakefile Deleted

_service:tar_scm:cucumber-wire-0.0.1.gem/data/cucumber-wire.gemspec Deleted

@@ -1,28 +0,0 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = 'cucumber-wire'
-  s.version     = File.read(File.dirname(__FILE__) + "/lib/cucumber/wire/version")
-  s.authors     = "Matt Wynne"
-  s.description = "Wire protocol for Cucumber"
-  s.summary     = "cucumber-wire-#{s.version}"
-  s.email       = 'cukes@googlegroups.com'
-  s.homepage    = "http://cucumber.io"
-  s.platform    = Gem::Platform::RUBY
-  s.license     = "MIT"
-  s.required_ruby_version = ">= 1.9.3"
-
-  s.add_development_dependency 'cucumber', '~> 2.1.0'
-
-  s.add_development_dependency 'bundler',   '>= 1.3.5'
-  s.add_development_dependency 'rake',      '>= 0.9.2'
-  s.add_development_dependency 'rspec',     '~> 3'
-  s.add_development_dependency 'aruba',     '~> 0'
-
-  s.rubygems_version = ">= 1.6.1"
-  s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
-  s.test_files       = `git ls-files -- spec/*`.split("\n")
-  s.rdoc_options     = "--charset=UTF-8"
-  s.require_path     = "lib"
-end

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/erb_configuration.feature Deleted

@@ -1,54 +0,0 @@
-Feature: ERB configuration
-
-  As a developer on server with multiple users
-  I want to be able to configure which port my wire server runs on
-  So that I can avoid port conflicts
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: High strung
-        Scenario: Wired
-          Given we're all wired
-
-      """
-
-  Scenario: ERB is used in the wire file which references an environment variable that is not set
-      Given a file named "features/step_definitions/server.wire" with:
-        """
-        host: localhost
-        port: <%= ENV'PORT' || 12345 %>
-        """
-      And there is a wire server running on port 12345 which understands the following protocol:
-        | request                                              | response       |
-        | "step_matches",{"name_to_match":"we're all wired"} | "success", |
-      When I run `cucumber --dry-run --no-snippets -f progress`
-      Then it should pass with:
-        """
-        U
-
-        1 scenario (1 undefined)
-        1 step (1 undefined)
-
-        """
-
-
-  Scenario: ERB is used in the wire file which references an environment variable
-      Given I have environment variable PORT set to "16816"
-      And a file named "features/step_definitions/server.wire" with:
-        """
-        host: localhost
-        port: <%= ENV'PORT' || 12345 %>
-        """
-      And there is a wire server running on port 16816 which understands the following protocol:
-        | request                                              | response       |
-        | "step_matches",{"name_to_match":"we're all wired"} | "success", |
-      When I run `cucumber --dry-run --no-snippets -f progress`
-      Then it should pass with:
-        """
-        U
-
-        1 scenario (1 undefined)
-        1 step (1 undefined)
-
-        """

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/handle_unexpected_response.feature Deleted

@@ -1,29 +0,0 @@
-Feature: Handle unexpected response
-
-  When the server sends us back a message we don't understand, this is how Cucumber will behave.
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: High strung
-        Scenario: Wired
-          Given we're all wired
-
-      """
-    And a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-
-  Scenario: Unexpected response
-    Given there is a wire server running on port 54321 which understands the following protocol:
-      | request                                              | response                            |
-      | "begin_scenario"                                   | "yikes"                           |
-      | "step_matches",{"name_to_match":"we're all wired"} | "success",{"id":"1", "args":} |
-    When I run `cucumber -f pretty`
-    Then the output should contain:
-      """
-      undefined method `handle_yikes'
-      """

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/invoke_message.feature Deleted

@@ -1,212 +0,0 @@
-Feature: Invoke message
-
-  Assuming a StepMatch was returned for a given step name, when it's time to
-  invoke that step definition, Cucumber will send an invoke message.
-
-  The invoke message contains the ID of the step definition, as returned by
-  the wire server in response to the the step_matches call, along with the
-  arguments that were parsed from the step name during the same step_matches
-  call.
-
-  The wire server will normally reply one of the following:
-
-  * `success`
-  * `fail`
-  * `pending` - optionally takes a message argument
-
-  This isn't quite the whole story: see also table_diffing.feature
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: High strung
-        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 which is pending
-    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":}                      | "pending", "I'll do it later"     |
-      | "end_scenario"                                     | "success"                         |
-    When I run `cucumber -f pretty -q`
-    And it should pass with exactly:
-      """
-      Feature: High strung
-
-        Scenario: Wired
-          Given we're all wired
-            I'll do it later (Cucumber::Pending)
-            features/wired.feature:3:in `Given we're all wired'
-
-      1 scenario (1 pending)
-      1 step (1 pending)
-
-      """
-
-  Scenario: Invoke a step definition which 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":}                      | "success"                         |
-      | "end_scenario"                                     | "success"                         |
-    When I run `cucumber -f progress`
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  @spawn
-  Scenario: Invoke a step definition which fails
-
-    If an invoked step definition fails, it can return details of the exception
-    in the reply to invoke. This causes a Cucumber::WireSupport::WireException to be
-    raised.
-
-    Valid arguments are:
-
-    - `message` (mandatory)
-    - `exception`
-    - `backtrace`
-
-    See the specs for Cucumber::WireSupport::WireException for more details
-
-    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":}                      | "fail",{"message":"The wires are down", "exception":"Some.Foreign.ExceptionType"} |
-      | "end_scenario"                                     | "success"                                                                         |
-    When I run `cucumber -f progress`
-    Then the stderr should not contain anything
-    And it should fail with:
-      """
-      F
-
-      (::) failed steps (::)
-
-      The wires are down (Some.Foreign.ExceptionType from localhost:54321)
-      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 which takes string arguments (and passes)
-
-    If the step definition at the end of the wire captures arguments, these are
-    communicated back to Cucumber in the `step_matches` message.
-
-    Cucumber expects these StepArguments to be returned in the StepMatch. The keys
-    have the following meanings:
-
-    - `val` - the value of the string captured for that argument from the step
-      name passed in step_matches
-    - `pos` - the position within the step name that the argument was matched
-      (used for formatter highlighting)
-
-    The argument values are then sent back by Cucumber in the `invoke` message.
-
-    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":{"val":"wired", "pos":10}} |
-      | "begin_scenario"                                   | "success"                                                  |
-      | "invoke",{"id":"1","args":"wired"}               | "success"                                                  |
-      | "end_scenario"                                     | "success"                                                  |
-    When I run `cucumber -f progress`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Invoke a step definition which takes regular and table arguments (and passes)
-
-    If the step has a multiline table argument, it will be passed with the
-    invoke message as an array of array of strings.
-
-    In this scenario our step definition takes two arguments - one
-    captures the "we're" and the other takes the table.
-
-    Given a file named "features/wired_on_tables.feature" with:
-      """
-      Feature: High strung
-        Scenario: Wired and more
-          Given we're all:
-            | wired |
-            | high  |
-            | happy |
-      """
-    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:"}                       | "success",{"id":"1", "args":{"val":"we're", "pos":0}} |
-      | "begin_scenario"                                                    | "success"                                                 |
-      | "invoke",{"id":"1","args":"we're","wired","high","happy"} | "success"                                                 |
-      | "end_scenario"                                                      | "success"                                                 |
-    When I run `cucumber -f progress features/wired_on_tables.feature`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-
-  Scenario: Invoke a scenario outline step
-    Given a file named "features/wired_in_an_outline.feature" with:
-      """
-      Feature:
-        Scenario Outline:
-          Given we're all <arg>
-
-          Examples:
-            | arg   |
-            | 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"                                   | "success"                         |
-      | "invoke",{"id":"1","args":}                      | "success"                         |
-      | "end_scenario"                                     | "success"                         |
-    When I run `cucumber -f progress features/wired_in_an_outline.feature`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      .
-
-      1 scenario (1 passed)
-      1 step (1 passed)
-
-      """
-    And the wire server should have received the following messages:
-      | step_matches   |
-      | begin_scenario |
-      | invoke         |
-      | end_scenario   |

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/readme.md Deleted

@@ -1,26 +0,0 @@
-Cucumber's wire protocol allows step definitions to be
-implemented and invoked on any platform.
-
-Communication is over a TCP socket, which Cucumber connects to when it finds
-a definition file with the .wire extension in the step_definitions folder
-(or other load path). Note that these files are rendered with ERB when loaded.
-
-A `Wire::DataPacket` flowing in either direction is formatted as a JSON-encoded
-string, with a newline character signaling the end of a packet. See the
-specs for `Cucumber::Wire::DataPacket` for more details.
-
-Cucumber sends the following request messages out over the wire:
-
-* `step_matches` - Find out whether the wire server has a definition for a step
-* `invoke` - Ask for a step definition to be invoked
-* `begin_scenario` - signals that cucumber is about to execute a scenario
-* `end_scenario` - signals that cucumber has finished executing a scenario
-* `snippet_text` - requests a snippet for an undefined step
-
-Every message supports two standard responses:
-
-* `success` - expects different arguments (sometimes none at all) depending
-  on the request that was sent.
-* `fail` - causes a Cucumber::Wire::Exception to be raised.
-
-Some messages support more responses - see individual scenarios for details.

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/snippets_message.feature Deleted

@@ -1,47 +0,0 @@
-Feature: Snippets message
-
-  If a step doesn't match, Cucumber will ask the wire server to return a snippet of code for a
-  step definition.
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: High strung
-        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: Wire server returns snippets for a step that didn't match
-    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",                   |
-      | "snippet_text",{"step_keyword":"Given","multiline_arg_class":"","step_name":"we're all wired"} | "success","foo()\n  bar;\nbaz" |
-      | "begin_scenario"                                                                               | "success"                      |
-      | "end_scenario"                                                                                 | "success"                      |
-    When I run `cucumber -f pretty`
-    Then the stderr should not contain anything
-    And it should pass with:
-      """
-      Feature: High strung
-
-        Scenario: Wired         # features/wired.feature:2
-          Given we're all wired # features/wired.feature:3
-
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-      """
-    And the output should contain:
-      """
-      foo()
-        bar;
-      baz
-
-      """

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/step_definitions/aruba_steps.rb Deleted

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/step_definitions/wire_steps.rb Deleted

@@ -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 do
-  extend(WireHelper)
-end
-
-After do
-  stop_wire_server
-end

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/step_matches_message.feature Deleted

@@ -1,79 +0,0 @@
-Feature: Step matches message
-
-  When the features have been parsed, Cucumber will send a `step_matches`
-  message to ask the wire server if it can match a step name. This happens for
-  each of the steps in each of the features.
-
-  The wire server replies with an array of StepMatch objects.
-
-  When each StepMatch is returned, it contains the following data:
-
-  * `id` - identifier for the step definition to be used later when if it
-  needs to be invoked. The identifier can be any string value and
-  is simply used for the wire server's own reference.
-  * `args` - any argument values as captured by the wire end's own regular
-  expression (or other argument matching) process.
-
-  Background:
-    Given a file named "features/wired.feature" with:
-      """
-      Feature: High strung
-        Scenario: Wired
-          Given we're all wired
-
-      """
-    And a file named "features/step_definitions/some_remote_place.wire" with:
-      """
-      host: localhost
-      port: 54321
-
-      """
-
-  Scenario: Dry run finds no step match
-    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", |
-    When I run `cucumber --dry-run --no-snippets -f progress`
-    And it should pass with:
-      """
-      U
-
-      1 scenario (1 undefined)
-      1 step (1 undefined)
-
-      """
-
-  Scenario: Dry run finds a step match
-    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":} |
-    When I run `cucumber --dry-run -f progress`
-    And it should pass with:
-      """
-      -
-
-      1 scenario (1 skipped)
-      1 step (1 skipped)
-
-      """
-
-  Scenario: Step matches returns details about the remote step definition
-
-    Optionally, the StepMatch can also contain a source reference, and a native
-    regexp string which will be used by some formatters.
-
-    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":, "source":"MyApp.MyClass:123", "regexp":"we.*"} |
-    When I run `cucumber -f stepdefs --dry-run`
-    Then it should pass with:
-      """
-      -
-
-      we.*   # MyApp.MyClass:123
-
-      1 scenario (1 skipped)
-      1 step (1 skipped)
-
-      """
-    And the stderr should not contain anything

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/support/fake_wire_server.rb Deleted

@@ -1,80 +0,0 @@
-require 'multi_json'
-require 'socket'
-
-class FakeWireServer
-  def initialize(port, protocol_table)
-    @port, @protocol_table = port, protocol_table
-    @delays = {}
-  end
-
-  def run(io)
-    @server = TCPServer.open(@port)
-    loop { handle_connections(io) }
-  end
-
-  def delay_response(message, delay)
-    @delaysmessage = delay
-  end
-
-  private
-
-  def handle_connections(io)
-    Thread.start(@server.accept) { |socket| open_session_on socket, io }
-  end
-
-  def open_session_on(socket, io)
-    begin
-      on_message = lambda { |message| io.puts message }
-      SocketSession.new(socket, @protocol_table, @delays, on_message).start
-    rescue Exception => e
-      raise e
-    ensure
-      socket.close
-    end
-  end
-
-  class SocketSession
-    def initialize(socket, protocol, delays, on_message)
-      @socket = socket
-      @protocol = protocol
-      @delays = delays
-      @on_message = on_message
-    end
-
-    def start
-      while message = @socket.gets
-        handle(message)
-      end
-    end
-
-    private
-
-    def handle(data)
-      if protocol_entry = response_to(data.strip)
-        sleep delay(data)
-        @on_message.call(MultiJson.load(protocol_entry'request')0)
-        send_response(protocol_entry'response')
-      else
-        serialized_exception = { :message => "Not understood: #{data}", :backtrace =>  }
-        send_response('fail', serialized_exception .to_json)
-      end
-    rescue => e
-      send_response('fail', { :message => e.message, :backtrace => e.backtrace, :exception => e.class } .to_json)
-    end
-
-    def response_to(data)
-      @protocol.detect do |entry|
-        MultiJson.load(entry'request') == MultiJson.load(data)
-      end
-    end
-
-    def send_response(response)
-      @socket.puts response + "\n"
-    end
-
-    def delay(data)
-      message = MultiJson.load(data.strip)0
-      @delaysmessage.to_sym || 0
-    end
-  end
-end

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/table_diffing.feature Deleted

@@ -1,124 +0,0 @@
-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 -q`
-    Then the stderr should not contain anything
-    And it should fail with exactly:
-      """
-      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
-
-      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 -q`
-    Then it should pass with exactly:
-      """
-      .
-
-      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 -q`
-    Then it should fail with exactly:
-      """
-      F
-
-      (::) failed steps (::)
-
-      I wanted things to be different for us (Cucumber::Wire::Exception)
-      features/wired.feature:3:in `Given we're all wired'
-
-      Failing Scenarios:
-      cucumber features/wired.feature:2
-
-      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 -q`
-    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
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/tags.feature Deleted

@@ -1,86 +0,0 @@
-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:
-    Given 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 exactly:
-    """
-    @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)
-
-    """

_service:tar_scm:cucumber-wire-0.0.1.gem/data/features/timeouts.feature Deleted

@@ -1,63 +0,0 @@
-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:
-    Given 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 -q`
-    Then the stderr should not contain anything
-    And it should fail with exactly:
-      """
-      Feature: Telegraphy
-
-        Scenario: Wired
-          Given we're all wired
-            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
-
-      1 scenario (1 failed)
-      1 step (1 failed)
-
-      """

_service:tar_scm:cucumber-wire-0.0.1.gem/checksums.yaml.gz -> _service:tar_scm:cucumber-wire-6.2.0.gem/checksums.yaml.gz Changed

_service:tar_scm:cucumber-wire-6.2.0.gem/data/CHANGELOG.md Added

@@ -0,0 +1,128 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to Semantic Versioning(http://semver.org).
+
+This document is formatted according to the principles of Keep A CHANGELOG(http://keepachangelog.com).
+
+Please visit cucumber/CONTRIBUTING.md(https://github.com/cucumber/cucumber/blob/master/CONTRIBUTING.md) for more info on how to contribute to Cucumber.
+
+## Unreleased
+
+### Changed
+
+### Added
+
+### Fixed
+
+### Removed
+
+## 6.2.0
+
+### Changed
+
+- Patched `cucumber-core`, `cucumber-expressions` and `cucumber-messages`
+
+## 6.1.1
+
+### Changed
+
+- Use the new `InstallPlugin` hook rather than `AfterConfiguration`.
+  (#52(https://github.com/cucumber/cucumber-ruby-wire/pull/52))
+
+## 6.1.0
+### Added
+- The possibility to verify if the plugin has already been installed or not. To
+do so, use `Cucumber::Wire::Plugin.installed?`.
+(46(https://github.com/cucumber/cucumber-ruby-wire/pull/46))
+
+### Changed
+- `cucumber-wire` is now able to install itself as a plugin into `cucumber-ruby`.
+(46(https://github.com/cucumber/cucumber-ruby-wire/pull/46))
+
+## 6.0.1
+### Changed
+- Patched `cucumber-core` and `cucumber-messages`
+
+## 6.0.0
+### Changed
+- Updated `cucumber-core` ~> 10.0.0 and `cucumber-messages` ~> 17.0.0
+This brings breaking changes because of internal changes in Cucumber::Messages.
+(#44(https://github.com/cucumber/cucumber-ruby-wire/pull/44))
+
+## 5.0.1
+### Changed
+- Updated `cucumber-core` ~> 9.0.1
+
+## 5.0.0
+### Changed
+- Update from cucumber-expressions 10 to 12 introduces significant underlying changes
+in how step definitions are matched. This should be backward compatible but there
+is a risk of regressions.
+- Updated dependencies (look at the diff for details)
+
+## 4.0.1
+### Changed
+- Updated dependencies (look at the diff for details)
+
+## 3.1.0
+### Changed
+- `cucumber-core` ~> 7.1.0
+- `cucumber-messages` ~> 12.2.0
+- Updated gems:
+
+## 3.0.0
+### Changed
+- Use `cucumber-ruby-core` 7.0.0
+- cucumber-cucumber-expressions ~> 10
+- cucumber-messages ~> 12
+- Updated monorepo libraries:
+
+## 2.0.1
+### Removed
+- Replace use of `MultiJSON` to use native JSON gem
+
+## 2.0.0
+### Changed
+- Use `cucumber-ruby-core` 6.0.0
+
+## 1.2.0
+### Added
+- Use `Cucumber:Messages::IdGenerator::UUID` to provide ids for `Hooks`
+
+### Removed
+- Multiline arguments do not need `Location` anymore
+
+## 1.1.0
+### Changed
+- Update to cucumber-expressions 8.0.2
+- Update to cucumber 4.0.0
+
+## 1.0.0
+### Added
+- Added this CHANGELOG.md file per cucumber/cucumber #251(https://github.com/cucumber/cucumber/issues/251) (#13(https://github.com/cucumber/cucumber-ruby-wire/pull/13) jaysonesmith(https://github.com/jaysonesmith))
+
+### Changed
+- Changes to work with a modern Cucumber-Ruby (#14(https://github.com/cucumber/cucumber-ruby-wire/pull/14) brasmusson(https://github.com/brasmusson))
+- Adapt to the move of Location to Cucumber::Core::Test (#14(https://github.com/cucumber/cucumber-ruby-wire/pull/14) brasmusson(https://github.com/brasmusson))
+
+Unreleased: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.2.0...main
+6.2.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.1.1...v6.2.0
+6.1.1: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.1.0...v6.1.1
+6.1.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.0.1...v6.1.0
+6.0.1: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.0.0...v6.0.1
+6.0.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v5.0.1...v6.0.0
+5.0.1: https://github.com/cucumber/cucumber-ruby-wire/compare/v5.0.0...v5.0.1
+5.0.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v4.0.1...v5.0.0
+4.0.1: https://github.com/cucumber/cucumber-ruby-wire/compare/v4.0.0...v4.0.1
+3.1.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v3.0.0...v3.1.0
+3.0.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v2.0.1...v3.0.0
+2.0.1: https://github.com/cucumber/cucumber-ruby-wire/compare/v2.0.0...v2.0.1
+2.0.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v1.2.0...v2.0.0
+1.2.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v1.1.0...v1.2.0
+1.1.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v1.0.0...v1.1.0
+1.0.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v0.0.1...v1.0.0
+ire/compare/v6.1.0...main
+6.1.0: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.0.1...v6.1.0
+6.0.1: https://github.com/cucumber/cucumber-ruby-wire/compare/v6.0.0...v6.0.1
\ No newline at end of file

_service:tar_scm:cucumber-wire-6.2.0.gem/data/CONTRIBUTING.md Added

_service:tar_scm:cucumber-wire-6.2.0.gem/data/LICENSE Added

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2015 Cucumber Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

_service:tar_scm:cucumber-wire-0.0.1.gem/data/README.md -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/README.md Changed

@@ -1,1 +1,41 @@
-Work in progress: See https://github.com/cucumber/cucumber-ruby/pull/878
+!CircleCI(https://circleci.com/gh/cucumber/cucumber-ruby-wire.svg?style=svg)(https://circleci.com/gh/cucumber/cucumber-ruby-wire)
+
+# cucumber-wire
+
+This gem was extracted from the cucumber gem(https://github.com/cucumber/cucumber-ruby), and remains a runtime dependency to that gem.
+
+Its tests are a bit hairy and prone to the occasional flicker.
+
+In the future, it may become an opt-in plugin rather than a direct dependency on every Cucumber.
+
+## Configuration
+
+You can configure the connection using a YAML file called a `.wire` file:
+
+```yaml
+host: localhost
+port: 54321
+timeout:
+  connect: 11
+  invoke: 120
+  begin_scenario: 120
+  end_scenario: 120
+```
+
+### Timeouts
+
+The default timeout is 120 seconds. `connect` has a default timeout of 11 seconds.
+
+### YAML with ERB templating
+
+The file format is YAML, with ERB templating, so you could make the configuration configurable:
+
+```yaml,erb
+host: localhost
+port: 54321
+timeout:
+  connect: <%= (ENV'MY_CONNECT_TIMEOUT' || 11).to_i %>
+  invoke: 120
+  begin_scenario: 120
+  end_scenario: 120
+```

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire.rb Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/add_hooks_filter.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/add_hooks_filter.rb Changed

@@ -1,3 +1,6 @@
+# coding: utf-8
+require 'cucumber/messages'
+
 module Cucumber
   module Wire
     class AddHooksFilter < Core::Filter.new(:connections)
@@ -8,18 +11,22 @@
       end
 
       def before_hook(test_case)
-        # TODO: is this dependency on Cucumber::Hooks OK? Feels a bit internal..
-        # TODO: how do we express the location of the hook? Should we create one hook per connection so we can use the host:port of the connection?
-        Cucumber::Hooks.before_hook(test_case.source, Core::Ast::Location.new('TODO:wire')) do
+        # TODO: is this dependency on Cucumber::Hooks OK? Feels a bit internal..
+        # TODO: how do we express the location of the hook? Should we create one hook per connection so we can use the host:port of the connection?
+        Cucumber::Hooks.before_hook(id_generator.new_id, Core::Test::Location.new('TODO:wire')) do
           connections.begin_scenario(test_case)
         end
       end
 
       def after_hook(test_case)
-        Cucumber::Hooks.after_hook(test_case.source, Core::Ast::Location.new('TODO:wire')) do
+        Cucumber::Hooks.after_hook(id_generator.new_id, Core::Test::Location.new('TODO:wire')) do
           connections.end_scenario(test_case)
         end
       end
+
+      def id_generator
+        @id_generator ||= Cucumber::Messages::IdGenerator::UUID.new
+      end
     end
   end
 end

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/connections.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/connections.rb Changed

@@ -1,4 +1,4 @@
-require 'multi_json'
+require 'json'
 require 'socket'
 require 'cucumber/wire/connection'
 require 'cucumber/wire/configuration'
@@ -16,21 +16,22 @@
       attr_reader :connections
       private :connections
 
-      def initialize(connections, configuration)
+      def initialize(connections, configuration, registry)
         raise ArgumentError unless connections
         @connections = connections
         @configuration = configuration
+        @registry = registry
       end
 
       def find_match(test_step)
         matches = step_matches(test_step.name)
         return unless matches.any?
-        # TODO: handle ambiguous matches (push to cucumber?)
+        # TODO: handle ambiguous matches (push to cucumber?)
         matches.first
       end
 
       def step_matches(step_name)
-        connections.map{ |c| c.step_matches(step_name)}.flatten
+        connections.map{ |c| c.step_matches(step_name, @registry)}.flatten
       end
 
       def begin_scenario(test_case)

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/data_packet.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/data_packet.rb Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/plugin.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/plugin.rb Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/protocol.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/protocol.rb Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/protocol/requests.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/protocol/requests.rb Changed

@@ -1,5 +1,6 @@
+# coding: utf-8
 require 'cucumber/wire/request_handler'
-require 'cucumber/step_argument'
+require 'cucumber/wire/step_argument'
 
 module Cucumber
   module Wire
@@ -25,7 +26,7 @@
           private
 
           def create_step_match(raw_step_match)
-            step_definition = StepDefinition.new(@connection, raw_step_match)
+            step_definition = StepDefinition.new(@connection, raw_step_match, @registry)
             step_args = raw_step_match'args'.map do |raw_arg|
               StepArgument.new(raw_arg'pos', raw_arg'val')
             end
@@ -68,10 +69,8 @@
           end
 
           def handle_diff!(tables)
-            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
-            location = Core::Ast::Location.new(__FILE__, __LINE__)
-            table1 = table(tables0, location)
-            table2 = table(tables1, location)
+            table1 = table(tables0)
+            table2 = table(tables1)
             table1.diff!(table2)
           end
 
@@ -88,8 +87,8 @@
 
           private
 
-          def table(data, location)
-            Cucumber::MultilineArgument.from_core(Core::Ast::DataTable.new(data, location))
+          def table(data)
+            Cucumber::MultilineArgument.from_core(Core::Test::DataTable.new(data))
           end
         end

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/request_handler.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/request_handler.rb Changed

_service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/step_argument.rb Added

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/step_definition.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/step_definition.rb Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/lib/cucumber/wire/version -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/lib/cucumber/wire/version Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/data/spec/cucumber/wire/connections_spec.rb -> _service:tar_scm:cucumber-wire-6.2.0.gem/data/spec/cucumber/wire/connections_spec.rb Changed

_service:tar_scm:cucumber-wire-0.0.1.gem/metadata.gz -> _service:tar_scm:cucumber-wire-6.2.0.gem/metadata.gz Changed

@@ -1,109 +1,165 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-wire
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 6.2.0
 platform: ruby
 authors:
 - Matt Wynne
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2015-12-23 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: cucumber
+  name: cucumber-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
-  type: :development
+        version: '10.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '10.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.1.0
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: cucumber-cucumber-expressions
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '14.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 14.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '14.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.5
+        version: 14.0.0
+- !ruby/object:Gem::Dependency
+  name: cucumber-messages
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '17.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 17.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '17.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 17.1.1
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.5
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 7.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
 - !ruby/object:Gem::Dependency
-  name: aruba
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.10.0
 description: Wire protocol for Cucumber
 email: cukes@googlegroups.com
 executables: 
 extensions: 
 extra_rdoc_files: 
 files:
-- ".rspec"
-- ".travis.yml"
-- Gemfile
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
 - README.md
-- Rakefile
-- cucumber-wire.gemspec
-- features/erb_configuration.feature
-- features/handle_unexpected_response.feature
-- features/invoke_message.feature
-- features/readme.md
-- features/snippets_message.feature
-- features/step_definitions/aruba_steps.rb
-- features/step_definitions/wire_steps.rb
-- features/step_matches_message.feature
-- features/support/fake_wire_server.rb
-- features/table_diffing.feature
-- features/tags.feature
-- features/timeouts.feature
 - lib/cucumber/wire.rb
 - lib/cucumber/wire/add_hooks_filter.rb
 - lib/cucumber/wire/configuration.rb
@@ -116,6 +172,7 @@
 - lib/cucumber/wire/protocol/requests.rb
 - lib/cucumber/wire/request_handler.rb
 - lib/cucumber/wire/snippet.rb
+- lib/cucumber/wire/step_argument.rb
 - lib/cucumber/wire/step_definition.rb
 - lib/cucumber/wire/version
 - spec/cucumber/wire/configuration_spec.rb
@@ -136,22 +193,20 @@
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: 
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: cucumber-wire-0.0.1
+summary: cucumber-wire-6.2.0
 test_files:
-- spec/cucumber/wire/configuration_spec.rb
-- spec/cucumber/wire/connection_spec.rb
 - spec/cucumber/wire/connections_spec.rb
+- spec/cucumber/wire/connection_spec.rb
 - spec/cucumber/wire/data_packet_spec.rb
 - spec/cucumber/wire/exception_spec.rb
-has_rdoc: 
+- spec/cucumber/wire/configuration_spec.rb

_service:tar_scm:v6.2.0.tar.gz Added

Changes of Revision 2