aslakhellesoy-cucumber 0.1.99.3 → 0.1.99.4

data/lib/cucumber/parser/feature.tt

@@ -1,160 +0,0 @@
-module Cucumber
-  module Parser
-    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
-    # 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) .)* feature_elements {
-          def build
-            Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build)
-          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:([a-z0-9])+
-      end
-
-      rule comment
-        (comment_line eol+)* {
-          def build
-            Ast::Comment.new(text_value)
-          end
-        }
-      end
-
-      rule comment_line
-        '#' line_to_eol
-      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 (eol+ / eof) steps {
-          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 {
-          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
-        space* step_keyword space* name:line_to_eol (eol+ / eof) multi:multiline_arg? {
-          def build
-            if multi.respond_to?(:build)
-              Ast::Step.new(step_keyword.line, step_keyword.text_value, name.text_value, multi.build)
-            else
-              Ast::Step.new(step_keyword.line, step_keyword.text_value, name.text_value)
-            end
-          end
-        }
-      end
-
-      rule examples_sections
-        examples+ {
-          def build
-            elements.map{|e| e.build}
-          end
-        }
-      end
-
-      rule examples
-        space* examples_keyword white table {
-          def build
-            [examples_keyword.line, examples_keyword.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

@@ -1,27 +0,0 @@
-module Cucumber
-  module Parser
-    grammar I18n
-
-      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

@@ -1,396 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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,67 +0,0 @@
-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
-      def line
-        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