aslakhellesoy-cucumber 0.1.99.1 → 0.1.99.2

data/History.txt

@@ -10,11 +10,19 @@ on how to use alternatives.
 **** CALL FOR TRANSLATORS ****
 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.
+There is no static code generation anymore. To list all languages:
 
-There are some exciting new feaqtures, so upgrading is not in vain. Tagging, Autoformatting,
-Auto aliasing of keywords in all languages, much better Ruby 1.9 support and improved output 
-for multiline arguments should make the upgrade worthwhile. 
+  cucumber --lang help
+  
+And to list the keywords for a particular language:
+
+  cucumber --lang en-lol help
+  
+So just go ahead and list the language of your choice and send us updated translations.
+
+There are some really awesome new features in this release: Tagging, Autoformatting, automatic 
+aliasing of keywords in all languages, much better Ruby 1.9 support and improved output 
+for multiline arguments are some of the highlights. 
 
 This version also brings Cucumber even closer to Java. Although it has been possible to
 run Cucumber on JRuby since v0.1.11, it has required that step definitions be defined
@@ -65,9 +73,9 @@ pure Ruby users have been enjoying for a while.
 * It's no longer necessary to compile the Treetop grammar when adding a new language. Localised parser is generated at runtime.
 
 === Removed features
-* "GivenScenario" is gone. Instead you can use "Background" or call Steps from Steps.
+* "GivenScenario" is gone. Instead you can call Steps from Steps, or wait for "Background (#153)"
 * "More Examples" is gone. "Scenario" + "More Examples" is no longer supported. Use "Scenario Outline" + "Examples" instead.
-* Pure Ruby features are no longer supported
+* Pure Ruby features are no longer supported.
 
 == 0.1.16.x (Master)
 

data/Manifest.txt

@@ -193,8 +193,9 @@ lib/cucumber/parser.rb
 lib/cucumber/parser/basic.rb
 lib/cucumber/parser/feature.rb
 lib/cucumber/parser/feature.tt
-lib/cucumber/parser/file_parser.rb
 lib/cucumber/parser/i18n.tt
+lib/cucumber/parser/table.rb
+lib/cucumber/parser/table.tt
 lib/cucumber/parser/treetop_ext.rb
 lib/cucumber/platform.rb
 lib/cucumber/rails/rspec.rb

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

@@ -9,15 +9,33 @@ Given "be_empty" do
 end
 
 Given "nested step is called" do
-  Given "nested step"
+  Given "I like mushroom", Cucumber::Ast::Table.new([
+    %w{sponge bob},
+    %w{is cool}
+  ])
 end
 
-Given "nested step" do
-  @magic = 'mushroom'
+Given 'nested step is called using text table' do
+  Given "I like mushroom", table(%{
+    | sponge | bob  |
+    | is     | cool |
+  })
+
+  # Alternative syntax (file and line will be reported on parse error)
+  # Given "I like mushroom", table(<<-EOT, __FILE__, __LINE__)
+  #   | sponge | bob  |
+  #   | is     | cool
+  # EOT
+end
+
+Given "I like $what" do |what, table|
+  @magic = what
+  @tool  = table.raw[0][0]
 end
 
 Then "nested step should be executed" do
   @magic.should == 'mushroom'
+  @tool.should == 'sponge'
 end
 
 Given /^the following table$/ do |table|

data/examples/tickets/features/tickets.feature

@@ -9,6 +9,10 @@ Feature: Cucumber
   Scenario: Call step from step
     Given nested step is called
     Then nested step should be executed
+
+  Scenario: Call step from step using text table
+    Given nested step is called using text table
+    Then nested step should be executed
     
   Scenario: Reading a table
     Given the following table

data/lib/cucumber.rb

@@ -12,6 +12,8 @@ require 'cucumber/broadcaster'
 require 'cucumber/core_ext/exception'
 
 module Cucumber
+  KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
+  
   class << self
     attr_reader :lang
     
@@ -22,6 +24,10 @@ module Cucumber
       Parser.load_parser(keyword_hash)
     end
 
+    def language_complete?(lang)
+      KEYWORD_KEYS.detect{|key| keyword_hash(lang)[key].nil?}
+    end
+
     # File mode that accounts for Ruby platform and current language
     def file_mode(m)
       Cucumber::RUBY_1_9 ? "#{m}:#{keyword_hash['encoding']}" : m

data/lib/cucumber/cli.rb

@@ -78,7 +78,7 @@ module Cucumber
           if v == 'help'
             list_languages
           elsif args==['help']
-            list_keywords('en', v)
+            list_keywords(v)
           else
             @options[:lang] = v
           end
@@ -364,23 +364,22 @@ Defined profiles in cucumber.yml:
       raw = Cucumber::LANGUAGES.keys.sort.map do |lang|
         [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
       end
-      print_table(raw)
+      print_lang_table(raw, {:check_lang=>true})
     end
 
-    def list_keywords(ref, lang)
+    def list_keywords(lang)
       unless Cucumber::LANGUAGES[lang]
         exit_with_error("No language with key #{v}")
       end
-      Cucumber.load_language(lang)
-      raw = %w{feature background scenario scenario_outline examples given when then but}.map do |key|
-        [Cucumber::LANGUAGES[ref][key], Cucumber::LANGUAGES[lang][key]]
+      raw = Cucumber::KEYWORD_KEYS.map do |key|
+        [key, Cucumber::LANGUAGES[lang][key]]
       end
-      print_table(raw)
+      print_lang_table(raw, {})
     end
     
-    def print_table(raw)
+    def print_lang_table(raw, options)
       table = Ast::Table.new(raw)
-      formatter = Formatter::Pretty.new(nil, @out_stream, {}, '')
+      formatter = Formatter::Pretty.new(nil, @out_stream, options, '')
 
       def formatter.visit_table_row(table_row, status)
         @col = 1
@@ -388,7 +387,15 @@ Defined profiles in cucumber.yml:
       end
 
       def formatter.visit_table_cell_value(value, width, status)
-        status = :comment if @col == 1
+        if @col == 1
+          if(@options[:check_lang])
+            @incomplete = Cucumber.language_complete?(value)
+          end
+          status = :comment 
+        elsif @incomplete
+          status = :failed
+        end
+        
         @col += 1
         super(value, width, status)
       end

data/lib/cucumber/languages.yml

@@ -52,6 +52,7 @@
   feature: Egenskab
   background: Baggrund
   scenario: Scenarie
+  scenario_outline: Abstrakt Scenario
   examples: Eksempler
   given: Givet
   when: Når
@@ -115,8 +116,6 @@
   encoding: UTF-8
   feature: Omadus
   scenario: Stsenaarium
-  scenario_outline: Scenario Outline
-  examples: Examples
   given: Eeldades
   when: Kui
   then: Siis
@@ -215,7 +214,7 @@
   feature: Egenskap
   background: Bakgrunn
   scenario: Scenario
-  scenario_outline: Scenarioskisse
+  scenario_outline: Abstrakt Scenario
   examples: Eksempler
   given: Gitt
   when: Når
@@ -284,6 +283,8 @@
   feature: Egenskap
   background: Bakgrund
   scenario: Scenario
+  scenario_outline: Abstrakt Scenario
+  examples: Exempel
   given: Givet
   when: När
   then: Så

data/lib/cucumber/parser.rb

@@ -1,11 +1,8 @@
 require 'erb'
-require 'treetop'
-require 'treetop/runtime'
-require 'treetop/ruby_extensions'
 require 'cucumber/platform'
 require 'cucumber/ast'
-require 'cucumber/parser/file_parser'
 require 'cucumber/parser/treetop_ext'
+require 'cucumber/parser/table'
 
 module Cucumber
   # Classes in this module parse feature files and translate the parse tree 

data/lib/cucumber/parser/feature.rb

@@ -10,10 +10,10 @@ module Cucumber
         @root || :feature
       end
 
-      include FileParser
-
       include I18n
 
+      include Table
+
       module Feature0
       end
 
@@ -976,271 +976,6 @@ module Cucumber
         return r0
       end
 
-      module Table0
-        def build
-          Ast::Table.new(raw)
-        end
-
-        def raw
-          elements.map{|e| e.build}
-        end
-      end
-
-      def _nt_table
-        start_index = index
-        if node_cache[:table].has_key?(index)
-          cached = node_cache[:table][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        s0, i0 = [], index
-        loop do
-          r1 = _nt_table_row
-          if r1
-            s0 << r1
-          else
-            break
-          end
-        end
-        if s0.empty?
-          self.index = i0
-          r0 = nil
-        else
-          r0 = SyntaxNode.new(input, i0...index, s0)
-          r0.extend(Table0)
-        end
-
-        node_cache[:table][start_index] = r0
-
-        return r0
-      end
-
-      module TableRow0
-        def cell
-          elements[0]
-        end
-
-      end
-
-      module TableRow1
-        def cells
-          elements[2]
-        end
-
-      end
-
-      module TableRow2
-        def build
-          row = cells.elements.map do |elt| 
-            value = elt.cell.text_value.strip
-            value.empty? ? nil : value
-          end
-
-          class << row
-            attr_accessor :line
-          end
-          row.line = cells.line
-
-          row
-        end
-      end
-
-      def _nt_table_row
-        start_index = index
-        if node_cache[:table_row].has_key?(index)
-          cached = node_cache[:table_row][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        i0, s0 = index, []
-        s1, i1 = [], index
-        loop do
-          r2 = _nt_space
-          if r2
-            s1 << r2
-          else
-            break
-          end
-        end
-        r1 = SyntaxNode.new(input, i1...index, s1)
-        s0 << r1
-        if r1
-          if input.index('|', index) == index
-            r3 = (SyntaxNode).new(input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure('|')
-            r3 = nil
-          end
-          s0 << r3
-          if r3
-            s4, i4 = [], index
-            loop do
-              i5, s5 = index, []
-              r6 = _nt_cell
-              s5 << r6
-              if r6
-                if input.index('|', index) == index
-                  r7 = (SyntaxNode).new(input, index...(index + 1))
-                  @index += 1
-                else
-                  terminal_parse_failure('|')
-                  r7 = nil
-                end
-                s5 << r7
-              end
-              if s5.last
-                r5 = (SyntaxNode).new(input, i5...index, s5)
-                r5.extend(TableRow0)
-              else
-                self.index = i5
-                r5 = nil
-              end
-              if r5
-                s4 << r5
-              else
-                break
-              end
-            end
-            if s4.empty?
-              self.index = i4
-              r4 = nil
-            else
-              r4 = SyntaxNode.new(input, i4...index, s4)
-            end
-            s0 << r4
-            if r4
-              s8, i8 = [], index
-              loop do
-                r9 = _nt_space
-                if r9
-                  s8 << r9
-                else
-                  break
-                end
-              end
-              r8 = SyntaxNode.new(input, i8...index, s8)
-              s0 << r8
-              if r8
-                i10 = index
-                s11, i11 = [], index
-                loop do
-                  r12 = _nt_eol
-                  if r12
-                    s11 << r12
-                  else
-                    break
-                  end
-                end
-                if s11.empty?
-                  self.index = i11
-                  r11 = nil
-                else
-                  r11 = SyntaxNode.new(input, i11...index, s11)
-                end
-                if r11
-                  r10 = r11
-                else
-                  r13 = _nt_eof
-                  if r13
-                    r10 = r13
-                  else
-                    self.index = i10
-                    r10 = nil
-                  end
-                end
-                s0 << r10
-              end
-            end
-          end
-        end
-        if s0.last
-          r0 = (SyntaxNode).new(input, i0...index, s0)
-          r0.extend(TableRow1)
-          r0.extend(TableRow2)
-        else
-          self.index = i0
-          r0 = nil
-        end
-
-        node_cache[:table_row][start_index] = r0
-
-        return r0
-      end
-
-      module Cell0
-      end
-
-      def _nt_cell
-        start_index = index
-        if node_cache[:cell].has_key?(index)
-          cached = node_cache[:cell][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        s0, i0 = [], index
-        loop do
-          i1, s1 = index, []
-          i2 = index
-          i3 = index
-          if input.index('|', index) == index
-            r4 = (SyntaxNode).new(input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure('|')
-            r4 = nil
-          end
-          if r4
-            r3 = r4
-          else
-            r5 = _nt_eol
-            if r5
-              r3 = r5
-            else
-              self.index = i3
-              r3 = nil
-            end
-          end
-          if r3
-            r2 = nil
-          else
-            self.index = i2
-            r2 = SyntaxNode.new(input, index...index)
-          end
-          s1 << r2
-          if r2
-            if index < input_length
-              r6 = (SyntaxNode).new(input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("any character")
-              r6 = nil
-            end
-            s1 << r6
-          end
-          if s1.last
-            r1 = (SyntaxNode).new(input, i1...index, s1)
-            r1.extend(Cell0)
-          else
-            self.index = i1
-            r1 = nil
-          end
-          if r1
-            s0 << r1
-          else
-            break
-          end
-        end
-        r0 = SyntaxNode.new(input, i0...index, s0)
-
-        node_cache[:cell][start_index] = r0
-
-        return r0
-      end
-
       module LineToEol0
       end
 
@@ -1570,120 +1305,6 @@ module Cucumber
         return r0
       end
 
-      def _nt_space
-        start_index = index
-        if node_cache[:space].has_key?(index)
-          cached = node_cache[:space][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        if input.index(Regexp.new('[ \\t]'), index) == index
-          r0 = (SyntaxNode).new(input, index...(index + 1))
-          @index += 1
-        else
-          r0 = nil
-        end
-
-        node_cache[:space][start_index] = r0
-
-        return r0
-      end
-
-      module Eol0
-      end
-
-      def _nt_eol
-        start_index = index
-        if node_cache[:eol].has_key?(index)
-          cached = node_cache[:eol][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        i0 = index
-        if input.index("\n", index) == index
-          r1 = (SyntaxNode).new(input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure("\n")
-          r1 = nil
-        end
-        if r1
-          r0 = r1
-        else
-          i2, s2 = index, []
-          if input.index("\r", index) == index
-            r3 = (SyntaxNode).new(input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure("\r")
-            r3 = nil
-          end
-          s2 << r3
-          if r3
-            if input.index("\n", index) == index
-              r5 = (SyntaxNode).new(input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("\n")
-              r5 = nil
-            end
-            if r5
-              r4 = r5
-            else
-              r4 = SyntaxNode.new(input, index...index)
-            end
-            s2 << r4
-          end
-          if s2.last
-            r2 = (SyntaxNode).new(input, i2...index, s2)
-            r2.extend(Eol0)
-          else
-            self.index = i2
-            r2 = nil
-          end
-          if r2
-            r0 = r2
-          else
-            self.index = i0
-            r0 = nil
-          end
-        end
-
-        node_cache[:eol][start_index] = r0
-
-        return r0
-      end
-
-      def _nt_eof
-        start_index = index
-        if node_cache[:eof].has_key?(index)
-          cached = node_cache[:eof][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        i0 = index
-        if index < input_length
-          r1 = (SyntaxNode).new(input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure("any character")
-          r1 = nil
-        end
-        if r1
-          r0 = nil
-        else
-          self.index = i0
-          r0 = SyntaxNode.new(input, index...index)
-        end
-
-        node_cache[:eof][start_index] = r0
-
-        return r0
-      end
-
     end
 
     class FeatureParser < Treetop::Runtime::CompiledParser

data/lib/cucumber/parser/feature.tt

@@ -4,8 +4,8 @@ module Cucumber
     # Treetop will then generate the parser in-memory. When you're happy, just generate
     # the rb file with tt feature.tt
     grammar Feature
-      include FileParser
       include I18n
+      include Table
 
       rule feature
         white comment white tags white header:(!(scenario_outline / scenario) .)* feature_elements {
@@ -119,40 +119,6 @@ module Cucumber
         table / py_string
       end
 
-      rule table
-        table_row+ {
-          def build
-            Ast::Table.new(raw)
-          end
-
-          def raw
-            elements.map{|e| e.build}
-          end
-        }
-      end
-
-      rule table_row
-        space* '|' cells:(cell '|')+ space* (eol+ / eof) {
-          def build
-            row = cells.elements.map do |elt| 
-              value = elt.cell.text_value.strip
-              value.empty? ? nil : value
-            end
-
-            class << row
-              attr_accessor :line
-            end
-            row.line = cells.line
-
-            row
-          end
-        }
-      end
-
-      rule cell
-        (!('|' / eol) .)*
-      end
-      
       rule line_to_eol
         (!eol .)+
       end
@@ -189,18 +155,6 @@ module Cucumber
         (space / eol)*
       end
 
-      rule space
-        [ \t]
-      end
-
-      rule eol
-        "\n" / ("\r" "\n"?)
-      end
-      
-      rule eof
-        !.
-      end
-
     end
   end
 end

data/lib/cucumber/parser/i18n.tt

@@ -21,6 +21,7 @@ module Cucumber
       rule examples_keyword
         '<%= keywords['examples'] %>' ':'?
       end
+
     end
   end
 end

data/lib/cucumber/parser/table.rb

@@ -0,0 +1,396 @@
+module Cucumber
+  module Parser
+    module Table
+      include Treetop::Runtime
+
+      def root
+        @root || :table
+      end
+
+      module Table0
+        def build
+          Ast::Table.new(raw)
+        end
+
+        def raw
+          elements.map{|e| e.build}
+        end
+      end
+
+      def _nt_table
+        start_index = index
+        if node_cache[:table].has_key?(index)
+          cached = node_cache[:table][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          r1 = _nt_table_row
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        if s0.empty?
+          self.index = i0
+          r0 = nil
+        else
+          r0 = SyntaxNode.new(input, i0...index, s0)
+          r0.extend(Table0)
+        end
+
+        node_cache[:table][start_index] = r0
+
+        return r0
+      end
+
+      module TableRow0
+        def cell
+          elements[0]
+        end
+
+      end
+
+      module TableRow1
+        def cells
+          elements[2]
+        end
+
+      end
+
+      module TableRow2
+        def build
+          row = cells.elements.map do |elt| 
+            value = elt.cell.text_value.strip
+            value.empty? ? nil : value
+          end
+
+          class << row
+            attr_accessor :line
+          end
+          row.line = cells.line
+
+          row
+        end
+      end
+
+      def _nt_table_row
+        start_index = index
+        if node_cache[:table_row].has_key?(index)
+          cached = node_cache[:table_row][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0, s0 = index, []
+        s1, i1 = [], index
+        loop do
+          r2 = _nt_space
+          if r2
+            s1 << r2
+          else
+            break
+          end
+        end
+        r1 = SyntaxNode.new(input, i1...index, s1)
+        s0 << r1
+        if r1
+          if input.index('|', index) == index
+            r3 = (SyntaxNode).new(input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('|')
+            r3 = nil
+          end
+          s0 << r3
+          if r3
+            s4, i4 = [], index
+            loop do
+              i5, s5 = index, []
+              r6 = _nt_cell
+              s5 << r6
+              if r6
+                if input.index('|', index) == index
+                  r7 = (SyntaxNode).new(input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure('|')
+                  r7 = nil
+                end
+                s5 << r7
+              end
+              if s5.last
+                r5 = (SyntaxNode).new(input, i5...index, s5)
+                r5.extend(TableRow0)
+              else
+                self.index = i5
+                r5 = nil
+              end
+              if r5
+                s4 << r5
+              else
+                break
+              end
+            end
+            if s4.empty?
+              self.index = i4
+              r4 = nil
+            else
+              r4 = SyntaxNode.new(input, i4...index, s4)
+            end
+            s0 << r4
+            if r4
+              s8, i8 = [], index
+              loop do
+                r9 = _nt_space
+                if r9
+                  s8 << r9
+                else
+                  break
+                end
+              end
+              r8 = SyntaxNode.new(input, i8...index, s8)
+              s0 << r8
+              if r8
+                i10 = index
+                s11, i11 = [], index
+                loop do
+                  r12 = _nt_eol
+                  if r12
+                    s11 << r12
+                  else
+                    break
+                  end
+                end
+                if s11.empty?
+                  self.index = i11
+                  r11 = nil
+                else
+                  r11 = SyntaxNode.new(input, i11...index, s11)
+                end
+                if r11
+                  r10 = r11
+                else
+                  r13 = _nt_eof
+                  if r13
+                    r10 = r13
+                  else
+                    self.index = i10
+                    r10 = nil
+                  end
+                end
+                s0 << r10
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = (SyntaxNode).new(input, i0...index, s0)
+          r0.extend(TableRow1)
+          r0.extend(TableRow2)
+        else
+          self.index = i0
+          r0 = nil
+        end
+
+        node_cache[:table_row][start_index] = r0
+
+        return r0
+      end
+
+      module Cell0
+      end
+
+      def _nt_cell
+        start_index = index
+        if node_cache[:cell].has_key?(index)
+          cached = node_cache[:cell][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          i1, s1 = index, []
+          i2 = index
+          i3 = index
+          if input.index('|', index) == index
+            r4 = (SyntaxNode).new(input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('|')
+            r4 = nil
+          end
+          if r4
+            r3 = r4
+          else
+            r5 = _nt_eol
+            if r5
+              r3 = r5
+            else
+              self.index = i3
+              r3 = nil
+            end
+          end
+          if r3
+            r2 = nil
+          else
+            self.index = i2
+            r2 = SyntaxNode.new(input, index...index)
+          end
+          s1 << r2
+          if r2
+            if index < input_length
+              r6 = (SyntaxNode).new(input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("any character")
+              r6 = nil
+            end
+            s1 << r6
+          end
+          if s1.last
+            r1 = (SyntaxNode).new(input, i1...index, s1)
+            r1.extend(Cell0)
+          else
+            self.index = i1
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        r0 = SyntaxNode.new(input, i0...index, s0)
+
+        node_cache[:cell][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_space
+        start_index = index
+        if node_cache[:space].has_key?(index)
+          cached = node_cache[:space][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        if input.index(Regexp.new('[ \\t]'), index) == index
+          r0 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          r0 = nil
+        end
+
+        node_cache[:space][start_index] = r0
+
+        return r0
+      end
+
+      module Eol0
+      end
+
+      def _nt_eol
+        start_index = index
+        if node_cache[:eol].has_key?(index)
+          cached = node_cache[:eol][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        if input.index("\n", index) == index
+          r1 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("\n")
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          i2, s2 = index, []
+          if input.index("\r", index) == index
+            r3 = (SyntaxNode).new(input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("\r")
+            r3 = nil
+          end
+          s2 << r3
+          if r3
+            if input.index("\n", index) == index
+              r5 = (SyntaxNode).new(input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("\n")
+              r5 = nil
+            end
+            if r5
+              r4 = r5
+            else
+              r4 = SyntaxNode.new(input, index...index)
+            end
+            s2 << r4
+          end
+          if s2.last
+            r2 = (SyntaxNode).new(input, i2...index, s2)
+            r2.extend(Eol0)
+          else
+            self.index = i2
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            self.index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:eol][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_eof
+        start_index = index
+        if node_cache[:eof].has_key?(index)
+          cached = node_cache[:eof][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        if index < input_length
+          r1 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("any character")
+          r1 = nil
+        end
+        if r1
+          r0 = nil
+        else
+          self.index = i0
+          r0 = SyntaxNode.new(input, index...index)
+        end
+
+        node_cache[:eof][start_index] = r0
+
+        return r0
+      end
+
+    end
+
+    class TableParser < Treetop::Runtime::CompiledParser
+      include Table
+    end
+
+  end
+end

data/lib/cucumber/parser/table.tt

@@ -0,0 +1,53 @@
+module Cucumber
+  module Parser
+    grammar Table
+
+      rule table
+        table_row+ {
+          def build
+            Ast::Table.new(raw)
+          end
+
+          def raw
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule table_row
+        space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def build
+            row = cells.elements.map do |elt| 
+              value = elt.cell.text_value.strip
+              value.empty? ? nil : value
+            end
+
+            class << row
+              attr_accessor :line
+            end
+            row.line = cells.line
+
+            row
+          end
+        }
+      end
+
+      rule cell
+        (!('|' / eol) .)*
+      end
+
+      rule space
+        [ \t]
+      end
+
+      rule eol
+        "\n" / ("\r" "\n"?)
+      end
+
+      rule eof
+        !.
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/treetop_ext.rb

@@ -1,3 +1,46 @@
+require 'treetop'
+require 'treetop/runtime'
+require 'treetop/ruby_extensions'
+
+module Cucumber
+  module Parser
+    module TreetopExt
+      FILE_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+
+      # Parses a file and returns a Cucumber::Ast
+      def parse_file(file)
+        _, path, lines = *FILE_LINE_PATTERN.match(file)
+        if path
+          lines = lines.split(':').map { |line| line.to_i }
+        else
+          path = file
+          lines = []
+        end
+
+        feature = File.open(path, Cucumber.file_mode('r')) do |io|
+          parse_or_fail(io.read, path)
+        end
+        feature.lines = lines
+        feature
+      end
+    end
+
+    class SyntaxError < StandardError
+      def initialize(parser, file, line_offset)
+        tf = parser.terminal_failures
+        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
+        after = parser.input[parser.index...parser.failure_index]
+        found = parser.input[parser.failure_index..parser.failure_index]
+        
+        line = parser.failure_line + line_offset
+        message = "#{file}:#{line}:#{parser.failure_column}: " +
+          "Parse error, expected #{expected}. After #{after.inspect}. Found: #{found.inspect}"
+        super(message)
+      end
+    end
+  end
+end
+
 module Treetop
   module Runtime
     class SyntaxNode
@@ -5,5 +48,20 @@ module Treetop
         input.line_of(interval.first)
       end
     end
+    
+    class CompiledParser
+      include Cucumber::Parser::TreetopExt
+      
+      def parse_or_fail(s, file=nil, line=0)
+        parse_tree = parse(s)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line)
+        else
+          ast = parse_tree.build
+          ast.file = file
+          ast
+        end
+      end
+    end
   end
 end

data/lib/cucumber/step_definition.rb

@@ -24,9 +24,13 @@ module Cucumber
 
     attr_reader :regexp
 
-    def initialize(regexp, &proc)
+    def initialize(pattern, &proc)
       raise MissingProc if proc.nil?
-      @regexp, @proc = regexp, proc
+      if String === pattern
+        p = pattern.gsub(/\$\w+/, '(.*)')
+        pattern = Regexp.new("^#{p}$") 
+      end
+      @regexp, @proc = pattern, proc
     end
 
     #:stopdoc:

data/lib/cucumber/step_mother.rb

@@ -130,12 +130,22 @@ module Cucumber
       # Call a step from within a step definition
       def __cucumber_invoke(name, *multiline_arguments)
         begin
-          @__cucumber_step_mother.step_definition(name).execute(name, self, *multiline_arguments)
+          # TODO: Very similar to code in Step. Refactor. Get back StepInvocation?
+          # Make more similar to JBehave?
+          step_definition = @__cucumber_step_mother.step_definition(name)
+          matched_args = step_definition.matched_args(name)
+          args = (matched_args + multiline_arguments)
+          step_definition.execute(name, self, *args)
         rescue Exception => e
           @__cucumber_current_step.exception = e
           raise e
         end
       end
+      
+      def table(text, file=nil, line=0)
+        @table_parser ||= Parser::TableParser.new
+        @table_parser.parse_or_fail(text.strip, file, line)
+      end
 
       def pending(message = "TODO")
         if block_given?

data/lib/cucumber/version.rb

@@ -3,7 +3,7 @@ module Cucumber #:nodoc:
     MAJOR = 0
     MINOR = 1
     TINY  = 99
-    PATCH = 1 # Set to nil for official release
+    PATCH = 2 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aslakhellesoy-cucumber
 version: !ruby/object:Gem::Version 
-  version: 0.1.99.1
+  version: 0.1.99.2
 platform: ruby
 authors: 
 - "Aslak Helles\xC3\xB8y"
@@ -172,7 +172,6 @@ files:
 - examples/jbehave/features/support/env.rb
 - examples/jbehave/features/trading.feature
 - examples/jbehave/pom.xml
-- examples/jbehave/target/maven-archiver/pom.properties
 - examples/selenium/Rakefile
 - examples/selenium/features/search.feature
 - examples/selenium/features/step_definitons/stories_steps.rb
@@ -259,8 +258,9 @@ files:
 - lib/cucumber/parser/basic.rb
 - lib/cucumber/parser/feature.rb
 - lib/cucumber/parser/feature.tt
-- lib/cucumber/parser/file_parser.rb
 - lib/cucumber/parser/i18n.tt
+- lib/cucumber/parser/table.rb
+- lib/cucumber/parser/table.tt
 - lib/cucumber/parser/treetop_ext.rb
 - lib/cucumber/platform.rb
 - lib/cucumber/rails/rspec.rb

data/lib/cucumber/parser/file_parser.rb

@@ -1,50 +0,0 @@
-module Cucumber
-  module Parser
-    module FileParser
-      FILE_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
-
-      # Parses a file and returns a Cucumber::Ast
-      def parse_file(file)
-        _, path, lines = *FILE_LINE_PATTERN.match(file)
-        if path
-          lines = lines.split(':').map { |line| line.to_i }
-        else
-          path = file
-          lines = []
-        end
-
-        feature = File.open(path, Cucumber.file_mode('r')) do |io|
-          parse_or_fail(io.read, path)
-        end
-        feature.lines = lines
-        feature
-      end
-      
-      def parse_or_fail(s, file=nil)
-        parse_tree = parse(s)
-        if parse_tree.nil?
-          raise SyntaxError.new(file, self)
-        else
-          ast = parse_tree.build
-          ast.file = file
-          ast
-        end
-      end
-    end
-
-    class SyntaxError < StandardError
-      def initialize(file, parser)
-        tf = parser.terminal_failures
-        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
-        after = parser.input[parser.index...parser.failure_index]
-        found = parser.input[parser.failure_index..parser.failure_index]
-        @message = "#{file}:#{parser.failure_line}:#{parser.failure_column}: " +
-          "Parse error, expected #{expected}. After #{after.inspect}. Found: #{found.inspect}"
-      end
-
-      def message
-        @message
-      end
-    end
-  end
-end