aslakhellesoy-cucumber 0.3.11.6 → 0.3.11.200907091518

data/History.txt

@@ -1,12 +1,18 @@
 == 0.3.12 (In Git)
 
-The Egality release
+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 some hot new features:
+
+=== Egality
 
 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,
@@ -14,6 +20,40 @@ or default to English if no --language option was specified. A nice side effect
 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).
 
+=== Table diffing
+
+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 and then you were done.
+
+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.
+
+As an extra bonus we provide you with a new Webrat method that you can use to transform the data from
+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:
+
+  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 users *see*, 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), :coldiff => false) # Don't care about extra columns
+  end
+
+=== Environment variables
+
 Another useful new feature is the ability to define environment variables on Cucumber's command line (just
 like you can with Rake). Example:
 
@@ -25,6 +65,8 @@ for example enabling your super hack that validates all HTTP responses for XHTML
 This release also has several bugfixes related to --format and Before/Adter hooks.
 
 === Bugfixes
+* Make it possible to write non-localized step definitions (#377 Aslak Hellesøy)
+* Table cells containing unicode are rendered incorrectly (#386 Stefan Kanev)
 * Before and After hooks run after everything is finished whn there are 2+ --format options (#371 Aslak Hellesøy)
 * When using --out and two --format the first is not delivered inline with execution of features (#361 Aslak Hellesøy)
 * Profile Formatter broken (#370 Aslak Hellesøy)
@@ -33,15 +75,21 @@ This release also has several bugfixes related to --format and Before/Adter hook
 * rake gems no longer lists cucumber as a [F]ramework gem (David Chelimsky)
 * CLI issues correct exit code when using --drb. Requires Spork version >= 0.5.1. (#355 Ben Mabey)
 * Make sure script/generate cucumber --spork uses the cucumber Rails environment (Philippe Lafoucrière)
+* Fixed bug with rake task raising errors with feature files with spaces (#380 Joseph Wilk)
 
 === New Features
+* Access to scenario outline name from After hook scenario parameter (#342 Aslak Hellesøy)
+* Allow multiple --tags switches to be passed 
+* Load step definitions from vendored gems and plugins (#388 Mike Burns)
 * New --format steps formatter. Variant of the usage formatter that lists available step definitions (Demetrius Nunes)
 * Possibility to specify scenario language as part of the .feature file (#345 Aslak Hellesøy)
 * Support specifying environment variables using foo=bar syntax on command line or in profiles (#362 Bryan Helmkamp)
 * Display failing scenarios at the end of pretty format to make it easier for people to play them back (#360 Ryan Bigg)
 
 === Changed Features
+* With --tags, positive tags are &&'ed while negative tags are ||'ed (John Wilger)
 * The data returned from Table#hashes and similar methods are frozen. Dup if you need to modify. (Aslak Hellesøy)
+* Visitor.visit_table_cell_value(value, col_width, status) is now visitor.visit_table_cell_value(value, status)
 
 == 0.3.11 2009-06-05
 

data/Manifest.txt

@@ -239,6 +239,7 @@ examples/tickets/features/step_definitons/246_steps.rb
 examples/tickets/features/step_definitons/248_steps.rb
 examples/tickets/features/step_definitons/scenario_outline_steps.rb
 examples/tickets/features/step_definitons/tickets_steps.rb
+examples/tickets/features/table_diffing.feature
 examples/tickets/features/tickets.feature
 examples/watir/README.textile
 examples/watir/Rakefile
@@ -268,6 +269,7 @@ features/step_definitions/cucumber_steps.rb
 features/step_definitions/extra_steps.rb
 features/steps_formatter.feature
 features/support/env.rb
+features/table_diffing.feature
 features/usage.feature
 features/work_in_progress.feature
 gem_tasks/deployment.rake
@@ -349,6 +351,7 @@ lib/cucumber/step_definition.rb
 lib/cucumber/step_match.rb
 lib/cucumber/step_mother.rb
 lib/cucumber/version.rb
+lib/cucumber/webrat/table_locator.rb
 lib/cucumber/world.rb
 rails_generators/cucumber/USAGE
 rails_generators/cucumber/cucumber_generator.rb

data/examples/i18n/no/features/step_definitons/kalkulator_steps.rb

@@ -4,7 +4,7 @@ Before do
   @calc = Kalkulator.new
 end
 
-Gitt /at jeg har tastet inn (\d+)/ do |n|
+Given /at jeg har tastet inn (\d+)/ do |n|
   @calc.push n.to_i
 end
 

data/examples/self_test/features/support/env.rb

@@ -1,4 +1,5 @@
 require 'spec/expectations'
+$KCODE = 'u' unless Cucumber::RUBY_1_9
 
 Before('@not_used') do
   raise "Should never run"
@@ -14,4 +15,4 @@ end
 
 After('@background_tagged_before_on_outline') do
   @cukes.should == '888'
-end
+end

data/examples/steps_library/features/step_definitions/steps_lib1.rb

@@ -0,0 +1,8 @@
+Given /^I defined a first step$/ do
+end
+
+When /^I define a second step$/ do
+end
+
+Then /^I should also have a third step$/ do
+end

data/examples/steps_library/features/step_definitions/steps_lib2.rb

@@ -0,0 +1,8 @@
+Given /^I defined a step 4$/ do
+end
+
+When /^I create a step 5$/ do
+end
+
+Then /^I should be too tired for step 6$/ do
+end

data/examples/tickets/features/step_definitons/tickets_steps.rb

@@ -64,3 +64,18 @@ end
 Then /^I should get a no method error for 'backtrace_line'$/ do
   pending
 end
+
+Then /the table should be different with table:/ do |expected|
+  expected.diff!(table(%{
+    | b     | c    | a     | d |
+    | KASHA | AIIT | BOOYA | X |
+    | four  | five | three | Y |
+  }), :coldiff => true)
+end
+
+Then /the table should be different with array:/ do |expected|
+  expected.diff!([
+    {'a' => 'BOOYA', 'b' => 'KASHA'},
+    {'a' => 'three', 'b' => 'four'},
+  ])
+end

data/features/html_formatter/a.html

@@ -142,7 +142,7 @@ features/background/failing_background_after_success.feature:5:in `And '10' glob
   I sleep all night and I test all day</pre></li></ol></div></div><div class="feature"><h2><span class="val">Feature: Passing background sample</span></h2><p class="narrative"></p><div class="background"><h3><span class="keyword">Background:</span> <span class="val"></span></h3><ol><li class="step passed" id="features_background_passing_background_feature_4"><div><span class="keyword">Given</span> <span class="step val">'<span class="param">10</span>' cukes</span></div></li></ol></div><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">passing background</span></h3><ol><li class="step passed" id="features_background_passing_background_feature_7"><div><span class="keyword">Then</span> <span class="step val">I should have '<span class="param">10</span>' cukes</span></div></li></ol></div><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">another passing background</span></h3><ol><li class="step passed" id="features_background_passing_background_feature_10"><div><span class="keyword">Then</span> <span class="step val">I should have '<span class="param">10</span>' cukes</span></div></li></ol></div></div><div class="feature"><h2><span class="val">Feature: Pending background sample</span></h2><p class="narrative"></p><div class="background"><h3><span class="keyword">Background:</span> <span class="val"></span></h3><ol><li class="step undefined" id="features_background_pending_background_feature_4"><div><span class="keyword">Given</span> <span class="step val">pending</span></div></li></ol></div><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">pending background</span></h3><ol><li class="step skipped" id="features_background_pending_background_feature_7"><div><span class="keyword">Then</span> <span class="step val">I should have '<span class="param">10</span>' cukes</span></div></li></ol></div><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">another pending background</span></h3><ol><li class="step skipped" id="features_background_pending_background_feature_10"><div><span class="keyword">Then</span> <span class="step val">I should have '<span class="param">10</span>' cukes</span></div></li></ol></div></div><div class="feature"><h2><span class="val">Feature: Failing background with scenario outlines sample</span></h2><p class="narrative"></p><div class="background"><h3><span class="keyword">Background:</span> <span class="val"></span></h3><ol><li class="step failed" id="features_background_scenario_outline_failing_background_feature_4"><div><span class="keyword">Given</span> <span class="step val">failing without a table</span></div><pre class="failed">FAIL (RuntimeError)
 ./features/step_definitions/sample_steps.rb:2:in `flunker'
 ./features/step_definitions/sample_steps.rb:16:in `/^failing without a table$/'
-features/background/scenario_outline_failing_background.feature:4:in `Given failing without a table'</pre></li></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">failing background</span></h3><ol><li class="step skipped" id="features_background_scenario_outline_failing_background_feature_7"><div><span class="keyword">Then</span> <span class="step val">I should have '&lt;count&gt;' cukes</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_9"><th class="val skipped_param" id="row_9_0">count</th></tr><tr id="row_10"><td class="val skipped" id="row_10_0">10</td></tr><tr><td class="failed" colspan="1"><pre>FAIL (RuntimeError)
+features/background/scenario_outline_failing_background.feature:4:in `Given failing without a table'</pre></li></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">failing background</span></h3><ol><li class="step skipped" id="features_background_scenario_outline_failing_background_feature_7"><div><span class="keyword">Then</span> <span class="step val">I should have '&lt;count&gt;' cukes</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_9"><th class="val skipped_param" id="row_9_0">count</th></tr><tr id="row_10"><td class="val skipped" id="row_10_0">10</td></tr><tr><td colspan="1" class="failed"><pre>FAIL (RuntimeError)
 ./features/step_definitions/sample_steps.rb:2:in `flunker'
 ./features/step_definitions/sample_steps.rb:16:in `/^failing without a table$/'
 features/background/scenario_outline_failing_background.feature:4:in `Given failing without a table'</pre></td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">another failing background</span></h3><ol><li class="step skipped" id="features_background_scenario_outline_failing_background_feature_13"><div><span class="keyword">Then</span> <span class="step val">I should have '&lt;count&gt;' cukes</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_15"><th class="val skipped_param" id="row_15_0">count</th></tr><tr id="row_16"><td class="val skipped" id="row_16_0">10</td></tr></table></div></div></div><div class="feature"><h2><span class="val">Feature: Passing background with scenario outlines sample</span></h2><p class="narrative"></p><div class="background"><h3><span class="keyword">Background:</span> <span class="val"></span></h3><ol><li class="step passed" id="features_background_scenario_outline_passing_background_feature_4"><div><span class="keyword">Given</span> <span class="step val">'<span class="param">10</span>' cukes</span></div></li></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">passing background</span></h3><ol><li class="step skipped" id="features_background_scenario_outline_passing_background_feature_7"><div><span class="keyword">Then</span> <span class="step val">I should have '&lt;count&gt;' cukes</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_9"><th class="val skipped_param" id="row_9_0">count</th></tr><tr id="row_10"><td class="val passed" id="row_10_0">10</td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">another passing background</span></h3><ol><li class="step skipped" id="features_background_scenario_outline_passing_background_feature_13"><div><span class="keyword">Then</span> <span class="step val">I should have '&lt;count&gt;' cukes</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_15"><th class="val skipped_param" id="row_15_0">count</th></tr><tr id="row_16"><td class="val passed" id="row_16_0">10</td></tr></table></div></div></div><div class="feature"><h2><span class="val">Feature: Calling undefined step</span></h2><p class="narrative"></p><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">Call directly</span></h3><ol><li class="step undefined" id="features_call_undefined_step_from_step_def_feature_4"><div><span class="keyword">Given</span> <span class="step val">a step definition that calls an undefined step</span></div><pre class="undefined">Undefined step: "this does not exist" (Cucumber::Undefined)
@@ -165,7 +165,7 @@ yawn</span></h3><ol><li class="step passed" id="features_multiline_name_feature_
 which goes on and on and on for three lines
 yawn</span></h3><ol><li class="step skipped" id="features_multiline_name_feature_16"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_18"><th class="val skipped_param" id="row_18_0">state</th></tr><tr id="row_19"><td class="val passed" id="row_19_0">passing</td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">name</span></h3><ol><li class="step skipped" id="features_multiline_name_feature_22"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">I'm a multiline name
 which goes on and on and on for three lines
-yawn</span></h4><table><tr id="row_26"><th class="val skipped_param" id="row_26_0">state</th></tr><tr id="row_27"><td class="val passed" id="row_27_0">passing</td></tr></table></div></div></div><div class="feature"><h2><span class="val">Feature: Outline Sample</span></h2><p class="narrative"></p><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">I have no steps</span></h3><ol></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">Test state</span></h3><ol><li class="step skipped" id="features_outline_sample_feature_6"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li><li class="step skipped" id="features_outline_sample_feature_7"><div><span class="keyword">Given</span> <span class="step val">&lt;other_state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Rainbow colours</span></h4><table><tr id="row_9"><th class="val skipped_param" id="row_9_0">state</th><th class="val skipped_param" id="row_9_1">other_state</th></tr><tr id="row_10"><td class="val undefined" id="row_10_0">missing</td><td class="val skipped" id="row_10_1">passing</td></tr><tr id="row_11"><td class="val passed" id="row_11_0">passing</td><td class="val passed" id="row_11_1">passing</td></tr><tr id="row_12"><td class="val failed" id="row_12_0">failing</td><td class="val skipped" id="row_12_1">passing</td></tr><tr><td class="failed" colspan="2"><pre>FAIL (RuntimeError)
+yawn</span></h4><table><tr id="row_26"><th class="val skipped_param" id="row_26_0">state</th></tr><tr id="row_27"><td class="val passed" id="row_27_0">passing</td></tr></table></div></div></div><div class="feature"><h2><span class="val">Feature: Outline Sample</span></h2><p class="narrative"></p><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">I have no steps</span></h3><ol></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">Test state</span></h3><ol><li class="step skipped" id="features_outline_sample_feature_6"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li><li class="step skipped" id="features_outline_sample_feature_7"><div><span class="keyword">Given</span> <span class="step val">&lt;other_state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Rainbow colours</span></h4><table><tr id="row_9"><th class="val skipped_param" id="row_9_0">state</th><th class="val skipped_param" id="row_9_1">other_state</th></tr><tr id="row_10"><td class="val undefined" id="row_10_0">missing</td><td class="val skipped" id="row_10_1">passing</td></tr><tr id="row_11"><td class="val passed" id="row_11_0">passing</td><td class="val passed" id="row_11_1">passing</td></tr><tr id="row_12"><td class="val failed" id="row_12_0">failing</td><td class="val skipped" id="row_12_1">passing</td></tr><tr><td colspan="2" class="failed"><pre>FAIL (RuntimeError)
 ./features/step_definitions/sample_steps.rb:2:in `flunker'
 ./features/step_definitions/sample_steps.rb:16:in `/^failing without a table$/'
 features/outline_sample.feature:6:in `Given <state> without a table'</pre></td></tr></table></div><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Only passing</span></h4><table><tr id="row_14"><th class="val skipped_param" id="row_14_0">state</th><th class="val skipped_param" id="row_14_1">other_state</th></tr><tr id="row_15"><td class="val passed" id="row_15_0">passing</td><td class="val passed" id="row_15_1">passing</td></tr></table></div></div></div><div class="feature"><pre class="comment"># Feature comment<br/></pre><span class="tag">@one</span><h2><span class="val">Feature: Sample</span></h2><p class="narrative"></p><div class="scenario"><span class="tag">@two</span><span class="tag">@three</span><h3><span class="keyword">Scenario:</span> <span class="val">Missing</span></h3><ol><li class="step undefined" id="features_sample_feature_7"><div><span class="keyword">Given</span> <span class="step val">missing</span></div></li></ol></div><div class="scenario"><pre class="comment"># Scenario comment<br/></pre><span class="tag">@three</span><h3><span class="keyword">Scenario:</span> <span class="val">Passing</span></h3><ol><li class="step passed" id="features_sample_feature_12"><div><span class="keyword">Given</span> <span class="step val">passing</span></div><table><tr id="row_13"><td class="val" id="row_13_0">a</td><td class="val" id="row_13_1">b</td></tr><tr id="row_14"><td class="val" id="row_14_0">c</td><td class="val" id="row_14_1">d</td></tr></table></li></ol></div><div class="scenario"><span class="tag">@four</span><h3><span class="keyword">Scenario:</span> <span class="val">Failing</span></h3><ol><li class="step failed" id="features_sample_feature_18"><div><span class="keyword">Given</span> <span class="step val">failing</span></div><pre class="val">  hello</pre><pre class="failed">FAIL (RuntimeError)
@@ -174,10 +174,10 @@ features/outline_sample.feature:6:in `Given <state> without a table'</pre></td><
 features/sample.feature:18:in `Given failing'</pre></li></ol></div></div><div class="feature"><h2><span class="val">Feature: search examples</span></h2><p class="narrative"></p><div class="background"><h3><span class="keyword">Background:</span> <span class="val">Hantu Pisang background match</span></h3><ol><li class="step passed" id="features_search_sample_feature_4"><div><span class="keyword">Given</span> <span class="step val">passing without a table</span></div></li></ol></div><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">should match Hantu Pisang</span></h3><ol><li class="step passed" id="features_search_sample_feature_7"><div><span class="keyword">Given</span> <span class="step val">passing without a table</span></div></li></ol></div><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">Ignore me</span></h3><ol><li class="step failed" id="features_search_sample_feature_10"><div><span class="keyword">Given</span> <span class="step val">failing without a table</span></div><pre class="failed">FAIL (RuntimeError)
 ./features/step_definitions/sample_steps.rb:2:in `flunker'
 ./features/step_definitions/sample_steps.rb:16:in `/^failing without a table$/'
-features/search_sample.feature:10:in `Given failing without a table'</pre></li></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">Ignore me</span></h3><ol><li class="step skipped" id="features_search_sample_feature_13"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_15"><th class="val skipped_param" id="row_15_0">state</th></tr><tr id="row_16"><td class="val failed" id="row_16_0">failing</td></tr><tr><td class="failed" colspan="1"><pre>FAIL (RuntimeError)
+features/search_sample.feature:10:in `Given failing without a table'</pre></li></ol></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">Ignore me</span></h3><ol><li class="step skipped" id="features_search_sample_feature_13"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_15"><th class="val skipped_param" id="row_15_0">state</th></tr><tr id="row_16"><td class="val failed" id="row_16_0">failing</td></tr><tr><td colspan="1" class="failed"><pre>FAIL (RuntimeError)
 ./features/step_definitions/sample_steps.rb:2:in `flunker'
 ./features/step_definitions/sample_steps.rb:16:in `/^failing without a table$/'
-features/search_sample.feature:13:in `Given <state> without a table'</pre></td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">Hantu Pisang match</span></h3><ol><li class="step skipped" id="features_search_sample_feature_19"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_21"><th class="val skipped_param" id="row_21_0">state</th></tr><tr id="row_22"><td class="val passed" id="row_22_0">passing</td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">no match in name but in examples</span></h3><ol><li class="step skipped" id="features_search_sample_feature_25"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Hantu Pisang</span></h4><table><tr id="row_27"><th class="val skipped_param" id="row_27_0">state</th></tr><tr id="row_28"><td class="val passed" id="row_28_0">passing</td></tr></table></div><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Ignore me</span></h4><table><tr id="row_31"><th class="val skipped_param" id="row_31_0">state</th></tr><tr id="row_32"><td class="val failed" id="row_32_0">failing</td></tr><tr><td class="failed" colspan="1"><pre>FAIL (RuntimeError)
+features/search_sample.feature:13:in `Given <state> without a table'</pre></td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">Hantu Pisang match</span></h3><ol><li class="step skipped" id="features_search_sample_feature_19"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val"></span></h4><table><tr id="row_21"><th class="val skipped_param" id="row_21_0">state</th></tr><tr id="row_22"><td class="val passed" id="row_22_0">passing</td></tr></table></div></div><div class="scenario outline"><h3><span class="keyword">Scenario Outline:</span> <span class="val">no match in name but in examples</span></h3><ol><li class="step skipped" id="features_search_sample_feature_25"><div><span class="keyword">Given</span> <span class="step val">&lt;state&gt; without a table</span></div></li></ol><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Hantu Pisang</span></h4><table><tr id="row_27"><th class="val skipped_param" id="row_27_0">state</th></tr><tr id="row_28"><td class="val passed" id="row_28_0">passing</td></tr></table></div><div class="examples"><h4><span class="keyword">Examples:</span> <span class="val">Ignore me</span></h4><table><tr id="row_31"><th class="val skipped_param" id="row_31_0">state</th></tr><tr id="row_32"><td class="val failed" id="row_32_0">failing</td></tr><tr><td colspan="1" class="failed"><pre>FAIL (RuntimeError)
 ./features/step_definitions/sample_steps.rb:2:in `flunker'
 ./features/step_definitions/sample_steps.rb:16:in `/^failing without a table$/'
 features/search_sample.feature:25:in `Given <state> without a table'</pre></td></tr></table></div></div></div><div class="feature"><span class="tag">@lots</span><h2><span class="val">Feature: Tons of cukes</span></h2><p class="narrative"></p><div class="scenario"><h3><span class="keyword">Scenario:</span> <span class="val">Lots and lots</span></h3><ol><li class="step passed" id="features_tons_of_cukes_feature_4"><div><span class="keyword">Given</span> <span class="step val">'<span class="param">2</span>' cukes</span></div></li><li class="step failed" id="features_tons_of_cukes_feature_5"><div><span class="keyword">Given</span> <span class="step val">'<span class="param">2</span>' cukes</span></div><pre class="failed">We already have 2 cukes! (RuntimeError)

data/features/rake_task.feature

@@ -148,3 +148,31 @@ Feature: Rake task
       """
         * features/support/dont_require_me.rb
       """
+
+  Scenario: feature files with spaces
+    Given a file named "features/spaces are nasty.feature" with:
+       """
+       Feature: The futures green
+
+         Scenario: Orange
+           Given this is missing
+       """
+    And a file named "Rakefile" with:
+       """
+       $LOAD_PATH.unshift(CUCUMBER_LIB)
+       require 'cucumber/rake/task'
+
+       Cucumber::Rake::Task.new(:features) do |t|
+         t.cucumber_opts = %w{--quiet --no-color}
+       end
+       """
+    When I run rake features
+    Then it should pass
+    And the output should contain
+       """
+       Feature: The futures green
+
+         Scenario: Orange
+           Given this is missing
+
+       """

data/features/steps_formatter.feature

@@ -0,0 +1,25 @@
+Feature: --formatter steps option - Steps Formatter
+  In order to easily see which steps are already defined,
+  specially when using 3rd party steps libraries,
+  Cucumber should show the available steps in a user-friendly format
+
+  Background:
+    Given I am in steps_library
+
+  Scenario: Printing steps
+    When I run cucumber -f steps features
+    Then it should pass with
+    """
+    features/step_definitions/steps_lib1.rb
+      /^I defined a first step$/           # features/step_definitions/steps_lib1.rb:1
+      /^I define a second step$/           # features/step_definitions/steps_lib1.rb:4
+      /^I should also have a third step$/  # features/step_definitions/steps_lib1.rb:7
+    
+    features/step_definitions/steps_lib2.rb
+      /^I defined a step 4$/                # features/step_definitions/steps_lib2.rb:1
+      /^I create a step 5$/                 # features/step_definitions/steps_lib2.rb:4
+      /^I should be too tired for step 6$/  # features/step_definitions/steps_lib2.rb:7
+    
+    6 step definition(s) in 2 source file(s).
+
+    """

data/features/support/env.rb

@@ -70,6 +70,11 @@ class CucumberWorld
     stderr_file.close
     in_current_dir do
       @last_stdout = `#{command} 2> #{stderr_file.path}`
+      mode = Cucumber::RUBY_1_9 ? {:external_encoding=>"UTF-8"} : 'r'
+      IO.popen("#{command} 2> #{stderr_file.path}", mode) do |io|
+        @last_stdout = io.read
+      end
+
       @last_exit_status = $?.exitstatus
     end
     @last_stderr = IO.read(stderr_file.path)

data/lib/cucumber/ast/outline_table.rb

@@ -44,7 +44,8 @@ module Cucumber
       end
 
       class ExampleRow < Cells
-        
+        attr_reader :scenario_outline # https://rspec.lighthouseapp.com/projects/16211/tickets/342
+
         def create_step_invocations!(scenario_outline)
           @scenario_outline = scenario_outline
           @step_invocations = scenario_outline.step_invocations(self)

data/lib/cucumber/ast/py_string.rb

@@ -17,7 +17,6 @@ module Cucumber
     # Note how the indentation from the source is stripped away.
     #
     class PyString
-
       def self.default_arg_name
         "string"
       end

data/lib/cucumber/ast/step.rb

@@ -85,8 +85,11 @@ module Cucumber
       private
 
       def matched_cells(cells)
+        col_index = 0
         cells.select do |cell|
-          delimited = delimited(cell.header_cell.value)
+          header_cell = cell.table.header_cell(col_index)
+          col_index += 1
+          delimited = delimited(header_cell.value)
           @name.index(delimited) || (@multiline_arg && @multiline_arg.has_text?(delimited))
         end
       end

data/lib/cucumber/ast/table.rb

@@ -7,7 +7,9 @@ module Cucumber
     #
     # This gets parsed into a Table holding the values <tt>[['a', 'b'], ['c', 'd']]</tt>
     #
-    class Table      
+    class Table
+      include Enumerable
+      
       NULL_CONVERSIONS = Hash.new(lambda{ |cell_value| cell_value }).freeze
 
       attr_accessor :file
@@ -16,18 +18,19 @@ module Cucumber
         "table"
       end
 
-      def initialize(raw, conversions = NULL_CONVERSIONS.dup)
-        # Verify that it's square
-        raw.transpose
-        @raw = raw
+      def initialize(raw, conversion_procs = NULL_CONVERSIONS.dup)
         @cells_class = Cells
         @cell_class = Cell
-        @conversion_procs = conversions
+
+        # Verify that it's square
+        transposed = raw.transpose
+        create_cell_matrix(raw)
+        @conversion_procs = conversion_procs
       end
 
       # Creates a copy of this table, inheriting the column mappings.
       def dup
-        self.class.new(@raw.dup, @conversion_procs.dup)
+        self.class.new(raw.dup, @conversion_procs.dup)
       end
 
       # Returns a new, transposed table. Example:
@@ -42,7 +45,7 @@ module Cucumber
       # | 4 | 2 |
       #
       def transpose
-        self.class.new(@raw.transpose, @conversion_procs.dup)
+        self.class.new(raw.transpose, @conversion_procs.dup)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -78,8 +81,9 @@ module Cucumber
       # The table must be exactly two columns wide 
       #
       def rows_hash
+        return @rows_hash if @rows_hash
         verify_table_width(2)
-        @rows_hash = self.transpose.hashes[0]
+        @rows_hash = self.transpose.hashes[0].freeze
       end
 
       # Gets the raw data of this table. For example, a Table built from
@@ -88,17 +92,21 @@ module Cucumber
       #   | a | b |
       #   | c | d |
       #
-      # Get converted into the following:
+      # gets converted into the following:
       #
       #   [['a', 'b], ['c', 'd']]
       #
       def raw
-        @raw
+        cell_matrix.map do |row|
+          row.map do |cell|
+            cell.value
+          end
+        end
       end
 
       # Same as #raw, but skips the first (header) row
       def rows
-        @raw[1..-1]
+        raw[1..-1]
       end
 
       def each_cells_row(&proc)
@@ -117,7 +125,7 @@ module Cucumber
         [:table, *cells_rows.map{|row| row.to_sexp}]
       end
 
-      # Returns a new Table where the headers are redefined. This makes it
+      # Redefines the table headers. This makes it
       # possible to use prettier header names in the features. Example:
       #
       #   | Phone Number | Address |
@@ -130,6 +138,18 @@ module Cucumber
       #   hashes = mapped_table.hashes
       #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
       #
+      def map_headers!(mappings)
+        header_cells = cell_matrix[0]
+        mappings.each_pair do |pre, post|
+          header_cell = header_cells.detect{|cell| cell.value == pre}
+          header_cell.value = post
+          if @conversion_procs.has_key?(pre)
+            @conversion_procs[post] = @conversion_procs.delete(pre)
+          end
+        end
+      end
+
+      # Returns a new Table where the headers are redefined. See #map_headers!
       def map_headers(mappings)
         table = self.dup
         table.map_headers!(mappings)
@@ -153,11 +173,110 @@ module Cucumber
         @conversion_procs[column_name] = conversion_proc
       end
 
+      # Compares +other_table+ to self. If +other_table+ contains columns
+      # and/or rows that are not in self, new columns/rows are added at the
+      # relevant positions, marking the cells in those rows/columns as
+      # <tt>surplus</tt>. Likewise, if +other_table+ lacks columns and/or 
+      # rows that are present in self, these are marked as <tt>missing</tt>.
+      #
+      # <tt>surplus</tt> and <tt>missing</tt> cells are recognised by formatters
+      # and displayed so that it's easy to read the differences.
+      #
+      # Cells that are different, but <em>look</em> identical (for example the
+      # boolean true and the string "true") are converted to their Object#inspect
+      # representation and preceded with (i) - to make it easier to identify
+      # where the difference actually is.
+      #
+      # Since all tables that are passed to StepDefinitions always have String
+      # objects in their cells, you may want to use #map_column! before calling
+      # #diff!
+      #
+      # An exception is raised if there are missing rows or columns, or
+      # surplus rows. An error is <em>not</em> raised for surplus columns.
+      # Whether to raise or not raise can be changed by setting values in
+      # +options+ to true or false:
+      #
+      #   * <tt>missing_row</tt>: Raise on missing rows (defaults to true)
+      #   * <tt>surplus_row</tt>: Raise on surplus rows (defaults to true)
+      #   * <tt>missing_col</tt>: Raise on missing columns (defaults to true)
+      #   * <tt>surplus_col</tt>: Raise on surplus columns (defaults to false)
+      #
+      # The +other_table+ argument can be another Table, an Array of Array or
+      # an Array of Hash (similar to the structure returned by #hashes).
+      #
+      # Calling this method is particularly useful in <tt>Then</tt> steps that take
+      # a Table argument, if you want to compare that table to some actual values. 
+      #
+      def diff!(other_table, options={})
+        options = {:missing_row => true, :surplus_row => true, :missing_col => true, :surplus_col => false}.merge(options)
+
+        other_table = ensure_table(other_table)
+        ensure_green!
+
+        original_width = cell_matrix[0].length
+        other_table_cell_matrix = pad!(other_table.cell_matrix)
+        padded_width = cell_matrix[0].length
+
+        missing_col = cell_matrix[0].detect{|cell| cell.status == :undefined}
+        surplus_col = padded_width > original_width
+
+        require_diff_lcs
+        cell_matrix.extend(Diff::LCS)
+        convert_columns!
+        changes = cell_matrix.diff(other_table_cell_matrix).flatten
+
+        inserted = 0
+        missing  = 0
+
+        row_indices = Array.new(other_table_cell_matrix.length) {|n| n}
+
+        last_change = nil
+        missing_row_pos = nil
+        insert_row_pos  = nil
+        
+        changes.each do |change|
+          if(change.action == '-')
+            missing_row_pos = change.position + inserted
+            cell_matrix[missing_row_pos].each{|cell| cell.status = :undefined}
+            row_indices.insert(missing_row_pos, nil)
+            missing += 1
+          else # '+'
+            insert_row_pos = change.position + missing
+            inserted_row = change.element
+            inserted_row.each{|cell| cell.status = :comment}
+            cell_matrix.insert(insert_row_pos, inserted_row)
+            row_indices[insert_row_pos] = nil
+            inspect_rows(cell_matrix[missing_row_pos], inserted_row) if last_change && last_change.action == '-'
+            inserted += 1
+          end
+          last_change = change
+        end
+
+        other_table_cell_matrix.each_with_index do |other_row, i|
+          row_index = row_indices.index(i)
+          row = cell_matrix[row_index] if row_index
+          if row
+            (original_width..padded_width).each do |col_index|
+              surplus_cell = other_row[col_index]
+              row[col_index].value = surplus_cell.value if row[col_index]
+            end
+          end
+        end
+        
+        clear_cache!
+        should_raise = 
+          missing_row_pos && options[:missing_row] ||
+          insert_row_pos  && options[:surplus_row] ||
+          missing_col     && options[:missing_col] ||
+          surplus_col     && options[:surplus_col]
+        raise 'Tables were not identical' if should_raise
+      end
+
       def to_hash(cells) #:nodoc:
         hash = Hash.new do |hash, key|
           hash[key.to_s] if key.is_a?(Symbol)
         end
-        @raw[0].each_with_index do |column_name, column_index|
+        raw[0].each_with_index do |column_name, column_index|
           value = @conversion_procs[column_name].call(cells.value(column_index))
           hash[column_name] = value
         end
@@ -169,11 +288,11 @@ module Cucumber
       end
 
       def verify_column(column_name)
-        raise %{The column named "#{column_name}" does not exist} unless @raw[0].include?(column_name)
+        raise %{The column named "#{column_name}" does not exist} unless raw[0].include?(column_name)
       end
       
       def verify_table_width(width)
-        raise %{The table must have exactly #{width} columns} unless @raw[0].size == width
+        raise %{The table must have exactly #{width} columns} unless raw[0].size == width
       end
 
       def arguments_replaced(arguments) #:nodoc:
@@ -198,33 +317,88 @@ module Cucumber
       def cells_rows
         @rows ||= cell_matrix.map do |cell_row|
           @cells_class.new(self, cell_row)
-        end.freeze
+        end
       end
 
       def headers
-        @raw.first
+        raw.first
       end
 
       def header_cell(col)
         cells_rows[0][col]
       end
 
+      def cell_matrix
+        @cell_matrix
+      end
+
+      def col_width(col)
+        columns[col].__send__(:width)
+      end
+
+      def to_s(options = {})
+        options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
+        io = StringIO.new
+
+        c = Term::ANSIColor.coloring?
+        Term::ANSIColor.coloring = options[:color]
+        f = Formatter::Pretty.new(nil, io, options)
+        f.instance_variable_set('@indent', options[:indent])
+        f.visit_multiline_arg(self)
+        Term::ANSIColor.coloring = c
+
+        io.rewind
+        s = "\n" + io.read + (" " * (options[:indent] - 2))
+        s
+      end
+
+      private
+
+      TO_S_PREFIXES = Hash.new('    ')
+      TO_S_PREFIXES[:comment]   = ['(+) ']
+      TO_S_PREFIXES[:undefined] = ['(-) ']
+
       protected
 
-      def map_headers!(mappings)
-        headers = @raw[0]
-        mappings.each_pair do |pre, post|
-          headers[headers.index(pre)] = post
-          if @conversion_procs.has_key?(pre)
-            @conversion_procs[post] = @conversion_procs.delete(pre)
+      def inspect_rows(missing_row, inserted_row)
+        missing_row.each_with_index do |missing_cell, col|
+          inserted_cell = inserted_row[col]
+          if(missing_cell.value != inserted_cell.value && (missing_cell.value.to_s == inserted_cell.value.to_s))
+            missing_cell.inspect!
+            inserted_cell.inspect!
           end
         end
       end
 
-      private
+      def create_cell_matrix(raw)
+        @cell_matrix = raw.map do |raw_row|
+          line = raw_row.line rescue -1
+          raw_row.map do |raw_cell|
+            new_cell(raw_cell, line)
+          end
+        end
+      end
 
-      def col_width(col)
-        columns[col].__send__(:width)
+      def convert_columns!
+        cell_matrix.transpose.each do |col|
+          conversion_proc = @conversion_procs[col[0].value]
+          col[1..-1].each do |cell|
+            cell.value = conversion_proc.call(cell.value)
+          end
+        end
+      end
+
+      def require_diff_lcs
+        begin
+          require 'diff/lcs'
+        rescue LoadError => e
+          e.message << "\n Please gem install diff-lcs\n"
+          raise e
+        end
+      end
+
+      def clear_cache!
+        @hashes = @rows_hash = @rows = @columns = nil
       end
 
       def columns
@@ -233,17 +407,73 @@ module Cucumber
         end.freeze
       end
 
-      def cell_matrix
-        row = -1
-        @cell_matrix ||= @raw.map do |raw_row|
-          line = raw_row.line rescue -1
-          row += 1
-          col = -1
-          raw_row.map do |raw_cell|
-            col += 1
-            @cell_class.new(raw_cell, self, row, col, line)
+      def new_cell(raw_cell, line)
+        @cell_class.new(raw_cell, self, line)
+      end
+
+      # Pads our own cell_matrix and returns a cell matrix of same
+      # column width that can be used for diffing
+      def pad!(other_cell_matrix)
+        clear_cache!
+        cols = cell_matrix.transpose
+        unmapped_cols = other_cell_matrix.transpose
+
+        mapped_cols = []
+
+        cols.each_with_index do |col, col_index|
+          header = col[0]
+          candidate_cols, unmapped_cols = unmapped_cols.partition do |other_col|
+            other_col[0] == header
           end
-        end.freeze
+          raise "More than one column has the header #{header}" if candidate_cols.size > 2
+
+          other_padded_col = if candidate_cols.size == 1
+            # Found a matching column
+            candidate_cols[0]
+          else
+            mark_as_missing(cols[col_index])
+            (0...other_cell_matrix.length).map do |row|
+              val = row == 0 ? header.value : nil
+              SurplusCell.new(val, self, -1)
+            end
+          end
+          mapped_cols.insert(col_index, other_padded_col)
+        end
+
+        unmapped_cols.each_with_index do |col, col_index|
+          empty_col = (0...cell_matrix.length).map do |row| 
+            SurplusCell.new(nil, self, -1)
+          end
+          cols << empty_col
+        end
+
+        @cell_matrix = cols.transpose
+        (mapped_cols + unmapped_cols).transpose
+      end
+
+      def ensure_table(table_or_array)
+        return table_or_array if Table === table_or_array
+        table_or_array = hashes_to_array(table_or_array) if Hash === table_or_array[0]
+        Table.new(table_or_array)
+      end
+
+      def hashes_to_array(hashes)
+        header = hashes[0].keys
+        [header] + hashes.map{|hash| header.map{|key| hash[key]}}
+      end
+
+      def ensure_green!
+        each_cell{|cell| cell.status = :passed}
+      end
+
+      def each_cell(&proc)
+        cell_matrix.each{|row| row.each(&proc)}
+      end
+
+      def mark_as_missing(col)
+        col.each do |cell|
+          cell.status = :undefined
+        end
       end
 
       # Represents a row of cells or columns of cells
@@ -303,30 +533,38 @@ module Cucumber
       end
 
       class Cell
-        attr_reader :value, :line
-        attr_writer :status
+        attr_reader :line, :table
+        attr_accessor :status, :value
 
-        def initialize(value, table, row, col, line)
-          @value, @table, @row, @col, @line = value, table, row, col, line
+        def initialize(value, table, line)
+          @value, @table, @line = value, table, line
         end
 
         def accept(visitor)
-          visitor.visit_table_cell_value(@value, col_width, @status)
+          visitor.visit_table_cell_value(value, status)
+        end
+
+        def inspect!
+          @value = "(i) #{value.inspect}"
         end
 
-        def header_cell
-          @table.header_cell(@col)
+        def ==(o)
+          SurplusCell === o || value == o.value
         end
 
         # For testing only
         def to_sexp #:nodoc:
           [:cell, @value]
         end
+      end
+      
+      class SurplusCell < Cell
+        def status
+          :comment
+        end
 
-        private
-
-        def col_width
-          @col_width ||= @table.__send__(:col_width, @col).freeze
+        def ==(o)
+          true
         end
       end
     end