CHANGELOG.old.md
NB: This is the legacy changelog. Please consult the new CHANGELOG.md for new updates
BeforeAll and AfterAll hooksInstallPluginAfterConfiguration is deprecated. Please use InstallPlugin or BeforeAll instead.
See the UPGRADING.md to update your code accordingly.
(1570)cucumber-core, cucumber-gherkin and cucumber-messages.negative argument ArgumentError
(1546
1548
Serghei Moret)--no-color, or install
ANSICON globally.
(1561
yosukei3108)--dry-run now supports message based-formatters
(1540
1496
1488
aurelien-reeves)attach can now handle null bytes in the data.
(1536
1529
aurelien-reeves)embed in step definitions in favor of attach.
embed has been deprecated in version 4.0.
Simply replace embed with attach.
(#1523
aurelien-reeves)puts in step definitions in favor of log.
puts has been deprecated in version 4.0.
Simply replace puts with log.
(#1523
aurelien-reeves)fileattribute cli argument available to attach file to junit formatter--publish and no formatter now uses the pretty formatter per default
(#1468
#1500
aurelien-reeves)--publish uses the response provided by the server as the banner #1472CUCUMBER_PUBLISH_TOKEN now sets the correct HTTP header, following a fix in the curl option parser.-X GET in an --out URL will now issue a GET request without a body. If the response is 202 Accepted and
the Location header is present, a new PUT request will be sent with the body.--format=json, embed and puts to version 6.0.0 in deprecation messages--publish automatically publishes reports to reports.cucumber.io--publish-quiet does not print information banner about reports.cucumber.io-q, --quiet will also imply --publish-quiet in addition to --no-snippets --no-source --no-durationdiff-lcs versions 1.3 and 1.4at_exit hook that flushes and closes formatter streams
(#1458)puts on the wrapped stream (#1445)cucumber-create-meta to produce the Meta message before the run.diff-lcs to 1.3 as 1.4 introduced breaking changes.log method can now be called with non-string objects and will run .to_s on them. #1410doc_string instead of string in block params
(#1401
#1402
karamosky)cucumber-ruby-core 7.0.0cucumber-ruby-wire 3.0.0body field of attachments--format html --out report.html.--out URL to POST results to a web server
If a URL is used as output, the output will be sent with a POST request.
This can be overridden by specifying e.g. http-method=PUT as a query parameter.
Other http- prefixed query parameters will be converted to request headers
(with the http- prefix stripped off).messageformatter which produces Cucumber::Messages ndjson output.log and attach can be used in step definitions to attach text or images--format=json in favor of the message formatter and the stand-alone JSON formatterputs in step definitions in favor of log (cucumber#897)embed in step definitions in favor of attach (cucumber#897)load behaviour is now replaced with a newer require behaviourrequire methodCucumber.use_legacy_autoloaderspec_helper.rb or env.rb file is advisedCtrl+c behavior consistent with SIGTERM/kill behavior - now first invocation causes existing scenario to stop running and jump to at_exit, second invocation causes immediate exit. Before that first invocation only instructed Cucumber to exit after scenario and second invocation caused immediate exit skipping at_exit.
(#1353
akostadinov)dots-formatter introduced in4.0.0rc1`Rule keyword. Read more here.dots formatter. This is the first step of a larger strategy to move the formatters to a new architecture where they delegate to shared executables via messages.cucumber-core 3.2.0cucumber-expressions dependency to ~> 6.0.0 (#1299 @aslakhellesoy)gherkin 5.1.0 (#1299 @aslakhellesoy)--fail-fast play nice with --retry (#1283 @yrral86)cucumber -f stepdefs when steps aren't defined. (#1286 @xtrasimplicity)frozen_string_literal is enabled and the Syntax gem is not installed. (#1287 @xtrasimplicity)cucumber-expressions 5.0.4cucumber-tag_expressions 1.1.0gherkin 5.0.0--retry option in profiles (#1050 @brasmusson)ParameterType can now override use_for_snippets and prefer_for_regexp_match without throwing an error. (@aslakhellesoy)required_ruby_version = '>= 2.1' (@aslakhellesoy)(\d+) are automatically converted to IntegerStep#name to #text (#1130 @olleolleolle)Transform has been removed and replaced with ParameterType. See upgrading instructions. (#1190 @aslakhellesoy)chdir issues. (#1111 @akostadinov)--guess (#1132, #1113 @MadameSheema, @enkessler, @brasmusson)Brought the event bus code back into Cucumber to avoid https://github.com/fedux-org/event-bus/issues/6
Better deprecation warnings to help fix https://github.com/cucumber/cucumber-ruby/issues/942
Although this release is only bugfixes and refactorings, the extraction of the wire protocol is quite a significant change and could cause breaking changes for users of undocumented APIs. Hence the minor version bump.
#puts (#918 #915 @enkessler @brasmusson)### Bugfixes
Cucumber::Cli::Configuration to Cucumber::Configuration (@tooky, @mattwynne)--no-duration flag on command-line (#822 @richarda)cucumber --i18n <invalid_language> breaks (#869 (@danascheider)### Refactoring
--init command (818 @olleolleolle)--init command (699 @LGordon2)require Forwardable (@tooky)--dotcucumber option is no longer supported and stepdefs.json is no longer written. (Aslak Hellesøy)### Bugfixes
#source_tag_names method to TestCase object passed to hooks (@mattwynne)Version 2.0 contains a major internal redesign, extracting the core logic of parsing and executing tests into a separate gem.
Although we've tried to keep the API and behaviour consistent through this change,
there are bound to be differences our tests haven't picked up. We're still working through
a backlog of scenarios that are not yet passing. Run cucumber -p wip to see them
all.
--order randomdup it first. (Aslak Hellesøy)--expand option (710 @brasmusson)Ast::Table#map_column for non-mutating column mapping (@tooky)Ast::Table (@tooky)Fixed incorrect html formatter behaviour when background step fails (520, 521 @mlex)
Fixed problem with printing badly formatted backtrace for failed background (522, 523 @mlex)
required Gherkin version bumped to 2.12.1
All mutating methods of AST::Table deprecated (505, 525 @adbatista)
AST::Table#map_headers doesn't use #map_headers! anymore (505 @adbatista)
Cucumber::RUBY_1_8_7
(#492 Matt Wynne)Yanked. See (#428).
source_tag_names. It's not deprecated anymore. (Aslak Hellesøy)file_colon_line to stepdefs.json (outputted by --dotcucumber). (#214 MOROHASHI Kyosuke)Deprecated i18n methods in World, and added a new #step method to use instead. (#68 Matt Wynne)
The JSON formatter output has changed slightly. Old format:
{ features: [feature here] }
New format:
[feature here]
Also see Gherkin 2.6.0 History for info about new id and uri elements in the JSON.
Yipeeeeeeeee!
(0.10.4 was forgotten!)
We're bumping the minor number in this release because there are some incompatible changes in the JSON support. This should not affect users. The major new feature in this release is ANSICON support for Windows users.
Maintenance release for the new release of Gherkin 2.2.3.
Just a quick bugfix release.
Bugfix release which most importantly fixes an issue with the gem's gemspec.
This release is an important milestone for Cucumber. A new parser (the gherkin gem) parses feature files 50-100 times faster than with 0.6.x and previous releases. Make sure you read the upgrade instructions! http://wiki.github.com/aslakhellesoy/cucumber/upgrading
Treetop is gone and replaced with Ragel. The new Ragel parser lives in the gherkin gem. Parse times are up to 100 times faster.
Bumping to 0.6.0 for this release since we're breaking backwards compatibility with tags.
Tag boolean logic is inverted. What was ORed before is now ANDed and vice versa. (#504 Aslak Hellesøy) This makes it more practical in most cases to mix tags from profiles and the command line
In previous versions the following command line:
--tags @foo,~@bar --tags @zap (on the command line)
or the following Hook:
Before("@foo,~@bar", "@zap") (for Hooks)
would be equivalent to the boolean expression: (@foo && !@bar) || @zap Starting with this release it will be equivalent to: (@foo || !@bar) && @zap
Another small release today to please a sister project. This time Cuke4Nuke.
Small bugfix release.
We're bumping to 0.5.0 for this release since all of the Rails code has now moved to a new gem - cucumber-rails. Please see History.txt in cucumber-rails for details about what's new on the Rails side.
What a bad day to make a release, but here goes.
The exciting thing about this release is that the wire protocol is starting to take shape. This means you can now use Cucumber with .NET - writing step definitions in C#. And this is without having to use IronRuby at all! See Cuke4Nuke (http://wiki.github.com/richardlawrence/Cuke4Nuke) for more information.
As usual there are several small features and bug fixes.
Bugfix release. The 0.4.1 release was hosed when switching from Hoe to Jeweler.
This is mostly a bugfix release. Some of Cucumber's own features have been fixed so they pass on more platforms, making it easier for people to contribute. The README.txt also describes how to get up and running with the development environment.
The back to stable release. When we went from 0.3.11 to 0.3.90 we thought we were close to a 0.4.0 release. Then the community went nuts and a lot of great contributions came in. Some of those broke backwards compatibility, and we decided it would be better to do this while still on 0.3.x.
Rails users: youmust run script/generate cucumber after installing this version.
If something breaks for you, please please please read this file carefully. It's most likely something referenced here, and that will give you more information so you can solve any problems. If not, just get in touch on IRC or the Google Group.
This release has some minor changes to the command line and formatters. The biggest change is internally, paving the way for more programming language support in Cuke4Duke, which now supports step definitions written in Java, Scala, Groovy, Clojure and Javascript!
This release gives you back some of the control over the Rails environment that was accidentally taken away from you in the previous release.
Using this release on a Rails project requires a rerun of script/generate cucumber.
This release has some changes in the Rails support, so make sure you run "script/generate cucumber" after you upgrade. Other noteworthy new features are improved Hook, tags and Transform support, and as always - several smaller bug fixes.
Two exciting things in this release. Step Argument Transforms and a PDF formatter you can use to send your features to your customer for review!
The JavaZone release!
Just a small release to help Cuke4Duke, which will be presented at Agile2009 in 2 days.
The AA-FTT release. Creating a release for the AA-FTT meeting in Chicago so that we can play with the new language API and maybe knock out some better .NET support.
This release doesn't have any significant new features or bug fixes, but there are big internal changes. This release has a new API for plugging in other programming languages. You can read more about that here: http://groups.google.com/group/cukes/browse_thread/thread/b9db8bf1f3ec9708
This might break other tools that are using Cucumber's internal APIs. For example Spork broke and had to be patched. Please upgrade to Spork 0.5.9 if you are using Spork.
This release improves Webrat support for table-like HTML markup. Now you can easily turn the HTML elements table, dl, ol and ul elements into a 2D array. This is particularly useful for comparing data in your HTML with a Cucumber table using Cucumber::Ast::Table#diff!
This release also fixes several bugs related to --drb (Spork) and profiles (cucumber.yml)
Kanban take II.
Release 0.3.6 introduced a new --wip switch that can be used to limit work in progress (WIP). Limiting WIP is central for Kanban Software Development (http://www.infoq.com/articles/hiranabe-lean-agile-kanban).
However, this feature went mostly unnoticed, and because we think it's so great we have decided to make it the default for Rails projects. When you bootstrap your Rails project for Cucumber you will now get 2 Cucumber Rake tasks for Kanban development:
cucumber:ok : Run features that should pass. This runs your "good,old" features
cucumber:wip : Run the features you're working on that don't pass yet. Tag them with @wip. Max 2!
So upgrade today and get into the habit of tagging new features with @wip (or invent your own tags). You'll achieve better flow this way.
Highlights in this release: Improved profile handling (cucumber.yml) and a fix for cucumber hanging.
This release has some minor improvements to the new Table.diff! functionality. For example, if you're using Webrat and you want to compare a feature table with a HTML table containing links in one of the columns, you can do:
actual = Cucumber::Ast::Table.new(table_at('table').to_a)
actual.map_column!('Name') { |text| text.strip.match(/>(.*)</)[1] }
table.diff!(actual)
The Hot summer release
This is a hot summer in Norway, and Cucumbers are growing in abundance. To celebrate this we give you a new release with lots of new features and bugfixes. This is also one of the last releases in the 0.3 series (hence the 0.3.90 number), so 0.4 (or maybe 1.0!) will be coming up soon. The highlights of this release are:
English is not the world's most spoken language, so why should Cucumber force non-English speakers to use the --language flag? As of this release you're no longer forced to do that. Instead, you can add a comment header to your .feature files:
# language: fr
# Cucumber understands that this is French
Fonctionnalité: Trou de boulette
If you don't have that header, Cucumber will work as before - using whatever you specified with --language, or default to English if no --language option was specified. A nice side effect of this is that you can now have features in several languages side by side and run them in the same cucumber. (Not recommended unless you want to take polyglot programming to an extreme level).
When you pass a table as an argument to your Then steps you often want to compare that table to some actual values. In previous releases you had to iterate over the table's values and manually compare each row using cell.should equal('foo') or assert_equal('foo', cell). If a discrepancy was found you'd get an error, but it was hard to see how the entire expected data set was different from the actual one.
With this release you have a much more powerful way to compare expected tables with actual data. An Ast::Table object now has a new #diff!(table) method that you can invoke in your step definitions that take table arguments. If the table you pass in is different from the expected table (from your plain text step), Cucumber will print the difference for each of the row or column and fail your step.
The Table#diff! method expects an Array of Array, Array of Hash (similar to what you'd get from table#hashes) or simply another Ast::Table object. Here is a simple example:
Then /^I should see the following cukes:$/ do |expected_cukes_table|
actual_table = ... # For example [['Latin', 'English'], ['Cucumis sativus', 'Cucumber'], ['Cucumis anguria', 'Burr Gherkin']]
expected_cukes_table.diff!(actual_table)
end
As an extra bonus we provide Webrat users with a new #table_at(selector) method that you can use to transform an HTML table into an Array of Array, so that you can easily compare the contents of your HTML table to expected data passed to a step. Here is an example:
Then /^I should see the following cukes:$/ do |expected_cukes_table|
expected_cukes_table.diff!(table_at('#cuke_table').to_a)
end
You can do the same trick to compare data from a Rails ActiveRecord table (although this is not a recommended practice - your Then steps should compare against what userssee, not what's in the database):
# This requires that you use the column names in the header of the plain text expected table
Then /^I should have the following cukes in the database:$/ do |expected_cukes_table|
expected_cukes_table.diff!(Cuke.find(:all).map(&attributes))
end
Another useful new feature is the ability to define environment variables on Cucumber's command line (just like you can with Rake). Example:
cucumber FOO=BAR --format progress features
You can now pick up ENV['FOO'] in ruby (for example in env.rb) and take actions according to the value, for example enabling your super hack that validates all HTTP responses for XHTML validity.
This release also has several bugfixes related to --format and Before/After hooks.
This release just fixes a tiny bug in the formatter to fix an incompatibility with the latest RedMine release. It should have been included in 0.3.10, but was forgotten.
The Spork Release!
This release has an exciting new feature - a new --drb switch! This magic switch lets you run your features much faster than before, because you can eliminate the startup time for your code. This is thanks to a brand new gem called Spork by Tim Harper and Ben Mabey. (You can find out more about Spork here: http://github.com/timcharper/spork/tree/master). You can start Spork and have it preload your application in a separate process. Spork listens for DRb connections, and when you run cucumber with --drb the features will run inside the Spork server instead. Spork provides two simple hooks for preloading your application - one for framework/stable code (Spork.prefork) and one for the code thatyou write and change often (Spork.each_run). Keep in mind that all World, Before, and other Cucumber hooks need to be in the Spork.each_run block. Using Spork works great for Ruby on Rails, which can take a while to load, but --drb and Spork aren't tied to Rails at all. The new --drb switch also works great alongside autotest (just add --drb to your autotest profile in cucumber.yml), so now you can get even faster feedback.
Cucumber's built-in cucumber generator now has a new --spork switch, so when you bootstrap your Rails application for cucumber, you can have spork configuration set up out of the box. (It's just a slightly different env.rb.)
Although Spork was in mind when the --drb switch was added it is important to realize that all that was added to Cucumber was a DRb client. Any DRb server that adheres to this protocol can be used with Cucumber's --drb switch. While Spork is geared towards removing the load time to give you a faster feedback loop you could just as easily use this client with a server that distributes your features to run in parallel. Someone just needs to write such a server. ;)
This release also has some minor bugfixes related to RSpec and Rails interop.
Bugfix release for 0.3.8 released earlier today. 0.3.8 had a bug in the Rails cucumber generator which is fixed in 0.3.9.
This Cucumber version fixes several bugs related to Ruby on Rails and RSpec. If you use Cucumber with a Rails app westrongly recommend you bootstrap Cucumber again:
ruby script/generate cucumber
This is the "Help JetBrains RubyMine" release!
Kanban! With this release you can tag features or scenarios that are work in progress with a tag and use the new --wip switch.
Another handy feature in this release is that you can package your own formatters in RubyGems.
Let's make a new release today because two annoying bugs are fixed.
A couple of great new features in this release. Running with Rake is faster than before, and there is a brand new JUnit formatter - great for Continuous Integration reports!
This release was made especially for the Oslo XP Meetup today.
** IMPORTANT UPGRADE NOTES FOR RAILS USERS**
Running Cucumber features in the same Ruby interpreter as Rake doesn't seem to work, so you have to explicitly tell the task to fork (like it was doing by default in prior versions). In lib/tasks/cucumber.rake:
Cucumber::Rake::Task.new(:features) do |t|
t.fork = true # Explicitly fork
t.cucumber_opts = %w{--format pretty}
end
(If you run script/generate cucumber this will be done for you). Alternatively you can omit forking and run features like this:
RAILS_ENV=test rake cucumber
However, setting the RAILS_ENV is easy to forget, so I don't recommend relying on this.
Minor bugfix release, made specially for EuRuKo!
This release has some minor bug fixes and new features. Nothing major, but we need a release for RailsConf'09 in Las Vegas!
This release has several minor bug fixes and new features. With the addition of Latvian and Hungarian Cucumber now supports 32(!!) languages.
This release has some minor changes to the APIs, but big enough that a new major release is in order. The biggest change is the new semantics of the #World method. Previously you would call this method several times, passing a Proc and extending the world object of the previous one with a Ruby module. The problem was that there was no nice way to ensure the order in which these procs were called, which led to some unexpected situations. In this release you can only register a single World proc. If you want to extend a world with certain modules, you simply call the #World method with the module(s) you wish to extend the World with. The Sinatra example illustrates how to do this. Also check out the RDoc for Cucumber::StepMother#World.
The Visitor API (which is used for formatters) has also changed slightly. However, we have tried to do this in a backwards compatible way, so if you have custom formatters for Cucumber 0.2 they should still work.
One of the most significant new features is Tagged Hooks: http://wiki.github.com/aslakhellesoy/cucumber/hooks This lets you associate Before and After blocks with specific scenarios.
We are also deprecating the step_list, step_pattern, feature_list, and feature_pattern accessors on Cucumber::Rake::Task. These accessors will be completely removed in version 0.4. For complex settings please rely on cucumber profiles in your rake tasks: http://wiki.github.com/aslakhellesoy/cucumber/using-rake#profiles
This release sports 4 updated languages, slightly better help with snippets if you "quote" arguments in your steps. Windows/JRuby users can enjoy colours and you get some more sugar with Tables.
This release includes some minor changes to make Cucumber work with pure Java. Cucumber has already worked with Java for a while (using JRuby and step definitions in Ruby), but now you can write step definitions in pure Java!
Check out the Cucumber Java project for more details: http://github.com/aslakhellesoy/cucumber_java/tree/master
This release fixes a few minor bugs and adds a couple of new features.
This release sports a bunch of new and exciting features, as well a major rewrite of Cucumber's internals. The rewrite was done to address technical debt and to have a code base that is easier to evolve and maintain.
There are some changes to the Gherkin language that breaks backwards compatible with the 0.1.x series. Most importantly, "GivenScenario" and "More Examples" no longer exist. See the "Removed features" section below for more details on how to use alternatives.
Since the grammar has changed, there are some new keywords. We have to rely on the community to provide updated translations. This is much easier than before - just update languages.yml. There is no static code generation anymore. To list all languages:
cucumber --lang help
And to list the keywords for a particular language:
cucumber --lang en-lol help
There are some really awesome new features in this release: Tagging, Autoformatting, automatic aliasing of keywords in all languages, full Ruby 1.9 support and improved output for multiline arguments are some of the highlights.
Bugfix release.
IMPORTANT NOTE FOR RAILS USERS. The template used to generate your features/support/env.rb has changed. You have to apply a minor change manually for existing Rails projects when you upgrade to this version. Change this:
require 'webrat/rspec-rails'
to this:
require 'webrat/core/matchers'
== Bugfixes
This is a small bugfix release. The most notable improvement is compatibility with Webrat 0.4. Rails/Webrat users should upgrade both Cucumber and Webrat gems.
Bugfix release
This is the first release of Cucumber that runs on Ruby 1.9. There are still some encoding-related issues with Arabic (ar), Japanese (ja) and Simplified Chinese (zh-CN). Patches are welcome. Other than that - a couple of minor bug fixes and polishing.
It's time for some new features again. Output is now much better since you can use diffing, tweak the output colours and get the full --backtrace if you want. Managing your support/* files became a little easier since they are now always loaded before the step definitions. Life became easier for Windows users in Norway (and other countries using unicode in the features). Plus several other bug fixes.
Enjoy!
This is the "getting serious with IronRuby release" - largely based on "Patrick Gannon":http://www.patrickgannon.net/archive/2008/10/23/bdd-style-feature-tests-using-ironruby-and-rspeccucumber.aspx's blog entry.
None
Bugfix release with a couple of minor additional features to the command line options.
This release mostly has smaller bugfixes. The most significant new feature is how line numbers are specified. You can now run multiple features at specific lines numbers like this:
cucumber foo.feature:15 bar.feature:6:45:111
This will run foo.feature at line 15 and bar.feature at line 6, 45 and 111.
With this release Cucumber supports 19 (!) natural languages:
Thanks a lot to everyone who has contributed translations. If you don't see your language here, please add it: http://github.com/aslakhellesoy/cucumber/wikis/spoken-languages
Main functional changes in this release is "Autotest":http://github.com/aslakhellesoy/cucumber/wikis/autotest-integration support and how multiline strings work in feature files:
# In your .feature file
Then I should see
"""
A string
that "indents"
and spans
several lines
"""
# In your steps.rb file
Then 'I should see' do |text|
text.should == "A string\n that \"indents\"\nand spans\nseveral lines\n"
end
The triple quotes are used to define the start and end of a string, and it also defines what gets stripped away in the inside string. If the triple quotes are indented 4 spaces, then the text within will have the 4 first spaces removed too.
This release extends the support for tables. PLEASE NOTE THAT TABLES ARE STILL EXPERIMENTAL. In previous releases it has been possible to use tables to define "more examples" of a scenario in a FIT-style column fixture kind of way. Now you can also use tables as arguments to steps.
Tables used to define more examples after a scenario must now be prefixed. In English it looks like this:
Feature: Addition
In order to avoid silly mistakes
As a math idiot
I want to be told the sum of two numbers
Scenario: Add two numbers
Given I have entered 50 into the calculator
And I have entered 70 into the calculator
When I press add
Then the result should be 120 on the screen
More Examples:
| input_1 | input_2 | button | output |
| 20 | 30 | add | 50 |
| 2 | 5 | add | 7 |
| 0 | 40 | add | 40 |
Languages that are not updated yet will have to use "More Examples" until we get the translations.
Tables can also be used as arguments to individual steps. In fact, steps now support a single argument that can span several lines. This can be a table or a string.
Example:
Given the following people exist:
| name | email | phone |
| Aslak | [email protected] | 123 |
| Joe | [email protected] | 234 |
| Bryan | [email protected] | 456 |
When I search for email.com
Then I should see:
| name | email | phone |
| Aslak | [email protected] | 123 |
| Joe | [email protected] | 234 |
And I should see:
"Some text
on several lines"
The step definitions for such multiline steps must define an extra block argument for the argument:
Given /the following people exist:/ do |people_table|
# people_table is of type Cucumber::Model::Table
# See RDoc for more info
end
Then /I should see:/ do |string|
# string is a plain old ruby String with leading spaces on each line removed
end
This release fixes a few bugs and adds some new features. The most notable features are:
Step definitions are a little bit closer to having regular method semantics. You define them, but now you can also call them from other steps. Here is an example:
Given /I am logged in as an (.*) named (.*)$/ do |role, name|
Given "I am registered as #{role}, #{name}, secret"
When "I log in with #{name}, secret"
end
Given /I am registered as (.*), (.*), (.*)/ do |role, name, password|
# (Code removed for brevity)
end
When /I log in with (.*), (.*)/ do |name, password|
# (Code removed for brevity)
end
This means that steps can be reused in other steps. The GivenScenario feature achieves a similar effect (on the scenario level), but this feature is something we're not very happy with, mostly because it's not parameterisable. Calling steps from steps is.
GivenScenario will still be working several releases, but the plan is to remove it completely in the 0.3.0 release.
Prior to this release it could be hard to find out where the ruby step definition matching a plain text step is defined. Not anymore! Cucumber will now output this:
Scenario: Regular numbers
Given I have entered 3 into the calculator # features/steps/calculator_steps.rb:12
And I have entered 2 into the calculator # features/steps/calculator_steps.rb:12
When I press divide # features/steps/calculator_steps.rb:16
Then the result should be 1.5 on the screen # features/steps/calculator_steps.rb:20
And the result class should be Float # features/steps/calculator_steps.rb:24
First gem release!