module Cucumber module TreetopParser module Feature include Treetop::Runtime def root @root || :root end module Root0 def header elements[0] end def scenarios elements[1] end end module Root1 def feature f = Tree::Feature.new(header.text_value.strip) scenarios.populate(f) f end end 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 end i0, s0 = index, [] r1 = _nt_header s0 << r1 if r1 r2 = _nt_scenarios s0 << r2 end if s0.last r0 = (SyntaxNode).new(input, i0...index, s0) r0.extend(Root0) r0.extend(Root1) else self.index = i0 r0 = nil end node_cache[:root][start_index] = r0 return r0 end module Header0 end 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 end s0, i0 = [], index loop do i1, s1 = index, [] i2 = index r3 = _nt_step_scenario if r3 r2 = nil else self.index = i2 r2 = SyntaxNode.new(input, index...index) end s1 << r2 if r2 if index < input_length r4 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure("any character") r4 = nil end s1 << r4 end if s1.last r1 = (SyntaxNode).new(input, i1...index, s1) r1.extend(Header0) else self.index = i1 r1 = nil end if r1 s0 << r1 else break end end r0 = SyntaxNode.new(input, i0...index, s0) node_cache[:header][start_index] = r0 return r0 end module Scenarios0 def step_scenario elements[0] end def more elements[1] end end module Scenarios1 def populate(feature) step_scenario.populate(feature) more.elements.each { |m| m.populate(feature) } end end def _nt_scenarios start_index = index if node_cache[:scenarios].has_key?(index) cached = node_cache[:scenarios][index] @index = cached.interval.end if cached return cached end i0, s0 = index, [] r1 = _nt_step_scenario s0 << r1 if r1 s2, i2 = [], index loop do i3 = index r4 = _nt_table if r4 r3 = r4 else r5 = _nt_step_scenario if r5 r3 = r5 else self.index = i3 r3 = nil end end if r3 s2 << r3 else break end end r2 = SyntaxNode.new(input, i2...index, s2) s0 << r2 end if s0.last r0 = (SyntaxNode).new(input, i0...index, s0) r0.extend(Scenarios0) r0.extend(Scenarios1) else self.index = i0 r0 = nil end node_cache[:scenarios][start_index] = r0 return r0 end module StepScenario0 end module StepScenario1 def scenario_keyword elements[1] end def name elements[4] end def steps elements[6] end end module StepScenario2 def populate(feature) sc = feature.add_scenario(name.text_value) steps.elements.each{|s| s.populate(sc)} Feature.last_scenario = sc end end def _nt_step_scenario start_index = index if node_cache[:step_scenario].has_key?(index) cached = node_cache[:step_scenario][index] @index = cached.interval.end if cached return cached end i0, s0 = index, [] s1, i1 = [], index loop do r2 = _nt_whitespace if r2 s1 << r2 else break end end r1 = SyntaxNode.new(input, i1...index, s1) s0 << r1 if r1 r3 = _nt_scenario_keyword s0 << r3 if r3 if input.index(":", index) == index r4 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure(":") r4 = nil end s0 << r4 if r4 s5, i5 = [], index loop do r6 = _nt_whitespace if r6 s5 << r6 else break end end r5 = SyntaxNode.new(input, i5...index, s5) s0 << r5 if r5 s7, i7 = [], index loop do i8, s8 = index, [] i9 = index r10 = _nt_newline if r10 r9 = nil else self.index = i9 r9 = SyntaxNode.new(input, index...index) end s8 << r9 if r9 if index < input_length r11 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure("any character") r11 = nil end s8 << r11 end if s8.last r8 = (SyntaxNode).new(input, i8...index, s8) r8.extend(StepScenario0) else self.index = i8 r8 = nil end if r8 s7 << r8 else break end end r7 = SyntaxNode.new(input, i7...index, s7) s0 << r7 if r7 s12, i12 = [], index loop do r13 = _nt_newline if r13 s12 << r13 else break end end r12 = SyntaxNode.new(input, i12...index, s12) s0 << r12 if r12 s14, i14 = [], index loop do r15 = _nt_step if r15 s14 << r15 else break end end if s14.empty? self.index = i14 r14 = nil else r14 = SyntaxNode.new(input, i14...index, s14) end s0 << r14 end end end end end end if s0.last r0 = (SyntaxNode).new(input, i0...index, s0) r0.extend(StepScenario1) r0.extend(StepScenario2) else self.index = i0 r0 = nil end node_cache[:step_scenario][start_index] = r0 return r0 end module Step0 end module Step1 def step_keyword elements[1] end def name elements[3] end end module Step2 def populate(scenario) line = input.line_of(interval.first) scenario.add_step(step_keyword.text_value, name.text_value, line) end end 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 end i0, s0 = index, [] s1, i1 = [], index loop do r2 = _nt_whitespace if r2 s1 << r2 else break end end r1 = SyntaxNode.new(input, i1...index, s1) s0 << r1 if r1 r3 = _nt_step_keyword s0 << r3 if r3 s4, i4 = [], index loop do r5 = _nt_whitespace if r5 s4 << r5 else break end end r4 = SyntaxNode.new(input, i4...index, s4) s0 << r4 if r4 s6, i6 = [], index loop do i7, s7 = index, [] i8 = index r9 = _nt_newline if r9 r8 = nil else self.index = i8 r8 = SyntaxNode.new(input, index...index) end s7 << r8 if r8 if index < input_length r10 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure("any character") r10 = nil end s7 << r10 end if s7.last r7 = (SyntaxNode).new(input, i7...index, s7) r7.extend(Step0) else self.index = i7 r7 = nil end if r7 s6 << r7 else break end end r6 = SyntaxNode.new(input, i6...index, s6) s0 << r6 if r6 s11, i11 = [], index loop do r12 = _nt_newline if r12 s11 << r12 else break end end r11 = SyntaxNode.new(input, i11...index, s11) s0 << r11 end end end end if s0.last r0 = (SyntaxNode).new(input, i0...index, s0) r0.extend(Step1) r0.extend(Step2) else self.index = i0 r0 = nil end node_cache[:step][start_index] = r0 return r0 end 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 end i0 = index if input.index('Dado', index) == index r1 = (SyntaxNode).new(input, index...(index + 4)) @index += 4 else terminal_parse_failure('Dado') r1 = nil end if r1 r0 = r1 else if input.index('Cuando', index) == index r2 = (SyntaxNode).new(input, index...(index + 6)) @index += 6 else terminal_parse_failure('Cuando') r2 = nil end if r2 r0 = r2 else if input.index('Entonces', index) == index r3 = (SyntaxNode).new(input, index...(index + 8)) @index += 8 else terminal_parse_failure('Entonces') r3 = nil end if r3 r0 = r3 else if input.index('Y', index) == index r4 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure('Y') r4 = nil end if r4 r0 = r4 else self.index = i0 r0 = nil end end end end node_cache[:step_keyword][start_index] = r0 return r0 end 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 end if input.index('Escenario', index) == index r0 = (SyntaxNode).new(input, index...(index + 9)) @index += 9 else terminal_parse_failure('Escenario') r0 = nil end node_cache[:scenario_keyword][start_index] = r0 return r0 end module Table0 def newline elements[0] end def table_line elements[1] end end module Table1 def table_line elements[0] end def more elements[1] end end module Table2 def populate(feature) Feature.last_scenario.table_header = table_line.values more.elements.each do |e| feature.add_row_scenario(Feature.last_scenario, e.table_line.values, e.table_line.line) end 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 i0, s0 = index, [] r1 = _nt_table_line s0 << r1 if r1 s2, i2 = [], index loop do i3, s3 = index, [] r4 = _nt_newline s3 << r4 if r4 r5 = _nt_table_line s3 << r5 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 end if s2.empty? self.index = i2 r2 = nil else r2 = SyntaxNode.new(input, i2...index, s2) end s0 << r2 if r2 s6, i6 = [], index loop do r7 = _nt_newline if r7 s6 << r7 else break end end r6 = SyntaxNode.new(input, i6...index, s6) s0 << r6 end end if s0.last r0 = (SyntaxNode).new(input, i0...index, s0) r0.extend(Table1) r0.extend(Table2) else self.index = i0 r0 = nil end node_cache[:table][start_index] = r0 return r0 end module TableLine0 def cell_value elements[1] end def separator elements[3] end end module TableLine1 def separator elements[1] end def cells elements[2] end end module TableLine2 def values cells.elements.map { |cell| cell.cell_value.text_value } end def line input.line_of(interval.first) end end 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 end i0, s0 = index, [] s1, i1 = [], index loop do r2 = _nt_whitespace if r2 s1 << r2 else break end end r1 = SyntaxNode.new(input, i1...index, s1) s0 << r1 if r1 r3 = _nt_separator s0 << r3 if r3 s4, i4 = [], index loop do i5, s5 = index, [] s6, i6 = [], index loop do r7 = _nt_whitespace if r7 s6 << r7 else break end end r6 = SyntaxNode.new(input, i6...index, s6) s5 << r6 if r6 r8 = _nt_cell_value s5 << r8 if r8 s9, i9 = [], index loop do r10 = _nt_whitespace if r10 s9 << r10 else break end end r9 = SyntaxNode.new(input, i9...index, s9) s5 << r9 if r9 r11 = _nt_separator s5 << r11 end end end if s5.last r5 = (SyntaxNode).new(input, i5...index, s5) r5.extend(TableLine0) 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 end end if s0.last r0 = (SyntaxNode).new(input, i0...index, s0) r0.extend(TableLine1) r0.extend(TableLine2) else self.index = i0 r0 = nil end node_cache[:table_line][start_index] = r0 return r0 end module CellValue0 end 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 end s0, i0 = [], index loop do i1, s1 = index, [] i2 = index i3 = index r4 = _nt_separator if r4 r3 = r4 else r5 = _nt_newline if r5 r3 = r5 else r6 = _nt_whitespace if r6 r3 = r6 else self.index = i3 r3 = nil end 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 r7 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure("any character") r7 = nil end s1 << r7 end if s1.last r1 = (SyntaxNode).new(input, i1...index, s1) r1.extend(CellValue0) 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_value][start_index] = r0 return r0 end 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 end if input.index('|', index) == index r0 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure('|') r0 = nil end node_cache[:separator][start_index] = r0 return r0 end def _nt_newline start_index = index if node_cache[:newline].has_key?(index) cached = node_cache[:newline][index] @index = cached.interval.end if cached return cached end i0 = index if input.index("\r\n?", index) == index r1 = (SyntaxNode).new(input, index...(index + 3)) @index += 3 else terminal_parse_failure("\r\n?") r1 = nil end if r1 r0 = r1 else if input.index("\n", index) == index r2 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else terminal_parse_failure("\n") r2 = nil end if r2 r0 = r2 else self.index = i0 r0 = nil end end node_cache[:newline][start_index] = r0 return r0 end def _nt_whitespace start_index = index if node_cache[:whitespace].has_key?(index) cached = node_cache[:whitespace][index] @index = cached.interval.end if cached return cached end if input.index(Regexp.new('[ \\v\\f\\t]'), index) == index r0 = (SyntaxNode).new(input, index...(index + 1)) @index += 1 else r0 = nil end node_cache[:whitespace][start_index] = r0 return r0 end end class FeatureParser < Treetop::Runtime::CompiledParser include Feature end end end