开源软件构建与测试

Changes of Revision 2

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

@@ -1,16 +1,14 @@
 %global gem_name cucumber-core
 Name:                rubygem-%{gem_name}
-Version:             3.2.0
-Release:             3
+Version:             10.1.0
+Release:             1
 Summary:             Core library for the Cucumber BDD app
 License:             MIT
 URL:                 https://cucumber.io
 Source0:             https://rubygems.org/gems/%{gem_name}-%{version}.gem
-Source1:             https://github.com/cucumber/cucumber-ruby-core/archive/v%{version}.tar.gz
-Patch0:		     0001-remove-unintended-private-call.patch
-BuildRequires:       ruby(release) rubygems-devel ruby rubygem(gherkin) rubygem(rspec)
-BuildRequires:       rubygem(kramdown) rubygem(cucumber-tag_expressions) rubygem(backports)
-BuildRequires:       rubygem(kramdown-parser-gfm)
+BuildRequires:       ruby(release) rubygems-devel ruby rubygem-cucumber-gherkin rubygem(rspec)
+BuildRequires:       rubygem(kramdown) rubygem-cucumber-tag-expressions rubygem(backports)
+BuildRequires:       rubygem(kramdown-parser-gfm) rubygem(cucumber-messages)
 BuildArch:           noarch
 %description
 Core library for the Cucumber BDD app.
@@ -23,10 +21,10 @@
 Documentation for %{name}.
 
 %prep
-%setup -q -n %{gem_name}-%{version} -b 1
-%patch0 -p1
-%gemspec_remove_dep -s ../%{gem_name}-%{version}.gemspec -g gherkin '>= 5.0.0'
-%gemspec_add_dep -s ../%{gem_name}-%{version}.gemspec -g gherkin '>= 4.1.0'
+%setup -q -n %{gem_name}-%{version}
+
+%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
@@ -39,7 +37,6 @@
 
 %check
 pushd .%{gem_instdir}
-ln -s %{_builddir}/cucumber-ruby-core-%{version}/spec spec
 for file in $(grep -Rl unindent spec); do
   sed -i "/require 'unindent'/ s/^/#/" "${file}"
   sed -i '/^ *expect.*unindent$/ i \pending' "${file}"
@@ -60,8 +57,12 @@
 %doc %{gem_instdir}/CONTRIBUTING.md
 %doc %{gem_instdir}/README.md
 %doc %{gem_instdir}/CHANGELOG.md
+%{gem_instdir}/spec
 
 %changelog
+* Mon Jan 9 2023 liyanan <liyanan32@h-partners.com> - 10.1.0-1
+- Update to 10.1.0
+
 * Tue Mar 1 2022 baizhonggui <baizhonggui@huawei.com> -3.2.0-3
 - Remove unintended private call for fixing build error

_service:tar_scm:0001-remove-unintended-private-call.patch Deleted

@@ -1,26 +0,0 @@
-From 320b6fc7ed593311340313a1ed15ce07b7f5217f Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
-Date: Sun, 12 Jan 2020 13:41:59 +0100
-Subject: PATCH Remove unintended `private` call
-
-From reading https://bugs.ruby-lang.org/issues/13249, I don't think
-`private` is having any effect here, since it's only supposed to affect
-further methods defined inside the current class method (if at all), and
-this method does not define any method inside itself.
----
- lib/cucumber/core/test/result.rb | 1 -
- 1 file changed, 1 deletion(-)
-
-diff --git a/lib/cucumber/core/test/result.rb b/lib/cucumber/core/test/result.rb
-index 136002a..21d06c8 100644
---- a/lib/cucumber/core/test/result.rb
-+++ b/lib/cucumber/core/test/result.rb
-@@ -9,7 +9,6 @@ module Result
-         STRICT_AFFECTED_TYPES = :flaky, :undefined, :pending.freeze
- 
-         def self.ok?(type, be_strict = StrictConfiguration.new)
--          private
-           class_name = type.to_s.slice(0, 1).capitalize + type.to_s.slice(1..-1)
-           const_get(class_name).ok?(be_strict.strict?(type))
-         end
-

_service Changed

_service:tar_scm:cucumber-core-3.2.0.gem/checksums.yaml.gz -> _service:tar_scm:cucumber-core-10.1.0.gem/checksums.yaml.gz Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/CHANGELOG.md -> _service:tar_scm:cucumber-core-10.1.0.gem/data/CHANGELOG.md Changed

@@ -1,5 +1,156 @@
 Please see CONTRIBUTING.md(https://github.com/cucumber/cucumber/blob/master/CONTRIBUTING.md) on how to contribute to Cucumber.
 
+## In GIT(https://github.com/cucumber/cucumber-ruby-core/compare/v10.0.1...main)
+
+### Added
+
+### Changed
+
+### Deprecate
+
+### Removed
+
+### Fixed
+
+### Dependencies
+
+## 10.1.0(https://github.com/cucumber/cucumber-ruby-core/compare/v10.0.1...v10.1.0)
+
+### Dependencies
+
+* Patched `cucumber-gherkin`, `cucumber-messages` and `cucumber-tag-expressions`
+
+## 10.0.1(https://github.com/cucumber/cucumber-ruby-core/compare/v10.0.0...v10.0.1)
+
+### Dependencies
+
+* Patched `cucumber-gherkin` and `cucumber-messages`
+
+## 10.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v9.0.1...v10.0.0)
+
+### Dependencies
+
+* Upgraded to gherkin v20 and messages v17.
+
+  This removes protocol buffers from the runtime dependencies.
+
+  This deeply impacts the API as the internal representation of messages has changed from
+  Protocol Buffer objects to new auto-generated DTOs.
+
+## 9.0.1(https://github.com/cucumber/cucumber-ruby-core/compare/v9.0.0...v9.0.1)
+
+### Fixed
+
+* Skipped scenarios do not affect anymore status of flaky scenarios on retry
+  (#218(https://github.com/cucumber/cucumber-ruby-core/pull/218) @eduardrudko)
+
+## 9.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v8.0.1...v9.0.0)
+
+### Dependencies
+
+* Upgraded to gherkin v18 and messages v15
+* Updated other dependencies (look at the diff for details)
+
+## 8.0.1(https://github.com/cucumber/cucumber-ruby-core/compare/v8.0.0...v8.0.1)
+
+### Fixed
+
+* Make releases from docker using secrets from keybase
+
+## 8.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v7.1.0...v8.0.0)
+
+This release failed
+
+### Dependencies
+
+* Updated dependencies (look at the diff for details)
+
+## 7.1.0(https://github.com/cucumber/cucumber-ruby-core/compare/v7.0.0...v7.1.0)
+
+### Changed
+
+* Updated gems:
+  * `cucumber-gherkin` ~> 14.0.1
+  * `cucumber-messages` ~> 12.2.0
+
+## 7.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v6.0.0...v7.0.0)
+
+### Changed
+
+* Updated monorepo libraries:
+  - cucumber-gherkin ~> 13
+  - cucumber-messages ~> 12
+
+## 6.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v5.0.2...v6.0.0)
+
+### Changed
+
+* Update to Gherkin 10
+
+### Added
+
+* Add `envelope` event, which are used when emitting `Cucumber::Messages`
+* Add `TestCaseCreated` and `TestStepCreated` events, emitted when compiling a `Pickle`
+* Add `Id` field to `TestCase` and `TestStep`
+* Added rubocop (with todo file), and removed backports gems
+  (#186(https://github.com/cucumber/cucumber-ruby-core/pull/186),
+  #182(https://github.com/cucumber/cucumber-ruby-core/issues/182)
+  tas50(https://github.com/tas50),
+  luke-hill(https://github.com/luke-hill))
+
+### Removed
+
+* Remove location for MultiLine arguments
+
+
+## 5.0.2(https://github.com/cucumber/cucumber-ruby-core/compare/v5.0.1...v5.0.2)
+
+### Changed
+
+* Update to use Gherkin v8
+
+## 5.0.1(https://github.com/cucumber/cucumber-ruby-core/compare/v5.0.0...v5.0.1)
+
+### Removed
+
+* Remove support for ruby 2.2 and below. 2.3 or higher is required now.
+
+## 5.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v4.0.0...v5.0.0)
+
+### Changed
+
+* Update to use Gherkin v7
+
+## 4.0.0(https://github.com/cucumber/cucumber-ruby-core/compare/v3.2.0...v4.0.0)
+
+### Changed
+
+* Update to use Gherkin v6 (#158(https://github.com/cucumber/cucumber-ruby-core/pull/158) @brasmusson)
+* Let Scenarios with no Steps get the result status Undefined (#157(https://github.com/cucumber/cucumber-ruby-core/pull/157) @brasmusson)
+* Convert to use the Gherkin compiler and Pickles (#156(https://github.com/cucumber/cucumber-ruby-core/pull/156) @brasmusson)
+
+### Added
+
+* N/A
+
+### Fixed
+
+* N/A
+
+### Removed
+
+* Remove the support for old style tag expressions (#159(https://github.com/cucumber/cucumber-ruby-core/pull/159) @brasmusson)
+
+### Improved
+
+* N/A
+
+## 3.2.1(https://github.com/cucumber/cucumber-ruby-core/compare/v3.2.0...v3.2.1)
+
+### Fixed
+
+* Switched `gherkin` in Gemspec to use _pessimistic_ versioning. (These two commits aren't merged into `master`, as they already exist in newer commits. This is a 'backported' patch to resolve #160(https://github.com/cucumber/cucumber-ruby-core/issues/160)).
+
 ## 3.2.0(https://github.com/cucumber/cucumber-ruby-core/compare/v3.1.0...v3.2.0)
 
 ### Added

_service:tar_scm:cucumber-core-3.2.0.gem/data/CONTRIBUTING.md -> _service:tar_scm:cucumber-core-10.1.0.gem/data/CONTRIBUTING.md Changed

@@ -1,13 +1,186 @@
-Release Process
-===============
+# Contributing to Cucumber Ruby Core
 
-* Bump the version number in `lib/cucumber/core/version.rb`
-* Update `CHANGELOG.md` with the upcoming version number and create a new `In Git` section
-* Now release it:
+Thank you for considering contributing to Cucumber!
 
-```
-bundle update
+If you are not sure your contribution is related to `cucumber-ruby-core`, please
+consider taking a look at `cucumber-ruby`'s CONTRIBUTING.md(https://github.com/cucumber/cucumber-ruby/blob/main/CONTRIBUTING.md) first.
+
+## Code of Conduct
+
+Everyone interacting in this codebase and issue tracker is expected to follow
+the Cucumber code of conduct(https://cucumber.io/conduct).
+
+## How can I contribute?
+
+If you just want to know how to contribute to the code of `cucumber-ruby-core`,
+go to Contribute to the code(#contribute-to-the-code).
+
+## Report bugs and submit feature requests
+
+The short version is:
+
+- Try to check there is not already an issue or pull request that deals with
+  your bug or request
+- Explain your issue and include as much details as possible to help other
+  people reproduce your problem or understand your request
+- Consider submitting a pull request if you feel confident enough
+
+You can find more details for each of these steps in the following sections.
+
+### Look for existing issues and pull requests
+
+Search in the current repositorycucumber-ruby-core-issues, in the
+mono-repocucumber/common-issues, but also in the
+whole cucumber organizationcucumber-issues if the problem or feature has already
+been reported. If you find an issue or pull request which is still open, add
+comments to it instead of opening a new one.
+
+If you're not sure, don't hesitate to just open a new issue. We can always merge
+and de-duplicate later.
+
+### Submitting a pull request
+
+When submitting a pull request:
+
+- create a draft pull requesthow-to-create-a-draft-pr
+- try to follow the instructions in the template(.github/PULL_REQUEST_TEMPLATE.md)
+- if possible, sign your commits
+- update CHANGELOG.md with your changes
+- once the PR is ready, request for reviews
+
+More info on how to contribute to the code(#contribute-to-the-code) can be
+found below.
+
+### Opening a new issue
+
+To open a good issue, be clear and precise.
+
+If you report a problem, the reader must be able to reproduce it easily.
+Please do your best to create a minimal, reproducible exampleminimal-reproducible-example.
+
+Consider submitting a pull request. Even if you think you cannot fix it by
+yourself, a pull request with a failing test is always welcome.
+
+If your request is for an enhancement - a new feature - try to be specific and
+support your request with referenced facts and include examples to illustrate
+your proposal.
+
+## Contribute to the code
+
+### Development environment
+
+Development environment for `cucumber-ruby-core` is a simple Ruby environment with
+Bundler. Use a supported Ruby version(./README.md#supported-platforms), make
+sure Bundler is set-up, and voilà!
+
+You can then forkhow-to-fork and clone the repository. If your environment
+is set-up properly, the following commands should install the dependencies and
+execute all the tests successfully.
+
+```shell
+bundle install
 bundle exec rake
-git commit -m "Release X.Y.Z"
-rake release
 ```
+
+You can now create a branch for your changes and submit a pull request(#submitting-a-pull-request)!
+
+### Working with local cucumber dependencies
+
+You may need to use local dependencies instead of released gems for `cucumber-gherkin`
+or `cucumber-messages`. To do so the `Gemfile`(./Gemfile) for `cucumber-core`
+allows you to specify a local path for your gems using environment variables:
+
+    CUCUMBER_GHERKIN_RUBY
+    CUCUMBER_MESSAGES_RUBY
+
+For example, the following would use a local version of `cucumber-gherkin` with
+the `rake` command:
+
+```shell
+CUCUMBER_GHERKIN_RUBY=../common/gherkin/ruby bundle exec rake
+```
+
+In the same way, if you want to test your changes to `cucumber-core` with a local
+`cucumber-ruby`, checkout `cucumber-ruby`cucumber-ruby and do your tests with
+`CUCUMBER_RUBY_CORE` pointing to your local `cucumber-core`:
+
+```shell
+~/cucumber-ruby-core> cd ../cucumber-ruby
+~/cucumber-ruby> CUCUMBER_RUBY_CORE=../cucumber-ruby-core bundle exec rake
+```
+
+### Using a local Gemfile
+
+A local Gemfile allows you to use your prefer set of gems for your own
+development workflow, like gems dedicated to debugging. Such gems are not part
+of `cucumber-ruby` standard `Gemfile`.
+
+`Gemfile.local`, `Gemfile.local.lock` and `.bundle` have been added to
+`.gitignore` so local changes cannot be accidentaly commited and pushed to the
+repository.
+
+A `Gemfile.local` may look like this:
+
+```ruby
+# Gemfile.local
+
+# Include the regular Gemfile
+eval File.read('Gemfile')
+
+# Include your favorites development gems
+group :development do
+  gem 'byebug'
+  gem 'pry'
+  gem 'pry-byebug'
+
+  gem 'debase', require: false
+  gem 'ruby-debug-ide', require: false
+end
+```
+
+Then you can execute bundler with the `--gemfile` flag:
+`bundle install --gemfile Gemfile.local`, or with an environment variable:
+`BUNDLE_GEMFILE=Gemfile.local bundle COMMAND`.
+
+To use your local Gemfile per default, you can also execute
+`bundle config set --local gemfile Gemfile.local`.
+
+### First timer? Welcome!
+
+Looking for something simple to begin with? Look at issues with the label
+'good first issue(https://github.com/cucumber/cucumber-ruby-core/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)'.
+
+### Having trouble getting started with the code? We're here to help!
+
+If you have trouble setting-up your development environment, or getting started
+with the code, you can join us on Slackcommunity-slack. You will find there
+a lot of contributors.
+
+Full-time maintainers are also available. We would be please to have 1:1 pairing
+sessions to help you getting started. Look for
+Matt Wynne(https://cucumberbdd.slack.com/team/U590XDLF3) or
+Aurélien Reeves(https://cucumberbdd.slack.com/team/U011BB95MC7) on
+Slackcommunity-slack.
+
+### Additional documentation and notice
+
+You can find additional documentation in the docs(./docs) directory such as
+(non-exhaustive list):
+
+- How to release cucumber-ruby-core(./docs/RELEASE_PROCESS.md) (for maintainers)
+- Overview of cucumber-ruby-core(./docs/ARCHITECTURE.md)
+
+
+
+community-slack: https://cucumberbdd.slack.com/
+cucumber/common: https://github.com/cucumber/common
+cucumber-ruby: https://github.com/cucumber/cucumber-ruby
+cucumber-ruby-core: https://github.com/cucumber/cucumber-ruby-core
+cucumber-ruby-core-issues: https://github.com/cucumber/cucumber-ruby-core/search?q=is%3Aissue
+cucumber/common-issues: https://github.com/cucumber/common/search?q=is%3Aissue
+cucumber-issues: https://github.com/search?q=is%3Aissue+user%3Acucumber
+how-to-create-a-draft-pr: https://docs.github.com/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests#draft-pull-requests
+how-to-fork: https://docs.github.com/github/collaborating-with-pull-requests/working-with-forks/about-forks
+sign your commits: https://docs.github.com/en/github/authenticating-to-github/managing-commit-signature-verification/signing-commits
+minimal-reproducible-example: https://stackoverflow.com/help/minimal-reproducible-example
+Bundler: https://bundler.io/

_service:tar_scm:cucumber-core-3.2.0.gem/data/README.md -> _service:tar_scm:cucumber-core-10.1.0.gem/data/README.md Changed

@@ -1,123 +1,128 @@
-# cucumber-core
+<p align="center">
+  <img src="./.github/img/cucumber-open-logo.png" alt="Cucumber Open - Supported by Smartbear" width="428" />
+</p>
 
-!Chat with us(https://badges.gitter.im/Join%20Chat.svg)(https://gitter.im/cucumber/cucumber-ruby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-!Build Status(https://secure.travis-ci.org/cucumber/cucumber-ruby-core.svg)(http://travis-ci.org/cucumber/cucumber-ruby-core)
-!Code Climate(https://codeclimate.com/github/cucumber/cucumber-ruby-core.svg)(https://codeclimate.com/github/cucumber/cucumber-ruby-core)
-!Coverage Status(https://coveralls.io/repos/cucumber/cucumber-ruby-core/badge.svg?branch=master)(https://coveralls.io/r/cucumber/cucumber-ruby-core?branch=master)
-!Dependency Status(https://gemnasium.com/cucumber/cucumber-ruby-core.svg)(https://gemnasium.com/cucumber/cucumber-ruby-core)
-
-Cucumber Core is the inner hexagon(http://alistair.cockburn.us/Hexagonal+architecture) for the Ruby flavour of Cucumber(https://github.com/cucumber/cucumber-ruby).
-
-It contains the core domain logic to execute Cucumber features. It has no user interface, just a Ruby API. If you're interested in how Cucumber works, or in building other tools that work with Gherkin documents, you've come to the right place.
-
-## An overview
+# Cucumber
 
-The entry-point is a single method on the module `Cucumber::Core`(Cucumber/Core.html) called `#execute`(Cucumber/Core.html#execute-instance_method). Here's what it does:
-
-1. Parses the plain-text Gherkin documents into an **AST**
-2. Compiles the AST down to **test cases**
-3. Passes the test cases through any **filters**
-4. Executes the test cases, emitting **events** as it goes
+!OpenCollective(https://opencollective.com/cucumber/backers/badge.svg)(https://opencollective.com/cucumber)
+!OpenCollective(https://opencollective.com/cucumber/sponsors/badge.svg)(https://opencollective.com/cucumber)
+!pull requests(https://oselvar.com/api/badge?label=pull%20requests&csvUrl=https%3A%2F%2Fraw.githubusercontent.com%2Fcucumber%2Foselvar-github-metrics%2Fmain%2Fdata%2Fcucumber%2Fcucumber-ruby-core%2FpullRequests.csv)(https://oselvar.com/github/cucumber/oselvar-github-metrics/main/cucumber/cucumber-ruby-core)
+!issues(https://oselvar.com/api/badge?label=issues&csvUrl=https%3A%2F%2Fraw.githubusercontent.com%2Fcucumber%2Foselvar-github-metrics%2Fmain%2Fdata%2Fcucumber%2Fcucumber-ruby-core%2Fissues.csv)(https://oselvar.com/github/cucumber/oselvar-github-metrics/main/cucumber/cucumber-ruby-core)
+!Test cucumber-core(https://github.com/cucumber/cucumber-ruby-core/actions/workflows/cucumber-ruby-core.yml/badge.svg)(https://github.com/cucumber/cucumber-ruby-core/actions/workflows/cucumber-ruby-core.yml)
+!Code Climate(https://codeclimate.com/github/cucumber/cucumber-ruby-core.svg)(https://codeclimate.com/github/cucumber/cucumber-ruby-core)
+!Coverage Status(https://coveralls.io/repos/cucumber/cucumber-ruby-core/badge.svg?branch=main)(https://coveralls.io/r/cucumber/cucumber-ruby-core?branch=main)
 
-We've introduced a number of concepts here, so let's go through them in detail.
+Cucumber is a tool for running automated tests written in plain language. Because they're
+written in plain language, they can be read by anyone on your team. Because they can be
+read by anyone, you can use them to help improve communication, collaboration and trust on
+your team.
 
-### The AST
+<p align="center">
+  <img src="./.github/img/gherkin-example.png" alt="Cucumber Gherkin Example" width="728" />
+</p>
 
-The Abstract Syntax Tree or AST(Cucumber/Core/Ast.html) is an object graph that represents the Gherkin documents you've passed into the core. Things like Feature(Cucumber/Core/Ast/Feature.html), Scenario(Cucumber/Core/Ast/Scenario.html) and ExamplesTable(Cucumber/Core/Ast/ExamplesTable.html).
+Cucumber Core is the inner hexagon(https://en.wikipedia.org/wiki/Hexagonal_architecture_(software))
+for the Ruby flavour of Cucumber(https://github.com/cucumber/cucumber-ruby).
 
-These are immutable value objects.
+It contains the core domain logic to execute Cucumber features. It has no user interface,
+just a Ruby API. If you're interested in how Cucumber works, or in building other
+tools that work with Gherkin documents, you've come to the right place.
 
-### Test cases
+See CONTRIBUTING.md(CONTRIBUTING.md) for info on contributing to Cucumber (issues,
+PRs, etc.).
 
-Your gherkin might contain scenarios, as well as examples from tables beneath a scenario outline.
+Everyone interacting in this codebase and issue tracker is expected to follow the
+Cucumber code of conduct(https://cucumber.io/conduct).
 
-Test cases represent the general case of both of these. We compile the AST down to instances of `Cucumber::Core::Test::Case`(Cucumber/Core/Test/Case.html), each containing a number of instances of `Cucumber::Core::Test::Step`(Cucumber/Core/Test/Step.html). It's these that are then filtered and executed.
+## Installation
 
-Test cases and their test steps are also immutable value objects.
+`cucumber-core` is a Ruby gem. Install it as you would install any gem: add
+`cucumber-core` to your Gemfile:
 
-### Filters
+    gem 'cucumber-core'
 
-Once we have the test cases, and they've been activated by the mappings, you may want to pass them through a filter or two. Filters can be used to do things like activate, sort, replace or remove some of the test cases or their steps before they're executed.
+then install it:
 
-### Events
+    $ bundle
 
-Events are how you find out what is happening during your test run. As the test cases and steps are executed, the runner emits events to signal what's going on.
+or install the gem directly:
 
-The following events are emitted during a run:
+    $ gem install cucumber-core
 
-- `TestCaseStarting`(Cucumber/Core/Events/TestCaseStarting.html)
-- `TestStepStarting`(Cucumber/Core/Events/TestStepStarting.html)
-- `TestStepFinished`(Cucumber/Core/Events/TestStepFinished.html)
-- `TestCaseFinished`(Cucumber/Core/Events/TestCaseFinished.html)
+### Supported platforms
 
-That's probably best illustrated with an example.
+- Ruby 3.0
+- Ruby 2.7
+- Ruby 2.6
+- Ruby 2.5
+- Ruby 2.4
+- Ruby 2.3
+- JRuby 9.2 (with some limitations(https://github.com/cucumber/cucumber-ruby/blob/main/docs/jruby-limitations.md))
 
-## Example
+## Usage
 
-Here's an example of how you might use `Cucumber::Core#execute`(Cucumber/Core#execute-instance_method)
+The following example aims to illustrate how to use `cucumber-core` gem and to
+make sure it is working well within your environment. For more details
+explanation on what it actually does and how to work with it, see
+docs/ARCHITECTURE.md(docs/ARCHITECTURE.md).
 
 ```ruby
+# cucumber_core_example.rb
+
 require 'cucumber/core'
 require 'cucumber/core/filter'
 
-# This is the most complex part of the example. The filter takes test cases as input,
-# activates each step with an action block, then passes a new test case with those activated
-# steps in it on to the next filter in the chain.
 class ActivateSteps < Cucumber::Core::Filter.new
   def test_case(test_case)
     test_steps = test_case.test_steps.map do |step|
-      activate(step)
+      step.with_action { print "processing: " }
     end
 
     test_case.with_steps(test_steps).describe_to(receiver)
   end
-
-  private
-
-  def activate(step)
-    case step.text
-    when /fail/
-      step.with_action { raise Failure }
-    when /pass/
-      step.with_action {}
-    else
-      step
-    end
-  end
 end
 
-# Create a Gherkin document to run
 feature = Cucumber::Core::Gherkin::Document.new(__FILE__, <<-GHERKIN)
 Feature:
   Scenario:
-    Given passing
-    And failing
-    And undefined
+    Given some requirements
+    When we do something
+    Then it should pass
 GHERKIN
 
-# Create a runner class that uses the Core's DSL
 class MyRunner
   include Cucumber::Core
 end
 
-# Now execute the feature, using the filter we built, and subscribing to
-# an event so we can print the output.
 MyRunner.new.execute(feature, ActivateSteps.new) do |events|
   events.on(:test_step_finished) do |event|
     test_step, result = event.test_step, event.result
-    puts "#{test_step.text} #{result}"
+    print "#{test_step.text} #{result}\n"
   end
 end
 ```
 
-If you run this little Ruby script, you should see the following output:
+If you run this Ruby script:
+
+```shell
+ruby cucumber_core_example.rb
+```
+
+You should see the following output:
 
 ```
-passing ✓
-failing ✗
-undefined ?
+processing: some requirements ✓
+processing: we do something ✓
+processing: it should pass ✓
 ```
 
+## Documentation and support
+
+- Getting started with Cucumber, writing features, step definitions, and more: https://cucumber.io/docs
+- Slack: register for an account(https://cucumberbdd-slack-invite.herokuapp.com/) then head over to #intro(https://cucumberbdd.slack.com/messages/C5WD8SA21/)
+- `cucumber-core` overview: docs/ARCHITECTURE.md(docs/ARCHITECTURE.md)
+- How to work with local repositories for `cucumber-gherkin`, `cucumber-messages` or `cucumber-ruby`: CONTRIBUTING.md#working-with-local-cucumber-dependencies(./CONTRIBUTING.md#working-with-local-cucumber-dependencies)
+
 ## Copyright
 
-Copyright (c) Cucumber Limited.
+Copyright (c) Cucumber Ltd. and Contributors. See LICENSE for details.

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core.rb Changed

@@ -4,6 +4,8 @@
 require 'cucumber/core/gherkin/document'
 require 'cucumber/core/compiler'
 require 'cucumber/core/test/runner'
+require 'cucumber/messages'
+require 'gherkin/query'
 
 module Cucumber
   module Core
@@ -11,21 +13,22 @@
     def execute(gherkin_documents, filters = , event_bus = EventBus.new)
       yield event_bus if block_given?
       receiver = Test::Runner.new(event_bus)
-      compile gherkin_documents, receiver, filters
+      compile gherkin_documents, receiver, filters, event_bus
       self
     end
 
     def compile(gherkin_documents, last_receiver, filters = , event_bus = EventBus.new)
       first_receiver = compose(filters, last_receiver)
-      compiler = Compiler.new(first_receiver)
-      parse gherkin_documents, compiler, event_bus
+      gherkin_query = ::Gherkin::Query.new
+      compiler = Compiler.new(first_receiver, gherkin_query, event_bus)
+      parse gherkin_documents, compiler, event_bus, gherkin_query
       self
     end
 
     private
 
-    def parse(gherkin_documents, compiler, event_bus)
-      parser = Core::Gherkin::Parser.new(compiler, event_bus)
+    def parse(gherkin_documents, compiler, event_bus, gherkin_query)
+      parser = Core::Gherkin::Parser.new(compiler, event_bus, gherkin_query)
       gherkin_documents.each do |document|
         parser.document document
       end
@@ -38,6 +41,5 @@
         filter.with_receiver(receiver)
       end
     end
-
   end
 end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/compiler.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/compiler.rb Changed

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
+
 require 'cucumber/core/test/case'
 require 'cucumber/core/test/step'
+require 'cucumber/core/test/tag'
+require 'cucumber/core/test/doc_string'
+require 'cucumber/core/test/data_table'
+require 'cucumber/core/test/empty_multiline_argument'
+require 'cucumber/messages'
 
 module Cucumber
   module Core
-
-    # Compiles the AST into test cases
+    # Compiles the Pickles into test cases
     class Compiler
-      attr_reader :receiver
-      private     :receiver
+      attr_reader :receiver, :gherkin_query, :id_generator
+      private     :receiver, :gherkin_query, :id_generator
 
-      def initialize(receiver)
+      def initialize(receiver, gherkin_query, event_bus = nil)
         @receiver = receiver
+        @id_generator = Cucumber::Messages::IdGenerator::UUID.new
+        @gherkin_query = gherkin_query
+        @event_bus = event_bus
       end
 
-      def feature(feature)
-        compiler = FeatureCompiler.new(TestCaseBuilder.new(receiver))
-        feature.describe_to(compiler)
-        self
+      def pickle(pickle)
+        test_case = create_test_case(pickle)
+        test_case.describe_to(receiver)
       end
 
       def done
@@ -25,152 +32,60 @@
         self
       end
 
-      # @private
-      class TestCaseBuilder
-        attr_reader :receiver
-        private     :receiver
-
-        def initialize(receiver)
-          @receiver = receiver
-        end
-
-        def on_background_step(source)
-          background_test_steps << Test::Step.new(source)
-          self
-        end
-
-        def on_step(source)
-          test_steps << Test::Step.new(source)
-          self
-        end
-
-        def on_test_case(source)
-          Test::Case.new(test_steps, source).describe_to(receiver) if test_steps.count > 0
-          @test_steps = nil
-          self
-        end
-
-        private
+      private
 
-        def background_test_steps
-          @background_test_steps ||= 
-        end
-
-        def test_steps
-          @test_steps ||= background_test_steps.dup
-        end
+      def create_test_case(pickle)
+        uri = pickle.uri
+        test_steps = pickle.steps.map { |step| create_test_step(step, uri) }
+        lines = source_lines_for_pickle(pickle).sort.reverse
+        tags = pickle.tags.map { |tag| Test::Tag.new(Test::Location.new(uri, source_line_for_pickle_tag(tag)), tag.name) }
+        test_case = Test::Case.new(id_generator.new_id, pickle.name, test_steps, Test::Location.new(uri, lines), tags, pickle.language)
+        @event_bus&.test_case_created(test_case, pickle)
+        test_case
       end
 
-      # @private
-      class FeatureCompiler
-        attr_reader :receiver
-        private     :receiver
-
-        def initialize(receiver)
-          @receiver = receiver
-        end
-
-        def feature(feature, &descend)
-          @feature = feature
-          descend.call(self)
-          self
-        end
-
-        def background(background, &descend)
-          source = @feature, background
-          compiler = BackgroundCompiler.new(source, receiver)
-          descend.call(compiler)
-          self
-        end
-
-        def scenario(scenario, &descend)
-          source = @feature, scenario
-          scenario_compiler = ScenarioCompiler.new(source, receiver)
-          descend.call(scenario_compiler)
-          receiver.on_test_case(source)
-          self
-        end
-
-        def scenario_outline(scenario_outline, &descend)
-          source = @feature, scenario_outline
-          compiler = ScenarioOutlineCompiler.new(source, receiver)
-          descend.call(compiler)
-          self
-        end
+      def create_test_step(pickle_step, uri)
+        lines = source_lines_for_pickle_step(pickle_step).sort.reverse
+        multiline_arg = create_multiline_arg(pickle_step, uri)
+        step = Test::Step.new(id_generator.new_id, pickle_step.text, Test::Location.new(uri, lines), multiline_arg)
+        @event_bus&.test_step_created(step, pickle_step)
+        step
       end
 
-      # @private
-      class ScenarioOutlineCompiler
-        attr_reader :source, :receiver
-        private     :source, :receiver
-
-        def initialize(source, receiver)
-          @source   = source
-          @receiver = receiver
-        end
-
-        def outline_step(outline_step)
-          outline_steps << outline_step
-          self
-        end
-
-        def examples_table(examples_table, &descend)
-          @examples_table = examples_table
-          descend.call(self)
-          self
-        end
-
-        def examples_table_row(row)
-          steps(row).each do |step|
-            receiver.on_step(source + @examples_table, row, step)
+      def create_multiline_arg(pickle_step, _uri)
+        if pickle_step.argument
+          if pickle_step.argument.doc_string
+            doc_string = pickle_step.argument.doc_string
+            Test::DocString.new(
+              doc_string.content,
+              doc_string.media_type
+            )
+          elsif pickle_step.argument.data_table
+            data_table = pickle_step.argument.data_table
+            Test::DataTable.new(
+              data_table.rows.map { |row| row.cells.map { |cell| cell.value } }
+            )
           end
-          receiver.on_test_case(source + @examples_table, row)
-          self
-        end
-
-        private
-
-        def steps(row)
-          outline_steps.map { |s| s.to_step(row) }
-        end
-
-        def outline_steps
-          @outline_steps ||= 
+        else
+          Test::EmptyMultilineArgument.new
         end
       end
 
-      # @private
-      class ScenarioCompiler
-        attr_reader :source, :receiver
-        private     :source, :receiver
-
-        def initialize(source, receiver)
-          @source   = source
-          @receiver = receiver
-        end
-
-        def step(step)
-          receiver.on_step(source + step)
-          self
-        end
+      def source_lines_for_pickle(pickle)
+        pickle.ast_node_ids.map { |id| source_line(id) }
       end
 
-      # @private
-      class BackgroundCompiler
-        attr_reader :source, :receiver
-        private     :source, :receiver
-
-        def initialize(source, receiver)
-          @source   = source
-          @receiver = receiver
-        end
+      def source_lines_for_pickle_step(pickle_step)
+        pickle_step.ast_node_ids.map { |id| source_line(id) }
+      end
 
-        def step(step)
-          receiver.on_background_step(source + step)
-          self
-        end
+      def source_line_for_pickle_tag(tag)
+        source_line(tag.ast_node_id)
       end
 
+      def source_line(id)
+        gherkin_query.location(id).line
+      end
     end
   end
 end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/event.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/event.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/event_bus.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/event_bus.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/events.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/events.rb Changed

@@ -5,16 +5,35 @@
   module Core
     module Events
 
-      # Signals that a gherkin source has been parsed
-      class GherkinSourceParsed < Event.new(:uri, :gherkin_document)
-        # The uri of the file
-        attr_reader :uri
+      class Envelope < Event.new(:envelope)
+        attr_reader :envelope
+      end
 
+      # Signals that a gherkin source has been parsed
+      class GherkinSourceParsed < Event.new(:gherkin_document)
         # @return GherkinDocument the GherkinDocument Ast Node
         attr_reader :gherkin_document
 
       end
 
+      # Signals that a Test::Step was created from a PickleStep
+      class TestStepCreated < Event.new(:test_step, :pickle_step)
+        # The created test step
+        attr_reader :test_step
+
+        # The source pickle step
+        attr_reader :pickle_step
+      end
+
+      # Signals that a Test::Case was created from a Pickle
+      class TestCaseCreated < Event.new(:test_case, :pickle)
+        # The created test step
+        attr_reader :test_case
+
+        # The source pickle step
+        attr_reader :pickle
+      end
+
       # Signals that a {Test::Case} is about to be executed
       class TestCaseStarted < Event.new(:test_case)
 
@@ -42,7 +61,6 @@
 
       end
 
-
       # Signals that a {Test::Case} has finished executing
       class TestCaseFinished < Event.new(:test_case, :result)
 
@@ -58,7 +76,10 @@
       # that will be used by the {EventBus} by default.
       def self.registry
         build_registry(
+          Envelope,
           GherkinSourceParsed,
+          TestStepCreated,
+          TestCaseCreated,
           TestCaseStarted,
           TestStepStarted,
           TestStepFinished,

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/gherkin/parser.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/gherkin/parser.rb Changed

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
-require 'gherkin/parser'
-require 'gherkin/token_scanner'
-require 'gherkin/errors'
-require 'cucumber/core/gherkin/ast_builder'
-require 'cucumber/core/ast'
+require 'gherkin'
 
 module Cucumber
   module Core
@@ -11,39 +7,45 @@
       ParseError = Class.new(StandardError)
 
       class Parser
-        attr_reader :receiver, :event_bus
-        private     :receiver, :event_bus
+        attr_reader :receiver, :event_bus, :gherkin_query
+        private     :receiver, :event_bus, :gherkin_query
 
-        def initialize(receiver, event_bus)
+        def initialize(receiver, event_bus, gherkin_query)
           @receiver = receiver
           @event_bus = event_bus
+          @gherkin_query = gherkin_query
         end
 
         def document(document)
-          parser        = ::Gherkin::Parser.new
-          scanner       = ::Gherkin::TokenScanner.new(document.body)
-          token_matcher = ::Gherkin::TokenMatcher.new(document.language)
-          core_builder  = AstBuilder.new(document.uri)
-
-          begin
-            result = parser.parse(scanner, token_matcher)
-            event_bus.gherkin_source_parsed(document.uri, result.dup)
-
-            receiver.feature core_builder.feature(result)
-          rescue *PARSER_ERRORS => e
-            raise Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
+          messages = ::Gherkin.from_source(document.uri, document.body, gherkin_options(document))
+          messages.each do |message|
+            event_bus.envelope(message)
+            gherkin_query.update(message)
+            if !message.gherkin_document.nil?
+              event_bus.gherkin_source_parsed(message.gherkin_document)
+            elsif !message.pickle.nil?
+              receiver.pickle(message.pickle)
+            elsif message.parse_error
+              raise Core::Gherkin::ParseError.new("#{document.uri}: #{message.parse_error.message}")
+            else
+              raise "Unknown message: #{message.to_hash}"
+            end
           end
         end
 
+        def gherkin_options(document)
+          {
+            default_dialect: document.language,
+            include_source: false,
+            include_gherkin_document: true,
+            include_pickles: true
+          }
+        end
+
         def done
           receiver.done
           self
         end
-
-        private
-
-        PARSER_ERRORS = ::Gherkin::ParserError
-
       end
     end
   end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/gherkin/writer.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/gherkin/writer.rb Changed

@@ -48,7 +48,7 @@
 
           default_keyword 'Feature'
 
-          elements :background, :scenario, :scenario_outline
+          elements :background, :rule, :scenario, :scenario_outline
 
           def build(source = )
             elements.inject(source + statements) { |acc, el| el.build(acc) + NEW_LINE }
@@ -60,12 +60,14 @@
           end
 
           def statements
-            prepare_statements language_statement,
+            prepare_statements(
+              language_statement,
               comments_statement,
               tag_statement,
               name_statement,
               description_statement,
               NEW_LINE
+            )
           end
 
           def language_statement
@@ -85,7 +87,33 @@
 
           private
           def statements
-            prepare_statements comments_statement, tag_statement, name_statement, description_statement
+            prepare_statements(
+              comments_statement,
+              tag_statement,
+              name_statement,
+              description_statement
+            )
+          end
+        end
+
+        class Rule
+          include HasElements
+          include HasOptionsInitializer
+          include HasDescription
+          include Indentation.level 2
+
+          default_keyword 'Rule'
+
+          elements :example, :scenario
+
+          private
+          def statements
+            prepare_statements(
+              comments_statement,
+              name_statement,
+              description_statement,
+              NEW_LINE
+            )
           end
         end
 
@@ -101,13 +129,21 @@
 
           private
           def statements
-            prepare_statements comments_statement,
+            prepare_statements(
+              comments_statement,
               tag_statement,
               name_statement,
               description_statement
+            )
           end
         end
 
+        class Example < Scenario
+          include Indentation.level 4
+
+          default_keyword 'Example'
+        end
+
         class ScenarioOutline
           include HasElements
           include HasOptionsInitializer
@@ -207,12 +243,14 @@
 
           private
           def statements
-            prepare_statements NEW_LINE,
+            prepare_statements(
+              NEW_LINE,
               comments_statement,
               tag_statement,
               name_statement,
               description_statement,
               row_statements(2)
+            )
           end
         end
       end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/gherkin/writer/helpers.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/gherkin/writer/helpers.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/report/summary.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/report/summary.rb Changed

@@ -23,38 +23,16 @@
             if event.test_case != @previous_test_case
               @previous_test_case = event.test_case
               event.result.describe_to test_cases
-            elsif event.result.passed?
+            elsif event.result.passed? || event.result.skipped?
               test_cases.flaky
               test_cases.decrement_failed
             end
           end
           event_bus.on(:test_step_finished) do |event|
-            event.result.describe_to test_steps if is_step?(event.test_step)
+            event.result.describe_to test_steps unless event.test_step.hook?
           end
           self
         end
-
-        def is_step?(test_step)
-          StepQueryVisitor.new(test_step).is_step?
-        end
-      end
-
-      class StepQueryVisitor
-        def initialize(test_step)
-          @step = false
-          test_step.source.last.describe_to(self)
-        end
-
-        def is_step?
-          @step
-        end
-
-        def step(*)
-          @step = true
-        end
-        
-        def method_missing(*)
-        end
       end
     end
   end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/action.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/action.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/around_hook.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/around_hook.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/case.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/case.rb Changed

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
+
 require 'cucumber/core/test/result'
 require 'cucumber/tag_expressions'
-require 'cucumber/core/gherkin/tag_expression'
-require 'cucumber/core/ast/location'
 
 module Cucumber
   module Core
     module Test
       class Case
-        attr_reader :source, :test_steps, :around_hooks
+        attr_reader :id, :name, :test_steps, :location, :tags, :language, :around_hooks
 
-        def initialize(test_steps, source, around_hooks = )
-          raise ArgumentError.new("test_steps should be an Array but is a #{test_steps.class}") unless test_steps.kind_of?(Array)
+        def initialize(id, name, test_steps, location, tags, language, around_hooks = )
+          raise ArgumentError.new("test_steps should be an Array but is a #{test_steps.class}") unless test_steps.is_a?(Array)
+          @id = id
+          @name = name
           @test_steps = test_steps
-          @source = source
+          @location = location
+          @tags = tags
+          @language = language
           @around_hooks = around_hooks
         end
 
@@ -32,31 +35,12 @@
           self
         end
 
-        def describe_source_to(visitor, *args)
-          source.reverse.each do |node|
-            node.describe_to(visitor, *args)
-          end
-          self
-        end
-
         def with_steps(test_steps)
-          self.class.new(test_steps, source, around_hooks)
+          self.class.new(id, name, test_steps, location, tags, language, around_hooks)
         end
 
         def with_around_hooks(around_hooks)
-          self.class.new(test_steps, source, around_hooks)
-        end
-
-        def name
-          @name ||= NameBuilder.new(self).result
-        end
-        
-        def keyword
-          @keyword ||= NameBuilder.new(self).keyword
-        end
-
-        def tags
-          @tags ||= TagCollector.new(self).result
+          self.class.new(id, name, test_steps, location, tags, language, around_hooks)
         end
 
         def match_tags?(*expressions)
@@ -64,43 +48,19 @@
         end
 
         def match_name?(name_regexp)
-          source.any? { |node| node.respond_to?(:name) && node.name =~ name_regexp }
-        end
-
-        def language
-          feature.language
-        end
-
-        def location
-          source.last.location
+          name =~ name_regexp
         end
 
         def match_locations?(queried_locations)
-          queried_locations.any? { |queried_location|
-            all_source.any? { |node|
-              node.all_locations.any? { |location|
-                queried_location.match? location
-              }
-            }
-          }
-        end
-
-        def all_locations
-          @all_locations ||= Ast::Location.merge(all_source.map(&:all_locations).flatten)
-        end
-
-        def all_source
-          @all_source ||= (source + test_steps.map(&:source)).flatten.uniq
+          queried_locations.any? do |queried_location|
+            queried_location.match? location
+          end
         end
 
         def inspect
           "#<#{self.class}: #{location}>"
         end
 
-        def feature
-          source.first
-        end
-
         def hash
           location.hash
         end
@@ -122,73 +82,8 @@
         end
 
         def match_single_tag_expression?(expression)
-          if old_style_tag_expression?(expression)
-            Cucumber::Core::Gherkin::TagExpression.new(expression).evaluate(tags)
-          else
-            Cucumber::TagExpressions::Parser.new.parse(expression).evaluate(tags.map(&:name))
-          end
-        end
-
-        def old_style_tag_expression?(expression)
-          expression.include?(',') || expression.include?('~')
+          Cucumber::TagExpressions::Parser.new.parse(expression).evaluate(tags.map(&:name))
         end
-
-        class NameBuilder
-          attr_reader :result
-          attr_reader :keyword
-
-          def initialize(test_case)
-            test_case.describe_source_to self
-          end
-
-          def feature(*)
-            self
-          end
-
-          def scenario(scenario)
-            @result = scenario.name
-            @keyword = scenario.keyword
-            self
-          end
-
-          def scenario_outline(outline)
-            @result = outline.name + @result
-            @keyword = outline.keyword
-            self
-          end
-
-          def examples_table(table)
-            name = table.name.strip
-            name = table.keyword if name.length == 0
-            @result = ", #{name}" + @result
-            self
-          end
-
-          def examples_table_row(row)
-            @result = " (##{row.number})"
-            self
-          end
-        end
-
-        class TagCollector
-          attr_reader :result
-
-          def initialize(test_case)
-            @result = 
-            test_case.describe_source_to self
-          end
-
-          :feature, :scenario, :scenario_outline, :examples_table.each do |node_name|
-            define_method(node_name) do |node|
-              @result = node.tags + @result
-              self
-            end
-          end
-
-          def examples_table_row(*)
-          end
-        end
-
       end
     end
   end

_service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/data_table.rb Added

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Core
+    module Test
+      # Step Definitions that match a plain text Step with a multiline argument table
+      # will receive it as an instance of DataTable. A DataTable object holds the data of a
+      # table parsed from a feature file and lets you access and manipulate the data
+      # in different ways.
+      #
+      # For example:
+      #
+      #   Given I have:
+      #     | a | b |
+      #     | c | d |
+      #
+      # And a matching StepDefinition:
+      #
+      #   Given /I have:/ do |table|
+      #     data = table.raw
+      #   end
+      #
+      # This will store <tt>'a', 'b', 'c', 'd'</tt> in the <tt>data</tt> variable.
+      #
+      class DataTable
+        # Creates a new instance. +raw+ should be an Array of Array of String
+        # or an Array of Hash
+        # You don't typically create your own DataTable objects - Cucumber will do
+        # it internally and pass them to your Step Definitions.
+        #
+        def initialize(rows)
+          raw = ensure_array_of_array(rows)
+          verify_rows_are_same_length(raw)
+          @raw = raw.freeze
+        end
+        attr_reader :raw
+
+        def describe_to(visitor, *args)
+          visitor.data_table(self, *args)
+        end
+
+        def to_step_definition_arg
+          dup
+        end
+
+        def data_table?
+          true
+        end
+
+        def doc_string?
+          false
+        end
+
+        # Creates a copy of this table
+        #
+        def dup
+          self.class.new(raw.dup)
+        end
+
+        # Returns a new, transposed table. Example:
+        #
+        #   | a | 7 | 4 |
+        #   | b | 9 | 2 |
+        #
+        # Gets converted into the following:
+        #
+        #   | a | b |
+        #   | 7 | 9 |
+        #   | 4 | 2 |
+        #
+        def transpose
+          self.class.new(raw.transpose)
+        end
+
+        def map(&block)
+          new_raw = raw.map do |row|
+            row.map(&block)
+          end
+
+          self.class.new(new_raw)
+        end
+
+        def ==(other)
+          other.class == self.class && raw == other.raw
+        end
+
+        def inspect
+          %{#<#{self.class} #{raw.inspect})>}
+        end
+
+        private
+
+        def verify_rows_are_same_length(raw)
+          begin
+            raw.transpose
+          rescue IndexError
+            raise ArgumentError, "Rows must all be the same length"
+          end
+        end
+
+        def ensure_array_of_array(array)
+          Hash === array0 ? hashes_to_array(array) : array
+        end
+
+        def hashes_to_array(hashes)
+          header = hashes0.keys.sort
+          header + hashes.map {|hash| header.map {|key| hashkey}}
+        end
+
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/doc_string.rb Added

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'delegate'
+module Cucumber
+  module Core
+    module Test
+      # Represents an inline argument in a step. Example:
+      #
+      #   Given the message
+      #     """
+      #     I like
+      #     Cucumber sandwich
+      #     """
+      #
+      # The text between the pair of <tt>"""</tt> is stored inside a DocString,
+      # which is yielded to the StepDefinition block as the last argument.
+      #
+      # The StepDefinition can then access the String via the #to_s method. In the
+      # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
+      #
+      # Note how the indentation from the source is stripped away.
+      #
+      class DocString < SimpleDelegator
+        attr_reader :content_type, :content
+
+        def initialize(content, content_type)
+          @content = content
+          @content_type = content_type
+          super @content
+        end
+
+        def describe_to(visitor, *args)
+          visitor.doc_string(self, *args)
+        end
+
+        def data_table?
+          false
+        end
+
+        def doc_string?
+          true
+        end
+
+        def map
+          raise ArgumentError, "No block given" unless block_given?
+          new_content = yield content
+          self.class.new(new_content, content_type)
+        end
+
+        def to_step_definition_arg
+          self
+        end
+
+        def ==(other)
+          if other.respond_to?(:content_type)
+            return false unless content_type == other.content_type
+          end
+          if other.respond_to?(:to_str)
+            return content == other.to_str
+          end
+          false
+        end
+
+        def inspect
+          
+            %{#<#{self.class}},
+            %{  """#{content_type}},
+            %{  #{@content}},
+            %{  """>}
+          .join("\n")
+        end
+
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/empty_multiline_argument.rb Added

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/filters/activate_steps_for_self_test.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/filters/activate_steps_for_self_test.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/filters/locations_filter.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/filters/locations_filter.rb Changed

_service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/location.rb Added

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'cucumber/core/platform'
+module Cucumber
+  module Core
+    module Test
+      IncompatibleLocations = Class.new(StandardError)
+
+      module Location
+
+        def self.of_caller(additional_depth = 0)
+          from_file_colon_line(*caller1 + additional_depth)
+        end
+
+        def self.from_file_colon_line(file_colon_line)
+          file, raw_line = file_colon_line.match(/(.*):(\d+)/)1..2
+          from_source_location(file, raw_line.to_i)
+        end
+
+        def self.from_source_location(file, line)
+          file = File.expand_path(file)
+          pwd = File.expand_path(Dir.pwd)
+          pwd.force_encoding(file.encoding)
+          if file.index(pwd)
+            file = filepwd.length+1..-1
+          elsif file =~ /.*\/gems\/(.*\.rb)$/
+            file = $1
+          end
+          new(file, line)
+        end
+
+        def self.new(file, raw_lines=nil)
+          file || raise(ArgumentError, "file is mandatory")
+          if raw_lines
+            Precise.new(file, Lines.new(raw_lines))
+          else
+            Wildcard.new(file)
+          end
+        end
+
+        class Wildcard < Struct.new(:file)
+          def to_s
+            file
+          end
+
+          def match?(other)
+            other.file == file
+          end
+
+          def include?(lines)
+            true
+          end
+        end
+
+        class Precise < Struct.new(:file, :lines)
+          def include?(other_lines)
+            lines.include?(other_lines)
+          end
+
+          def line
+            lines.first
+          end
+
+          def match?(other)
+            return false unless other.file == file
+            other.include?(lines)
+          end
+
+          def to_s
+            file, lines.to_s.join(":")
+          end
+
+          def hash
+            self.class.hash ^ to_s.hash
+          end
+
+          def to_str
+            to_s
+          end
+
+          def on_line(new_line)
+            Location.new(file, new_line)
+          end
+
+          def inspect
+            "<#{self.class}: #{to_s}>"
+          end
+        end
+
+        require 'set'
+        class Lines < Struct.new(:data)
+          protected :data
+
+          def initialize(raw_data)
+            super Array(raw_data).to_set
+          end
+
+          def first
+            data.first
+          end
+
+          def min
+            data.min
+          end
+
+          def max
+            data.max
+          end
+
+          def include?(other)
+            other.data.subset?(data) || data.subset?(other.data)
+          end
+
+          def +(more_lines)
+            new_data = data + more_lines.data
+            self.class.new(new_data)
+          end
+
+          def to_s
+            return first.to_s if data.length == 1
+            return "#{data.min}..#{data.max}" if range?
+            data.to_a.join(":")
+          end
+
+          def inspect
+            "<#{self.class}: #{to_s}>"
+          end
+
+          protected
+
+          def range?
+            data.size == (data.max - data.min + 1)
+          end
+        end
+      end
+
+      module HasLocation
+        def file_colon_line
+          location.to_s
+        end
+
+        def file
+          location.file
+        end
+
+        def line
+          location.line
+        end
+
+        def location
+          raise('Please set @location in the constructor') unless defined?(@location)
+          @location
+        end
+
+        def attributes
+          tags, comments, multiline_arg.flatten
+        end
+
+        def tags
+          # will be overriden by nodes that actually have tags
+          
+        end
+
+        def comments
+          # will be overriden by nodes that actually have comments
+          
+        end
+
+        def multiline_arg
+          # will be overriden by nodes that actually have a multiline_argument
+          Test::EmptyMultilineArgument.new
+        end
+
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/result.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/result.rb Changed

@@ -1,5 +1,7 @@
 # encoding: utf-8
 # frozen_string_literal: true
+require "cucumber/messages"
+require "cucumber/messages/time_conversion"
 
 module Cucumber
   module Core
@@ -9,7 +11,6 @@
         STRICT_AFFECTED_TYPES = :flaky, :undefined, :pending.freeze
 
         def self.ok?(type, be_strict = StrictConfiguration.new)
-          private
           class_name = type.to_s.slice(0, 1).capitalize + type.to_s.slice(1..-1)
           const_get(class_name).ok?(be_strict.strict?(type))
         end
@@ -43,6 +44,13 @@
           def with_filtered_backtrace(filter)
             self
           end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::UNKNOWN,
+              duration: UnknownDuration.new.to_message_duration
+            )
+          end
         end
 
         class Passed
@@ -68,6 +76,13 @@
             "✓"
           end
 
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::PASSED,
+              duration: duration.to_message_duration
+            )
+          end
+
           def ok?(be_strict = nil)
             self.class.ok?
           end
@@ -83,6 +98,7 @@
 
         class Failed
           include Result.query_methods :failed
+
           attr_reader :duration, :exception
 
           def self.ok?(be_strict = false)
@@ -107,6 +123,20 @@
             "✗"
           end
 
+          def to_message
+            begin
+              message = exception.backtrace.join("\n")
+            rescue NoMethodError
+              message = ""
+            end
+
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::FAILED,
+              duration: duration.to_message_duration,
+              message: message
+            )
+          end
+
           def ok?(be_strict = nil)
             self.class.ok?
           end
@@ -186,6 +216,13 @@
           def to_s
             "?"
           end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::UNDEFINED,
+              duration: duration.to_message_duration
+            )
+          end
         end
 
         class Skipped < Raisable
@@ -204,6 +241,13 @@
           def to_s
             "-"
           end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::SKIPPED,
+              duration: duration.to_message_duration
+            )
+          end
         end
 
         class Pending < Raisable
@@ -222,6 +266,13 @@
           def to_s
             "P"
           end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::PENDING,
+              duration: duration.to_message_duration
+            )
+          end
         end
 
         # Handles the strict settings for the result types that are
@@ -229,9 +280,9 @@
         class StrictConfiguration
           attr_accessor :settings
           private :settings
-          
+
           def initialize(strict_types = )
-            @settings = HashSTRICT_AFFECTED_TYPES.map { |t| t, :default }
+            @settings = STRICT_AFFECTED_TYPES.map { |t| t, :default }.to_h
             strict_types.each do |type|
               set_strict(true, type)
             end
@@ -261,7 +312,7 @@
           end
 
           def merge!(other)
-            settings.keys.each do |type|
+            settings.each_key do |type|
               set_strict(other.strict?(type), type) if other.set?(type)
             end
             self
@@ -320,7 +371,7 @@
 
           def total(for_status = nil)
             if for_status
-              @totals.fetch(for_status) { 0 }
+              @totals.fetch(for_status, 0)
             else
               @totals.reduce(0) { |total, status| total += status1 }
             end
@@ -329,12 +380,12 @@
           def decrement_failed
             @totals:failed -= 1
           end
-          
+
           private
 
           def get_total(method_name)
             status = method_name.to_s.gsub('total_', '').to_sym
-            return @totals.fetch(status) { 0 }
+            return @totals.fetch(status, 0)
           end
 
           def increment_total(status)
@@ -344,14 +395,29 @@
         end
 
         class Duration
+          include Cucumber::Messages::TimeConversion
+
           attr_reader :nanoseconds
 
           def initialize(nanoseconds)
             @nanoseconds = nanoseconds
           end
+
+          def to_message_duration
+            duration_hash = seconds_to_duration(nanoseconds.to_f / NANOSECONDS_PER_SECOND)
+            duration_hash.transform_keys! do |key|
+              key.to_sym
+            rescue Error
+              return key
+            end
+
+            Cucumber::Messages::Duration.from_h(duration_hash)
+          end
         end
 
         class UnknownDuration
+          include Cucumber::Messages::TimeConversion
+
           def tap(&block)
             self
           end
@@ -359,6 +425,10 @@
           def nanoseconds
             raise "#nanoseconds only allowed to be used in #tap block"
           end
+
+          def to_message_duration
+            Cucumber::Messages::Duration.new(seconds: 0, nanos: 0)
+          end
         end
       end
     end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/runner.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/runner.rb Changed

@@ -17,7 +17,9 @@
           @running_test_step = nil
           event_bus.test_case_started(test_case)
           descend.call(self)
-          event_bus.test_case_finished(test_case, running_test_case.result)
+          result = running_test_case.result
+          result = Result::Undefined.new('The test case has no steps', Result::UnknownDuration.new, "#{test_case.location}:in `#{test_case.name}'") if result.unknown?
+          event_bus.test_case_finished(test_case, result)
           self
         end
 
@@ -103,7 +105,7 @@
               def execute(test_step, monitor, &continue)
                 result = test_step.execute(monitor.result, &continue)
                 result = result.with_message(%(Undefined step: "#{test_step.text}")) if result.undefined?
-                result = result.with_appended_backtrace(test_step.source.last) if IsStepVisitor.new(test_step).step?
+                result = result.with_appended_backtrace(test_step) unless test_step.hook?
                 result.describe_to(monitor, result)
               end
 
@@ -129,7 +131,7 @@
                 result = test_step.skip(monitor.result)
                 if result.undefined?
                   result = result.with_message(%(Undefined step: "#{test_step.text}"))
-                  result = result.with_appended_backtrace(test_step.source.last)
+                  result = result.with_appended_backtrace(test_step)
                 end
                 result
               end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/step.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/step.rb Changed

@@ -1,27 +1,30 @@
 # frozen_string_literal: true
+
 require 'cucumber/core/test/result'
 require 'cucumber/core/test/action'
+require 'cucumber/core/test/empty_multiline_argument'
 
 module Cucumber
   module Core
     module Test
       class Step
-        attr_reader :source
+        attr_reader :id, :text, :location, :multiline_arg
 
-        def initialize(source, action = Test::UndefinedAction.new(source.last.location))
-          raise ArgumentError if source.any?(&:nil?)
-          @source, @action = source, action
+        def initialize(id, text, location, multiline_arg = Test::EmptyMultilineArgument.new, action = Test::UndefinedAction.new(location))
+          raise ArgumentError if text.nil? || text.empty?
+          @id = id
+          @text = text
+          @location = location
+          @multiline_arg = multiline_arg
+          @action = action
         end
 
         def describe_to(visitor, *args)
           visitor.test_step(self, *args)
         end
 
-        def describe_source_to(visitor, *args)
-          source.reverse.each do |node|
-            node.describe_to(visitor, *args)
-          end
-          self
+        def hook?
+          false
         end
 
         def skip(*args)
@@ -32,26 +35,18 @@
           @action.execute(*args)
         end
 
-        def with_action(location = nil, &block)
-          self.class.new(source, Test::Action.new(location, &block))
+        def with_action(action_location = nil, &block)
+          self.class.new(id, text, location, multiline_arg, Test::Action.new(action_location, &block))
         end
 
-        def text
-          source.last.text
+        def backtrace_line
+          "#{location}:in `#{text}'"
         end
 
         def to_s
           text
         end
 
-        def location
-          source.last.location
-        end
-
-        def original_location
-          source.last.original_location
-        end
-
         def action_location
           @action.location
         end
@@ -59,25 +54,15 @@
         def inspect
           "#<#{self.class}: #{location}>"
         end
-
       end
 
-      class IsStepVisitor
-        def initialize(test_step)
-          @is_step = false
-          test_step.describe_to(self)
-        end
-
-        def step?
-          @is_step
-        end
-
-        def test_step(*)
-          @is_step = true
+      class HookStep < Step
+        def initialize(id, text, location, action)
+          super(id, text, location, Test::EmptyMultilineArgument.new, action)
         end
 
-        def method_missing(*)
-          self
+        def hook?
+          true
         end
       end
     end

_service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/tag.rb Added

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/test/timer.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/test/timer.rb Changed

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/version.rb -> _service:tar_scm:cucumber-core-10.1.0.gem/data/lib/cucumber/core/version.rb Changed

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/coverage.rb Added

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/compiler_spec.rb Added

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+require 'cucumber/core'
+require 'cucumber/core/compiler'
+require 'cucumber/core/gherkin/writer'
+
+module Cucumber::Core
+  describe Compiler do
+    include Gherkin::Writer
+    include Cucumber::Core
+
+    def self.stubs(*names)
+      names.each do |name|
+        let(name) { double(name.to_s) }
+      end
+    end
+
+    it "compiles a feature with a single scenario" do
+      gherkin_documents = 
+        gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered.and_yield(visitor)
+        expect( visitor ).to receive(:test_step).once.ordered
+        expect( visitor ).to receive(:done).once.ordered
+      end
+    end
+
+    context "when the event_bus is provided" do
+      let(:event_bus) { double }
+
+      before do
+        allow( event_bus ).to receive(:envelope)
+        allow( event_bus ).to receive(:gherkin_source_parsed).and_return(nil)
+        allow( event_bus ).to receive(:test_case_created).and_return(nil)
+        allow( event_bus ).to receive(:test_step_created).and_return(nil)
+      end
+
+      it "emits a TestCaseCreated event with the created Test::Case and Pickle" do
+        gherkin_documents = 
+          gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+        
+
+        compile(gherkin_documents, event_bus) do |visitor|
+          allow( visitor ).to receive(:test_case)
+          allow( visitor ).to receive(:test_step)
+          allow( visitor ).to receive(:done)
+          allow( event_bus ).to receive(:envelope)
+
+          expect( event_bus ).to receive(:test_case_created).once
+        end
+      end
+
+      it "emits a TestStepCreated event with the created Test::Step and PickleStep" do
+        gherkin_documents = 
+          gherkin do
+            feature do
+              scenario do
+                step 'passing'
+                step 'passing'
+              end
+            end
+          end
+        
+
+        compile(gherkin_documents, event_bus) do |visitor|
+          allow( visitor ).to receive(:test_case)
+          allow( visitor ).to receive(:test_step)
+          allow( visitor ).to receive(:done)
+          allow( event_bus ).to receive(:envelope)
+
+          expect( event_bus ).to receive(:test_step_created).twice
+        end
+      end
+    end
+
+    it "compiles a feature with a background" do
+      gherkin_documents = 
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered.and_yield(visitor)
+        expect( visitor ).to receive(:test_step).exactly(2).times.ordered
+        expect( visitor ).to receive(:done).once.ordered
+      end
+    end
+
+    it "compiles multiple features" do
+      gherkin_documents = 
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end,
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered
+        expect( visitor ).to receive(:test_step).twice.ordered
+        expect( visitor ).to receive(:test_case).once.ordered
+        expect( visitor ).to receive(:test_step).twice.ordered
+        expect( visitor ).to receive(:done).once
+      end
+    end
+
+    context "compiling scenario outlines" do
+      it "compiles a scenario outline to test cases" do
+        gherkin_documents = 
+          gherkin do
+            feature do
+              background do
+                step 'passing'
+              end
+
+              scenario_outline do
+                step 'passing <arg>'
+                step 'passing'
+
+                examples 'examples 1' do
+                  row 'arg'
+                  row '1'
+                  row '2'
+                end
+
+                examples 'examples 2' do
+                  row 'arg'
+                  row 'a'
+                end
+              end
+            end
+          end
+        
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_case).exactly(3).times.and_yield(visitor)
+          expect( visitor ).to receive(:test_step).exactly(9).times
+          expect( visitor ).to receive(:done).once
+        end
+      end
+
+      it 'replaces arguments correctly when generating test steps' do
+        gherkin_documents = 
+          gherkin do
+            feature do
+              scenario_outline do
+                step 'passing <arg1> with <arg2>'
+                step 'as well as <arg3>'
+
+                examples do
+                  row 'arg1', 'arg2', 'arg3'
+                  row '1',    '2',    '3'
+                end
+              end
+            end
+          end
+        
+
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_step) do |test_step|
+            expect(test_step.text).to eq 'passing 1 with 2'
+          end.once.ordered
+
+          expect( visitor ).to receive(:test_step) do |test_step|
+            expect(test_step.text).to eq 'as well as 3'
+          end.once.ordered
+
+          expect( visitor ).to receive(:done).once.ordered
+        end
+      end
+    end
+
+    context 'empty scenarios' do
+      it 'does create test cases for them' do
+        gherkin_documents = 
+          gherkin do
+            feature do
+              scenario do
+              end
+            end
+          end
+        
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_case).once.ordered
+          expect( visitor ).to receive(:done).once.ordered
+        end
+      end
+    end
+
+    def compile(gherkin_documents, event_bus = nil)
+      visitor = double
+      allow( visitor ).to receive(:test_suite).and_yield(visitor)
+      allow( visitor ).to receive(:test_case).and_yield(visitor)
+
+      if event_bus.nil?
+        event_bus = double
+        allow( event_bus ).to receive(:envelope).and_return(nil)
+        allow( event_bus ).to receive(:gherkin_source_parsed).and_return(nil)
+        allow( event_bus ).to receive(:test_case_created).and_return(nil)
+        allow( event_bus ).to receive(:test_step_created).and_return(nil)
+        allow( event_bus ).to receive(:envelope).and_return(nil)
+      end
+
+      yield visitor
+      super(gherkin_documents, visitor, , event_bus)
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/event_bus_spec.rb Added

@@ -0,0 +1,163 @@
+require "cucumber/core/event_bus"
+
+module Cucumber
+  module Core
+    module Events
+
+      class TestEvent < Core::Event.new(:some_attribute)
+      end
+
+      AnotherTestEvent = Core::Event.new
+
+      UnregisteredEvent = Core::Event.new
+    end
+
+    describe EventBus do
+      let(:event_bus) { EventBus.new(registry) }
+      let(:registry) { { test_event: Events::TestEvent, another_test_event: Events::AnotherTestEvent } }
+
+      context "broadcasting events" do
+
+        it "can broadcast by calling a method named after the event ID" do
+          called = false
+          event_bus.on(:test_event) {called = true }
+          event_bus.test_event
+          expect(called).to be true
+        end
+
+        it "can broadcast by calling the `broadcast` method with an instance of the event type" do
+          called = false
+          event_bus.on(:test_event) {called = true }
+          event_bus.broadcast(Events::TestEvent.new(:some_attribute))
+          expect(called).to be true
+        end
+
+        it "calls a subscriber for an event, passing details of the event" do
+          received_payload = nil
+          event_bus.on :test_event do |event|
+            received_payload = event
+          end
+
+          event_bus.test_event :some_attribute
+
+          expect(received_payload.some_attribute).to eq(:some_attribute)
+        end
+
+        it "does not call subscribers for other events" do
+          handler_called = false
+          event_bus.on :test_event do
+            handler_called = true
+          end
+
+          event_bus.another_test_event
+
+          expect(handler_called).to eq(false)
+        end
+
+        it "broadcasts to multiple subscribers" do
+          received_events = 
+          event_bus.on :test_event do
+            received_events << :event
+          end
+          event_bus.on :test_event do
+            received_events << :event
+          end
+
+          event_bus.test_event(:some_attribute)
+
+          expect(received_events.length).to eq 2
+        end
+
+        it "raises an error when given an event to broadcast that it doesn't recognise" do
+          expect { event_bus.some_unknown_event }.to raise_error(NameError)
+        end
+
+        context "#broadcast method" do
+          it "must be passed an instance of a registered event type" do
+            expect {
+              event_bus.broadcast Events::UnregisteredEvent
+            }.to raise_error(ArgumentError)
+          end
+        end
+
+      end
+
+      context "subscribing to events" do
+        it "allows subscription by symbol (Event ID)" do
+          received_payload = nil
+          event_bus.on(:test_event) do |event|
+            received_payload = event
+          end
+
+          event_bus.test_event :some_attribute
+
+          expect(received_payload.some_attribute).to eq(:some_attribute)
+        end
+
+        it "raises an error if you use an unknown Event ID" do
+          expect {
+            event_bus.on(:some_unknown_event) { :whatever }
+          }.to raise_error(ArgumentError)
+        end
+
+        it "allows handlers that are objects with a `call` method" do
+          class MyHandler
+            attr_reader :received_payload
+
+            def call(event)
+              @received_payload = event
+            end
+          end
+
+          handler = MyHandler.new
+          event_bus.on(:test_event, handler)
+
+          event_bus.test_event :some_attribute
+
+          expect(handler.received_payload.some_attribute).to eq :some_attribute
+        end
+
+        it "allows handlers that are procs" do
+          class MyProccyHandler
+            attr_reader :received_payload
+
+            def initialize(event_bus)
+              event_bus.on :test_event, &method(:on_test_event)
+            end
+
+            def on_test_event(event)
+              @received_payload = event
+            end
+          end
+
+          handler = MyProccyHandler.new(event_bus)
+
+          event_bus.test_event :some_attribute
+          expect(handler.received_payload.some_attribute).to eq :some_attribute
+        end
+
+        it "sends events that were broadcast before you subscribed" do
+          event_bus.test_event :some_attribute
+          event_bus.another_test_event
+
+          received_payload = nil
+          event_bus.on(:test_event) do |event|
+            received_payload = event
+          end
+
+          expect(received_payload.some_attribute).to eq(:some_attribute)
+        end
+
+      end
+
+      it "will let you inspect the registry" do
+        expect(event_bus.event_types:test_event).to eq Events::TestEvent
+      end
+
+      it "won't let you modify the registry" do
+        expect { event_bus.event_types:foo = :bar }.to raise_error(RuntimeError)
+      end
+
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/event_spec.rb Added

@@ -0,0 +1,40 @@
+require 'cucumber/core/event'
+
+module Cucumber
+  module Core
+    describe Event do
+
+      describe ".new" do
+        it "generates new types of events" do
+          my_event_type = Event.new
+          my_event = my_event_type.new
+          expect(my_event).to be_kind_of(Core::Event)
+        end
+
+        it "generates events with attributes" do
+          my_event_type = Event.new(:foo, :bar)
+          my_event = my_event_type.new(1, 2)
+          expect(my_event.attributes).to eq 1, 2
+          expect(my_event.foo).to eq 1
+          expect(my_event.bar).to eq 2
+        end
+      end
+
+      describe "a generated event" do
+        class MyEventType < Event.new(:foo, :bar)
+        end
+
+        it "can be converted to a hash" do
+          my_event = MyEventType.new(1, 2)
+          expect(my_event.to_h).to eq foo: 1, bar: 2
+        end
+
+        it "has an event_id" do
+          expect(MyEventType.event_id).to eq :my_event_type
+          expect(MyEventType.new(1, 2).event_id).to eq :my_event_type
+        end
+      end
+    end
+
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/filter_spec.rb Added

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+require 'cucumber/core/filter'
+
+module Cucumber::Core
+  describe Filter do
+    include Cucumber::Core::Gherkin::Writer
+    include Cucumber::Core
+
+    describe ".new" do
+      let(:receiver) { double.as_null_object }
+
+      let(:doc) {
+        gherkin do
+          feature do
+            scenario 'x' do
+              step 'a step'
+            end
+
+            scenario 'y' do
+              step 'a step'
+            end
+          end
+        end
+      }
+
+      it "creates a filter class that can pass-through by default" do
+        my_filter_class = Filter.new
+        my_filter = my_filter_class.new
+        expect(receiver).to receive(:test_case) { |test_case|
+          expect(test_case.test_steps.length).to eq 1
+          expect(test_case.test_steps.first.text).to eq 'a step'
+        }.exactly(2).times
+        compile doc, receiver, my_filter
+      end
+
+      context "customizing by subclassing" do
+
+        # Each filter imlicitly gets a :receiver attribute
+        # that you need to call with the new test case
+        # once you've received yours and modified it.
+        class BasicBlankingFilter < Filter.new
+          def test_case(test_case)
+            test_case.with_steps().describe_to(receiver)
+          end
+        end
+
+        # You can pass the names of attributes when building a
+        # filter, allowing you to have custom attributes.
+        class NamedBlankingFilter < Filter.new(:name_pattern)
+          def test_case(test_case)
+            if test_case.name =~ name_pattern
+              test_case.with_steps().describe_to(receiver)
+            else
+              test_case.describe_to(receiver) # or just call `super`
+            end
+            self
+          end
+        end
+
+        it "can override methods from the base class" do
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 0
+          }.exactly(2).times
+          run BasicBlankingFilter.new
+        end
+
+        it "can take arguments" do
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 0
+          }.once.ordered
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 1
+          }.once.ordered
+          run NamedBlankingFilter.new(/x/)
+        end
+
+      end
+
+      context "customizing by using a block" do
+        BlockBlankingFilter = Filter.new do
+          def test_case(test_case)
+            test_case.with_steps().describe_to(receiver)
+          end
+        end
+
+        it "allows methods to be overridden" do
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 0
+          }.exactly(2).times
+          run BlockBlankingFilter.new
+        end
+      end
+
+      def run(filter)
+        compile doc, receiver, filter
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/gherkin/parser_spec.rb Added

@@ -0,0 +1,162 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+require 'cucumber/core/gherkin/parser'
+require 'cucumber/core/gherkin/writer'
+
+module Cucumber
+  module Core
+    module Gherkin
+      describe Parser do
+        let(:receiver)  { double }
+        let(:event_bus) { double }
+        let(:gherkin_query) { double }
+        let(:parser)    { Parser.new(receiver, event_bus, gherkin_query) }
+        let(:visitor)   { double }
+
+        before do
+          allow( event_bus ).to receive(:gherkin_source_parsed)
+          allow( event_bus).to receive(:envelope)
+          allow( gherkin_query ).to receive(:update)
+        end
+
+        def parse
+          parser.document(source)
+        end
+
+        context "for invalid gherkin" do
+          let(:source) { Gherkin::Document.new(path, "\nnot gherkin\n\nFeature: \n") }
+          let(:path)   { 'path_to/the.feature' }
+
+          it "raises an error" do
+            expect { parse }.to raise_error(ParseError) do |error|
+              expect( error.message ).to match(/not gherkin/)
+              expect( error.message ).to match(/#{path}/)
+            end
+          end
+        end
+
+        context "for valid gherkin" do
+          let(:source) { Gherkin::Document.new(path, 'Feature:') }
+          let(:path)   { 'path_to/the.feature' }
+
+          it "issues a gherkin_source_parsed event" do
+            expect( event_bus ).to receive(:gherkin_source_parsed)
+            parse
+          end
+
+          it "emits an 'envelope' event for every message produced by Gherkin" do
+            # Only one message emited, there's no pickles generated
+            expect( event_bus ).to receive(:envelope).once
+            parse
+          end
+        end
+
+        context "for empty files" do
+          let(:source) { Gherkin::Document.new(path, '') }
+          let(:path)   { 'path_to/the.feature' }
+
+          it "passes on no pickles" do
+            expect( receiver ).not_to receive(:pickle)
+            parse
+          end
+        end
+
+        include Writer
+        def self.source(&block)
+          let(:source) { gherkin(&block) }
+        end
+
+        RSpec::Matchers.define :pickle_with_language do |language|
+          match { |actual| actual.language == language }
+        end
+
+        context "when the Gherkin has a language header" do
+          source do
+            feature(language: 'ja', keyword: '機能') do
+              scenario(keyword: 'シナリオ')
+            end
+          end
+
+          it "the pickles have the correct language" do
+            expect( receiver ).to receive(:pickle).with(pickle_with_language('ja'))
+            parse
+          end
+        end
+
+        context "when the Gherkin produces one pickle" do
+          source do
+            feature do
+              scenario do
+                step 'text'
+              end
+            end
+          end
+
+          it "passes on the pickle" do
+            expect( receiver ).to receive(:pickle)
+            parse
+          end
+
+          it "emits an 'envelope' event containing the pickle" do
+            allow( receiver ).to receive(:pickle)
+            # Once for the gherkin document, once with the pickle
+            expect( event_bus ).to receive(:envelope).twice
+            parse
+          end
+        end
+
+        context "when scenario is inside a rule" do
+          source do
+            feature do
+              rule do
+                scenario name: "My scenario"
+              end
+            end
+          end
+
+          it "passes on the pickle" do
+            expect( receiver ).to receive(:pickle)
+            parse
+          end
+        end
+
+        context "when example is inside a rule" do
+          source do
+            feature do
+              rule do
+                example name: "My example"
+              end
+            end
+          end
+
+          it "passes on the pickle" do
+            expect( receiver ).to receive(:pickle)
+            parse
+          end
+        end
+
+        context "when there are multiple rules and scenarios or examples" do
+          source do
+            feature do
+              rule description: "First rule" do
+                scenario name: "Do not talk about the fight club" do
+                  step 'text'
+                end
+              end
+              rule description: "Second rule" do
+                example name: "Do not talk about the fight club" do
+                  step 'text'
+                end
+              end
+            end
+          end
+
+          it "passes on the pickles" do
+            expect( receiver ).to receive(:pickle).twice
+            parse
+          end
+        end
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/gherkin/writer_spec.rb Added

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+require 'cucumber/core/gherkin/writer'
+require 'unindent'
+
+module Cucumber::Core::Gherkin
+  describe Writer do
+    include Writer
+
+    context 'specifying uri' do
+      it 'generates a uri by default' do
+        source = gherkin { feature }
+        expect( source.uri ).to eq 'features/test.feature'
+      end
+
+      it 'allows you to specify a URI' do
+        source = gherkin('features/path/to/my.feature') { feature }
+        expect( source.uri ).to eq 'features/path/to/my.feature'
+      end
+    end
+
+    context 'a feature' do
+
+      it 'generates the feature statement' do
+        source = gherkin { feature }
+        expect( source ).to eq "Feature:\n"
+      end
+
+      context 'when a name is provided' do
+        it 'includes the name in the feature statement' do
+          source = gherkin do
+            feature "A Feature\n"
+          end
+          expect( source ).to eq "Feature: A Feature\n"
+        end
+      end
+
+      context 'when a description is provided' do
+        it 'includes the description in the feature statement' do
+          source = gherkin do
+            feature "A Feature", description: <<-END
+              This is the description
+              which can span
+              multiple lines.
+              END
+          end
+          expected = <<-END
+          Feature: A Feature
+            This is the description
+            which can span
+            multiple lines.
+          END
+
+          expect( source ).to eq expected.unindent
+        end
+      end
+
+      context 'when a keyword is provided' do
+        it 'uses the supplied keyword' do
+          source = gherkin do
+            feature "A Feature", keyword: "Business Need"
+          end
+          expect( source ).to eq "Business Need: A Feature\n"
+        end
+      end
+
+      context 'when a language is supplied' do
+        it 'inserts a language statement' do
+          source = gherkin do
+            feature language: 'ru'
+          end
+
+          expect( source ).to eq "# language: ru\nFeature:\n"
+        end
+      end
+
+      context 'when a comment is supplied' do
+        it 'inserts a comment' do
+          source = gherkin do
+            comment 'wow'
+            comment 'great'
+            feature
+          end
+
+          expect( source.to_s ).to eq "# wow\n# great\nFeature:\n"
+        end
+      end
+
+      context 'with a scenario' do
+        it 'includes the scenario statement' do
+          source = gherkin do
+            feature "A Feature" do
+              scenario
+            end
+          end
+
+          expect( source.to_s ).to match(/Scenario:/)
+        end
+
+        context 'when a comment is provided' do
+          it 'includes the comment in the scenario statement' do
+            source = gherkin do
+              feature do
+                comment 'wow'
+                scenario
+              end
+            end
+            expect( source.to_s ).to eq <<-END.unindent
+            Feature:
+
+              # wow
+              Scenario:
+            END
+          end
+        end
+
+        context 'when a description is provided' do
+          it 'includes the description in the scenario statement' do
+            source = gherkin do
+              feature do
+                scenario description: <<-END
+                  This is the description
+                  which can span
+                  multiple lines.
+                  END
+              end
+            end
+
+            expect( source ).to eq <<-END.unindent
+            Feature:
+
+              Scenario:
+                This is the description
+                which can span
+                multiple lines.
+            END
+          end
+        end
+
+        context 'with a step' do
+          it 'includes the step statement' do
+            source = gherkin do
+              feature "A Feature" do
+                scenario do
+                  step 'passing'
+                end
+              end
+            end
+
+            expect( source.to_s ).to match(/Given passing\Z/m)
+          end
+
+          context 'when a docstring is provided' do
+            it 'includes the content type when provided' do
+              source = gherkin do
+                feature do
+                  scenario do
+                    step 'failing' do
+                      doc_string 'some text', 'text/plain'
+                    end
+                  end
+                end
+
+              end
+
+              expect( source ).to eq <<-END.unindent
+              Feature:
+
+                Scenario:
+                  Given failing
+                    """text/plain
+                    some text
+                    """
+              END
+            end
+          end
+        end
+      end
+
+      context 'with a background' do
+        it 'can have a description' do
+          source = gherkin do
+            feature do
+              background description: "One line,\nand two.."
+            end
+          end
+
+          expect( source ).to eq <<-END.unindent
+          Feature:
+
+            Background:
+              One line,
+              and two..
+          END
+        end
+      end
+
+      context 'with a scenario outline' do
+        it 'can have a description' do
+          source = gherkin do
+            feature do
+              scenario_outline description: "Doesn't need to be multi-line."
+            end
+          end
+
+          expect( source ).to eq <<-END.unindent
+          Feature:
+
+            Scenario Outline:
+              Doesn't need to be multi-line.
+          END
+        end
+
+        context 'and examples table' do
+          it 'can have a description' do
+            source = gherkin do
+              feature do
+                scenario_outline do
+                  examples description: "Doesn't need to be multi-line." do
+
+                  end
+                end
+              end
+            end
+
+            expect( source ).to eq <<-END.unindent
+            Feature:
+
+              Scenario Outline:
+
+                Examples:
+                  Doesn't need to be multi-line.
+            END
+          end
+        end
+      end
+    end
+
+    it 'generates a complex feature' do
+      source = gherkin do
+        comment 'wow'
+        feature 'Fully featured', language: 'en', tags: '@always' do
+          comment 'cool'
+          background do
+            step 'passing'
+          end
+
+          scenario do
+            step 'passing'
+          end
+
+          comment 'here'
+          scenario 'with doc string', tags: '@first @second' do
+            comment 'and here'
+            step 'passing'
+            step 'failing', keyword: 'When' do
+              doc_string <<-END
+              I wish I was a little bit taller.
+              I wish I was a baller.
+              END
+            end
+          end
+
+          scenario 'with a table...' do
+            step 'passes:' do
+              table do
+                row 'name',   'age', 'location'
+                row 'Janine', '43',  'Antarctica'
+              end
+            end
+          end
+
+          comment 'yay'
+          scenario_outline 'eating' do
+            step 'there are <start> cucumbers'
+            step 'I eat <eat> cucumbers', keyword: 'When'
+            step 'I should have <left> cucumbers', keyword: 'Then'
+
+            comment 'hmmm'
+            examples do
+              row 'start', 'eat', 'left'
+              row '12',    '5',   '7'
+              row '20',    '5',   '15'
+            end
+          end
+        end
+      end
+
+      expect( source.to_s ).to eq <<-END.unindent
+      # language: en
+      # wow
+      @always
+      Feature: Fully featured
+
+        # cool
+        Background:
+          Given passing
+
+        Scenario:
+          Given passing
+
+        # here
+        @first @second
+        Scenario: with doc string
+          # and here
+          Given passing
+          When failing
+            """
+            I wish I was a little bit taller.
+            I wish I was a baller.
+            """
+
+        Scenario: with a table...
+          Given passes:
+            | name   | age | location   |
+            | Janine | 43  | Antarctica |
+
+        # yay
+        Scenario Outline: eating
+          Given there are <start> cucumbers
+          When I eat <eat> cucumbers
+          Then I should have <left> cucumbers
+
+          # hmmm
+          Examples:
+            | start | eat | left |
+            | 12    | 5   | 7    |
+            | 20    | 5   | 15   |
+      END
+
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/report/summary_spec.rb Added

@@ -0,0 +1,178 @@
+# -*- encoding: utf-8 -*-
+require 'cucumber/core/event_bus'
+require 'cucumber/core/events'
+require 'cucumber/core/report/summary'
+require 'cucumber/core/test/result'
+
+module Cucumber::Core::Report
+  describe Summary do
+    let(:event_bus) { ::Cucumber::Core::EventBus.new(registry) }
+    let(:registry) { ::Cucumber::Core::Events.registry }
+    let(:passed_result) { ::Cucumber::Core::Test::Result::Passed.new(duration) }
+    let(:failed_result) { ::Cucumber::Core::Test::Result::Failed.new(duration, exception) }
+    let(:pending_result) { ::Cucumber::Core::Test::Result::Pending.new(duration) }
+    let(:skipped_result) { ::Cucumber::Core::Test::Result::Skipped.new(duration) }
+    let(:undefined_result) { ::Cucumber::Core::Test::Result::Undefined.new(duration) }
+    let(:duration) { double }
+    let(:exception) { double }
+
+    before(:each) { @summary = Summary.new(event_bus) }
+
+    context "test case summary" do
+      let(:test_case) { double }
+
+      it "counts passed test cases" do
+        event_bus.send(:test_case_finished, test_case, passed_result)
+
+        expect( @summary.test_cases.total(:passed) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+
+      it "counts failed test cases" do
+        event_bus.send(:test_case_finished, test_case, failed_result)
+
+        expect( @summary.test_cases.total(:failed) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+
+      it "counts pending test cases" do
+        event_bus.send(:test_case_finished, test_case, pending_result)
+
+        expect( @summary.test_cases.total(:pending) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+
+      it "counts skipped test cases" do
+        event_bus.send(:test_case_finished, test_case, skipped_result)
+
+        expect( @summary.test_cases.total(:skipped) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+
+      it "counts undefined test cases" do
+        event_bus.send(:test_case_finished, test_case, undefined_result)
+
+        expect( @summary.test_cases.total(:undefined) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+
+      it "handles flaky test cases" do
+        allow(test_case).to receive(:==).and_return(false, true)
+        event_bus.send(:test_case_finished, test_case, failed_result)
+        event_bus.send(:test_case_finished, test_case, passed_result)
+
+        expect( @summary.test_cases.total(:failed) ).to eq(0)
+        expect( @summary.test_cases.total(:flaky) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+
+      it "handless flaky with following skip test cases" do
+        allow(test_case).to receive(:==).and_return(false, true)
+        event_bus.send(:test_case_finished, test_case, failed_result)
+        event_bus.send(:test_case_finished, test_case, skipped_result)
+
+        expect( @summary.test_cases.total(:failed) ).to eq(0)
+        expect( @summary.test_cases.total(:skipped) ).to eq(0)
+        expect( @summary.test_cases.total(:flaky) ).to eq(1)
+        expect( @summary.test_cases.total ).to eq(1)
+      end
+    end
+
+    context "test step summary" do
+      context "with test steps from gherkin steps" do
+        let(:test_step) { double }
+
+        before(:each) do
+          expect( test_step ).to receive(:hook?).and_return(false)
+        end
+
+        it "counts passed test steps" do
+          event_bus.send(:test_step_finished, test_step, passed_result)
+
+          expect( @summary.test_steps.total(:passed) ).to eq(1)
+          expect( @summary.test_steps.total ).to eq(1)
+        end
+
+        it "counts failed test cases" do
+          event_bus.send(:test_step_finished, test_step, failed_result)
+
+          expect( @summary.test_steps.total(:failed) ).to eq(1)
+          expect( @summary.test_steps.total ).to eq(1)
+        end
+
+        it "counts pending test cases" do
+          event_bus.send(:test_step_finished, test_step, pending_result)
+
+          expect( @summary.test_steps.total(:pending) ).to eq(1)
+          expect( @summary.test_steps.total ).to eq(1)
+        end
+
+        it "counts skipped test cases" do
+          event_bus.send(:test_step_finished, test_step, skipped_result)
+
+          expect( @summary.test_steps.total(:skipped) ).to eq(1)
+          expect( @summary.test_steps.total ).to eq(1)
+        end
+
+        it "counts undefined test cases" do
+          event_bus.send(:test_step_finished, test_step, undefined_result)
+
+          expect( @summary.test_steps.total(:undefined) ).to eq(1)
+          expect( @summary.test_steps.total ).to eq(1)
+        end
+      end
+
+      context "with test steps not from gherkin steps" do
+        let(:test_step) { double }
+
+        before(:each) do
+          expect( test_step ).to receive(:hook?).and_return(true)
+        end
+
+        it "ignores test steps not defined by gherkin steps" do
+          event_bus.send(:test_step_finished, test_step, passed_result)
+
+          expect( @summary.test_steps.total ).to eq(0)
+        end
+      end
+    end
+
+    context "ok? result" do
+      let(:test_case) { double }
+
+      it "passed test case is ok" do
+        event_bus.send(:test_case_finished, test_case, passed_result)
+
+        expect( @summary.ok? ).to eq true
+      end
+
+      it "skipped test case is ok" do
+        event_bus.send(:test_case_finished, test_case, skipped_result)
+
+        expect( @summary.ok? ).to eq true
+      end
+
+      it "failed test case is not ok" do
+        event_bus.send(:test_case_finished, test_case, failed_result)
+
+        expect( @summary.ok? ).to eq false
+      end
+
+      it "pending test case is ok if not strict" do
+        event_bus.send(:test_case_finished, test_case, pending_result)
+
+        expect( @summary.ok? ).to eq true
+        be_strict = ::Cucumber::Core::Test::Result::StrictConfiguration.new(:pending)
+        expect( @summary.ok?(be_strict) ).to eq false
+      end
+
+      it "undefined test case is ok if not strict" do
+        event_bus.send(:test_case_finished, test_case, undefined_result)
+
+        expect( @summary.ok? ).to eq true
+        be_strict = ::Cucumber::Core::Test::Result::StrictConfiguration.new(:undefined)
+        expect( @summary.ok?(be_strict) ).to eq false
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/action_spec.rb Added

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/action'
+require 'cucumber/core/test/duration_matcher'
+
+module Cucumber
+  module Core
+    module Test
+
+      describe Action do
+
+        context "constructed without a block" do
+          it "raises an error" do
+            expect { Action.new }.to raise_error(ArgumentError)
+          end
+        end
+
+        context "location" do
+
+          context "with location passed to the constructor" do
+            let(:location) { double }
+
+            it "returns the location passed to the constructor" do
+              action = Action.new(location) {}
+              expect( action.location ).to be location
+            end
+          end
+
+          context "without location passed to the constructor" do
+            let(:block) { proc {} }
+
+            it "returns the location of the block passed to the constructor" do
+              action = Action.new(&block)
+              expect( action.location ).to eq Test::Location.new(*block.source_location)
+            end
+          end
+
+        end
+
+        context "executing" do
+          it "executes the block passed to the constructor" do
+            executed = false
+            action = Action.new { executed = true }
+            action.execute
+            expect( executed ).to be_truthy
+          end
+
+          it "returns a passed result if the block doesn't fail" do
+            action = Action.new {}
+            expect( action.execute ).to be_passed
+          end
+
+          it "returns a failed result when the block raises an error" do
+            exception = StandardError.new
+            action = Action.new { raise exception }
+            result = action.execute
+            expect( result ).to be_failed
+            expect( result.exception ).to eq exception
+          end
+
+          it "yields the args passed to #execute to the block" do
+            args = double, double
+            args_spy = nil
+            action = Action.new { |arg1, arg2| args_spy = arg1, arg2 }
+            action.execute(*args)
+            expect(args_spy).to eq args
+          end
+
+          it "returns a pending result if a Result::Pending error is raised" do
+            exception = Result::Pending.new("TODO")
+            action = Action.new { raise exception }
+            result = action.execute
+            expect( result ).to be_pending
+            expect( result.message ).to eq "TODO"
+          end
+
+          it "returns a skipped result if a Result::Skipped error is raised" do
+            exception = Result::Skipped.new("Not working right now")
+            action = Action.new { raise exception }
+            result = action.execute
+            expect( result ).to be_skipped
+            expect( result.message ).to eq "Not working right now"
+          end
+
+          it "returns an undefined result if a Result::Undefined error is raised" do
+            exception = Result::Undefined.new("new step")
+            action = Action.new { raise exception }
+            result = action.execute
+            expect( result ).to be_undefined
+            expect( result.message ).to eq "new step"
+          end
+
+          context "recording the duration" do
+            before do
+              allow( Timer::MonotonicTime ).to receive(:time_in_nanoseconds).and_return(525702744080000, 525702744080001)
+            end
+
+            it "records the nanoseconds duration of the execution on the result" do
+              action = Action.new { }
+              duration = action.execute.duration
+              expect( duration ).to be_duration 1
+            end
+
+            it "records the duration of a failed execution" do
+              action = Action.new { raise StandardError }
+              duration = action.execute.duration
+              expect( duration ).to be_duration 1
+            end
+          end
+
+        end
+
+        context "skipping" do
+          it "does not execute the block" do
+            executed = false
+            action = Action.new { executed = true }
+            action.skip
+            expect( executed ).to be_falsey
+          end
+
+          it "returns a skipped result" do
+            action = Action.new {}
+            expect( action.skip ).to be_skipped
+          end
+        end
+      end
+
+      describe UndefinedAction do
+        let(:location) { double }
+        let(:action) { UndefinedAction.new(location) }
+        let(:test_step) { double }
+
+        context "location" do
+          it "returns the location passed to the constructor" do
+            expect( action.location ).to be location
+          end
+        end
+
+        context "executing" do
+          it "returns an undefined result" do
+            expect( action.execute ).to be_undefined
+          end
+        end
+
+        context "skipping" do
+          it "returns an undefined result" do
+            expect( action.skip ).to be_undefined
+          end
+        end
+      end
+
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/case_spec.rb Added

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core/platform'
+require 'cucumber/core/test/case'
+require 'unindent'
+
+module Cucumber
+  module Core
+    module Test
+      describe Case do
+        include Core
+        include Core::Gherkin::Writer
+
+        let(:id) { double }
+        let(:name) { double }
+        let(:location) { double }
+        let(:tags) { double }
+        let(:language) { double }
+        let(:test_case) { Test::Case.new(id, name, test_steps, location, tags, language) }
+        let(:test_steps) { double, double }
+
+        context 'describing itself' do
+          it "describes itself to a visitor" do
+            visitor = double
+            args = double
+            expect(visitor).to receive(:test_case).with(test_case, args)
+            test_case.describe_to(visitor, args)
+          end
+
+          it "asks each test_step to describe themselves to the visitor" do
+            visitor = double
+            args = double
+            test_steps.each do |test_step|
+              expect(test_step).to receive(:describe_to).with(visitor, args)
+            end
+            allow(visitor).to receive(:test_case).and_yield(visitor)
+            test_case.describe_to(visitor, args)
+          end
+
+          it "describes around hooks in order" do
+            visitor = double
+            allow(visitor).to receive(:test_case).and_yield(visitor)
+            first_hook = double
+            second_hook = double
+            expect(first_hook).to receive(:describe_to).ordered.and_yield
+            expect(second_hook).to receive(:describe_to).ordered.and_yield
+            around_hooks = first_hook, second_hook
+            Test::Case.new(id, name, , location, tags, language, around_hooks).describe_to(visitor, double)
+          end
+        end
+
+        describe "#name" do
+          it "the name is passed when creating the test case" do
+            expect(test_case.name).to eq(name)
+          end
+        end
+
+        describe "#location" do
+          it "the location is passed when creating the test case" do
+            expect(test_case.location).to eq(location)
+          end
+        end
+
+        describe "#tags" do
+          it "the tags are passed when creating the test case" do
+            expect(test_case.tags).to eq(tags)
+          end
+        end
+
+        describe "matching tags" do
+          let(:tags) { '@a', '@b', '@c'.map { |value| Tag.new(location, value) } }
+          it "matches tags using tag expressions" do
+            expect(test_case.match_tags?('@a and @b')).to be_truthy
+            expect(test_case.match_tags?('@a or @d')).to be_truthy
+            expect(test_case.match_tags?('not @d')).to be_truthy
+            expect(test_case.match_tags?('@a and @d')).to be_falsy
+          end
+
+          it "matches handles multiple expressions" do
+            expect(test_case.match_tags?('@a and @b', 'not @d')).to be_truthy
+            expect(test_case.match_tags?('@a and @b', 'not @c')).to be_falsy
+          end
+        end
+
+        describe "matching names" do
+          let(:name) { 'scenario' }
+          it "matches names against regexp" do
+            expect(test_case.match_name?(/scenario/)).to be_truthy
+          end
+        end
+
+        describe "#language" do
+          let(:language) { 'en-pirate' }
+          it "the language is passed when creating the test case" do
+            expect(test_case.language).to eq 'en-pirate'
+          end
+        end
+
+        describe "equality" do
+          it "is equal to another test case at the same location" do
+            gherkin = gherkin('features/foo.feature') do
+              feature do
+                scenario do
+                  step 'text'
+                end
+              end
+            end
+            test_case_instances = 
+            receiver = double.as_null_object
+            allow(receiver).to receive(:test_case) do |test_case|
+              test_case_instances << test_case
+            end
+            2.times { compile(gherkin, receiver) }
+            expect(test_case_instances.length).to eq 2
+            expect(test_case_instances.uniq.length).to eq 1
+            expect(test_case_instances0).to be_eql test_case_instances1
+            expect(test_case_instances0).to eq test_case_instances1
+            expect(test_case_instances0).not_to equal test_case_instances1
+          end
+        end
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/data_table_spec.rb Added

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'cucumber/core/test/data_table'
+
+module Cucumber
+  module Core
+    module Test
+      describe DataTable do
+        before do
+          @table = DataTable.new(
+            %w{one four seven},
+            %w{4444 55555 666666}
+          )
+        end
+
+        describe "equality" do
+          it "is equal to another table with the same data" do
+            expect( DataTable.new(1, 2, 3, 4) ).to eq DataTable.new(1, 2, 3, 4)
+          end
+
+          it "is not equal to another table with different data" do
+            expect( DataTable.new(1, 2, 3, 4) ).not_to eq DataTable.new(1, 2)
+          end
+
+          it "is not equal to a non table" do
+            expect( DataTable.new(1, 2, 3, 4) ).not_to eq Object.new
+          end
+        end
+
+        describe "#data_table?" do
+          let(:table) { DataTable.new(1, 2, 3, 4) }
+
+          it "returns true" do
+            expect(table).to be_data_table
+          end
+        end
+
+        describe "#doc_string" do
+          let(:table) { DataTable.new(1, 2, 3, 4) }
+
+          it "returns false" do
+            expect(table).not_to be_doc_string
+          end
+        end
+
+        describe "#map" do
+          let(:table) { DataTable.new( %w{foo bar}, %w{1 2} ) }
+
+          it 'yields the contents of each cell to the block' do
+
+            expect { |b| table.map(&b) }.to yield_successive_args('foo', 'bar', '1', '2')
+          end
+
+          it 'returns a new table with the cells modified by the block' do
+            expect( table.map { |cell| "*#{cell}*" } ).to eq DataTable.new(%w{*foo* *bar*}, %w{*1* *2*})
+          end
+        end
+
+        describe "#transpose" do
+          before(:each) do
+            @table = DataTable.new(
+              %w{one 1111},
+              %w{two 22222}
+            )
+          end
+
+          it "should transpose the table" do
+            transposed = DataTable.new(
+              %w{one two},
+              %w{1111 22222}
+            )
+            expect( @table.transpose ).to eq( transposed )
+          end
+        end
+
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/doc_string_spec.rb Added

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/doc_string'
+require 'unindent'
+
+module Cucumber
+  module Core
+    module Test
+      describe DocString do
+        let(:doc_string) { DocString.new(content, content_type) }
+
+        describe "#data_table?" do
+          let(:doc_string) { DocString.new("test", "text/plain" ) }
+
+          it "returns false" do
+            expect(doc_string).not_to be_data_table
+          end
+        end
+
+        describe "#doc_string" do
+          let(:doc_string) { DocString.new("test", "text/plain" ) }
+
+          it "returns true" do
+            expect(doc_string).to be_doc_string
+          end
+        end
+
+        context '#map' do
+          let(:content) { 'original content' }
+          let(:content_type) { double }
+
+          it 'yields with the content' do
+            expect { |b| doc_string.map(&b) }.to yield_with_args(content)
+          end
+
+          it 'returns a new docstring with new content' do
+            expect( doc_string.map { 'foo' }.content ).to eq 'foo'
+          end
+
+          it 'raises an error if no block is given' do
+            expect { doc_string.map }.to raise_error ArgumentError
+          end
+        end
+
+        context 'equality' do
+          let(:content) { 'foo' }
+          let(:content_type) { 'text/plain' }
+
+          it 'is equal to another DocString with the same content and content_type' do
+            expect( doc_string ).to eq DocString.new(content, content_type)
+          end
+
+          it 'is not equal to another DocString with different content' do
+            expect( doc_string ).not_to eq DocString.new('bar', content_type)
+          end
+
+          it 'is not equal to another DocString with different content_type' do
+            expect( doc_string ).not_to eq DocString.new(content, 'text/html')
+          end
+
+          it 'is equal to a string with the same content' do
+            expect( doc_string ).to eq 'foo'
+          end
+
+          it 'returns false when compared with something odd' do
+            expect( doc_string ).not_to eq 5
+          end
+        end
+
+        context 'quacking like a String' do
+          let(:content) { String.new('content') }
+          let(:content_type) { 'text/plain' }
+
+          it 'delegates #encoding to the content string' do
+            content.force_encoding('us-ascii')
+            expect( doc_string.encoding ).to eq Encoding.find('US-ASCII')
+          end
+
+          it 'allows implicit conversion to a String' do
+            expect( 'expected content' ).to include(doc_string)
+          end
+
+          it 'allows explicit conversion to a String' do
+            expect( doc_string.to_s ).to eq 'content'
+          end
+
+          it 'delegates #gsub to the content string' do
+            expect( doc_string.gsub(/n/, '_') ).to eq 'co_te_t'
+          end
+
+          it 'delegates #split to the content string' do
+            expect(doc_string.split('n')).to eq 'co', 'te', 't'
+          end
+        end
+      end
+
+      context "inspect" do
+        let(:content_type) { 'text/plain' }
+
+        it "provides a useful inspect method" do
+          doc_string = DocString.new("some text", content_type)
+          expect(doc_string.inspect).to eq <<-END.chomp.unindent
+          #<Cucumber::Core::Test::DocString
+            """text/plain
+            some text
+            """>
+          END
+        end
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/duration_matcher.rb Added

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/empty_multiline_argument_spec.rb Added

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/filters/locations_filter_spec.rb Added

@@ -0,0 +1,271 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+require 'cucumber/core/test/filters/locations_filter'
+require 'timeout'
+require 'cucumber/core/test/location'
+
+module Cucumber::Core
+  describe Test::LocationsFilter do
+    include Cucumber::Core::Gherkin::Writer
+    include Cucumber::Core
+
+    let(:receiver) { SpyReceiver.new }
+
+    let(:doc) do
+      gherkin('features/test.feature') do
+        feature do
+          scenario 'x' do
+            step 'a step'
+          end
+
+          scenario 'y' do
+            step 'a step'
+          end
+        end
+      end
+    end
+
+    it "sorts by the given locations" do
+      locations = 
+        Test::Location.new('features/test.feature', 6),
+        Test::Location.new('features/test.feature', 3)
+      
+      filter = Test::LocationsFilter.new(locations)
+      compile doc, receiver, filter
+      expect(receiver.test_case_locations).to eq locations
+    end
+
+    it "works with wildcard locations" do
+      locations = 
+        Test::Location.new('features/test.feature')
+      
+      filter = Test::LocationsFilter.new(locations)
+      compile doc, receiver, filter
+      expect(receiver.test_case_locations).to eq 
+        Test::Location.new('features/test.feature', 3),
+        Test::Location.new('features/test.feature', 6)
+      
+    end
+
+    it "filters out scenarios that don't match" do
+      locations = 
+        Test::Location.new('features/test.feature', 3)
+      
+      filter = Test::LocationsFilter.new(locations)
+      compile doc, receiver, filter
+      expect(receiver.test_case_locations).to eq locations
+    end
+
+    describe "matching location" do
+      let(:file) { 'features/path/to/the.feature' }
+
+      let(:test_cases) do
+        receiver = double.as_null_object
+        result = 
+        allow(receiver).to receive(:test_case) { |test_case| result << test_case }
+        compile doc, receiver
+        result
+      end
+
+      context "for a scenario" do
+        let(:doc) do
+          Gherkin::Document.new(file, <<-END)
+            Feature:
+
+              Scenario: one
+                Given one a
+
+              # comment
+              @tags
+              Scenario: two
+                Given two a
+                And two b
+
+              Scenario: three
+                Given three b
+
+              Scenario: with docstring
+                Given a docstring
+                  """
+                  this is a docstring
+                  """
+
+              Scenario: with a table
+                Given a table
+                  | a | b |
+                  | 1 | 2 |
+                  | 3 | 4 |
+
+          END
+        end
+
+        def test_case_named(name)
+          test_cases.find { |c| c.name == name }
+        end
+
+        it 'matches the precise location of the scenario' do
+          location = test_case_named('two').location
+          filter = Test::LocationsFilter.new(location)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations).to eq test_case_named('two').location
+        end
+
+        it 'matches multiple locations' do
+          good_location = Test::Location.new(file, 8)
+          bad_location = Test::Location.new(file, 5)
+          filter = Test::LocationsFilter.new(good_location, bad_location)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations).to eq test_case_named('two').location
+        end
+
+        it "doesn't match a location after the scenario line" do
+          location = Test::Location.new(file, 9)
+          filter = Test::LocationsFilter.new(location)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations).to eq 
+        end
+
+        it "doesn't match a location before the scenario line" do
+          location = Test::Location.new(file, 7)
+          filter = Test::LocationsFilter.new(location)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations).to eq 
+        end
+
+        context "with duplicate locations in the filter" do
+          it "matches each test case only once" do
+            location_tc_two = test_case_named('two').location
+            location_tc_one = test_case_named('one').location
+            location_last_step_tc_two = Test::Location.new(file, 10)
+            filter = Test::LocationsFilter.new(location_tc_two, location_tc_one, location_last_step_tc_two)
+            compile doc, receiver, filter
+            expect(receiver.test_case_locations).to eq test_case_named('two').location, location_tc_one = test_case_named('one').location
+          end
+        end
+      end
+
+      context "for a scenario outline" do
+        let(:doc) do
+          Gherkin::Document.new(file, <<-END)
+            Feature:
+
+              Scenario: one
+                Given one a
+
+              # comment on line 6
+              @tags-on-line-7
+              Scenario Outline: two <arg>
+                Given two a
+                And two <arg>
+                  """
+                  docstring
+                  """
+
+                # comment on line 15
+                @tags-on-line-16
+                Examples: x1
+                  | arg |
+                  | b   |
+
+                Examples: x2
+                  | arg |
+                  | c   |
+                  | d   |
+
+              Scenario: three
+                Given three b
+          END
+        end
+
+        let(:test_case) do
+          test_cases.find { |c| c.name == "two b" }
+        end
+
+        it "matches row location to the test case of the row" do
+          locations = 
+            Test::Location.new(file, 19),
+          
+          filter = Test::LocationsFilter.new(locations)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations).to eq test_case.location
+        end
+
+        it "matches outline location with the all test cases of all the tables" do
+          locations = 
+            Test::Location.new(file, 8),
+          
+          filter = Test::LocationsFilter.new(locations)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations.map(&:line)).to eq 19, 23, 24
+        end
+
+        it "doesn't match the location of the examples line" do
+          location = Test::Location.new(file, 17)
+          filter = Test::LocationsFilter.new(location)
+          compile doc, receiver, filter
+          expect(receiver.test_case_locations).to eq 
+        end
+      end
+    end
+
+    context "under load", slow: true do
+      num_features = 50
+      num_scenarios_per_feature = 50
+
+      let(:docs) do
+        (1..num_features).map do |i|
+          gherkin("features/test_#{i}.feature") do
+            feature do
+              (1..num_scenarios_per_feature).each do |j|
+                scenario "scenario #{j}" do
+                  step 'text'
+                end
+              end
+            end
+          end
+        end
+      end
+
+      num_locations = num_features
+      let(:locations) do
+        (1..num_locations).map do |i|
+          (1..num_scenarios_per_feature).map do |j|
+            line = 3 + ((j - 1) * 3)
+            Test::Location.new("features/test_#{i}.feature", line)
+          end
+        end.flatten
+      end
+
+      max_duration_ms = 10000
+      max_duration_ms *= 2.5 if defined?(JRUBY_VERSION)
+      it "filters #{num_features * num_scenarios_per_feature} test cases within #{max_duration_ms}ms" do
+        filter = Test::LocationsFilter.new(locations)
+        Timeout.timeout(max_duration_ms / 1000.0) do
+          compile docs, receiver, filter
+        end
+        expect(receiver.test_cases.length).to eq num_features * num_scenarios_per_feature
+      end
+
+    end
+  end
+
+  class SpyReceiver
+    def test_case(test_case)
+      test_cases << test_case
+    end
+
+    def done
+    end
+
+    def test_case_locations
+      test_cases.map(&:location)
+    end
+
+    def test_cases
+      @test_cases ||= 
+    end
+
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/location_spec.rb Added

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/location'
+
+module Cucumber::Core::Test
+  RSpec::Matchers.define :be_included_in do |expected|
+    match do |actual|
+      expected.include? actual
+    end
+  end
+
+  describe Location do
+    let(:line) { 12 }
+    let(:file) { "foo.feature" }
+
+    describe "equality" do
+      it "is equal to another Location on the same line of the same file" do
+        one_location = Location.new(file, line)
+        another_location = Location.new(file, line)
+        expect( one_location ).to eq another_location
+      end
+
+      it "is not equal to a wild card of the same file" do
+        expect( Location.new(file, line) ).not_to eq Location.new(file)
+      end
+
+      context "collections of locations" do
+        it "behave as expected with uniq" do
+          unique_collection = Location.new(file, line), Location.new(file, line).uniq
+          expect( unique_collection ).to eq Location.new(file, line)
+        end
+      end
+    end
+
+    describe "to_s" do
+      it "is file:line for a precise location" do
+        expect( Location.new("foo.feature", 12).to_s ).to eq "foo.feature:12"
+      end
+
+      it "is file for a wildcard location" do
+        expect( Location.new("foo.feature").to_s ).to eq "foo.feature"
+      end
+
+      it "is file:first_line..last_line for a ranged location" do
+        expect( Location.new("foo.feature", 13..19).to_s ).to eq "foo.feature:13..19"
+      end
+
+      it "is file:line:line:line for an arbitrary set of lines" do
+        expect( Location.new("foo.feature", 1, 3, 5).to_s ).to eq "foo.feature:1:3:5"
+      end
+    end
+
+    describe "matches" do
+      let(:matching) { Location.new(file, line) }
+      let(:same_file_other_line) { Location.new(file, double) }
+      let(:not_matching) { Location.new(other_file, line) }
+      let(:other_file) { double }
+
+      context 'a precise location' do
+        let(:precise) { Location.new(file, line) }
+
+        it "matches a precise location of the same file and line" do
+          expect( matching ).to be_match(precise)
+        end
+
+        it "does not match a precise location on a different line in the same file" do
+          expect( matching ).not_to be_match(same_file_other_line)
+        end
+
+      end
+
+      context 'a wildcard' do
+        let(:wildcard) { Location.new(file) }
+
+        it "matches any location with the same filename" do
+          expect( wildcard ).to be_match(matching)
+        end
+
+        it "is matched by any location of the same file" do
+          expect( matching ).to be_match(wildcard)
+        end
+
+        it "does not match a location in a different file" do
+          expect( wildcard ).not_to be_match(not_matching)
+        end
+      end
+    end
+
+    describe "created from source location" do
+      context "when the location is in the tree below pwd" do
+        it "create a relative path from pwd" do
+          expect( Location.from_source_location("#{Dir.pwd}/path/file.rb", 1).file ).to eq "path/file.rb"
+        end
+      end
+
+      context "when the location is in an installed gem" do
+        it "create a relative path from the gem directory" do
+          expect( Location.from_source_location("/path/gems/gem-name/path/file.rb", 1).file ).to eq "gem-name/path/file.rb"
+        end
+      end
+
+      context "when the location is neither below pwd nor in an installed gem" do
+        it "use the absolute path to the file" do
+          # Use File.expand on expectation to ensure tests work on multiple platform.
+          # On Windows, it will return "C:/path/file.rb" as an absolute path while it will return "/path/file.rb" on Linux.
+          expect( Location.from_source_location("/path/file.rb", 1).file ).to eq File.expand_path("/path/file.rb")
+        end
+      end
+    end
+
+    describe "created from file-colon-line" do
+      it "handles also Windows paths" do
+        # NOTE: running this test on Windows will produce "c:/path/file.rb", but "c:\path\file.rb" on Linux.
+        expect( Location.from_file_colon_line("c:\\path\\file.rb:123").file ).to match(/c:(\\|\/)path(\\|\/)file.rb/)
+      end
+    end
+
+    describe "created of caller" do
+      it "use the location of the caller" do
+        expect( Location.of_caller.to_s ).to be_included_in caller0
+      end
+
+      context "when specifying additional caller depth" do
+        it "use the location of the n:th caller" do
+          expect( Location.of_caller(1).to_s ).to be_included_in caller1
+        end
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/result_spec.rb Added

@@ -0,0 +1,504 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+require 'cucumber/core/test/result'
+require 'cucumber/core/test/duration_matcher'
+
+module Cucumber::Core::Test
+  describe Result do
+
+    let(:visitor) { double('visitor') }
+    let(:args)    { double('args')    }
+
+    describe Result::Passed do
+      subject(:result) { Result::Passed.new(duration) }
+      let(:duration)   { Result::Duration.new(1 * 1000 * 1000) }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:passed).with(args)
+        expect( visitor ).to receive(:duration).with(duration, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "converts to a string" do
+        expect( result.to_s ).to eq "✓"
+      end
+
+      it "converts to a Cucumber::Message::TestResult" do
+        message = result.to_message
+        expect(message.status).to eq(Cucumber::Messages::TestStepResultStatus::PASSED)
+      end
+
+      it "has a duration" do
+        expect( result.duration ).to eq duration
+      end
+
+      it "requires the constructor argument" do
+        expect { Result::Passed.new }.to raise_error(ArgumentError)
+      end
+
+      it "does nothing when appending the backtrace" do
+        expect( result.with_appended_backtrace(double) ).to equal result
+      end
+
+      it "does nothing when filtering the backtrace" do
+        expect( result.with_filtered_backtrace(double) ).to equal result
+      end
+
+      specify { expect( result.to_sym ).to eq :passed }
+
+      specify { expect( result ).to     be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+      specify { expect( result ).not_to be_flaky     }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok? ).to be_truthy }
+    end
+
+    describe Result::Failed do
+      subject(:result) { Result::Failed.new(duration, exception) }
+      let(:duration)   { Result::Duration.new(1 * 1000 * 1000) }
+      let(:exception)  { StandardError.new("error message") }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:failed).with(args)
+        expect( visitor ).to receive(:duration).with(duration, args)
+        expect( visitor ).to receive(:exception).with(exception, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "has a duration" do
+        expect( result.duration ).to eq duration
+      end
+
+      it "converts to a Cucumber::Message::TestResult" do
+        message = result.to_message
+        expect(message.status).to eq(Cucumber::Messages::TestStepResultStatus::FAILED)
+      end
+
+      it "requires both constructor arguments" do
+        expect { Result::Failed.new }.to raise_error(ArgumentError)
+        expect { Result::Failed.new(duration) }.to raise_error(ArgumentError)
+      end
+
+      it "does nothing if step has no backtrace line" do
+        result.exception.set_backtrace("exception backtrace")
+        step = "does not respond_to?(:backtrace_line)"
+
+        expect( result.with_appended_backtrace(step).exception.backtrace ).to eq("exception backtrace")
+      end
+
+      it "appends the backtrace line of the step" do
+        result.exception.set_backtrace("exception backtrace")
+        step = double
+        expect( step ).to receive(:backtrace_line).and_return("step_line")
+
+        expect( result.with_appended_backtrace(step).exception.backtrace ).to eq("exception backtrace", "step_line")
+      end
+
+      it "apply filters to the exception" do
+        filter_class = double
+        filter = double
+        filtered_exception = double
+        expect( filter_class ).to receive(:new).with(result.exception).and_return(filter)
+        expect( filter ).to receive(:exception).and_return(filtered_exception)
+
+        expect( result.with_filtered_backtrace(filter_class).exception ).to equal filtered_exception
+      end
+
+      specify { expect( result.to_sym ).to eq :failed }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).to     be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+      specify { expect( result ).not_to be_flaky     }
+
+      specify { expect( result ).to_not be_ok }
+      specify { expect( result.ok? ).to be_falsey }
+    end
+
+    describe Result::Unknown do
+      subject(:result) { Result::Unknown.new }
+
+      it "doesn't describe itself to a visitor" do
+        visitor = double('never receives anything')
+        result.describe_to(visitor, args)
+      end
+
+      it "defines a with_filtered_backtrace method" do
+        expect(result.with_filtered_backtrace(double("filter"))).to eql result
+      end
+
+      specify { expect( result.to_sym ).to eq :unknown }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).to     be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+      specify { expect( result ).not_to be_flaky     }
+
+      it "converts to a Cucumber::Message::TestResult" do
+        message = result.to_message
+        expect(message.status).to eq(Cucumber::Messages::TestStepResultStatus::UNKNOWN)
+      end
+    end
+
+    describe Result::Raisable do
+      context "with or without backtrace" do
+        subject(:result) { Result::Raisable.new }
+
+        it "does nothing if step has no backtrace line" do
+          step = "does not respond_to?(:backtrace_line)"
+
+          expect( result.with_appended_backtrace(step).backtrace ).to eq(nil)
+        end
+      end
+
+      context "without backtrace" do
+        subject(:result) { Result::Raisable.new }
+
+        it "set the backtrace to the backtrace line of the step" do
+          step = double
+          expect( step ).to receive(:backtrace_line).and_return("step_line")
+
+          expect( result.with_appended_backtrace(step).backtrace ).to eq("step_line")
+        end
+
+        it "does nothing when filtering the backtrace" do
+          expect( result.with_filtered_backtrace(double) ).to equal result
+        end
+      end
+
+      context "with backtrace" do
+        subject(:result) { Result::Raisable.new("message", 0, "backtrace") }
+
+        it "appends the backtrace line of the step" do
+          step = double
+          expect( step ).to receive(:backtrace_line).and_return("step_line")
+
+          expect( result.with_appended_backtrace(step).backtrace ).to eq("backtrace", "step_line")
+        end
+
+        it "apply filters to the backtrace" do
+          filter_class = double
+          filter = double
+          filtered_result = double
+          expect( filter_class ).to receive(:new).with(result.exception).and_return(filter)
+          expect( filter ).to receive(:exception).and_return(filtered_result)
+
+          expect( result.with_filtered_backtrace(filter_class) ).to equal filtered_result
+        end
+      end
+    end
+
+    describe Result::Undefined do
+      subject(:result) { Result::Undefined.new }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:undefined).with(args)
+        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "converts to a Cucumber::Message::TestResult" do
+        message = result.to_message
+        expect(message.status).to eq(Cucumber::Messages::TestStepResultStatus::UNDEFINED)
+      end
+
+      specify { expect( result.to_sym ).to eq :undefined }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).to     be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+      specify { expect( result ).not_to be_flaky     }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok? ).to be_truthy }
+      be_strict = Result::StrictConfiguration.new(:undefined)
+      specify { expect( result.ok?(be_strict) ).to be_falsey }
+    end
+
+    describe Result::Skipped do
+      subject(:result) { Result::Skipped.new }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:skipped).with(args)
+        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "converts to a Cucumber::Message::TestResult" do
+        message = result.to_message
+        expect(message.status).to eq(Cucumber::Messages::TestStepResultStatus::SKIPPED)
+      end
+
+      specify { expect( result.to_sym ).to eq :skipped }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).to     be_skipped   }
+      specify { expect( result ).not_to be_flaky     }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok? ).to be_truthy }
+    end
+
+    describe Result::Pending do
+      subject(:result) { Result::Pending.new }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:pending).with(result, args)
+        expect( visitor ).to receive(:duration).with(an_unknown_duration, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "converts to a Cucumber::Message::TestResult" do
+        message = result.to_message
+        expect(message.status).to eq(Cucumber::Messages::TestStepResultStatus::PENDING)
+      end
+
+      specify { expect( result.to_sym ).to eq :pending }
+
+      specify { expect( result ).not_to be_passed    }
+      specify { expect( result ).not_to be_failed    }
+      specify { expect( result ).not_to be_undefined }
+      specify { expect( result ).not_to be_unknown   }
+      specify { expect( result ).not_to be_skipped   }
+      specify { expect( result ).not_to be_flaky     }
+      specify { expect( result ).to     be_pending   }
+
+      specify { expect( result ).to be_ok }
+      specify { expect( result.ok? ).to be_truthy }
+      be_strict = Result::StrictConfiguration.new(:pending)
+      specify { expect( result.ok?(be_strict) ).to be_falsey }
+    end
+
+    describe Result::Flaky do
+      specify { expect( Result::Flaky.ok?(false) ).to be_truthy }
+      specify { expect( Result::Flaky.ok?(true) ).to be_falsey }
+    end
+
+    describe Result::StrictConfiguration do
+      subject(:strict_configuration) { Result::StrictConfiguration.new}
+
+      describe '#set_strict' do
+        context 'no type argument' do
+          it 'sets all result types to the setting argument' do
+            strict_configuration.set_strict(true)
+            expect( strict_configuration.strict?(:undefined) ).to be_truthy
+            expect( strict_configuration.strict?(:pending) ).to be_truthy
+            expect( strict_configuration.strict?(:flaky) ).to be_truthy
+
+            strict_configuration.set_strict(false)
+            expect( strict_configuration.strict?(:undefined) ).to be_falsey
+            expect( strict_configuration.strict?(:pending) ).to be_falsey
+            expect( strict_configuration.strict?(:flaky) ).to be_falsey
+          end
+        end
+        context 'with type argument' do
+          it 'sets the specified result type to the setting argument' do
+            strict_configuration.set_strict(true, :undefined)
+            expect( strict_configuration.strict?(:undefined) ).to be_truthy
+            expect( strict_configuration.set?(:pending) ).to be_falsey
+            expect( strict_configuration.set?(:flaky) ).to be_falsey
+
+            strict_configuration.set_strict(false, :undefined)
+            expect( strict_configuration.strict?(:undefined) ).to be_falsey
+            expect( strict_configuration.set?(:pending) ).to be_falsey
+            expect( strict_configuration.set?(:flaky) ).to be_falsey
+          end
+        end
+      end
+
+      describe '#strict?' do
+        context 'no type argument' do
+          it 'returns true if any result type is set to strict' do
+            strict_configuration.set_strict(false, :pending)
+            expect( strict_configuration.strict? ).to be_falsey
+
+            strict_configuration.set_strict(true, :flaky)
+            expect( strict_configuration.strict? ).to be_truthy
+          end
+        end
+        context 'with type argument' do
+          it 'returns true if the specified result type is set to strict' do
+            strict_configuration.set_strict(false, :pending)
+            strict_configuration.set_strict(true, :flaky)
+
+            expect( strict_configuration.strict?(:undefined) ).to be_falsey
+            expect( strict_configuration.strict?(:pending) ).to be_falsey
+            expect( strict_configuration.strict?(:flaky) ).to be_truthy
+          end
+        end
+      end
+
+      describe '#merge!' do
+        let(:merged_configuration) { Result::StrictConfiguration.new }
+        it 'sets the not default values from the argument accordingly' do
+          strict_configuration.set_strict(false, :undefined)
+          strict_configuration.set_strict(false, :pending)
+          strict_configuration.set_strict(true, :flaky)
+          merged_configuration.set_strict(true, :pending)
+          merged_configuration.set_strict(false, :flaky)
+          strict_configuration.merge!(merged_configuration)
+
+          expect( strict_configuration.strict?(:undefined) ).to be_falsey
+          expect( strict_configuration.strict?(:pending) ).to be_truthy
+          expect( strict_configuration.strict?(:flaky) ).to be_falsey
+        end
+      end
+    end
+
+    describe Result::Summary do
+      let(:summary)   { Result::Summary.new }
+      let(:failed)    { Result::Failed.new(Result::Duration.new(10), exception) }
+      let(:passed)    { Result::Passed.new(Result::Duration.new(11)) }
+      let(:skipped)   { Result::Skipped.new }
+      let(:unknown)   { Result::Unknown.new }
+      let(:pending)   { Result::Pending.new }
+      let(:undefined) { Result::Undefined.new }
+      let(:exception) { StandardError.new }
+
+      it "counts failed results" do
+        failed.describe_to summary
+        expect( summary.total_failed   ).to eq 1
+        expect( summary.total(:failed) ).to eq 1
+        expect( summary.total          ).to eq 1
+      end
+
+      it "counts passed results" do
+        passed.describe_to summary
+        expect( summary.total_passed   ).to eq 1
+        expect( summary.total(:passed) ).to eq 1
+        expect( summary.total          ).to eq 1
+      end
+
+      it "counts skipped results" do
+        skipped.describe_to summary
+        expect( summary.total_skipped   ).to eq 1
+        expect( summary.total(:skipped) ).to eq 1
+        expect( summary.total           ).to eq 1
+      end
+
+      it "counts undefined results" do
+        undefined.describe_to summary
+        expect( summary.total_undefined   ).to eq 1
+        expect( summary.total(:undefined) ).to eq 1
+        expect( summary.total             ).to eq 1
+      end
+
+      it "counts abitrary raisable results" do
+        flickering = Class.new(Result::Raisable) do
+          def describe_to(visitor, *args)
+            visitor.flickering(*args)
+          end
+        end
+
+        flickering.new.describe_to summary
+        expect( summary.total_flickering   ).to eq 1
+        expect( summary.total(:flickering) ).to eq 1
+        expect( summary.total              ).to eq 1
+      end
+
+      it "returns zero for a status where no messges have been received" do
+        expect( summary.total_passed   ).to eq 0
+        expect( summary.total(:passed) ).to eq 0
+        expect( summary.total_ponies   ).to eq 0
+        expect( summary.total(:ponies) ).to eq 0
+      end
+
+      it "doesn't count unknown results" do
+        unknown.describe_to summary
+        expect( summary.total ).to eq 0
+      end
+
+      it "counts combinations" do
+        passed, passed, failed, skipped, undefined.each { |r| r.describe_to summary }
+        expect( summary.total           ).to eq 5
+        expect( summary.total_passed    ).to eq 2
+        expect( summary.total_failed    ).to eq 1
+        expect( summary.total_skipped   ).to eq 1
+        expect( summary.total_undefined ).to eq 1
+      end
+
+      it "records durations" do
+        passed, failed.each { |r| r.describe_to summary }
+        expect( summary.durations0 ).to be_duration 11
+        expect( summary.durations1 ).to be_duration 10
+      end
+
+      it "records exceptions" do
+        passed, failed.each { |r| r.describe_to summary }
+        expect( summary.exceptions ).to eq exception
+      end
+
+      context "ok? result" do
+        it "passed result is ok" do
+          passed.describe_to summary
+          expect( summary.ok? ).to be true
+        end
+
+        it "skipped result is ok" do
+          skipped.describe_to summary
+          expect( summary.ok? ).to be true
+        end
+
+        it "failed result is not ok" do
+          failed.describe_to summary
+          expect( summary.ok? ).to be false
+        end
+
+        it "pending result is ok if not strict" do
+          pending.describe_to summary
+          expect( summary.ok? ).to be true
+          be_strict = Result::StrictConfiguration.new(:pending)
+          expect( summary.ok?(be_strict) ).to be false
+        end
+
+        it "undefined result is ok if not strict" do
+          undefined.describe_to summary
+          expect( summary.ok? ).to be true
+          be_strict = Result::StrictConfiguration.new(:undefined)
+          expect( summary.ok?(be_strict) ).to be false
+        end
+
+        it "flaky result is ok if not strict" do
+          summary.flaky
+          expect( summary.ok? ).to be true
+          be_strict = Result::StrictConfiguration.new(:flaky)
+          expect( summary.ok?(be_strict) ).to be false
+        end
+      end
+    end
+
+    describe Result::Duration do
+      subject(:duration) { Result::Duration.new(10) }
+
+      it "#nanoseconds can be accessed in #tap" do
+        expect( duration.tap { |duration| @duration = duration.nanoseconds } ).to eq duration
+        expect( @duration ).to eq 10
+      end
+    end
+
+    describe Result::UnknownDuration do
+      subject(:duration) { Result::UnknownDuration.new }
+
+      it "#tap does not execute the passed block" do
+        expect( duration.tap { raise "tap executed block" } ).to eq duration
+      end
+
+      it "accessing #nanoseconds outside #tap block raises exception" do
+        expect { duration.nanoseconds }.to raise_error(RuntimeError)
+      end
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/runner_spec.rb Added

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/runner'
+require 'cucumber/core/test/case'
+require 'cucumber/core/test/step'
+require 'cucumber/core/test/duration_matcher'
+
+module Cucumber::Core::Test
+  describe Runner do
+
+    let(:step_id)   { double }
+    let(:test_id)   { double }
+    let(:name)      { double }
+    let(:location)  { double }
+    let(:tags)      { double }
+    let(:language)  { double }
+    let(:test_case) { Case.new(test_id, name, test_steps, location, tags, language) }
+    let(:text)      { double }
+    let(:runner)    { Runner.new(event_bus) }
+    let(:event_bus) { double.as_null_object }
+    let(:passing)   { Step.new(step_id, text, location, location).with_action {} }
+    let(:failing)   { Step.new(step_id, text, location, location).with_action { raise exception } }
+    let(:pending)   { Step.new(step_id, text, location, location).with_action { raise Result::Pending.new("TODO") } }
+    let(:skipping)  { Step.new(step_id, text, location, location).with_action { raise Result::Skipped.new } }
+    let(:undefined) { Step.new(step_id, text, location, location) }
+    let(:exception) { StandardError.new('test error') }
+
+    before do
+      allow( event_bus ).to receive(:test_case_started)
+      allow( text ).to receive(:empty?)
+    end
+
+    context "reporting the duration of a test case" do
+      before do
+        allow( Timer::MonotonicTime ).to receive(:time_in_nanoseconds).and_return(525702744080000, 525702744080001)
+      end
+
+      context "for a passing test case" do
+        let(:test_steps) { passing }
+
+        it "records the nanoseconds duration of the execution on the result" do
+          expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
+            expect( result.duration ).to be_duration 1
+          end
+          test_case.describe_to runner
+        end
+      end
+
+      context "for a failing test case" do
+        let(:test_steps) { failing }
+
+        it "records the duration" do
+          expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
+            expect(result.duration).to be_duration 1
+          end
+          test_case.describe_to runner
+        end
+      end
+    end
+
+    context "reporting the exception that failed a test case" do
+      let(:test_steps) { failing }
+      it "sets the exception on the result" do
+        allow(event_bus).to receive(:before_test_case)
+        expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
+          expect( result.exception ).to eq exception
+        end
+        test_case.describe_to runner
+      end
+    end
+
+    context "with a single case" do
+      context "without steps" do
+        let(:test_steps) {  }
+
+        it "emits a test_case_started event before running the test case" do
+          expect(event_bus).to receive(:test_case_started).with(test_case)
+          test_case.describe_to runner
+        end
+
+        it "emits the test_case_finished event after running the the test case" do
+          expect(event_bus).to receive(:test_case_finished) do |reported_test_case, result|
+            expect( reported_test_case ).to eq test_case
+            expect( result ).to be_undefined
+          end
+          test_case.describe_to runner
+        end
+      end
+
+      context 'with steps' do
+        context 'that all pass' do
+          let(:test_steps) {  passing, passing   }
+
+          it 'emits the test_case_finished event with a passing result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result ).to be_passed
+            end
+            test_case.describe_to runner
+          end
+        end
+
+        context 'an undefined step' do
+          let(:test_steps) {  undefined   }
+
+          it 'emits the test_case_finished event with an undefined result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result ).to be_undefined
+            end
+
+            test_case.describe_to runner
+          end
+
+          it 'sets the message on the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.message ).to eq("Undefined step: \"step name\"")
+            end
+            allow( undefined ).to receive(:text).and_return('step name')
+
+            test_case.describe_to runner
+          end
+
+          it 'appends the backtrace of the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.backtrace ).to eq("step line")
+            end
+            expect( undefined ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context 'a pending step' do
+          let(:test_steps) {  pending  }
+
+          it 'emits the test_case_finished event with a pending result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result ).to be_pending
+            end
+            test_case.describe_to runner
+          end
+
+          it 'appends the backtrace of the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.backtrace.last ).to eq("step line")
+            end
+            expect( pending ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context "a skipping step" do
+          let(:test_steps) { skipping }
+
+          it "emits the test_case_finished event with a skipped result" do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result ).to be_skipped
+            end
+            test_case.describe_to runner
+          end
+
+          it 'appends the backtrace of the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.backtrace.last ).to eq("step line")
+            end
+            expect( skipping ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context 'that fail' do
+          let(:test_steps) {  failing  }
+
+          it 'emits the test_case_finished event with a failing result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result ).to be_failed
+            end
+            test_case.describe_to runner
+          end
+
+          it 'appends the backtrace of the exception of the result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result.exception.backtrace.last ).to eq("step line")
+            end
+            expect( failing ).to receive(:backtrace_line).and_return('step line')
+
+            test_case.describe_to runner
+          end
+        end
+
+        context 'where the first step fails' do
+          let(:test_steps) {  failing, passing  }
+
+          it 'emits the test_step_finished event with a failed result' do
+            expect(event_bus).to receive(:test_step_finished).with(failing, anything) do |test_step, result|
+              expect( result ).to be_failed
+            end
+            test_case.describe_to runner
+          end
+
+          it 'emits a test_step_finished event with a skipped result' do
+            expect(event_bus).to receive(:test_step_finished).with(passing, anything) do |test_step, result|
+              expect( result ).to be_skipped
+            end
+            test_case.describe_to runner
+          end
+
+          it 'emits a test_case_finished event with a failed result' do
+            expect(event_bus).to receive(:test_case_finished) do |test_case, result|
+              expect( result ).to be_failed
+              expect( result.exception ).to eq exception
+            end
+            test_case.describe_to runner
+          end
+
+          it 'skips, rather than executing the second step' do
+            expect( passing ).not_to receive(:execute)
+            expect( passing ).to receive(:skip).and_return(Result::Skipped.new)
+            test_case.describe_to runner
+          end
+        end
+
+      end
+    end
+
+    context 'with multiple test cases' do
+      context 'when the first test case fails' do
+        let(:first_test_case) { Case.new(test_id, name, failing, location, tags, language) }
+        let(:last_test_case)  { Case.new(test_id, name, passing, location, tags, language) }
+        let(:test_cases)      { first_test_case, last_test_case }
+
+        it 'reports the results correctly for the following test case' do
+          expect(event_bus).to receive(:test_case_finished) { |reported_test_case, result|
+            expect(result).to be_failed if reported_test_case.equal?(first_test_case)
+            expect(result).to be_passed if reported_test_case.equal?(last_test_case)
+          }.twice
+
+          test_cases.each { |c| c.describe_to runner }
+        end
+      end
+    end
+
+    context "passing latest result to a mapping" do
+      it "passes a Failed result when the scenario is failing" do
+        result_spy = nil
+        hook_mapping = UnskippableAction.new do |last_result|
+          result_spy = last_result
+        end
+        after_hook = HookStep.new(step_id, text, location, hook_mapping)
+        failing_step = Step.new(step_id, text, location).with_action { fail }
+        test_case = Case.new(test_id, name, failing_step, after_hook, location, tags, language)
+        test_case.describe_to runner
+        expect(result_spy).to be_failed
+      end
+    end
+
+    require 'cucumber/core/test/around_hook'
+    context "with around hooks" do
+      it "passes normally when around hooks don't fail" do
+        around_hook = AroundHook.new { |block| block.call }
+        passing_step = Step.new(step_id, text, location, location).with_action {}
+        test_case = Case.new(test_id, name, passing_step, location, tags, language, around_hook)
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
+          expect(result).to be_passed
+        end
+        test_case.describe_to runner
+      end
+
+      it "gets a failed result if the Around hook fails before the test case is run" do
+        around_hook = AroundHook.new { |block| raise exception }
+        passing_step = Step.new(step_id, text, location, location).with_action {}
+        test_case = Case.new(test_id, name, passing_step, location, tags, language, around_hook)
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
+          expect(result).to be_failed
+          expect(result.exception).to eq exception
+        end
+        test_case.describe_to runner
+      end
+
+      it "gets a failed result if the Around hook fails after the test case is run" do
+        around_hook = AroundHook.new { |block| block.call; raise exception }
+        passing_step = Step.new(step_id, text, location, location).with_action {}
+        test_case = Case.new(test_id, name, passing_step, location, tags, language, around_hook)
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
+          expect(result).to be_failed
+          expect(result.exception).to eq exception
+        end
+        test_case.describe_to runner
+      end
+
+      it "fails when a step fails if the around hook works" do
+        around_hook = AroundHook.new { |block| block.call }
+        failing_step = Step.new(step_id, text, location, location).with_action { raise exception }
+        test_case = Case.new(test_id, name, failing_step, location, tags, language, around_hook)
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
+          expect(result).to be_failed
+          expect(result.exception).to eq exception
+        end
+        test_case.describe_to runner
+      end
+
+      it "sends after_test_step for a step interrupted by (a timeout in) the around hook" do
+        around_hook = AroundHook.new { |block| block.call; raise exception }
+        passing_step = Step.new(step_id, text, location, location).with_action {}
+        test_case = Case.new(test_id, name, , location, tags, language, around_hook)
+        allow(runner).to receive(:running_test_step).and_return(passing_step)
+        expect(event_bus).to receive(:test_step_finished).with(passing_step, anything) do |reported_test_case, result|
+          expect(result).to be_failed
+          expect(result.exception).to eq exception
+        end
+        expect(event_bus).to receive(:test_case_finished).with(test_case, anything) do |reported_test_case, result|
+          expect(result).to be_failed
+          expect(result.exception).to eq exception
+        end
+        test_case.describe_to runner
+      end
+    end
+
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/step_spec.rb Added

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/step'
+
+module Cucumber::Core::Test
+  describe Step do
+    let(:id) { 'some-random-uid' }
+    let(:text) { 'step text' }
+    let(:location) { double }
+
+    describe "describing itself" do
+      it "describes itself to a visitor" do
+        visitor = double
+        args = double
+        test_step = Step.new(id, text, location)
+        expect( visitor ).to receive(:test_step).with(test_step, args)
+        test_step.describe_to(visitor, args)
+      end
+    end
+
+    describe "backtrace line" do
+      let(:text) { 'this step passes' }
+      let(:location)  { Location.new('path/file.feature', 10) }
+      let(:test_step) { Step.new(id, text, location) }
+
+      it "knows how to form the backtrace line" do
+        expect( test_step.backtrace_line ).to eq("path/file.feature:10:in `this step passes'")
+      end
+    end
+
+    describe "executing" do
+      it "passes arbitrary arguments to the action's block" do
+        args_spy = nil
+        expected_args = double, double
+        test_step = Step.new(id, text, location).with_action do |*actual_args|
+          args_spy = actual_args
+        end
+        test_step.execute(*expected_args)
+        expect(args_spy).to eq expected_args
+      end
+
+      context "when a passing action exists" do
+        it "returns a passing result" do
+          test_step = Step.new(id, text, location).with_action {}
+          expect( test_step.execute ).to be_passed
+        end
+      end
+
+      context "when a failing action exists" do
+        let(:exception) { StandardError.new('oops') }
+
+        it "returns a failing result" do
+          test_step = Step.new(id, text, location).with_action { raise exception }
+          result = test_step.execute
+          expect( result           ).to be_failed
+          expect( result.exception ).to eq exception
+        end
+      end
+
+      context "with no action" do
+        it "returns an Undefined result" do
+          test_step = Step.new(id, text, location)
+          result = test_step.execute
+          expect( result           ).to be_undefined
+        end
+      end
+    end
+
+    it "exposes the text and location of as attributes" do
+      test_step = Step.new(id, text, location)
+      expect( test_step.text              ).to eq text
+      expect( test_step.location          ).to eq location
+    end
+
+    it "exposes the location of the action as attribute" do
+      location = double
+      action = double(location: location)
+      test_step = Step.new(id, text, location, action)
+      expect( test_step.action_location ).to eq location
+    end
+
+    it "returns the text when converted to a string" do
+      text = 'a passing step'
+      test_step = Step.new(id, text, location)
+      expect( test_step.to_s     ).to eq 'a passing step'
+    end
+
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core/test/timer_spec.rb Added

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/cucumber/core_spec.rb Added

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require 'report_api_spy'
+require 'cucumber/core'
+require 'cucumber/core/filter'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core/platform'
+require 'cucumber/core/report/summary'
+require 'cucumber/core/test/around_hook'
+require 'cucumber/core/test/filters/activate_steps_for_self_test'
+
+module Cucumber
+  describe Core do
+    include Core
+    include Core::Gherkin::Writer
+
+    describe "compiling features to a test suite" do
+
+      it "compiles two scenarios into two test cases" do
+        visitor = ReportAPISpy.new
+
+        compile(
+          gherkin do
+            feature do
+              background do
+                step 'text'
+              end
+              scenario do
+                step 'text'
+              end
+              scenario do
+                step 'text'
+                step 'text'
+              end
+            end
+          end
+        , visitor)
+
+        expect( visitor.messages ).to eq 
+          :test_case,
+          :test_step,
+          :test_step,
+          :test_case,
+          :test_step,
+          :test_step,
+          :test_step,
+          :done,
+        
+      end
+
+      it "filters out test cases based on a tag expression" do
+        visitor = double.as_null_object
+        expect( visitor ).to receive(:test_case) do |test_case|
+          expect( test_case.name ).to eq 'foo'
+        end.exactly(1).times
+
+        gherkin = gherkin do
+          feature do
+            scenario tags: '@b' do
+              step 'text'
+            end
+
+            scenario_outline 'foo' do
+              step '<arg>'
+
+              examples tags: '@a' do
+                row 'arg'
+                row 'x'
+              end
+
+              examples 'bar', tags: '@a @b' do
+                row 'arg'
+                row 'y'
+              end
+            end
+          end
+        end
+
+        compile gherkin, visitor, Cucumber::Core::Test::TagFilter.new('@a', '@b')
+      end
+    end
+
+    describe "executing a test suite" do
+
+      it "fires events" do
+        gherkin = gherkin do
+          feature 'Feature name' do
+            scenario 'The one that passes' do
+              step 'passing'
+            end
+
+            scenario 'The one that fails' do
+              step 'passing'
+              step 'failing'
+              step 'passing'
+              step 'undefined'
+            end
+          end
+        end
+
+        observed_events = 
+        execute gherkin, Core::Test::Filters::ActivateStepsForSelfTest.new do |event_bus|
+          event_bus.on(:test_case_started) do |event|
+            test_case = event.test_case
+            observed_events << :test_case_started, test_case.name
+          end
+          event_bus.on(:test_case_finished) do |event|
+            test_case, result = *event.attributes
+            observed_events << :test_case_finished, test_case.name, result.to_sym
+          end
+          event_bus.on(:test_step_started) do |event|
+            test_step = event.test_step
+            observed_events << :test_step_started, test_step.text
+          end
+          event_bus.on(:test_step_finished) do |event|
+            test_step, result = *event.attributes
+            observed_events << :test_step_finished, test_step.text, result.to_sym
+          end
+        end
+
+        expect(observed_events).to eq 
+          :test_case_started, 'The one that passes',
+          :test_step_started, 'passing',
+          :test_step_finished, 'passing', :passed,
+          :test_case_finished, 'The one that passes', :passed,
+          :test_case_started, 'The one that fails',
+          :test_step_started, 'passing',
+          :test_step_finished, 'passing', :passed,
+          :test_step_started, 'failing',
+          :test_step_finished, 'failing', :failed,
+          :test_step_started, 'passing',
+          :test_step_finished, 'passing', :skipped,
+          :test_step_started, 'undefined',
+          :test_step_finished, 'undefined', :undefined,
+          :test_case_finished, 'The one that fails', :failed,
+        
+      end
+
+      context "without hooks" do
+        it "executes the test cases in the suite" do
+          gherkin = gherkin do
+            feature 'Feature name' do
+              scenario 'The one that passes' do
+                step 'passing'
+              end
+
+              scenario 'The one that fails' do
+                step 'passing'
+                step 'failing'
+                step 'passing'
+                step 'undefined'
+              end
+            end
+          end
+
+          event_bus = Core::EventBus.new
+          report = Core::Report::Summary.new(event_bus)
+          execute gherkin, Core::Test::Filters::ActivateStepsForSelfTest.new, event_bus
+
+          expect( report.test_cases.total           ).to eq 2
+          expect( report.test_cases.total_passed    ).to eq 1
+          expect( report.test_cases.total_failed    ).to eq 1
+          expect( report.test_steps.total           ).to eq 5
+          expect( report.test_steps.total_failed    ).to eq 1
+          expect( report.test_steps.total_passed    ).to eq 2
+          expect( report.test_steps.total_skipped   ).to eq 1
+          expect( report.test_steps.total_undefined ).to eq 1
+        end
+      end
+
+      context "with around hooks" do
+        class WithAroundHooks < Core::Filter.new(:logger)
+          def test_case(test_case)
+            base_step = Core::Test::Step.new('some-random-uid', 'text', nil, nil, nil)
+            test_steps = 
+              base_step.with_action { logger << :step },
+            
+
+            around_hook = Core::Test::AroundHook.new do |run_scenario|
+              logger << :before_all
+              run_scenario.call
+              logger << :middle
+              run_scenario.call
+              logger << :after_all
+            end
+            test_case.with_steps(test_steps).with_around_hooks(around_hook).describe_to(receiver)
+          end
+        end
+
+        it "executes the test cases in the suite" do
+          gherkin = gherkin do
+            feature do
+              scenario do
+                step 'text'
+              end
+            end
+          end
+          logger = 
+
+          event_bus = Core::EventBus.new
+          report = Core::Report::Summary.new(event_bus)
+          execute gherkin, WithAroundHooks.new(logger), event_bus
+
+          expect( report.test_cases.total        ).to eq 1
+          expect( report.test_cases.total_passed ).to eq 1
+          expect( report.test_cases.total_failed ).to eq 0
+          expect( logger ).to eq 
+            :before_all,
+              :step,
+            :middle,
+              :step,
+            :after_all
+          
+        end
+      end
+
+      require 'cucumber/core/test/filters'
+      it "filters test cases by tag" do
+        gherkin = gherkin do
+          feature do
+            scenario do
+              step 'text'
+            end
+
+            scenario tags: '@a @b' do
+              step 'text'
+            end
+
+            scenario tags: '@a' do
+              step 'text'
+            end
+          end
+        end
+
+        event_bus = Core::EventBus.new
+        report = Core::Report::Summary.new(event_bus)
+        execute gherkin,  Cucumber::Core::Test::TagFilter.new('@a') , event_bus
+
+        expect( report.test_cases.total ).to eq 2
+      end
+
+      it "filters test cases by name" do
+        gherkin = gherkin do
+          feature 'first feature' do
+            scenario 'first scenario' do
+              step 'missing'
+            end
+            scenario 'second' do
+              step 'missing'
+            end
+          end
+        end
+
+        event_bus = Core::EventBus.new
+        report = Core::Report::Summary.new(event_bus)
+        execute gherkin,  Cucumber::Core::Test::NameFilter.new(/scenario/) , event_bus
+
+        expect( report.test_cases.total ).to eq 1
+      end
+
+    end
+  end
+end

_service:tar_scm:cucumber-core-10.1.0.gem/data/spec/report_api_spy.rb Added

_service:tar_scm:cucumber-core-3.2.0.gem/metadata.gz -> _service:tar_scm:cucumber-core-10.1.0.gem/metadata.gz Changed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-core
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 10.1.0
 platform: ruby
 authors:
 - Aslak Hellesøy
@@ -12,148 +12,188 @@
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2018-07-13 00:00:00.000000000 Z
+date: 2021-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: gherkin
+  name: cucumber-gherkin
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '22.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 22.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '22.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 22.0.0
 - !ruby/object:Gem::Dependency
-  name: cucumber-tag_expressions
+  name: cucumber-messages
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        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: 1.1.0
+        version: '17.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 17.1.1
 - !ruby/object:Gem::Dependency
-  name: backports
+  name: cucumber-tag-expressions
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 4.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 4.0.2
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.0
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.23
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.0
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.23
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 13.0.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 13.0.6
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-- !ruby/object:Gem::Dependency
-  name: unindent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
+        version: '3.10'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 3.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 3.10.0
 - !ruby/object:Gem::Dependency
-  name: kramdown
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: '1.22'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.22.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: '1.22'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.22.1
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rubocop-packaging
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.1
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: unindent
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Core library for the Cucumber BDD app
 email: cukes@googlegroups.com
 executables: 
@@ -165,32 +205,13 @@
 - LICENSE
 - README.md
 - lib/cucumber/core.rb
-- lib/cucumber/core/ast.rb
-- lib/cucumber/core/ast/background.rb
-- lib/cucumber/core/ast/comment.rb
-- lib/cucumber/core/ast/data_table.rb
-- lib/cucumber/core/ast/describes_itself.rb
-- lib/cucumber/core/ast/doc_string.rb
-- lib/cucumber/core/ast/empty_background.rb
-- lib/cucumber/core/ast/empty_multiline_argument.rb
-- lib/cucumber/core/ast/examples_table.rb
-- lib/cucumber/core/ast/feature.rb
-- lib/cucumber/core/ast/location.rb
-- lib/cucumber/core/ast/names.rb
-- lib/cucumber/core/ast/outline_step.rb
-- lib/cucumber/core/ast/scenario.rb
-- lib/cucumber/core/ast/scenario_outline.rb
-- lib/cucumber/core/ast/step.rb
-- lib/cucumber/core/ast/tag.rb
 - lib/cucumber/core/compiler.rb
 - lib/cucumber/core/event.rb
 - lib/cucumber/core/event_bus.rb
 - lib/cucumber/core/events.rb
 - lib/cucumber/core/filter.rb
-- lib/cucumber/core/gherkin/ast_builder.rb
 - lib/cucumber/core/gherkin/document.rb
 - lib/cucumber/core/gherkin/parser.rb
-- lib/cucumber/core/gherkin/tag_expression.rb
 - lib/cucumber/core/gherkin/writer.rb
 - lib/cucumber/core/gherkin/writer/helpers.rb
 - lib/cucumber/core/platform.rb
@@ -198,20 +219,52 @@
 - lib/cucumber/core/test/action.rb
 - lib/cucumber/core/test/around_hook.rb
 - lib/cucumber/core/test/case.rb
+- lib/cucumber/core/test/data_table.rb
+- lib/cucumber/core/test/doc_string.rb
+- lib/cucumber/core/test/empty_multiline_argument.rb
 - lib/cucumber/core/test/filters.rb
 - lib/cucumber/core/test/filters/activate_steps_for_self_test.rb
 - lib/cucumber/core/test/filters/locations_filter.rb
 - lib/cucumber/core/test/filters/name_filter.rb
 - lib/cucumber/core/test/filters/tag_filter.rb
+- lib/cucumber/core/test/location.rb
 - lib/cucumber/core/test/result.rb
 - lib/cucumber/core/test/runner.rb
 - lib/cucumber/core/test/step.rb
+- lib/cucumber/core/test/tag.rb
 - lib/cucumber/core/test/timer.rb
 - lib/cucumber/core/version.rb
+- spec/coverage.rb
+- spec/cucumber/core/compiler_spec.rb
+- spec/cucumber/core/event_bus_spec.rb
+- spec/cucumber/core/event_spec.rb
+- spec/cucumber/core/filter_spec.rb
+- spec/cucumber/core/gherkin/parser_spec.rb
+- spec/cucumber/core/gherkin/writer_spec.rb
+- spec/cucumber/core/report/summary_spec.rb
+- spec/cucumber/core/test/action_spec.rb
+- spec/cucumber/core/test/case_spec.rb
+- spec/cucumber/core/test/data_table_spec.rb
+- spec/cucumber/core/test/doc_string_spec.rb
+- spec/cucumber/core/test/duration_matcher.rb
+- spec/cucumber/core/test/empty_multiline_argument_spec.rb
+- spec/cucumber/core/test/filters/locations_filter_spec.rb
+- spec/cucumber/core/test/location_spec.rb
+- spec/cucumber/core/test/result_spec.rb
+- spec/cucumber/core/test/runner_spec.rb
+- spec/cucumber/core/test/step_spec.rb
+- spec/cucumber/core/test/timer_spec.rb
+- spec/cucumber/core_spec.rb
+- spec/report_api_spy.rb
 homepage: https://cucumber.io
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/cucumber/cucumber-ruby-core/issues
+  changelog_uri: https://github.com/cucumber/cucumber-ruby-core/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/github/cucumber/cucumber-ruby-core
+  mailing_list_uri: https://groups.google.com/forum/#!forum/cukes
+  source_code_uri: https://github.com/cucumber/cucumber-ruby-core
 post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
@@ -221,16 +274,37 @@
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: 
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: cucumber-core-3.2.0
-test_files: 
+summary: cucumber-core-10.1.0
+test_files:
+- spec/report_api_spy.rb
+- spec/cucumber/core/test/case_spec.rb
+- spec/cucumber/core/test/location_spec.rb
+- spec/cucumber/core/test/duration_matcher.rb
+- spec/cucumber/core/test/doc_string_spec.rb
+- spec/cucumber/core/test/action_spec.rb
+- spec/cucumber/core/test/filters/locations_filter_spec.rb
+- spec/cucumber/core/test/result_spec.rb
+- spec/cucumber/core/test/step_spec.rb
+- spec/cucumber/core/test/data_table_spec.rb
+- spec/cucumber/core/test/timer_spec.rb
+- spec/cucumber/core/test/empty_multiline_argument_spec.rb
+- spec/cucumber/core/test/runner_spec.rb
+- spec/cucumber/core/compiler_spec.rb
+- spec/cucumber/core/event_bus_spec.rb
+- spec/cucumber/core/filter_spec.rb
+- spec/cucumber/core/report/summary_spec.rb
+- spec/cucumber/core/gherkin/parser_spec.rb
+- spec/cucumber/core/gherkin/writer_spec.rb
+- spec/cucumber/core/event_spec.rb
+- spec/cucumber/core_spec.rb
+- spec/coverage.rb

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/background.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/comment.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/data_table.rb Deleted

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/location'
-
-module Cucumber
-  module Core
-    module Ast
-      # Step Definitions that match a plain text Step with a multiline argument table
-      # will receive it as an instance of DataTable. A DataTable object holds the data of a
-      # table parsed from a feature file and lets you access and manipulate the data
-      # in different ways.
-      #
-      # For example:
-      #
-      #   Given I have:
-      #     | a | b |
-      #     | c | d |
-      #
-      # And a matching StepDefinition:
-      #
-      #   Given /I have:/ do |table|
-      #     data = table.raw
-      #   end
-      #
-      # This will store <tt>'a', 'b', 'c', 'd'</tt> in the <tt>data</tt> variable.
-      #
-      class DataTable
-        include DescribesItself
-        include HasLocation
-
-        # Creates a new instance. +raw+ should be an Array of Array of String
-        # or an Array of Hash
-        # You don't typically create your own DataTable objects - Cucumber will do
-        # it internally and pass them to your Step Definitions.
-        #
-        def initialize(rows, location)
-          raw = ensure_array_of_array(rows)
-          verify_rows_are_same_length(raw)
-          @raw = raw.freeze
-          @location = location
-        end
-        attr_reader :raw
-
-        def to_step_definition_arg
-          dup
-        end
-
-        def data_table?
-          true
-        end
-
-        def doc_string?
-          false
-        end
-
-        # Creates a copy of this table
-        #
-        def dup
-          self.class.new(raw.dup, location)
-        end
-
-        # Returns a new, transposed table. Example:
-        #
-        #   | a | 7 | 4 |
-        #   | b | 9 | 2 |
-        #
-        # Gets converted into the following:
-        #
-        #   | a | b |
-        #   | 7 | 9 |
-        #   | 4 | 2 |
-        #
-        def transpose
-          self.class.new(raw.transpose, location)
-        end
-
-        def map(&block)
-          new_raw = raw.map do |row|
-            row.map(&block)
-          end
-
-          self.class.new(new_raw, location)
-        end
-
-        def ==(other)
-          other.class == self.class && raw == other.raw
-        end
-
-        def inspect
-          %{#<#{self.class} #{raw.inspect} (#{location})>}
-        end
-
-        private
-
-        def verify_rows_are_same_length(raw)
-          begin
-            raw.transpose
-          rescue IndexError
-            raise ArgumentError, "Rows must all be the same length"
-          end
-        end
-
-        def ensure_array_of_array(array)
-          Hash === array0 ? hashes_to_array(array) : array
-        end
-
-        def hashes_to_array(hashes)
-          header = hashes0.keys.sort
-          header + hashes.map{|hash| header.map{|key| hashkey}}
-        end
-
-        def description_for_visitors
-          :data_table
-        end
-
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/describes_itself.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/doc_string.rb Deleted

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'delegate'
-module Cucumber
-  module Core
-    module Ast
-      # Represents an inline argument in a step. Example:
-      #
-      #   Given the message
-      #     """
-      #     I like
-      #     Cucumber sandwich
-      #     """
-      #
-      # The text between the pair of <tt>"""</tt> is stored inside a DocString,
-      # which is yielded to the StepDefinition block as the last argument.
-      #
-      # The StepDefinition can then access the String via the #to_s method. In the
-      # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
-      #
-      # Note how the indentation from the source is stripped away.
-      #
-      class DocString < SimpleDelegator
-        include HasLocation
-        include DescribesItself
-
-        attr_reader :content_type, :content
-
-        def initialize(content, content_type, location)
-          @content = content
-          @content_type = content_type
-          @location = location
-          super @content
-        end
-
-        def data_table?
-          false
-        end
-
-        def doc_string?
-          true
-        end
-
-        def map
-          raise ArgumentError, "No block given" unless block_given?
-          new_content = yield content
-          self.class.new(new_content, content_type, location)
-        end
-
-        def to_step_definition_arg
-          self
-        end
-
-        def ==(other)
-          if other.respond_to?(:content_type)
-            return false unless content_type == other.content_type
-          end
-          if other.respond_to?(:to_str)
-            return content == other.to_str
-          end
-          false
-        end
-
-        def inspect
-          
-            %{#<#{self.class} (#{location})},
-            %{  """#{content_type}},
-            %{  #{@content}},
-            %{  """>}
-          .join("\n")
-        end
-
-        private
-
-        def description_for_visitors
-          :doc_string
-        end
-
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/empty_background.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/empty_multiline_argument.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/examples_table.rb Deleted

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/location'
-require 'cucumber/core/ast/names'
-
-module Cucumber
-  module Core
-    module Ast
-
-      class ExamplesTable
-        include Names
-        include HasLocation
-        include DescribesItself
-
-        def initialize(location, comments, tags, keyword, name, description, header, example_rows)
-          @location = location
-          @comments = comments
-          @tags = tags
-          @keyword = keyword
-          @name = name
-          @description = description
-          @header = header
-          @example_rows = example_rows
-        end
-
-        attr_reader :location, :tags, :keyword, :comments,
-                    :header, :example_rows
-
-        private
-
-        def description_for_visitors
-          :examples_table
-        end
-
-        def children
-          @example_rows
-        end
-
-        class Header
-          include HasLocation
-
-          attr_reader :comments
-
-          def initialize(cells, location, comments)
-            @cells = cells
-            @location = location
-            @comments = comments
-          end
-
-          def values
-            @cells
-          end
-
-          def build_row(row_cells, number, location, language, comments)
-            Row.new(Hash@cells.zip(row_cells), number, location, language, comments)
-          end
-
-          def inspect
-            "#<#{self.class} #{values} (#{location})>"
-          end
-        end
-
-        class Row
-          include DescribesItself
-          include HasLocation
-
-          attr_reader :number, :language, :comments
-
-          def initialize(data, number, location, language, comments)
-            raise ArgumentError, data.to_s unless data.is_a?(Hash)
-            @data = data
-            @number = number
-            @location = location
-            @language = language
-            @comments = comments
-          end
-
-          def ==(other)
-            return false unless other.class == self.class
-            other.number == number &&
-              other.location == location &&
-              other.data == data
-          end
-
-          def (parameter_name)
-            @dataparameter_name
-          end
-
-          def values
-            @data.values
-          end
-
-          def expand(string)
-            result = string.dup
-            @data.each do |key, value|
-              result.gsub!("<#{key}>", value.to_s)
-            end
-            result
-          end
-
-          def inspect
-            "#<#{self.class}: #{@data.inspect} (#{location})>"
-          end
-
-          protected
-
-          attr_reader :data
-
-          private
-
-          def description_for_visitors
-            :examples_table_row
-          end
-        end
-      end
-      class Examples < ExamplesTable; end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/feature.rb Deleted

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/names'
-require 'cucumber/core/ast/location'
-require 'gherkin/dialect'
-
-module Cucumber
-  module Core
-    module Ast
-      # Represents the root node of a parsed feature.
-      class Feature
-        include Names
-        include HasLocation
-        include DescribesItself
-
-        attr_reader :language, :location, :background,
-                    :comments, :tags, :keyword, :description,
-                    :feature_elements
-
-        def initialize(language, location, comments, tags, keyword, name, description, feature_elements)
-          @language = language
-          @location = location
-          @background = BackgroundFinder.new(feature_elements).result
-          @comments = comments
-          @tags = tags
-          @keyword = keyword
-          @name = name
-          @description = description
-          @feature_elements = feature_elements
-        end
-
-        def children
-          @feature_elements
-        end
-
-        def short_name
-          first_line = name.split(/\n/)0
-          if first_line =~ /#{language.feature_keywords}:(.*)/
-            $1.strip
-          else
-            first_line
-          end
-        end
-
-        private
-
-        def description_for_visitors
-          :feature
-        end
-
-      end
-
-      class NullFeature
-        def method_missing(*args, &block)
-          self
-        end
-      end
-
-      class BackgroundFinder
-        def initialize(feature_elements)
-          @background = nil
-          feature_elements0.describe_to(self) unless feature_elements.empty?
-        end
-
-        def background(background)
-          @background = background
-        end
-
-        def result
-          @background ? @background : EmptyBackground.new
-        end
-
-        def method_missing(*)
-        end
-      end
-
-      require 'delegate'
-      class LanguageDelegator < SimpleDelegator
-        attr_reader :iso_code
-
-        def initialize(iso_code, obj)
-          super(obj)
-          @iso_code = iso_code
-        end
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/location.rb Deleted

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-require 'forwardable'
-require 'cucumber/core/platform'
-module Cucumber
-  module Core
-    module Ast
-      IncompatibleLocations = Class.new(StandardError)
-
-      module Location
-
-        def self.of_caller(additional_depth = 0)
-          from_file_colon_line(*caller1 + additional_depth)
-        end
-
-        def self.from_file_colon_line(file_colon_line)
-          file, raw_line = file_colon_line.match(/(.*):(\d+)/)1..2
-          from_source_location(file, raw_line.to_i)
-        end
-
-        def self.from_source_location(file, line)
-          file = File.expand_path(file)
-          pwd = File.expand_path(Dir.pwd)
-          pwd.force_encoding(file.encoding)
-          if file.index(pwd)
-            file = filepwd.length+1..-1
-          elsif file =~ /.*\/gems\/(.*\.rb)$/
-            file = $1
-          end
-          new(file, line)
-        end
-
-        def self.new(file, raw_lines=nil)
-          file || raise(ArgumentError, "file is mandatory")
-          if raw_lines
-            Precise.new(file, Lines.new(raw_lines))
-          else
-            Wildcard.new(file)
-          end
-        end
-
-        def self.merge(*locations)
-          locations.reduce do |a, b|
-            a + b
-          end
-        end
-
-        class Wildcard < Struct.new(:file)
-          def to_s
-            file
-          end
-
-          def match?(other)
-            other.file == file
-          end
-
-          def include?(lines)
-            true
-          end
-        end
-
-        class Precise < Struct.new(:file, :lines)
-          def include?(other_lines)
-            lines.include?(other_lines)
-          end
-
-          def line
-            lines.first
-          end
-
-          def match?(other)
-            return false unless other.file == file
-            other.include?(lines)
-          end
-
-          def to_s
-            file, lines.to_s.join(":")
-          end
-
-          def hash
-            self.class.hash ^ to_s.hash
-          end
-
-          def to_str
-            to_s
-          end
-
-          def on_line(new_line)
-            Location.new(file, new_line)
-          end
-
-          def +(other)
-            raise IncompatibleLocations if file != other.file
-            Precise.new(file, lines + other.lines)
-          end
-
-          def inspect
-            "<#{self.class}: #{to_s}>"
-          end
-        end
-
-        require 'set'
-        class Lines < Struct.new(:data)
-          protected :data
-
-          def initialize(raw_data)
-            super Array(raw_data).to_set
-          end
-
-          def first
-            data.first
-          end
-
-          def include?(other)
-            other.data.subset?(data) || data.subset?(other.data)
-          end
-
-          def +(more_lines)
-            new_data = data + more_lines.data
-            self.class.new(new_data)
-          end
-
-          def to_s
-            return first.to_s if data.length == 1
-            return "#{data.min}..#{data.max}" if range?
-            data.to_a.join(":")
-          end
-
-          def inspect
-            "<#{self.class}: #{to_s}>"
-          end
-
-          protected
-
-          def range?
-            data.size == (data.max - data.min + 1)
-          end
-        end
-      end
-
-      module HasLocation
-        def file_colon_line
-          location.to_s
-        end
-
-        def file
-          location.file
-        end
-
-        def line
-          location.line
-        end
-
-        def location
-          raise('Please set @location in the constructor') unless defined?(@location)
-          @location
-        end
-
-        def all_locations
-          @all_locations ||= Location.merge(location + attributes.map { |node| node.all_locations }.flatten)
-        end
-
-        def attributes
-          tags, comments, multiline_arg.flatten
-        end
-
-        def tags
-          # will be overriden by nodes that actually have tags
-          
-        end
-
-        def comments
-          # will be overriden by nodes that actually have comments
-          
-        end
-
-        def multiline_arg
-          # will be overriden by nodes that actually have a multiline_argument
-          EmptyMultilineArgument.new
-        end
-
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/names.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/outline_step.rb Deleted

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/location'
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/step'
-
-module Cucumber
-  module Core
-    module Ast
-
-      class OutlineStep
-        include HasLocation
-        include DescribesItself
-
-        attr_reader :language, :location, :comments, :keyword, :text, :multiline_arg
-
-        def initialize(language, location, comments, keyword, text, multiline_arg)
-          @language, @location, @comments, @keyword, @text, @multiline_arg = language, location, comments, keyword, text, multiline_arg
-        end
-
-        def to_step(row)
-          Ast::ExpandedOutlineStep.new(self, language, row.location, comments, keyword, row.expand(text), replace_multiline_arg(row))
-        end
-
-        def to_s
-          text
-        end
-
-        def inspect
-          keyword_and_text = keyword, text.join(": ")
-          %{#<#{self.class} "#{keyword_and_text}" (#{location})>}
-        end
-
-        private
-
-        def description_for_visitors
-          :outline_step
-        end
-
-        def children
-          # TODO remove duplication with Step
-          # TODO spec
-          @multiline_arg
-        end
-
-        def replace_multiline_arg(example_row)
-          return unless multiline_arg
-          multiline_arg.map { |cell| example_row.expand(cell) }
-        end
-      end
-
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/scenario.rb Deleted

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/names'
-require 'cucumber/core/ast/empty_background'
-require 'cucumber/core/ast/location'
-
-module Cucumber
-  module Core
-    module Ast
-      class Scenario
-        include Names
-        include HasLocation
-        include DescribesItself
-
-        attr_reader :location, :background,
-                    :comments, :tags, :keyword,
-                    :description, :raw_steps
-        private :raw_steps
-
-        def initialize(location, comments, tags, keyword, name, description, steps)
-          @location          = location
-          @comments          = comments
-          @tags              = tags
-          @keyword           = keyword
-          @name              = name
-          @description       = description
-          @raw_steps         = steps
-        end
-
-        def children
-          raw_steps
-        end
-
-        private
-
-        def description_for_visitors
-          :scenario
-        end
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/scenario_outline.rb Deleted

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/names'
-require 'cucumber/core/ast/location'
-require 'cucumber/core/ast/describes_itself'
-
-module Cucumber
-  module Core
-    module Ast
-      class ScenarioOutline
-        include Names
-        include HasLocation
-        include DescribesItself
-
-        MissingExamples = Class.new(StandardError)
-
-        attr_reader :comments, :tags, :keyword,
-                    :steps, :examples_tables, :line
-        private :line
-
-        def initialize(location, comments, tags, keyword, name, description, steps, examples)
-          @location          = location
-          @comments          = comments
-          @tags              = tags
-          @keyword           = keyword
-          @name              = name
-          @description       = description
-          @steps             = steps
-          @examples_tables   = examples
-        end
-
-        private
-
-        def children
-          @steps + @examples_tables
-        end
-
-        def description_for_visitors
-          :scenario_outline
-        end
-
-      end
-
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/step.rb Deleted

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/location'
-
-module Cucumber
-  module Core
-    module Ast
-      class Step
-        include HasLocation
-        include DescribesItself
-
-        attr_reader :keyword, :text, :language, :comments, :exception, :multiline_arg
-
-        def initialize(language, location, comments, keyword, text, multiline_arg)
-          @language, @location, @comments, @keyword, @text, @multiline_arg = language, location, comments, keyword, text, multiline_arg
-        end
-
-        def to_s
-          text
-        end
-
-        def backtrace_line
-          "#{location}:in `#{keyword}#{text}'"
-        end
-
-        def actual_keyword(previous_step_keyword = nil)
-          if language.and_keywords, language.but_keywords.flatten.uniq.include? keyword
-            if previous_step_keyword.nil?
-              language.given_keywords.reject{|kw| kw == '* '}0
-            else
-              previous_step_keyword
-            end
-          else
-            keyword
-          end
-        end
-
-        def original_location
-          location
-        end
-
-        def inspect
-          keyword_and_text = keyword, text.join(": ")
-          %{#<#{self.class} "#{keyword_and_text}" (#{location})>}
-        end
-
-
-        private
-
-        def children
-          @multiline_arg
-        end
-
-        def description_for_visitors
-          :step
-        end
-      end
-
-      class ExpandedOutlineStep < Step
-
-        def initialize(outline_step, language, location, comments, keyword, text, multiline_arg)
-          @outline_step, @language, @location, @comments, @keyword, @text, @multiline_arg = outline_step, language, location, comments, keyword, text, multiline_arg
-        end
-
-        def all_locations
-          @outline_step.all_locations
-        end
-
-        def original_location
-          @outline_step.location
-        end
-
-        alias :step_backtrace_line :backtrace_line
-
-        def backtrace_line
-          "#{step_backtrace_line}\n" +
-          "#{@outline_step.location}:in `#{@outline_step.keyword}#{@outline_step.text}'"
-        end
-
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/ast/tag.rb Deleted

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/gherkin/ast_builder.rb Deleted

@@ -1,403 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast'
-require 'cucumber/core/platform'
-
-module Cucumber
-  module Core
-    module Gherkin
-      # Builds an AST of a feature by listening to events from the
-      # Gherkin parser.
-      class AstBuilder
-
-        def initialize(uri)
-          @uri = uri
-        end
-
-        def feature(attributes)
-          DocumentBuilder.new(file, attributes).feature
-        end
-
-        private
-
-        def file
-          @uri
-        end
-
-        class Builder
-          attr_reader :file, :attributes, :comments, :line
-          private     :file, :attributes, :comments, :line
-
-          def initialize(file, attributes)
-            @file = file
-            @attributes = rubify_keys(attributes.dup)
-            @comments = 
-            @line = @attributes:location:line
-          end
-
-          def handle_comments(comments)
-            remaining_comments = 
-            comments.each do |comment|
-              if line > comment.location.line
-                @comments << comment
-              else
-                remaining_comments << comment
-              end
-            end
-            children.each { |child| remaining_comments = child.handle_comments(remaining_comments) }
-            remaining_comments
-          end
-
-          private
-
-          def keyword
-            attributes:keyword
-          end
-
-          def name
-            attributes:name
-          end
-
-          def description
-            attributes:description ||= ""
-          end
-
-          def tags
-            attributes:tags.map do |tag|
-              Ast::Tag.new(
-                Ast::Location.new(file, tag:location:line),
-                tag:name)
-            end
-          end
-
-          def location
-            Ast::Location.new(file, attributes:location:line)
-          end
-
-          def children
-            
-          end
-
-          def rubify_keys(hash)
-            hash.keys.each do |key|
-              if key.downcase != key
-                hashunderscore(key).to_sym = hash.delete(key)
-              end
-            end
-            return hash
-          end
-
-          def underscore(string)
-            string.to_s.gsub(/::/, '/').
-              gsub(/(A-Z+)(A-Za-z)/,'\1_\2').
-              gsub(/(a-z\d)(A-Z)/,'\1_\2').
-              tr("-", "_").
-              downcase
-          end
-        end
-
-        class DocumentBuilder < Builder
-          def initialize(file, attributes)
-            @file = file
-            @attributes = rubify_keys(attributes.dup)
-          end
-
-          def feature
-            return Ast::NullFeature.new unless attributes:feature
-            feature_builder = FeatureBuilder.new(file, attributes:feature)
-            feature_builder.handle_comments(all_comments)
-            feature_builder.result
-          end
-
-          def all_comments
-            attributes:comments.map do |comment|
-              Ast::Comment.new(
-                Ast::Location.new(file, comment:location:line),
-                comment:text
-              )
-            end
-          end
-        end
-
-        class FeatureBuilder < Builder
-          attr_reader :language, :feature_element_builders
-
-          def initialize(*)
-            super
-            @language = Ast::LanguageDelegator.new(attributes:language, ::Gherkin::Dialect.for(attributes:language))
-            @feature_element_builders = attributes:children.map do |child|
-              case child:type
-              when :Background
-                BackgroundBuilder.new(file, child)
-              when :Scenario
-                ScenarioBuilder.new(file, child)
-              else 
-                ScenarioOutlineBuilder.new(file, child)
-              end
-            end
-          end
-
-          def result
-            Ast::Feature.new(
-              language,
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              feature_elements
-            )
-          end
-
-          private
-
-          def feature_elements
-            feature_element_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            feature_element_builders
-          end
-        end
-
-        class BackgroundBuilder < Builder
-          attr_reader :step_builders
-
-          def initialize(*)
-            super
-            @step_builders = attributes:steps.map { |step| StepBuilder.new(file, step) }
-          end
-
-          def result(language)
-            Ast::Background.new(
-              location,
-              comments,
-              keyword,
-              name,
-              description,
-              steps(language)
-            )
-          end
-
-          def steps(language)
-            step_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            step_builders
-          end
-        end
-
-        class ScenarioBuilder < Builder
-          attr_reader :step_builders
-
-          def initialize(*)
-            super
-            @step_builders = attributes:steps.map { |step| StepBuilder.new(file, step) }
-          end
-
-          def result(language)
-            Ast::Scenario.new(
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              steps(language)
-            )
-          end
-
-          def steps(language)
-            step_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            step_builders
-          end
-        end
-
-        class StepBuilder < Builder
-          attr_reader :multiline_argument_builder
-
-          def initialize(*)
-            super
-            @multiline_argument_builder = attributes:argument ? argument_builder(attributes:argument) : nil
-          end
-
-          def result(language)
-            Ast::Step.new(
-              language,
-              location,
-              comments,
-              keyword,
-              attributes:text,
-              multiline_argument
-            )
-          end
-
-          def multiline_argument
-            return Ast::EmptyMultilineArgument.new unless multiline_argument_builder
-            multiline_argument_builder.result
-          end
-
-          def children
-            return  unless multiline_argument_builder
-            multiline_argument_builder
-          end
-
-          private
-
-          def argument_builder(attributes)
-            attributes:type == :DataTable ? DataTableBuilder.new(file, attributes) : DocStringBuilder.new(file, attributes) 
-          end
-        end
-
-        class OutlineStepBuilder < StepBuilder
-          def result(language)
-            Ast::OutlineStep.new(
-              language,
-              location,
-              comments,
-              keyword,
-              attributes:text,
-              multiline_argument
-            )
-          end
-        end
-
-        class ScenarioOutlineBuilder < Builder
-          attr_reader :step_builders, :example_builders
-
-          def initialize(*)
-            super
-            @step_builders = attributes:steps.map { |step| OutlineStepBuilder.new(file, step) }
-            @example_builders = attributes:examples ? attributes:examples.map { |example| ExamplesTableBuilder.new(file, example) } : 
-          end
-
-          def result(language)
-            Ast::ScenarioOutline.new(
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              steps(language),
-              examples(language)
-            )
-          end
-
-          def steps(language)
-            step_builders.map { |builder| builder.result(language) }
-          end
-
-          def examples(language)
-            example_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            step_builders + example_builders
-          end
-        end
-
-        class ExamplesTableBuilder < Builder
-          attr_reader :header_builder, :example_rows_builders
-
-          def initialize(*)
-            super
-            @header_builder = attributes:table_header ? HeaderBuilder.new(file, attributes:table_header) : NullHeaderBuilder.new
-            @example_rows_builders = attributes:table_body ? attributes:table_body.map { |row_attributes| ExampleRowBuilder.new(file, row_attributes) } : 
-          end
-
-          def result(language)
-            Ast::Examples.new(
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              header,
-              example_rows(language)
-            )
-          end
-
-          private
-
-          def header
-            @header = header_builder.result
-          end
-
-          def example_rows(language)
-            example_rows_builders.each.with_index.map { |builder, index| builder.result(language, header, index) }
-          end
-
-          class HeaderBuilder < Builder
-            def result
-              cells = attributes:cells.map { |c| c:value }
-              Ast::ExamplesTable::Header.new(cells, location, comments)
-            end
-          end
-
-          class NullHeaderBuilder < Builder
-            def initialize
-              @line = -1 # this inhibits Builder#handle_comments to put any comments in this object. 
-            end
-
-            def result
-              nil
-            end
-          end
-
-          def children
-            header_builder + example_rows_builders
-          end
-
-          class ExampleRowBuilder < Builder
-            def result(language, header, index)
-              cells = attributes:cells.map { |c| c:value }
-              header.build_row(cells, index + 1, location, language, comments)
-            end
-          end
-        end
-
-        class DataTableBuilder < Builder
-          def result
-            Ast::DataTable.new(
-              rows,
-              location
-            )
-          end
-
-          def rows
-            attributes:rows = attributes:rows.map { |r| r:cells.map { |c| c:value } }
-          end
-
-          def location
-            first_line = attributes:location:line
-            last_line = first_line + attributes:rows.length - 1
-            Ast::Location.new(file, first_line..last_line)
-          end
-        end
-
-        class DocStringBuilder < Builder
-          def result
-            Ast::DocString.new(
-              attributes:content,
-              attributes:content_type,
-              doc_string_location
-            )
-          end
-
-          def doc_string_location
-            start_line = attributes:location:line
-            end_line = start_line + attributes:content.each_line.to_a.length + 1
-            Ast::Location.new(file, start_line..end_line)
-          end
-        end
-
-      end
-    end
-  end
-end

_service:tar_scm:cucumber-core-3.2.0.gem/data/lib/cucumber/core/gherkin/tag_expression.rb Deleted

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-module Cucumber
-module Core
-module Gherkin
-  class TagExpression
-
-    attr_reader :limits
-
-    def initialize(tag_expressions)
-      @ands = 
-      @limits = {}
-      tag_expressions.each do |expr|
-        add(expr.strip.split(/\s*,\s*/))
-      end
-    end
-
-    def empty?
-      @ands.empty?
-    end
-
-    def evaluate(tags)
-      return true if @ands.flatten.empty?
-      vars = Hash*tags.map{|tag| tag.name, true}.flatten
-      raise "No vars" if vars.nil? # Useless statement to prevent ruby warnings about unused var
-      !!Kernel.eval(ruby_expression)
-    end
-
-  private
-
-    def add(tags_with_negation_and_limits)
-      negatives, positives = tags_with_negation_and_limits.partition{|tag| tag =~ /^~/}
-      @ands << (store_and_extract_limits(negatives, true) + store_and_extract_limits(positives, false))
-    end
-
-    def store_and_extract_limits(tags_with_negation_and_limits, negated)
-      tags_with_negation = 
-      tags_with_negation_and_limits.each do |tag_with_negation_and_limit|
-        tag_with_negation, limit = tag_with_negation_and_limit.split(':')
-        tags_with_negation << tag_with_negation
-        if limit
-          tag_without_negation = negated ? tag_with_negation1..-1 : tag_with_negation
-          if @limitstag_without_negation && @limitstag_without_negation != limit.to_i
-            raise "Inconsistent tag limits for #{tag_without_negation}: #{@limitstag_without_negation} and #{limit.to_i}"
-          end
-          @limitstag_without_negation = limit.to_i
-        end
-      end
-      tags_with_negation
-    end
-
-    def ruby_expression
-      "(" + @ands.map do |ors|
-        ors.map do |tag|
-          if tag =~ /^~(.*)/
-            "!vars'#{$1}'"
-          else
-            "vars'#{tag}'"
-          end
-        end.join("||")
-      end.join(")&&(") + ")"
-    end
-  end
-end
-end
-end

_service:tar_scm:v3.2.0.tar.gz Deleted