notch8-cucumber 0.1.99.23

data/lib/cucumber/parser/feature.tt

@@ -0,0 +1,188 @@
+module Cucumber
+  module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
+    grammar Feature
+      include I18n
+      include Table
+
+      rule feature
+        white 
+        comment 
+        white 
+        tags 
+        white 
+        header:(!(scenario_outline / scenario / background) .)* 
+        background:(background)? 
+        feature_elements
+        comment? {
+          def build
+            if background.respond_to?(:build)
+              Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build, background.build)
+            else
+              Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build)
+            end
+          end
+        }
+      end
+
+      rule tags
+        white ts:(tag (space/eol)+)* {
+          def build
+            tag_names = ts.elements.map{|e| e.tag.tag_name.text_value}
+            Ast::Tags.new(ts.line, tag_names)
+          end
+        }
+      end
+
+      rule tag
+        '@' tag_name:([^@\n\t ])+
+      end
+
+      rule comment
+        (comment_line white)* {
+          def build
+            Ast::Comment.new(text_value)
+          end
+        }
+      end
+
+      rule comment_line
+        '#' line_to_eol
+      end
+
+      rule background
+         comment white background_keyword space* (eol+ / eof) steps {
+           def build
+             Ast::Background.new(
+               comment.build, 
+               background_keyword.line,
+               background_keyword.text_value, 
+               steps.build
+             )
+            end
+          }
+      end
+
+      rule feature_elements
+        (scenario / scenario_outline)* {
+          def build
+            elements.map{|s| s.build}
+          end
+        }
+      end
+
+      rule scenario
+        comment tags white scenario_keyword space* name:line_to_eol (white / eof) steps white {
+          def build
+            Ast::Scenario.new(
+              comment.build, 
+              tags.build,
+              scenario_keyword.line,
+              scenario_keyword.text_value, 
+              name.text_value, 
+              steps.build
+            )
+          end
+        }
+      end
+
+      rule scenario_outline
+        comment tags white scenario_outline_keyword space* name:line_to_eol white steps examples_sections white {
+          def build
+            Ast::ScenarioOutline.new(
+              comment.build, 
+              tags.build,
+              scenario_outline_keyword.line, 
+              scenario_outline_keyword.text_value, 
+              name.text_value, 
+              steps.build, 
+              examples_sections.build
+            )
+          end
+        }
+      end
+
+      rule steps
+        step* {
+          def build
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule step
+        comment space* step_keyword space* name:line_to_eol (eol+ / eof) multi:multiline_arg? white {
+          def build
+            if multi.respond_to?(:build)
+              Ast::Step.new(step_keyword.line, step_keyword.text_value, name.text_value.strip, multi.build)
+            else
+              Ast::Step.new(step_keyword.line, step_keyword.text_value, name.text_value.strip)
+            end
+          end
+        }
+      end
+
+      rule examples_sections
+        examples* {
+          def build
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule examples
+        space* examples_keyword space* name:line_to_eol? eol table white {
+          def build
+            [examples_keyword.line, examples_keyword.text_value, name.text_value, table.raw]
+          end
+        }
+      end
+
+      rule multiline_arg
+        table / py_string
+      end
+
+      rule line_to_eol
+        (!eol .)*
+      end
+
+      rule py_string
+        open_py_string s:(!close_py_string .)* close_py_string {
+          def build
+            Ast::PyString.new(open_py_string.line, close_py_string.line, s.text_value, open_py_string.indentation)
+          end
+        }
+      end
+
+      rule open_py_string
+        white '"""' space* eol {
+          def indentation
+            white.text_value.length
+          end
+
+          def line
+            white.line
+          end
+        }
+      end
+
+      rule close_py_string
+        eol space* quotes:'"""' white {
+          def line
+            quotes.line
+          end
+        }
+      end
+
+      rule white
+        (space / eol)*
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/i18n.tt

@@ -0,0 +1,31 @@
+module Cucumber
+  module Parser
+    grammar I18n
+
+      rule background_keyword
+        (<%= keywords('background') %>) ':'
+      end
+
+      rule scenario_keyword
+        (<%= keywords('scenario') %>) ':'
+      end
+
+      rule scenario_outline_keyword
+        (<%= keywords('scenario_outline') %>) ':'
+      end
+
+      rule step_keyword
+        (<%= keywords('given') %>) /
+        (<%= keywords('when') %>) /
+        (<%= keywords('then') %>) /
+        (<%= keywords('and') %>) /
+        (<%= keywords('but') %>)
+      end
+
+      rule examples_keyword
+        (<%= keywords('examples') %>) ':'?
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/table.rb

@@ -0,0 +1,402 @@
+module Cucumber
+  module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
+    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