lib/cucumber/treetop_parser/feature_en.rb in cucumber-0.1.8 vs lib/cucumber/treetop_parser/feature_en.rb in cucumber-0.1.9
- old
+ new
@@ -1,35 +1,35 @@
-module Cucumber #:nodoc:
-module TreetopParser #:nodoc:
-
-module Feature #:nodoc:
+module Cucumber
+# :stopdoc:
+module TreetopParser
+module Feature
include Treetop::Runtime
- def root #:nodoc:
+ def root
@root || :root
end
- module Root0 #:nodoc:
- def header #:nodoc:
+ module Root0
+ def header
elements[1]
end
- def scenario_sequence #:nodoc:
+ def scenario_sequence
elements[2]
end
end
- module Root1 #:nodoc:
- def compile #:nodoc:
+ module Root1
+ def compile
feature = Tree::Feature.new(header.text_value.strip)
scenario_sequence.compile(feature)
feature
end
end
- def _nt_root #:nodoc:
+ def _nt_root
start_index = index
if node_cache[:root].has_key?(index)
cached = node_cache[:root][index]
@index = cached.interval.end if cached
return cached
@@ -72,14 +72,14 @@
node_cache[:root][start_index] = r0
return r0
end
- module Header0 #:nodoc:
+ module Header0
end
- def _nt_header #:nodoc:
+ def _nt_header
start_index = index
if node_cache[:header].has_key?(index)
cached = node_cache[:header][index]
@index = cached.interval.end if cached
return cached
@@ -142,43 +142,43 @@
node_cache[:header][start_index] = r0
return r0
end
- module ScenarioSequence0 #:nodoc:
- def space #:nodoc:
+ module ScenarioSequence0
+ def space
elements[0]
end
- def scenario_or_table #:nodoc:
+ def scenario_or_table
elements[1]
end
end
- module ScenarioSequence1 #:nodoc:
- def head #:nodoc:
+ module ScenarioSequence1
+ def head
elements[0]
end
- def tail #:nodoc:
+ def tail
elements[1]
end
end
- module ScenarioSequence2 #:nodoc:
- def compile(feature) #:nodoc:
+ module ScenarioSequence2
+ def compile(feature)
([head] + tail).each do |scenario_or_table|
scenario_or_table.compile(feature) if scenario_or_table.respond_to?(:compile)
end
end
- def tail #:nodoc:
+ def tail
super.elements.map { |elt| elt.scenario_or_table }
end
end
- def _nt_scenario_sequence #:nodoc:
+ def _nt_scenario_sequence
start_index = index
if node_cache[:scenario_sequence].has_key?(index)
cached = node_cache[:scenario_sequence][index]
@index = cached.interval.end if cached
return cached
@@ -230,46 +230,46 @@
node_cache[:scenario_sequence][start_index] = r0
return r0
end
- module Scenario0 #:nodoc:
- def space #:nodoc:
+ module Scenario0
+ def space
elements[0]
end
- def step_sequence #:nodoc:
+ def step_sequence
elements[1]
end
end
- module Scenario1 #:nodoc:
- def scenario_keyword #:nodoc:
+ module Scenario1
+ def scenario_keyword
elements[0]
end
- def name #:nodoc:
+ def name
elements[2]
end
- def steps #:nodoc:
+ def steps
elements[3]
end
end
- module Scenario2 #:nodoc:
- def compile(feature) #:nodoc:
+ module Scenario2
+ def compile(feature)
line = input.line_of(interval.first)
scenario = feature.add_scenario(name.text_value.strip, line)
steps.step_sequence.compile(scenario) if steps.respond_to?(:step_sequence)
# TODO - GET RID OF THIS last_scenario NASTINESS
# Use a better datastructure, like a linked list...
Feature.last_scenario = scenario
end
end
- def _nt_scenario #:nodoc:
+ def _nt_scenario
start_index = index
if node_cache[:scenario].has_key?(index)
cached = node_cache[:scenario][index]
@index = cached.interval.end if cached
return cached
@@ -325,11 +325,11 @@
node_cache[:scenario][start_index] = r0
return r0
end
- def _nt_scenario_or_table #:nodoc:
+ def _nt_scenario_or_table
start_index = index
if node_cache[:scenario_or_table].has_key?(index)
cached = node_cache[:scenario_or_table][index]
@index = cached.interval.end if cached
return cached
@@ -352,31 +352,27 @@
node_cache[:scenario_or_table][start_index] = r0
return r0
end
- module MoreExamples0 #:nodoc:
- def more_examples_keyword #:nodoc:
+ module MoreExamples0
+ def more_examples_keyword
elements[0]
end
- def space #:nodoc:
+ def table
elements[1]
end
-
- def table #:nodoc:
- elements[2]
- end
end
- module MoreExamples1 #:nodoc:
- def compile(f) #:nodoc:
+ module MoreExamples1
+ def compile(f)
table.compile(f)
end
end
- def _nt_more_examples #:nodoc:
+ def _nt_more_examples
start_index = index
if node_cache[:more_examples].has_key?(index)
cached = node_cache[:more_examples][index]
@index = cached.interval.end if cached
return cached
@@ -384,16 +380,12 @@
i0, s0 = index, []
r1 = _nt_more_examples_keyword
s0 << r1
if r1
- r2 = _nt_space
+ r2 = _nt_table
s0 << r2
- if r2
- r3 = _nt_table
- s0 << r3
- end
end
if s0.last
r0 = (SyntaxNode).new(input, i0...index, s0)
r0.extend(MoreExamples0)
r0.extend(MoreExamples1)
@@ -405,111 +397,119 @@
node_cache[:more_examples][start_index] = r0
return r0
end
- module Table0 #:nodoc:
- def eol #:nodoc:
+ module Table0
+ def eol
elements[1]
end
- def table_line #:nodoc:
+ def table_line
elements[3]
end
end
- module Table1 #:nodoc:
- def head #:nodoc:
+ module Table1
+ def space
elements[0]
end
- def body #:nodoc:
+ def head
elements[1]
end
+
+ def body
+ elements[2]
+ end
end
- module Table2 #:nodoc:
- def compile(feature) #:nodoc:
+ module Table2
+ def compile(feature)
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 matrix #:nodoc:
+ def matrix
([head] + body).map do |table_line|
- table_line.cell_values # We're losing the line - we'll get it back when we make our own class #:nodoc:
+ table_line.cell_values # We're losing the line - we'll get it back when we make our own class
end
end
- def to_arg #:nodoc:
+ def to_arg
Model::Table.new(matrix)
end
- def body #:nodoc:
+ def body
super.elements.map { |elt| elt.table_line }
end
end
- def _nt_table #:nodoc:
+ 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
i0, s0 = index, []
- r1 = _nt_table_line
+ r1 = _nt_space
s0 << r1
if r1
- s2, i2 = [], index
- loop do
- i3, s3 = index, []
- s4, i4 = [], index
+ r2 = _nt_table_line
+ s0 << r2
+ if r2
+ s3, i3 = [], index
loop do
- r5 = _nt_blank
- if r5
- s4 << r5
- else
- break
- end
- end
- r4 = SyntaxNode.new(input, i4...index, s4)
- s3 << r4
- if r4
- r6 = _nt_eol
- s3 << r6
- if r6
- r8 = _nt_space
- if r8
- r7 = r8
+ i4, s4 = index, []
+ s5, i5 = [], index
+ loop do
+ r6 = _nt_blank
+ if r6
+ s5 << r6
else
- r7 = SyntaxNode.new(input, index...index)
+ break
end
- s3 << r7
+ end
+ r5 = SyntaxNode.new(input, i5...index, s5)
+ s4 << r5
+ if r5
+ r7 = _nt_eol
+ s4 << r7
if r7
- r9 = _nt_table_line
- s3 << r9
+ r9 = _nt_space
+ if r9
+ r8 = r9
+ else
+ r8 = SyntaxNode.new(input, index...index)
+ end
+ s4 << r8
+ if r8
+ r10 = _nt_table_line
+ s4 << r10
+ end
end
end
+ if s4.last
+ r4 = (SyntaxNode).new(input, i4...index, s4)
+ r4.extend(Table0)
+ else
+ self.index = i4
+ r4 = nil
+ end
+ if r4
+ s3 << r4
+ else
+ break
+ end
end
- if s3.last
- r3 = (SyntaxNode).new(input, i3...index, s3)
- r3.extend(Table0)
- else
- self.index = i3
- r3 = nil
- end
- if r3
- s2 << r3
- else
- break
- end
+ r3 = SyntaxNode.new(input, i3...index, s3)
+ s0 << r3
end
- r2 = SyntaxNode.new(input, i2...index, s2)
- s0 << r2
end
if s0.last
r0 = (SyntaxNode).new(input, i0...index, s0)
r0.extend(Table1)
r0.extend(Table2)
@@ -521,41 +521,41 @@
node_cache[:table][start_index] = r0
return r0
end
- module TableLine0 #:nodoc:
- def cell_value #:nodoc:
+ module TableLine0
+ def cell_value
elements[1]
end
- def separator #:nodoc:
+ def separator
elements[3]
end
end
- module TableLine1 #:nodoc:
- def separator #:nodoc:
+ module TableLine1
+ def separator
elements[0]
end
- def cells #:nodoc:
+ def cells
elements[1]
end
end
- module TableLine2 #:nodoc:
- def cell_values #:nodoc:
+ module TableLine2
+ def cell_values
cells.elements.map { |elt| elt.cell_value.text_value.strip }
end
- def line #:nodoc:
+ def line
input.line_of(interval.first)
end
end
- def _nt_table_line #:nodoc:
+ def _nt_table_line
start_index = index
if node_cache[:table_line].has_key?(index)
cached = node_cache[:table_line][index]
@index = cached.interval.end if cached
return cached
@@ -633,14 +633,14 @@
node_cache[:table_line][start_index] = r0
return r0
end
- module CellValue0 #:nodoc:
+ module CellValue0
end
- def _nt_cell_value #:nodoc:
+ def _nt_cell_value
start_index = index
if node_cache[:cell_value].has_key?(index)
cached = node_cache[:cell_value][index]
@index = cached.interval.end if cached
return cached
@@ -698,43 +698,43 @@
node_cache[:cell_value][start_index] = r0
return r0
end
- module StepSequence0 #:nodoc:
- def space #:nodoc:
+ module StepSequence0
+ def space
elements[0]
end
- def step #:nodoc:
+ def step
elements[1]
end
end
- module StepSequence1 #:nodoc:
- def head #:nodoc:
+ module StepSequence1
+ def head
elements[0]
end
- def tail #:nodoc:
+ def tail
elements[1]
end
end
- module StepSequence2 #:nodoc:
- def compile(scenario) #:nodoc:
+ module StepSequence2
+ def compile(scenario)
([head] + tail).each do |step|
step.compile(scenario)
end
end
- def tail #:nodoc:
+ def tail
super.elements.map { |elt| elt.step }
end
end
- def _nt_step_sequence #:nodoc:
+ def _nt_step_sequence
start_index = index
if node_cache[:step_sequence].has_key?(index)
cached = node_cache[:step_sequence][index]
@index = cached.interval.end if cached
return cached
@@ -781,11 +781,11 @@
node_cache[:step_sequence][start_index] = r0
return r0
end
- def _nt_step #:nodoc:
+ def _nt_step
start_index = index
if node_cache[:step].has_key?(index)
cached = node_cache[:step][index]
@index = cached.interval.end if cached
return cached
@@ -808,28 +808,28 @@
node_cache[:step][start_index] = r0
return r0
end
- module GivenScenario0 #:nodoc:
- def given_scenario_keyword #:nodoc:
+ module GivenScenario0
+ def given_scenario_keyword
elements[0]
end
- def name #:nodoc:
+ def name
elements[2]
end
end
- module GivenScenario1 #:nodoc:
- def compile(scenario) #:nodoc:
+ module GivenScenario1
+ def compile(scenario)
line = input.line_of(interval.first)
scenario.create_given_scenario(name.text_value.strip, line)
end
end
- def _nt_given_scenario #:nodoc:
+ def _nt_given_scenario
start_index = index
if node_cache[:given_scenario].has_key?(index)
cached = node_cache[:given_scenario][index]
@index = cached.interval.end if cached
return cached
@@ -863,45 +863,36 @@
node_cache[:given_scenario][start_index] = r0
return r0
end
- module PlainStep0 #:nodoc:
- def space #:nodoc:
+ module PlainStep0
+ def step_keyword
elements[0]
end
- def multiline_arg #:nodoc:
- elements[1]
- end
- end
-
- module PlainStep1 #:nodoc:
- def step_keyword #:nodoc:
- elements[0]
- end
-
- def name #:nodoc:
+ def name
elements[2]
end
- def multi #:nodoc:
+ def multi
elements[3]
end
end
- module PlainStep2 #:nodoc:
- def compile(scenario) #:nodoc:
+ module PlainStep1
+ def compile(scenario)
line = input.line_of(interval.first)
step = scenario.create_step(step_keyword.text_value, name.text_value.strip, line)
- if multi.respond_to?(:multiline_arg)
- step.extra_args << multi.multiline_arg.to_arg
+
+ if multi.respond_to?(:to_arg)
+ step.extra_args << multi.to_arg
end
end
end
- def _nt_plain_step #:nodoc:
+ def _nt_plain_step
start_index = index
if node_cache[:plain_step].has_key?(index)
cached = node_cache[:plain_step][index]
@index = cached.interval.end if cached
return cached
@@ -920,24 +911,11 @@
s0 << r2
if r2
r4 = _nt_line_to_eol
s0 << r4
if r4
- i6, s6 = index, []
- r7 = _nt_space
- s6 << r7
- if r7
- r8 = _nt_multiline_arg
- s6 << r8
- end
- if s6.last
- r6 = (SyntaxNode).new(input, i6...index, s6)
- r6.extend(PlainStep0)
- else
- self.index = i6
- r6 = nil
- end
+ r6 = _nt_multiline_arg
if r6
r5 = r6
else
r5 = SyntaxNode.new(input, index...index)
end
@@ -945,23 +923,23 @@
end
end
end
if s0.last
r0 = (SyntaxNode).new(input, i0...index, s0)
+ r0.extend(PlainStep0)
r0.extend(PlainStep1)
- r0.extend(PlainStep2)
else
self.index = i0
r0 = nil
end
node_cache[:plain_step][start_index] = r0
return r0
end
- def _nt_multiline_arg #:nodoc:
+ def _nt_multiline_arg
start_index = index
if node_cache[:multiline_arg].has_key?(index)
cached = node_cache[:multiline_arg][index]
@index = cached.interval.end if cached
return cached
@@ -984,86 +962,106 @@
node_cache[:multiline_arg][start_index] = r0
return r0
end
- module MultilineString0 #:nodoc:
+ module MultilineString0
end
- module MultilineString1 #:nodoc:
- def quote #:nodoc:
+ module MultilineString1
+ def eol
elements[0]
end
- def string #:nodoc:
+ def indent
elements[1]
end
- def quote #:nodoc:
+ def triple_quote
elements[2]
end
+
+ def string
+ elements[3]
+ end
+
+ def triple_quote
+ elements[4]
+ end
end
- module MultilineString2 #:nodoc:
- def to_arg #:nodoc:
- string.text_value.split("\n").map{|l| l.strip}.join("\n")
+ module MultilineString2
+ def to_arg
+ indent_length = indent.text_value.length
+ significant_lines = string.text_value.split("\n")[1..-2]
+ significant_lines.map do |l|
+ l[indent_length..-1]
+ end.join("\n")
end
end
- def _nt_multiline_string #:nodoc:
+ def _nt_multiline_string
start_index = index
if node_cache[:multiline_string].has_key?(index)
cached = node_cache[:multiline_string][index]
@index = cached.interval.end if cached
return cached
end
i0, s0 = index, []
- r1 = _nt_quote
+ r1 = _nt_eol
s0 << r1
if r1
- s2, i2 = [], index
- loop do
- i3, s3 = index, []
- i4 = index
- r5 = _nt_quote
- if r5
- r4 = nil
- else
- self.index = i4
- r4 = SyntaxNode.new(input, index...index)
- end
- s3 << r4
- if r4
- if index < input_length
- r6 = (SyntaxNode).new(input, index...(index + 1))
- @index += 1
- else
- terminal_parse_failure("any character")
- r6 = nil
+ r2 = _nt_space
+ s0 << r2
+ if r2
+ r3 = _nt_triple_quote
+ s0 << r3
+ if r3
+ s4, i4 = [], index
+ loop do
+ i5, s5 = index, []
+ i6 = index
+ r7 = _nt_triple_quote
+ if r7
+ r6 = nil
+ else
+ self.index = i6
+ r6 = SyntaxNode.new(input, index...index)
+ end
+ s5 << r6
+ if r6
+ if index < input_length
+ r8 = (SyntaxNode).new(input, index...(index + 1))
+ @index += 1
+ else
+ terminal_parse_failure("any character")
+ r8 = nil
+ end
+ s5 << r8
+ end
+ if s5.last
+ r5 = (SyntaxNode).new(input, i5...index, s5)
+ r5.extend(MultilineString0)
+ else
+ self.index = i5
+ r5 = nil
+ end
+ if r5
+ s4 << r5
+ else
+ break
+ end
end
- s3 << r6
+ r4 = SyntaxNode.new(input, i4...index, s4)
+ s0 << r4
+ if r4
+ r9 = _nt_triple_quote
+ s0 << r9
+ end
end
- if s3.last
- r3 = (SyntaxNode).new(input, i3...index, s3)
- r3.extend(MultilineString0)
- else
- self.index = i3
- r3 = nil
- end
- if r3
- s2 << r3
- else
- break
- end
end
- r2 = SyntaxNode.new(input, i2...index, s2)
- s0 << r2
- if r2
- r7 = _nt_quote
- s0 << r7
- end
end
if s0.last
r0 = (SyntaxNode).new(input, i0...index, s0)
r0.extend(MultilineString1)
r0.extend(MultilineString2)
@@ -1075,32 +1073,32 @@
node_cache[:multiline_string][start_index] = r0
return r0
end
- def _nt_quote #:nodoc:
+ def _nt_triple_quote
start_index = index
- if node_cache[:quote].has_key?(index)
- cached = node_cache[:quote][index]
+ if node_cache[:triple_quote].has_key?(index)
+ cached = node_cache[:triple_quote][index]
@index = cached.interval.end if cached
return cached
end
- if input.index('"', index) == index
- r0 = (SyntaxNode).new(input, index...(index + 1))
- @index += 1
+ if input.index('"""', index) == index
+ r0 = (SyntaxNode).new(input, index...(index + 3))
+ @index += 3
else
- terminal_parse_failure('"')
+ terminal_parse_failure('"""')
r0 = nil
end
- node_cache[:quote][start_index] = r0
+ node_cache[:triple_quote][start_index] = r0
return r0
end
- def _nt_separator #:nodoc:
+ def _nt_separator
start_index = index
if node_cache[:separator].has_key?(index)
cached = node_cache[:separator][index]
@index = cached.interval.end if cached
return cached
@@ -1117,11 +1115,11 @@
node_cache[:separator][start_index] = r0
return r0
end
- def _nt_space #:nodoc:
+ 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
@@ -1158,14 +1156,14 @@
node_cache[:space][start_index] = r0
return r0
end
- module LineToEol0 #:nodoc:
+ module LineToEol0
end
- def _nt_line_to_eol #:nodoc:
+ def _nt_line_to_eol
start_index = index
if node_cache[:line_to_eol].has_key?(index)
cached = node_cache[:line_to_eol][index]
@index = cached.interval.end if cached
return cached
@@ -1211,17 +1209,17 @@
node_cache[:line_to_eol][start_index] = r0
return r0
end
- module CommentToEol0 #:nodoc:
- def line_to_eol #:nodoc:
+ module CommentToEol0
+ def line_to_eol
elements[1]
end
end
- def _nt_comment_to_eol #:nodoc:
+ def _nt_comment_to_eol
start_index = index
if node_cache[:comment_to_eol].has_key?(index)
cached = node_cache[:comment_to_eol][index]
@index = cached.interval.end if cached
return cached
@@ -1251,11 +1249,11 @@
node_cache[:comment_to_eol][start_index] = r0
return r0
end
- def _nt_white #:nodoc:
+ def _nt_white
start_index = index
if node_cache[:white].has_key?(index)
cached = node_cache[:white][index]
@index = cached.interval.end if cached
return cached
@@ -1278,11 +1276,11 @@
node_cache[:white][start_index] = r0
return r0
end
- def _nt_blank #:nodoc:
+ def _nt_blank
start_index = index
if node_cache[:blank].has_key?(index)
cached = node_cache[:blank][index]
@index = cached.interval.end if cached
return cached
@@ -1298,14 +1296,14 @@
node_cache[:blank][start_index] = r0
return r0
end
- module Eol0 #:nodoc:
+ module Eol0
end
- def _nt_eol #:nodoc:
+ 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
@@ -1364,11 +1362,11 @@
node_cache[:eol][start_index] = r0
return r0
end
- def _nt_step_keyword #:nodoc:
+ def _nt_step_keyword
start_index = index
if node_cache[:step_keyword].has_key?(index)
cached = node_cache[:step_keyword][index]
@index = cached.interval.end if cached
return cached
@@ -1436,14 +1434,14 @@
node_cache[:step_keyword][start_index] = r0
return r0
end
- module ScenarioKeyword0 #:nodoc:
+ module ScenarioKeyword0
end
- def _nt_scenario_keyword #:nodoc:
+ def _nt_scenario_keyword
start_index = index
if node_cache[:scenario_keyword].has_key?(index)
cached = node_cache[:scenario_keyword][index]
@index = cached.interval.end if cached
return cached
@@ -1484,14 +1482,14 @@
node_cache[:scenario_keyword][start_index] = r0
return r0
end
- module MoreExamplesKeyword0 #:nodoc:
+ module MoreExamplesKeyword0
end
- def _nt_more_examples_keyword #:nodoc:
+ def _nt_more_examples_keyword
start_index = index
if node_cache[:more_examples_keyword].has_key?(index)
cached = node_cache[:more_examples_keyword][index]
@index = cached.interval.end if cached
return cached
@@ -1532,14 +1530,14 @@
node_cache[:more_examples_keyword][start_index] = r0
return r0
end
- module GivenScenarioKeyword0 #:nodoc:
+ module GivenScenarioKeyword0
end
- def _nt_given_scenario_keyword #:nodoc:
+ def _nt_given_scenario_keyword
start_index = index
if node_cache[:given_scenario_keyword].has_key?(index)
cached = node_cache[:given_scenario_keyword][index]
@index = cached.interval.end if cached
return cached
@@ -1582,10 +1580,10 @@
return r0
end
end
-class FeatureParser < Treetop::Runtime::CompiledParser #:nodoc:
+class FeatureParser < Treetop::Runtime::CompiledParser
include Feature
end
end
\ No newline at end of file