gherkin 1.0.2 → 1.0.3

data/spec/gherkin/csharp_lexer_spec.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Lexer
+    describe "C# Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Gherkin::Lexer.csharp['en'].new(@listener)
+      end
+
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing py_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+    end
+  end
+end
+end

data/spec/gherkin/fixtures/comments_in_table.feature

@@ -0,0 +1,9 @@
+Feature: x
+
+  Scenario Outline: x
+    Then x is <state>
+
+    Examples:
+      | state |
+      # comment
+      | 1     |

data/spec/gherkin/fixtures/complex.feature

@@ -21,6 +21,7 @@ Feature: Feature Text
 
   @tag3
   Scenario: Reading a second scenario
+    With two lines of text
     #Comment on line 24
     Given a third step with a table
     |a|b|
@@ -39,5 +40,6 @@ Feature: Feature Text
     Given All work and no play
       """
       Makes Homer something something
+      And something else
       """
     Then crazy

data/spec/gherkin/fixtures/dos_line_endings.feature

@@ -0,0 +1,45 @@
+#Comment on line 1
+#Comment on line 2
+@tag1 @tag2
+Feature: Feature Text
+  In order to test multiline forms
+  As a ragel writer
+  I need to check for complex combinations
+
+  #Comment on line 9
+
+  #Comment on line 11
+
+  Background:
+    Given this is a background step
+    And this is another one
+
+  @tag3 @tag4
+  Scenario: Reading a Scenario
+    Given there is a step
+    But not another step
+
+  @tag3
+  Scenario: Reading a second scenario
+    With two lines of text
+    #Comment on line 24
+    Given a third step with a table
+    |a|b|
+    |c|d|
+    |e|f|
+    And I am still testing things
+      |g|h|
+      |e|r|
+      |k|i|
+      |n|| 
+    And I am done testing these tables
+    #Comment on line 29
+    Then I am happy
+
+  Scenario: Hammerzeit
+    Given All work and no play
+      """
+      Makes Homer something something
+      And something else
+      """
+    Then crazy

data/spec/gherkin/fixtures/i18n_fr.feature

@@ -1,3 +1,4 @@
+#language:fr
 Fonctionnalité: Addition
   Plan du scénario: Addition de produits dérivés
     Soit une calculatrice

data/spec/gherkin/fixtures/i18n_no.feature

@@ -1,3 +1,4 @@
+#language:no
 Egenskap: i18n support
 
   Scenario: Parsing many languages

data/spec/gherkin/fixtures/i18n_zh-CN.feature

@@ -1,3 +1,4 @@
+#language:zh-CN
 功能:加法
 
   场景: 两个数相加

data/spec/gherkin/format/argument_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'gherkin/format/argument'
+
+module Gherkin
+  module Format
+    class BracketFormat
+      class << self
+        def new
+          defined?(JRUBY_VERSION) ? ::Java::GherkinFormatter::ArgumentFormat.new("[", "]") : super
+        end
+      end
+
+      def format_argument(s)
+        "[#{s}]"
+      end
+    end
+    
+    describe Argument do
+      it "should replace one arg" do
+        argument_class = defined?(JRUBY_VERSION) ? ::Java::GherkinFormatter::Argument : Argument
+        argument_class.format("I have 10 cukes", BracketFormat.new, [Argument.new(7, '10')]).should == "I have [10] cukes"
+      end
+      
+      # TODO: Add this spec: http://github.com/alg/cucumber/commit/33188e9db51f59ced74c4861524d7b2e69454630
+    end
+  end
+end

data/spec/gherkin/i18n_lexer_spec.rb

@@ -4,19 +4,19 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 module Gherkin
   describe I18nLexer do
     before do
-      @lexer = I18nLexer.new(SexpRecorder.new)
+      @lexer = I18nLexer.new(SexpRecorder.new, false)
     end
 
     it "should store the i18n language of the last scanned feature" do
       @lexer.scan("# language: fr\n")
-      @lexer.language.key.should == "fr"
+      @lexer.i18n_language.should == "fr"
       @lexer.scan("# language: no\n")
-      @lexer.language.key.should == "no"
+      @lexer.i18n_language.should == "no"
     end
 
     it "should use English i18n by default" do
       @lexer.scan("Feature: foo\n")
-      @lexer.language.key.should == "en"
+      @lexer.i18n_language.should == "en"
     end
   end
 end

data/spec/gherkin/i18n_spec.rb

@@ -13,43 +13,51 @@ module Gherkin
       end
 
       it "should recognize keywords in the language of the lexer" do
-        lexer = Gherkin::Lexer['no'].new(@listener)
+        lexer = Gherkin::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_no.feature")
         @listener.to_sexp.should == [
-          [:feature, "Egenskap", "i18n support", 1], 
-          [:scenario, "Scenario", "Parsing many languages", 3], 
-          [:step, "Gitt", "Gherkin supports many languages", 4],
-          [:step, "Når",  "Norwegian keywords are parsed", 5],
-          [:step, "Så", "they should be recognized", 6]
+          [:comment, "#language:no", 1],
+          [:feature, "Egenskap", "i18n support", 2],
+          [:scenario, "Scenario", "Parsing many languages", 4],
+          [:step, "Gitt ", "Gherkin supports many languages", 5],
+          [:step, "Når ",  "Norwegian keywords are parsed", 6],
+          [:step, "Så ", "they should be recognized", 7],
+          [:eof]
         ]
       end
 
       it "should parse languages without a space after keywords" do
-        lexer = Gherkin::Lexer['zh-CN'].new(@listener)
+        lexer = Gherkin::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_zh-CN.feature")
         @listener.to_sexp.should == [
-          [:feature, "功能", "加法", 1],
-          [:scenario, "场景", "两个数相加", 3],
-          [:step, "假如", "我已经在计算器里输入6", 4],
-          [:step, "而且", "我已经在计算器里输入7", 5],
-          [:step, "当", "我按相加按钮", 6],
-          [:step, "那么", "我应该在屏幕上看到的结果是13", 7]
+          [:comment, "#language:zh-CN", 1],
+          [:feature, "功能", "加法", 2],
+          [:scenario, "场景", "两个数相加", 4],
+          [:step, "假如", "我已经在计算器里输入6", 5],
+          [:step, "而且", "我已经在计算器里输入7", 6],
+          [:step, "当", "我按相加按钮", 7],
+          [:step, "那么", "我应该在屏幕上看到的结果是13", 8],
+          [:eof]
         ] 
       end
 
       it "should parse languages with spaces after some keywords but not others" do
-        lexer = Gherkin::Lexer['fr'].new(@listener)
+        lexer = Gherkin::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_fr.feature")
         @listener.to_sexp.should == [
-          [:feature, "Fonctionnalité", "Addition", 1],
-          [:scenario_outline, "Plan du scénario", "Addition de produits dérivés", 2],
-          [:step, "Soit", "une calculatrice", 3],
-          [:step, "Etant donné", "qu'on tape <a>", 4],
-          [:step, "Et", "qu'on tape <b>", 5],
-          [:step, "Lorsqu'", "on tape additionner", 6],
-          [:step, "Alors", "le résultat doit être <somme>", 7],
-          [:examples, "Exemples", "", 9],
-          [:table, [["a","b","somme"],["2","2","4"],["2","3","5"]], 10]
+          [:comment, "#language:fr", 1],
+          [:feature, "Fonctionnalité", "Addition", 2],
+          [:scenario_outline, "Plan du scénario", "Addition de produits dérivés", 3],
+          [:step, "Soit ", "une calculatrice", 4],
+          [:step, "Etant donné ", "qu'on tape <a>", 5],
+          [:step, "Et ", "qu'on tape <b>", 6],
+          [:step, "Lorsqu'", "on tape additionner", 7],
+          [:step, "Alors ", "le résultat doit être <somme>", 8],
+          [:examples, "Exemples", "", 10],
+          [:row, %w{a b somme}, 11],
+          [:row, %w{2 2 4}, 12],
+          [:row, %w{2 3 5}, 13],
+          [:eof]
         ]
       end
     end

data/spec/gherkin/java_lexer_spec.rb

@@ -1,20 +1,21 @@
 #encoding: utf-8
 if defined?(JRUBY_VERSION)
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gherkin.jar'
 
 module Gherkin
   module JavaLexer
     describe "Java Lexer" do
       before do
         @listener = Gherkin::SexpRecorder.new
-        @lexer = Gherkin::Lexer.java['en'].new(@listener)
+        @lexer = Java::Gherkin::I18nLexer.new(@listener)
       end
 
       it_should_behave_like "a Gherkin lexer"
       it_should_behave_like "a Gherkin lexer lexing tags"
       it_should_behave_like "a Gherkin lexer lexing py_strings"
-      it_should_behave_like "a Gherkin lexer lexing tables"
+      it_should_behave_like "a Gherkin lexer lexing rows"
     end
   end
 end
-end
+end

data/spec/gherkin/parser_spec.rb

@@ -19,6 +19,11 @@ module Gherkin
       }.should raise_error(/Parse error on line 12\. Found scenario when expecting one of: comment, feature, tag\. \(Current state: root\)\.$/)
     end
 
+    it "should allow empty files" do
+      @listener.should_receive(:eof)
+      @parser.eof
+    end
+
     it "should delegate an error message when raise on error is false" do
       @listener.should_receive(:syntax_error).with(sym(:root), sym(:background), a([:comment, :feature, :tag]), 1)
       @parser = Parser.new(@listener, false)

data/spec/gherkin/rb_lexer_spec.rb

@@ -1,18 +1,20 @@
 #encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gherkin/rb_lexer'
+require 'gherkin/rb_lexer/en'
 
 module Gherkin
   module Lexer
     describe "Ruby Lexer" do
       before do
         @listener = Gherkin::SexpRecorder.new
-        @lexer = Gherkin::Lexer.rb['en'].new(@listener)
+        @lexer = Gherkin::RbLexer::En.new(@listener)
       end
 
       it_should_behave_like "a Gherkin lexer"
       it_should_behave_like "a Gherkin lexer lexing tags"
       it_should_behave_like "a Gherkin lexer lexing py_strings"
-      it_should_behave_like "a Gherkin lexer lexing tables"
+      it_should_behave_like "a Gherkin lexer lexing rows"
     end
   end
 end

data/spec/gherkin/sexp_recorder.rb

@@ -5,7 +5,7 @@ module Gherkin
     end
 
     def method_missing(m, *args)
-      args[0] = args[0].map{|row| row.map{|cell| cell}} if m == :table
+      args[0] = args[0].map{|cell| cell} if m == :row
       @sexps << [m] + args
     end
 

data/spec/gherkin/shared/lexer_spec.rb

@@ -8,14 +8,18 @@ module Gherkin
       describe "Comments" do
         it "should parse a one line comment" do
           @lexer.scan("# My comment\n")
-          @listener.to_sexp.should == [[:comment, "# My comment", 1]]
+          @listener.to_sexp.should == [
+            [:comment, "# My comment", 1],
+            [:eof]
+          ]
         end
 
         it "should parse a multiline comment" do
           @lexer.scan("# Hello\n\n# World\n")
           @listener.to_sexp.should == [
             [:comment, "# Hello", 1],
-            [:comment, "# World", 3]
+            [:comment, "# World", 3],
+            [:eof]
           ]
         end
 
@@ -24,7 +28,8 @@ module Gherkin
           @listener.to_sexp.should == [
             [:scenario, "Scenario", "test", 1],
             [:comment, "#hello", 2],
-            [:scenario, "Scenario", "another", 3]
+            [:scenario, "Scenario", "another", 3],
+            [:eof]
           ]
         end
 
@@ -33,7 +38,8 @@ module Gherkin
           @listener.to_sexp.should == [
             [:comment, "#", 1],
             [:comment, "# A comment", 2],
-            [:comment, "#", 3]
+            [:comment, "#", 3],
+            [:eof]
           ]
         end
         
@@ -51,7 +57,8 @@ module Gherkin
             [:feature, "Feature", "hi", 1],
             [:scenario, "Scenario", "test", 2],
             [:tag, "hello", 4],
-            [:scenario, "Scenario", "another", 5]
+            [:scenario, "Scenario", "another", 5],
+            [:eof]
           ]
         end  
       end
@@ -61,14 +68,16 @@ module Gherkin
           @lexer.scan("Background:\nGiven I am a step\n")
           @listener.to_sexp.should == [
             [:background, "Background", "", 1],
-            [:step, "Given", "I am a step", 2]
+            [:step, "Given ", "I am a step", 2],
+            [:eof]
           ]
         end
         
         it "should allow multiline names ending at eof" do
           @lexer.scan("Background: I have several\n   Lines to look at\n None starting with Given")
           @listener.to_sexp.should == [
-            [:background, "Background", "I have several\nLines to look at\nNone starting with Given", 1]
+            [:background, "Background", "I have several\nLines to look at\nNone starting with Given", 1],
+            [:eof]
           ]
         end
          
@@ -82,7 +91,8 @@ Given I am a step})
           @listener.to_sexp.should == [
             [:feature, "Feature", "Hi", 1],
             [:background, "Background", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.",2],
-            [:step, "Given", "I am a step", 6]
+            [:step, "Given ", "I am a step", 6],
+            [:eof]
           ]
         end
       end
@@ -91,7 +101,8 @@ Given I am a step})
         it "should be parsed" do
           @lexer.scan("Scenario: Hello\n")
           @listener.to_sexp.should == [
-            [:scenario, "Scenario", "Hello", 1]
+            [:scenario, "Scenario", "Hello", 1],
+            [:eof]
           ]
         end
  
@@ -102,7 +113,8 @@ Given I am a step})
                           })
           @listener.to_sexp.should == [
             [:scenario, "Scenario", "bar", 1],
-            [:step, "Given", "baz", 3]
+            [:step, "Given ", "baz", 3],
+            [:eof]
           ]
         end
         
@@ -115,14 +127,16 @@ Given I am a step})
                           })
           @listener.to_sexp.should == [
             [:scenario, "Scenario", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.", 1],
-            [:step, "Given", "I am a step", 5]
+            [:step, "Given ", "I am a step", 5],
+            [:eof]
           ]
         end
 
         it "should allow multiline names ending at eof" do
           @lexer.scan("Scenario: I have several\n       Lines to look at\n None starting with Given")
           @listener.to_sexp.should == [
-            [:scenario, "Scenario", "I have several\nLines to look at\nNone starting with Given", 1]
+            [:scenario, "Scenario", "I have several\nLines to look at\nNone starting with Given", 1],
+            [:eof]
           ]
         end
   
@@ -134,8 +148,9 @@ Given I am a step})
 })
           @listener.to_sexp.should == [
             [:scenario, "Scenario", "I have a Button\nButtons are great", 1],
-            [:step, "Given", "I have some", 3],
-            [:step, "But", "I might not because I am a Charles Dickens character", 4]
+            [:step, "Given ", "I have some", 3],
+            [:step, "But ", "I might not because I am a Charles Dickens character", 4],
+            [:eof]
           ]
         end
         
@@ -146,7 +161,8 @@ Given I am a step
 })
           @listener.to_sexp.should == [
             [:scenario, "Scenario", "When I have when in scenario\nI should be fine", 1],
-            [:step, "Given", "I am a step", 3]
+            [:step, "Given ", "I am a step", 3],
+            [:eof]
           ]
         end
       end
@@ -161,9 +177,11 @@ Given I am a step
                           })
           @listener.to_sexp.should == [
             [:scenario_outline, "Scenario Outline", "Hello", 1],
-            [:step, "Given", "a <what> cucumber", 2],
+            [:step, "Given ", "a <what> cucumber", 2],
             [:examples, "Examples", "", 3],
-            [:table, [["what"],["green"]], 4]
+            [:row, ["what"], 4],
+            [:row, ["green"], 5],
+            [:eof]
           ]
         end
 
@@ -174,7 +192,8 @@ Given I am a step
                           })
           @listener.to_sexp.should == [
             [:scenario_outline, "Scenario Outline", "Hello", 1],
-            [:scenario, "Scenario", "My Scenario", 3]
+            [:scenario, "Scenario", "My Scenario", 3],
+            [:eof]
           ]
         end
 
@@ -188,7 +207,8 @@ Given I am a step
                           })
           @listener.to_sexp.should == [
             [:scenario_outline, "Scenario Outline", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.", 1],
-            [:step, "Given", "I am a step", 5]
+            [:step, "Given ", "I am a step", 5],
+            [:eof]
           ]
         end        
       end
@@ -201,7 +221,9 @@ Given I am a step
                           })
           @listener.to_sexp.should == [
             [:examples, "Examples", "", 1],
-            [:table, [["x","y"],["5","6"]], 2]
+            [:row, ["x","y"], 2],
+            [:row, ["5","6"], 3],
+            [:eof]
           ]
         end
         
@@ -214,7 +236,9 @@ Given I am a step
                           })
           @listener.to_sexp.should == [
             [:examples, "Examples", "I'm a multiline name\nand I'm ok\nf'real", 1],
-            [:table, [["x"],["5"]], 4]
+            [:row, ["x"], 4],
+            [:row, ["5"], 5],
+            [:eof]
           ]
         end
       end
@@ -225,16 +249,18 @@ Given I am a step
                           |a|b|
                           })
           @listener.to_sexp.should == [
-            [:step, "Given", "I have a table", 1],
-            [:table, [['a','b']], 2]
+            [:step, "Given ", "I have a table", 1],
+            [:row, ['a','b'], 2],
+            [:eof]
           ]
         end
         
         it "should parse steps with inline py_string" do
           @lexer.scan("Given I have a string\n\"\"\"\nhello\nworld\n\"\"\"")
           @listener.to_sexp.should == [
-            [:step, "Given", "I have a string", 1],
-            [:py_string, "hello\nworld", 2]
+            [:step, "Given ", "I have a string", 1],
+            [:py_string, "hello\nworld", 2],
+            [:eof]
           ]
         end
       end
@@ -245,7 +271,8 @@ Given I am a step
           @listener.to_sexp.should == [
             [:feature, "Feature", "Feature Text", 1],
             [:scenario, "Scenario", "Reading a Scenario", 2],
-            [:step, "Given", "there is a step", 3]
+            [:step, "Given ", "there is a step", 3],
+            [:eof]
           ]
         end
       end
@@ -256,7 +283,8 @@ Given I am a step
           @listener.to_sexp.should == [
             [:feature, "Feature", "Feature Text", 1],
             [:scenario, "Scenario", "Reading a Scenario", 2],
-            [:step, "Given", "there is a step", 3]
+            [:step, "Given ", "there is a step", 3],
+            [:eof]
           ]
         end
       end
@@ -268,9 +296,10 @@ Given I am a step
           @listener.to_sexp.should == [
             [:feature, "Feature", "Feature Text", 1],
             [:scenario, "Scenario", "Reading a Scenario", 2],
-            [:step, "Given", "there is a step", 3],
-            [:step, "And", "another step", 4],
-            [:step, "And", "a third step", 5]
+            [:step, "Given ", "there is a step", 3],
+            [:step, "And ", "another step", 4],
+            [:step, "And ", "a third step", 5],
+            [:eof]
           ]
         end
       end
@@ -278,19 +307,28 @@ Given I am a step
       describe "A single feature with no scenario" do
         it "should find the feature" do
           @lexer.scan("Feature: Feature Text\n")
-          @listener.to_sexp.should == [[:feature, "Feature", "Feature Text", 1]]
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:eof]
+          ]
         end
 
         it "should parse a one line feature with no newline" do
           @lexer.scan("Feature: hi")
-          @listener.to_sexp.should == [[:feature, "Feature", "hi", 1]]
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "hi", 1],
+            [:eof]
+          ]
         end
       end
       
       describe "A multi-line feature with no scenario" do
         it "should find the feature" do
           @lexer.scan("Feature: Feature Text\n  And some more text")
-          @listener.to_sexp.should == [[:feature, "Feature", "Feature Text\nAnd some more text", 1]]
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text\nAnd some more text", 1],
+            [:eof]
+          ]
         end
       end
 
@@ -299,7 +337,8 @@ Given I am a step
           @lexer.scan("Feature: Feature Text\nScenario: Reading a Scenario\n")
           @listener.to_sexp.should == [
             [:feature, "Feature", "Feature Text", 1],
-            [:scenario, "Scenario", "Reading a Scenario", 2]
+            [:scenario, "Scenario", "Reading a Scenario", 2],
+            [:eof]
           ]
         end
       end
@@ -310,9 +349,10 @@ Given I am a step
           @listener.to_sexp.should == [
             [:feature, "Feature", "Feature Text", 1],
             [:scenario, "Scenario", "Reading a Scenario", 2],
-            [:step, "Given", "a step", 3],
+            [:step, "Given ", "a step", 3],
             [:scenario, "Scenario", "A second scenario", 5],
-            [:step, "Given", "another step", 6]
+            [:step, "Given ", "another step", 6],
+            [:eof]
           ]
         end
         
@@ -321,9 +361,10 @@ Given I am a step
           @listener.to_sexp.should == [
             [:feature, "Feature", "Feature Text", 1],
             [:scenario, "Scenario", "Reading a Scenario", 2],
-            [:step, "Given", "a step", 3],
+            [:step, "Given ", "a step", 3],
             [:scenario, "Scenario", "A second scenario", 4],
-            [:step, "Given", "another step", 5]
+            [:step, "Given ", "another step", 5],
+            [:eof]
           ]
         end
       end
@@ -337,8 +378,23 @@ Given I am a step
             [:comment, "# Here is another # comment", 3],
             [:scenario, "Scenario", "Reading a Scenario", 4],
             [:comment, "# Here is a third comment", 5],
-            [:step, "Given", "there is a step", 6],
-            [:comment, "# Here is a fourth comment", 7]
+            [:step, "Given ", "there is a step", 6],
+            [:comment, "# Here is a fourth comment", 7],
+            [:eof]
+          ]
+        end
+
+        it "should support comments in tables" do
+          scan_file("comments_in_table.feature")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "x", 1], 
+            [:scenario_outline, "Scenario Outline", "x", 3], 
+            [:step, "Then ", "x is <state>", 4], 
+            [:examples, "Examples", "", 6], 
+            [:row, ["state"], 7], 
+            [:comment, "# comment", 8], 
+            [:row, ["1"], 9],
+            [:eof]
           ]
         end
       end
@@ -353,12 +409,13 @@ Given I am a step
             [:tag, "st1", 5],
             [:tag, "st2", 5],
             [:scenario, "Scenario", "First", 6],
-            [:step, "Given", "Pepper", 7],
+            [:step, "Given ", "Pepper", 7],
             [:tag, "st3", 9],
             [:tag, "st4", 10],
             [:tag, "ST5", 10],
             [:tag, "#^%&ST6**!", 10],
-            [:scenario, "Scenario", "Second", 11]
+            [:scenario, "Scenario", "Second", 11],
+            [:eof]
           ]
         end        
       end
@@ -371,7 +428,8 @@ Given I am a step
             [:comment, "# Comment", 3],
             [:scenario, "Scenario", "Anonymous user can get a login form.\nScenery here", 4],
             [:tag, "tag", 7],
-            [:scenario, "Scenario", "Another one", 8]
+            [:scenario, "Scenario", "Another one", 8],
+            [:eof]
           ]
         end
       end   
@@ -388,30 +446,81 @@ Given I am a step
             [:comment, "#Comment on line 9", 9],
             [:comment, "#Comment on line 11", 11],
             [:background, "Background", "", 13],
-            [:step, "Given", "this is a background step", 14],
-            [:step, "And", "this is another one", 15],
+            [:step, "Given ", "this is a background step", 14],
+            [:step, "And ", "this is another one", 15],
             [:tag, "tag3", 17],
             [:tag, "tag4", 17],
             [:scenario, "Scenario", "Reading a Scenario", 18],
-            [:step, "Given", "there is a step", 19],
-            [:step, "But", "not another step", 20],
+            [:step, "Given ", "there is a step", 19],
+            [:step, "But ", "not another step", 20],
             [:tag, "tag3", 22],
-            [:scenario, "Scenario", "Reading a second scenario", 23],
-            [:comment, "#Comment on line 24", 24],
-            [:step, "Given", "a third step with a table", 25],
-            [:table, [['a','b'],['c','d'],['e','f']], 26],
-            [:step, "And", "I am still testing things", 29],
-            [:table, [['g','h'],['e','r'],['k','i'],['n','']], 30],
-            [:step, "And", "I am done testing these tables", 34],
-            [:comment, "#Comment on line 29", 35],
-            [:step, "Then", "I am happy", 36],
-            [:scenario, "Scenario", "Hammerzeit", 38],
-            [:step, "Given", "All work and no play", 39],
-            [:py_string, "Makes Homer something something", 40],
-            [:step, "Then", "crazy", 43]
+            [:scenario, "Scenario", "Reading a second scenario\nWith two lines of text", 23],
+            [:comment, "#Comment on line 24", 25],
+            [:step, "Given ", "a third step with a table", 26],
+            [:row, %w{a b}, 27],
+            [:row, %w{c d}, 28],
+            [:row, %w{e f}, 29],
+            [:step, "And ", "I am still testing things", 30],
+            [:row, %w{g h}, 31],
+            [:row, %w{e r}, 32],
+            [:row, %w{k i}, 33],
+            [:row, ['n', ''], 34], 
+            [:step, "And ", "I am done testing these tables", 35],
+            [:comment, "#Comment on line 29", 36],
+            [:step, "Then ", "I am happy", 37],
+            [:scenario, "Scenario", "Hammerzeit", 39],
+            [:step, "Given ", "All work and no play", 40],
+            [:py_string, "Makes Homer something something\nAnd something else", 41 ],
+            [:step, "Then ", "crazy", 45],
+            [:eof]
           ]
         end        
       end
+      
+      context "DOS line endings" do
+        describe "A complex feature with tags, comments, multiple scenarios, and multiple steps and tables" do
+          it "should find things in the right order" do
+            scan_file("dos_line_endings.feature")
+            @listener.to_sexp.should == [
+              [:comment, "#Comment on line 1", 1],
+              [:comment, "#Comment on line 2", 2],
+              [:tag, "tag1", 3],
+              [:tag, "tag2", 3],
+              [:feature, "Feature", "Feature Text\r\nIn order to test multiline forms\r\nAs a ragel writer\r\nI need to check for complex combinations", 4],
+              [:comment, "#Comment on line 9", 9],
+              [:comment, "#Comment on line 11", 11],
+              [:background, "Background", "", 13],
+              [:step, "Given ", "this is a background step", 14],
+              [:step, "And ", "this is another one", 15],
+              [:tag, "tag3", 17],
+              [:tag, "tag4", 17],
+              [:scenario, "Scenario", "Reading a Scenario", 18],
+              [:step, "Given ", "there is a step", 19],
+              [:step, "But ", "not another step", 20],
+              [:tag, "tag3", 22],
+              [:scenario, "Scenario", "Reading a second scenario\r\nWith two lines of text", 23],
+              [:comment, "#Comment on line 24", 25],
+              [:step, "Given ", "a third step with a table", 26],
+              [:row, %w{a b}, 27],
+              [:row, %w{c d}, 28],
+              [:row, %w{e f}, 29],
+              [:step, "And ", "I am still testing things", 30],
+              [:row, %w{g h}, 31],
+              [:row, %w{e r}, 32],
+              [:row, %w{k i}, 33],
+              [:row, ['n', ''], 34], 
+              [:step, "And ", "I am done testing these tables", 35],
+              [:comment, "#Comment on line 29", 36],
+              [:step, "Then ", "I am happy", 37],
+              [:scenario, "Scenario", "Hammerzeit", 39],
+              [:step, "Given ", "All work and no play", 40],
+              [:py_string, "Makes Homer something something\r\nAnd something else", 41],
+              [:step, "Then ", "crazy", 45],
+              [:eof]
+            ]
+          end        
+        end
+      end
 
       describe "errors" do
         it "should raise a Lexing error if an unparseable token is found" do