cucumber 0.1.6 → 0.1.7

data/lib/cucumber/formatters/pretty_formatter.rb

@@ -8,8 +8,10 @@ module Cucumber
       INDENT = "\n      "
       BACKTRACE_FILTER_PATTERNS = [/vendor\/rails/, /vendor\/plugins\/cucumber/, /spec\/expectations/, /spec\/matchers/]
     
-      def initialize(io)
+      def initialize(io, step_mother, options={})
         @io = (io == STDOUT) ? Kernel : io
+        @options = options
+        @step_mother = step_mother
         @passed = []
         @failed = []
         @pending = []
@@ -50,7 +52,12 @@ module Cucumber
           args.each{|arg| @io.print passed(arg) ; @io.print "|"}
         else
           @passed << step
-          @io.puts passed("    #{step.keyword} #{step.format(regexp){|param| passed_param(param) << passed}}") 
+          @io.print passed("    #{step.keyword} #{step.format(regexp){|param| passed_param(param) << passed}}")
+          if @options[:source]
+            @io.print padding_spaces(step)
+            @io.print source_comment(step) 
+          end
+          @io.puts
         end
       end
       
@@ -62,11 +69,30 @@ module Cucumber
         else
           @failed << step
           @scenario_failed = true
-          @io.puts failed("    #{step.keyword} #{step.format(regexp){|param| failed_param(param) << failed}}") 
+          @io.print failed("    #{step.keyword} #{step.format(regexp){|param| failed_param(param) << failed}}") 
+          if @options[:source]
+            @io.print padding_spaces(step)
+            @io.print source_comment(step) 
+          end
+          @io.puts
           output_failing_step(step)
         end
       end
       
+      def step_skipped(step, regexp, args)
+        @skipped << step
+        if step.row?
+          args.each{|arg| @io.print skipped(arg) ; @io.print "|"}
+        else
+          @io.print skipped("    #{step.keyword} #{step.format(regexp){|param| skipped_param(param) << skipped}}") 
+          if @options[:source]
+            @io.print padding_spaces(step)
+            @io.print source_comment(step) 
+          end
+          @io.puts
+        end
+      end
+
       def step_pending(step, regexp, args)
         if step.row?
           @pending << step
@@ -77,17 +103,9 @@ module Cucumber
         end
       end
       
-      def step_skipped(step, regexp, args)
-        @skipped << step
-        if step.row?
-          args.each{|arg| @io.print skipped(arg) ; @io.print "|"}
-        else
-          @io.puts skipped("    #{step.keyword} #{step.format(regexp){|param| skipped_param(param) << skipped}}") 
-        end
-      end
-
       def output_failing_step(step)
-        clean_backtrace = step.error.backtrace.map {|b| b.split("\n") }.flatten.reject do |line|
+        backtrace = step.error.backtrace || []
+        clean_backtrace = backtrace.map {|b| b.split("\n") }.flatten.reject do |line|
           BACKTRACE_FILTER_PATTERNS.detect{|p| line =~ p}
         end.map { |line| line.strip }
         @io.puts failed("      #{step.error.message.split("\n").join(INDENT)} (#{step.error.class})")
@@ -103,7 +121,7 @@ module Cucumber
         @io.print reset
         print_snippets
       end
-      
+            
       def print_snippets
         unless @pending.empty?
           @io.puts "\nYou can use these snippets to implement pending steps:\n\n"
@@ -111,7 +129,7 @@ module Cucumber
           prev_keyword = nil
           snippets = @pending.map do |step|
             next if step.row?
-            snippet = "#{step.actual_keyword} /#{step.name}/ do\nend\n\n"
+            snippet = "#{step.actual_keyword} /^#{step.name}$/ do\nend\n\n"
             prev_keyword = step.keyword
             snippet
           end.compact.uniq
@@ -121,6 +139,17 @@ module Cucumber
           end
         end
       end
+      
+      private
+
+      def source_comment(step)
+        _, _, proc = step.regexp_args_proc(@step_mother)
+        comment(proc.to_comment_line)
+      end
+      
+      def padding_spaces(step)
+        " " * step.padding_length
+      end
     end
   end
 end

data/lib/cucumber/languages.yml

@@ -9,6 +9,7 @@
   when: Når
   then: Så
   and: Og
+  but: Men
 "de":
   feature: Funktionalität
   scenario: Szenario
@@ -17,6 +18,7 @@
   when: Wenn
   then: Dann
   and: Und
+  but: Aber
 "en":
   feature: Feature
   scenario: Scenario
@@ -25,6 +27,7 @@
   when: When
   then: Then
   and: And
+  but: But
 "es":
   feature: Característica
   scenario: Escenario
@@ -33,6 +36,7 @@
   when: Cuando
   then: Entonces
   and: Y
+  but: Pero
 "fr":
   feature: Fonction
   scenario: Scenario
@@ -41,6 +45,7 @@
   when: Lorsque
   then: Alors
   and: Et
+  but: Mais
 "no":
   feature: Egenskap
   scenario: Scenario
@@ -49,6 +54,7 @@
   when: Når
   then: Så
   and: Og
+  but: Men
 "pt":
   feature: Característica
   scenario: Cenário
@@ -57,6 +63,7 @@
   when: Quando
   then: Então
   and: E
+  but: Mas
 "ru":
   feature: Функционал
   scenario: Сценарий
@@ -65,6 +72,7 @@
   when: Если
   then: То
   and: И
+  but: Но
 "se":
   feature: Egenskap
   scenario: Scenario
@@ -73,6 +81,7 @@
   when: Når
   then: Så
   and: Och
+  but: Men
 "et":
   feature: Omadus
   scenario: Stsenaarium
@@ -81,3 +90,4 @@
   when: Kui
   then: Siis
   and: Ja
+  but: Kuid

data/lib/cucumber/step_methods.rb

@@ -5,19 +5,19 @@ module Cucumber
   module StepMethods
     # Each scenario will execute in the context of what the supplied block returns.
     def World(&proc)
-      $executor.register_world_proc(&proc)
+      executor.register_world_proc(&proc)
     end
 
     def Before(&proc)
-      $executor.register_before_scenario_proc(&proc)
+      executor.register_before_scenario_proc(&proc)
     end
     
     def After(&proc)
-      $executor.register_after_scenario_proc(&proc)
+      executor.register_after_scenario_proc(&proc)
     end
 
     def AfterStep(&proc)
-      $executor.register_after_step_proc(&proc)
+      executor.register_after_step_proc(&proc)
     end
 
     def Given(key, &proc)
@@ -41,5 +41,9 @@ module Cucumber
     def step_mother #:nodoc:
       @step_mother ||= StepMother.new
     end
+    
+    def executor
+      @executor ||= Executor.new(step_mother)
+    end
   end
 end

data/lib/cucumber/step_mother.rb

@@ -40,8 +40,8 @@ module Cucumber
         first_proc = @step_procs[regexp]
         message = %{Duplicate step definitions:
 
-#{first_proc.backtrace_line}
-#{proc.backtrace_line}
+#{first_proc.to_backtrace_line}
+#{proc.to_backtrace_line}
 
 }
         raise Duplicate.new(message)
@@ -65,7 +65,7 @@ module Cucumber
       else
         message = %{Multiple step definitions match #{step_name.inspect}:
 
-#{candidates.map{|regexp, args, proc| proc.backtrace_line}.join("\n")}
+#{candidates.map{|regexp, args, proc| proc.to_backtrace_line}.join("\n")}
 
 }
         raise Multiple.new(message)
@@ -76,6 +76,7 @@ module Cucumber
       @step_procs[regexp]
     end
     
+    # TODO - move execute here?
     def execute(step)
     end
   end

data/lib/cucumber/tree/scenario.rb

@@ -27,9 +27,11 @@ module Cucumber
     end
 
     class Scenario < BaseScenario
+      MIN_PADDING = 2
       
       # If a table follows, the header will be stored here. Weird, but convenient.
       attr_accessor :table_header
+      attr_reader :name, :line
       
       def initialize(feature, name, &proc)
         @feature, @name = feature, name
@@ -49,36 +51,46 @@ module Cucumber
         @feature.scenario_named(name)
       end
 
+      def padding_length(step)
+        (max_step_length - step.length) + MIN_PADDING
+      end
+      
+      def max_step_length
+        steps.map{|step| step.length}.max
+      end
+
       def row?
         false
       end
       
-      def add_step(keyword, name, line)
-        @steps_and_given_scenarios << Step.new(self, keyword, name, line)
+      def create_step(keyword, name, line)
+        step = Step.new(self, keyword, name, line)
+        @steps_and_given_scenarios << step
+        step
       end
       
-      def add_given_scenario(name, line)
-        @steps_and_given_scenarios << GivenScenario.new(self, name, line)
+      def create_given_scenario(name, line)
+        given_scenario =  GivenScenario.new(self, name, line)
+        @steps_and_given_scenarios << given_scenario
+        given_scenario
       end
 
       def Given(name)
-        add_step('Given', name, *caller[0].split(':')[1].to_i)
+        create_step('Given', name, *caller[0].split(':')[1].to_i)
       end
 
       def When(name)
-        add_step('When', name, *caller[0].split(':')[1].to_i)
+        create_step('When', name, *caller[0].split(':')[1].to_i)
       end
 
       def Then(name)
-        add_step('Then', name, *caller[0].split(':')[1].to_i)
+        create_step('Then', name, *caller[0].split(':')[1].to_i)
       end
 
       def And(name)
-        add_step('And', name, *caller[0].split(':')[1].to_i)
+        create_step('And', name, *caller[0].split(':')[1].to_i)
       end
 
-      attr_reader :name, :line
-
     end
 
     class RowScenario < BaseScenario

data/lib/cucumber/tree/step.rb

@@ -17,6 +17,10 @@ module Cucumber
       def steps
         self
       end
+      
+      def length
+        keyword.length + 1 + name.length
+      end
 
       if defined?(JRUBY_VERSION)
         PENDING_ADJUSTMENT = 2
@@ -31,7 +35,7 @@ module Cucumber
         begin
           proc.call_in(world, *args)
         rescue ArityMismatchError => e
-          e.backtrace[0] = proc.backtrace_line
+          e.backtrace[0] = proc.to_backtrace_line
           strip_pos = e.backtrace.index("#{__FILE__}:#{__LINE__ - 3}:in `execute_in'")
           format_error(strip_pos, proc, e)
         rescue => e
@@ -73,6 +77,10 @@ module Cucumber
       def previous_step
         @scenario.previous_step(self)
       end
+      
+      def padding_length
+        @scenario.padding_length(self)
+      end
     end
     
     class Step < BaseStep

data/lib/cucumber/treetop_parser/feature.treetop.erb

@@ -99,7 +99,7 @@ grammar Feature
     given_scenario_keyword space name:line_to_eol {
       def compile(scenario)
         line = input.line_of(interval.first)
-        scenario.add_given_scenario(name.text_value.strip, line)
+        scenario.create_given_scenario(name.text_value.strip, line)
       end
     }
   end
@@ -108,7 +108,7 @@ grammar Feature
     step_keyword space name:line_to_eol {
       def compile(scenario)
         line = input.line_of(interval.first)
-        scenario.add_step(step_keyword.text_value, name.text_value.strip, line)
+        scenario.create_step(step_keyword.text_value, name.text_value.strip, line)
       end
     }
   end
@@ -138,11 +138,11 @@ grammar Feature
   end
   
   rule eol
-    "\r\n?" / "\n"
+    ("\r" "\n"?) / "\n"
   end
-
+  
   rule step_keyword
-    '<%= words['given'] %>' / '<%= words['when'] %>' / '<%= words['then'] %>' / '<%= words['and'] %>'
+    '<%= words['given'] %>' / '<%= words['when'] %>' / '<%= words['then'] %>' / '<%= words['and'] %>' / '<%= words['but'] %>'
   end
   
   rule scenario_keyword

data/lib/cucumber/treetop_parser/feature_da.rb

@@ -1,33 +1,33 @@
-module Cucumber
-module TreetopParser
+module Cucumber #:nodoc:
+module TreetopParser #:nodoc:
 
-module Feature
+module Feature #:nodoc:
   include Treetop::Runtime
 
-  def root
+  def root #:nodoc:
     @root || :root
   end
 
-  module Root0
-    def header
+  module Root0 #:nodoc:
+    def header #:nodoc:
       elements[0]
     end
 
-    def scenario_sequence
+    def scenario_sequence #:nodoc:
       elements[1]
     end
 
   end
 
-  module Root1
-    def compile
+  module Root1 #:nodoc:
+    def compile #:nodoc:
       feature = Tree::Feature.new(header.text_value.strip)
       scenario_sequence.compile(feature)
       feature
     end
   end
 
-  def _nt_root
+  def _nt_root #:nodoc:
     start_index = index
     if node_cache[:root].has_key?(index)
       cached = node_cache[:root][index]
@@ -65,10 +65,10 @@ module Feature
     return r0
   end
 
-  module Header0
+  module Header0 #:nodoc:
   end
 
-  def _nt_header
+  def _nt_header #:nodoc:
     start_index = index
     if node_cache[:header].has_key?(index)
       cached = node_cache[:header][index]
@@ -123,39 +123,39 @@ module Feature
     return r0
   end
 
-  module ScenarioSequence0
-    def space
+  module ScenarioSequence0 #:nodoc:
+    def space #:nodoc:
       elements[0]
     end
 
-    def scenario_or_table
+    def scenario_or_table #:nodoc:
       elements[1]
     end
   end
 
-  module ScenarioSequence1
-    def head
+  module ScenarioSequence1 #:nodoc:
+    def head #:nodoc:
       elements[0]
     end
 
-    def tail
+    def tail #:nodoc:
       elements[1]
     end
   end
 
-  module ScenarioSequence2
-    def compile(feature)
+  module ScenarioSequence2 #:nodoc:
+    def compile(feature) #:nodoc:
       ([head] + tail).each do |scenario_or_table|
         scenario_or_table.compile(feature) if scenario_or_table.respond_to?(:compile)
       end
     end
     
-    def tail
+    def tail #:nodoc:
       super.elements.map { |elt| elt.scenario_or_table }
     end
   end
 
-  def _nt_scenario_sequence
+  def _nt_scenario_sequence #:nodoc:
     start_index = index
     if node_cache[:scenario_sequence].has_key?(index)
       cached = node_cache[:scenario_sequence][index]
@@ -211,36 +211,36 @@ module Feature
     return r0
   end
 
-  module Scenario0
-    def space
+  module Scenario0 #:nodoc:
+    def space #:nodoc:
       elements[0]
     end
 
-    def step_sequence
+    def step_sequence #:nodoc:
       elements[1]
     end
   end
 
-  module Scenario1
-    def scenario_keyword
+  module Scenario1 #:nodoc:
+    def scenario_keyword #:nodoc:
       elements[0]
     end
 
-    def space
+    def space #:nodoc:
       elements[1]
     end
 
-    def name
+    def name #:nodoc:
       elements[2]
     end
 
-    def steps
+    def steps #:nodoc:
       elements[3]
     end
   end
 
-  module Scenario2
-    def compile(feature)
+  module Scenario2 #:nodoc:
+    def compile(feature) #:nodoc:
       scenario = feature.add_scenario(name.text_value.strip)
       steps.step_sequence.compile(scenario) if steps.respond_to?(:step_sequence)
       # TODO - GET RID OF THIS last_scenario NASTINESS
@@ -249,7 +249,7 @@ module Feature
     end
   end
 
-  def _nt_scenario
+  def _nt_scenario #:nodoc:
     start_index = index
     if node_cache[:scenario].has_key?(index)
       cached = node_cache[:scenario][index]
@@ -304,7 +304,7 @@ module Feature
     return r0
   end
 
-  def _nt_scenario_or_table
+  def _nt_scenario_or_table #:nodoc:
     start_index = index
     if node_cache[:scenario_or_table].has_key?(index)
       cached = node_cache[:scenario_or_table][index]
@@ -331,40 +331,40 @@ module Feature
     return r0
   end
 
-  module Table0
-    def eol
+  module Table0 #:nodoc:
+    def eol #:nodoc:
       elements[1]
     end
 
-    def table_line
+    def table_line #:nodoc:
       elements[3]
     end
   end
 
-  module Table1
-    def head
+  module Table1 #:nodoc:
+    def head #:nodoc:
       elements[0]
     end
 
-    def body
+    def body #:nodoc:
       elements[1]
     end
   end
 
-  module Table2
-    def compile(feature)
+  module Table2 #:nodoc:
+    def compile(feature) #:nodoc:
       Feature.last_scenario.table_header = head.cell_values
       body.each do |table_line|
         feature.add_row_scenario(Feature.last_scenario, table_line.cell_values, table_line.line)
       end
     end
 
-    def body
+    def body #:nodoc:
       super.elements.map { |elt| elt.table_line }
     end
   end
 
-  def _nt_table
+  def _nt_table #:nodoc:
     start_index = index
     if node_cache[:table].has_key?(index)
       cached = node_cache[:table][index]
@@ -437,37 +437,37 @@ module Feature
     return r0
   end
 
-  module TableLine0
-    def cell_value
+  module TableLine0 #:nodoc:
+    def cell_value #:nodoc:
       elements[1]
     end
 
-    def separator
+    def separator #:nodoc:
       elements[3]
     end
   end
 
-  module TableLine1
-    def separator
+  module TableLine1 #:nodoc:
+    def separator #:nodoc:
       elements[0]
     end
 
-    def cells
+    def cells #:nodoc:
       elements[1]
     end
   end
 
-  module TableLine2
-    def cell_values
+  module TableLine2 #:nodoc:
+    def cell_values #:nodoc:
       cells.elements.map { |elt| elt.cell_value.text_value.strip }
     end
 
-    def line
+    def line #:nodoc:
       input.line_of(interval.first)
     end
   end
 
-  def _nt_table_line
+  def _nt_table_line #:nodoc:
     start_index = index
     if node_cache[:table_line].has_key?(index)
       cached = node_cache[:table_line][index]
@@ -549,10 +549,10 @@ module Feature
     return r0
   end
 
-  module CellValue0
+  module CellValue0 #:nodoc:
   end
 
-  def _nt_cell_value
+  def _nt_cell_value #:nodoc:
     start_index = index
     if node_cache[:cell_value].has_key?(index)
       cached = node_cache[:cell_value][index]
@@ -614,39 +614,39 @@ module Feature
     return r0
   end
 
-  module StepSequence0
-    def space
+  module StepSequence0 #:nodoc:
+    def space #:nodoc:
       elements[0]
     end
 
-    def step
+    def step #:nodoc:
       elements[1]
     end
   end
 
-  module StepSequence1
-    def head
+  module StepSequence1 #:nodoc:
+    def head #:nodoc:
       elements[0]
     end
 
-    def tail
+    def tail #:nodoc:
       elements[1]
     end
   end
 
-  module StepSequence2
-    def compile(scenario)
+  module StepSequence2 #:nodoc:
+    def compile(scenario) #:nodoc:
       ([head] + tail).each do |step|
         step.compile(scenario)
       end
     end
     
-    def tail
+    def tail #:nodoc:
       super.elements.map { |elt| elt.step }
     end
   end
 
-  def _nt_step_sequence
+  def _nt_step_sequence #:nodoc:
     start_index = index
     if node_cache[:step_sequence].has_key?(index)
       cached = node_cache[:step_sequence][index]
@@ -697,7 +697,7 @@ module Feature
     return r0
   end
 
-  def _nt_step
+  def _nt_step #:nodoc:
     start_index = index
     if node_cache[:step].has_key?(index)
       cached = node_cache[:step][index]
@@ -724,28 +724,28 @@ module Feature
     return r0
   end
 
-  module GivenScenario0
-    def given_scenario_keyword
+  module GivenScenario0 #:nodoc:
+    def given_scenario_keyword #:nodoc:
       elements[0]
     end
 
-    def space
+    def space #:nodoc:
       elements[1]
     end
 
-    def name
+    def name #:nodoc:
       elements[2]
     end
   end
 
-  module GivenScenario1
-    def compile(scenario)
+  module GivenScenario1 #:nodoc:
+    def compile(scenario) #:nodoc:
       line = input.line_of(interval.first)
-      scenario.add_given_scenario(name.text_value.strip, line)
+      scenario.create_given_scenario(name.text_value.strip, line)
     end
   end
 
-  def _nt_given_scenario
+  def _nt_given_scenario #:nodoc:
     start_index = index
     if node_cache[:given_scenario].has_key?(index)
       cached = node_cache[:given_scenario][index]
@@ -778,28 +778,28 @@ module Feature
     return r0
   end
 
-  module PlainStep0
-    def step_keyword
+  module PlainStep0 #:nodoc:
+    def step_keyword #:nodoc:
       elements[0]
     end
 
-    def space
+    def space #:nodoc:
       elements[1]
     end
 
-    def name
+    def name #:nodoc:
       elements[2]
     end
   end
 
-  module PlainStep1
-    def compile(scenario)
+  module PlainStep1 #:nodoc:
+    def compile(scenario) #:nodoc:
       line = input.line_of(interval.first)
-      scenario.add_step(step_keyword.text_value, name.text_value.strip, line)
+      scenario.create_step(step_keyword.text_value, name.text_value.strip, line)
     end
   end
 
-  def _nt_plain_step
+  def _nt_plain_step #:nodoc:
     start_index = index
     if node_cache[:plain_step].has_key?(index)
       cached = node_cache[:plain_step][index]
@@ -832,7 +832,7 @@ module Feature
     return r0
   end
 
-  def _nt_separator
+  def _nt_separator #:nodoc:
     start_index = index
     if node_cache[:separator].has_key?(index)
       cached = node_cache[:separator][index]
@@ -853,7 +853,7 @@ module Feature
     return r0
   end
 
-  def _nt_space
+  def _nt_space #:nodoc:
     start_index = index
     if node_cache[:space].has_key?(index)
       cached = node_cache[:space][index]
@@ -894,10 +894,10 @@ module Feature
     return r0
   end
 
-  module LineToEol0
+  module LineToEol0 #:nodoc:
   end
 
-  def _nt_line_to_eol
+  def _nt_line_to_eol #:nodoc:
     start_index = index
     if node_cache[:line_to_eol].has_key?(index)
       cached = node_cache[:line_to_eol][index]
@@ -947,13 +947,13 @@ module Feature
     return r0
   end
 
-  module CommentToEol0
-    def line_to_eol
+  module CommentToEol0 #:nodoc:
+    def line_to_eol #:nodoc:
       elements[1]
     end
   end
 
-  def _nt_comment_to_eol
+  def _nt_comment_to_eol #:nodoc:
     start_index = index
     if node_cache[:comment_to_eol].has_key?(index)
       cached = node_cache[:comment_to_eol][index]
@@ -987,7 +987,7 @@ module Feature
     return r0
   end
 
-  def _nt_white
+  def _nt_white #:nodoc:
     start_index = index
     if node_cache[:white].has_key?(index)
       cached = node_cache[:white][index]
@@ -1014,7 +1014,7 @@ module Feature
     return r0
   end
 
-  def _nt_blank
+  def _nt_blank #:nodoc:
     start_index = index
     if node_cache[:blank].has_key?(index)
       cached = node_cache[:blank][index]
@@ -1034,7 +1034,10 @@ module Feature
     return r0
   end
 
-  def _nt_eol
+  module Eol0 #:nodoc:
+  end
+
+  def _nt_eol #:nodoc:
     start_index = index
     if node_cache[:eol].has_key?(index)
       cached = node_cache[:eol][index]
@@ -1043,25 +1046,49 @@ module Feature
     end
 
     i0 = index
-    if input.index("\r\n?", index) == index
-      r1 = (SyntaxNode).new(input, index...(index + 3))
-      @index += 3
+    i1, s1 = index, []
+    if input.index("\r", index) == index
+      r2 = (SyntaxNode).new(input, index...(index + 1))
+      @index += 1
     else
-      terminal_parse_failure("\r\n?")
+      terminal_parse_failure("\r")
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      if input.index("\n", index) == index
+        r4 = (SyntaxNode).new(input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("\n")
+        r4 = nil
+      end
+      if r4
+        r3 = r4
+      else
+        r3 = SyntaxNode.new(input, index...index)
+      end
+      s1 << r3
+    end
+    if s1.last
+      r1 = (SyntaxNode).new(input, i1...index, s1)
+      r1.extend(Eol0)
+    else
+      self.index = i1
       r1 = nil
     end
     if r1
       r0 = r1
     else
       if input.index("\n", index) == index
-        r2 = (SyntaxNode).new(input, index...(index + 1))
+        r5 = (SyntaxNode).new(input, index...(index + 1))
         @index += 1
       else
         terminal_parse_failure("\n")
-        r2 = nil
+        r5 = nil
       end
-      if r2
-        r0 = r2
+      if r5
+        r0 = r5
       else
         self.index = i0
         r0 = nil
@@ -1073,7 +1100,7 @@ module Feature
     return r0
   end
 
-  def _nt_step_keyword
+  def _nt_step_keyword #:nodoc:
     start_index = index
     if node_cache[:step_keyword].has_key?(index)
       cached = node_cache[:step_keyword][index]
@@ -1122,8 +1149,19 @@ module Feature
           if r4
             r0 = r4
           else
-            self.index = i0
-            r0 = nil
+            if input.index('Men', index) == index
+              r5 = (SyntaxNode).new(input, index...(index + 3))
+              @index += 3
+            else
+              terminal_parse_failure('Men')
+              r5 = nil
+            end
+            if r5
+              r0 = r5
+            else
+              self.index = i0
+              r0 = nil
+            end
           end
         end
       end
@@ -1134,7 +1172,7 @@ module Feature
     return r0
   end
 
-  def _nt_scenario_keyword
+  def _nt_scenario_keyword #:nodoc:
     start_index = index
     if node_cache[:scenario_keyword].has_key?(index)
       cached = node_cache[:scenario_keyword][index]
@@ -1155,10 +1193,10 @@ module Feature
     return r0
   end
 
-  module GivenScenarioKeyword0
+  module GivenScenarioKeyword0 #:nodoc:
   end
 
-  def _nt_given_scenario_keyword
+  def _nt_given_scenario_keyword #:nodoc:
     start_index = index
     if node_cache[:given_scenario_keyword].has_key?(index)
       cached = node_cache[:given_scenario_keyword][index]
@@ -1205,7 +1243,7 @@ module Feature
 
 end
 
-class FeatureParser < Treetop::Runtime::CompiledParser
+class FeatureParser < Treetop::Runtime::CompiledParser #:nodoc:
   include Feature
 end