cucumber 0.6.4 → 0.7.0.beta.1

data/lib/cucumber/parser/feature.tt

@@ -1,287 +0,0 @@
-require 'cucumber/ast/tags'
-
-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
-
-      rule feature_sub
-        white 
-        comment 
-        white 
-        tags 
-        white 
-        header:(!(scenario_outline / scenario / background) .)* 
-        bg:background? 
-        feature_elements
-        comment? {
-          def build(filter)
-            if(filter.nil? || feature_elements.accept?(filter) || (!bg.empty? && filter.accept?(bg)))
-              background = bg.respond_to?(:build) ? bg.build : nil      
-              Ast::Feature.new(
-                background, 
-                comment.build, 
-                tags.build, 
-                header.text_value, 
-                feature_elements.build(background, filter)
-              )
-            end
-          end
-        }
-      end
-
-      rule tags
-        white ts:(tag (space/eol)+)* {
-          def at_line?(line)
-            ts.elements.detect{|e| e.tag.line == line}
-          end
-
-          def build
-            Ast::Tags.new(ts.line, tag_names)
-          end
-          
-          def tag_names
-            @tag_names ||= ts.elements.map{|e| e.tag.text_value}
-          end
-        }
-      end
-
-      rule tag
-        '@' [^@\r\n\t ]+
-      end
-
-      rule comment
-        (comment_line white)* {
-          def build
-            Ast::Comment.new(text_value)
-          end
-        }
-      end
-
-      rule comment_line
-        space* '#' line_to_eol
-      end
-
-      rule background
-        comment white background_keyword space* name:lines_to_keyword? (eol+ / eof) steps {
-          def matches_name?(regexp_to_match)
-            name.build =~ regexp_to_match
-          end
-
-          def at_line?(line)
-            background_keyword.line == line ||
-            steps.at_line?(line)
-          end
-
-          def matches_tags?(tag_expression)
-            tag_expression.eval(self.parent.tags.tag_names)
-          end
-
-          def build
-            Ast::Background.new(
-              comment.build, 
-              background_keyword.line,
-              background_keyword.text_value,
-              name.build, 
-              steps.build
-            )
-          end
-        }
-      end
-
-      rule feature_elements
-        (scenario / scenario_outline)* {
-          def accept?(filter)
-            filter.nil? || elements.empty? || elements.detect{|feature_element| filter.accept?(feature_element)}
-          end
-          
-          def build(background, filter)
-            elements.map do |feature_element|
-              if filter.nil? || filter.accept?(feature_element)
-                feature_element.build(background, filter)
-              end
-            end.compact
-          end
-        }
-      end
-
-      rule scenario
-        comment tags white scenario_keyword space* name:lines_to_keyword white steps white {
-          def at_line?(line)
-            scenario_keyword.line == line ||
-            steps.at_line?(line) ||
-            tags.at_line?(line)
-          end
-
-          def matches_tags?(tag_expression)
-            feature_tag_names = self.parent.parent.tags.tag_names
-            source_tag_names = (feature_tag_names + tags.tag_names).uniq
-            tag_expression.eval(source_tag_names)
-          end
-
-          def matches_name?(regexp_to_match)
-            name.build =~ regexp_to_match
-          end
-
-          def build(background, filter)
-            Ast::Scenario.new(
-              background,
-              comment.build, 
-              tags.build,
-              scenario_keyword.line,
-              scenario_keyword.text_value, 
-              name.build, 
-              steps.build
-            )
-          end
-        }
-      end
-
-      rule scenario_outline
-        comment tags white scenario_outline_keyword space* name:lines_to_keyword white steps examples_sections white {
-          def at_line?(line)
-            outline_at_line?(line) ||
-            examples_sections.at_line?(line) ||
-            tags.at_line?(line)
-          end
-
-          def outline_at_line?(line)
-            scenario_outline_keyword.line == line ||
-            steps.at_line?(line)
-          end
-
-          def matches_tags?(tag_expression)
-            feature_tag_names = self.parent.parent.tags.tag_names
-            source_tag_names = (feature_tag_names + tags.tag_names).uniq
-            tag_expression.eval(source_tag_names)
-          end
-
-          def matches_name?(regexp_to_match)
-            outline_matches_name?(regexp_to_match) || examples_sections.matches_name?(regexp_to_match)
-          end
-
-          def outline_matches_name?(regexp_to_match)
-            name.build =~ regexp_to_match
-          end
-
-          def build(background, filter)
-            Ast::ScenarioOutline.new(
-              background,
-              comment.build, 
-              tags.build,
-              scenario_outline_keyword.line, 
-              scenario_outline_keyword.text_value, 
-              name.build, 
-              steps.build, 
-              examples_sections.build(filter, self)
-            )
-          end
-        }
-      end
-
-      rule steps
-        step* {
-          def at_line?(line)
-            elements.detect{|e| e.at_line?(line)}
-          end
-
-          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 at_line?(line)
-            step_keyword.line == line ||
-            (multi.respond_to?(:at_line?) && multi.at_line?(line))
-          end
-
-          def build
-            if multi.respond_to?(:build)
-              Ast::Step.new(step_keyword.line, step_keyword.text_value.strip, name.text_value.strip, multi.build)
-            else
-              Ast::Step.new(step_keyword.line, step_keyword.text_value.strip, name.text_value.strip)
-            end
-          end
-        }
-      end
-
-      rule examples_sections
-        examples* {
-          def at_line?(line)
-            elements.detect { |e| e.at_line?(line) }
-          end
-
-          def matches_name?(regexp_to_match)
-            elements.detect { |e| e.matches_name?(regexp_to_match) }
-          end
-
-          def build(filter, scenario_outline)
-            elements.map do |e|
-              if(filter.nil? || filter.accept_example?(e, scenario_outline))
-                e.build(filter, scenario_outline)
-              end
-            end.compact
-          end
-        }
-      end
-
-      rule examples
-        comment space* examples_keyword space* name:lines_to_keyword? eol table white {
-          def at_line?(line)
-            examples_keyword.line == line ||
-            table.at_line?(line)
-          end
-
-          def matches_tags?(tag_names)
-            true
-          end
-
-          def outline_at_line?(line)
-            true
-          end
-
-          def matches_name?(regexp_to_match)
-            name.build =~ regexp_to_match
-          end
-
-          def build(filter, scenario_outline)
-            [comment.build, examples_keyword.line, examples_keyword.text_value, name.build, table.raw(filter, scenario_outline)]
-          end
-        }
-      end
-
-      rule multiline_arg
-        table / py_string
-      end
-
-      rule line_to_eol
-        (!eol .)*
-      end
-
-      rule lines_to_keyword
-        (!(eol space* reserved_words_and_symbols) .)* {
-          def build
-            self.text_value.split("\n").map{|s| s.strip}.join("\n")
-          end
-        }
-      end
-
-      rule reserved_words_and_symbols
-        (step_keyword) / scenario_keyword / scenario_outline_keyword / table / tag / comment_line
-      end
-
-      rule white
-        (space / eol)*
-      end
-
-    end
-  end
-end

data/lib/cucumber/parser/i18n.tt

@@ -1,35 +0,0 @@
-module Cucumber
-  module Parser
-    module I18n
-      grammar <%= @grammar_name %>
-        include Feature
-        include Table
-        include PyString
-
-        rule feature
-          feature_sub
-        end
-
-        rule background_keyword
-          <%= treetop_keywords(background_keywords) %> ':'
-        end
-
-        rule scenario_keyword
-          <%= treetop_keywords(scenario_keywords) %> ':'
-        end
-
-        rule scenario_outline_keyword
-          <%= treetop_keywords(scenario_outline_keywords) %> ':'
-        end
-
-        rule step_keyword
-          <%= treetop_keywords(step_keywords) %>
-        end
-
-        rule examples_keyword
-          <%= treetop_keywords(examples_keywords) %> ':'?
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/parser/natural_language.rb

@@ -1,118 +0,0 @@
-# TODO: REMOVE ME
-# Most of this class now lives in Gherkin's i18n.rb
-module Cucumber
-  module Parser
-    class NaturalLanguage
-      KEYWORD_KEYS = %w{name native feature background scenario scenario_outline examples given when then and but}
-
-      class << self
-        def get(step_mother, lang)
-          languages[lang] ||= new(step_mother, lang)
-        end
-
-        def languages
-          @languages ||= {}
-        end
-
-        # Used by code generators for other lexer tools like pygments lexer and textmate bundle
-        def all(step_mother=nil)
-          Cucumber::LANGUAGES.keys.sort.map{|lang| get(step_mother, lang)}
-        end
-      end
-
-      def initialize(step_mother, lang)
-        @keywords = Cucumber::LANGUAGES[lang]
-        raise "Language not supported: #{lang.inspect}" if @keywords.nil?
-        @grammar_name = lang.gsub(/[\s-]/, '').upcase
-        register_adverbs(step_mother) if step_mother
-        @parser = nil
-      end
-
-      def register_adverbs(step_mother)
-        adverbs = %w{given when then and but}.map{|keyword| @keywords[keyword].split('|').map{|w| w.gsub(/[\s<']/, '')}}.flatten
-        step_mother.register_adverbs(adverbs) if step_mother
-      end
-
-      def parser
-        return @parser if @parser
-        i18n_tt = File.expand_path(File.dirname(__FILE__) + '/i18n.tt')
-        template = File.open(i18n_tt, Cucumber.file_mode('r')).read
-        erb = ERB.new(template)
-        grammar = erb.result(binding)
-
-        # The Rails 2-3-stable branch has decided to monkey-patch ERB so that ERB#result
-        # returns a subclass of String (SafeBuffer). This class will escape '&',  '>',  '<' and '"',
-        # effectively breaking any other library that relies on ERB behavig the way it _should_.
-        # This is a workaround hack until this has been fixed in Rails.
-        grammar = "" + grammar # Make SafeBuffer a String again.
-        Treetop.load_from_string(grammar)
-        @parser = Parser::I18n.const_get("#{@grammar_name}Parser").new
-        def @parser.inspect
-          "#<#{self.class.name}>"
-        end
-        @parser
-      end
-
-      def parse(source, path, filter)
-        feature = parser.parse_or_fail(source, path, filter)
-        feature.language = self if feature
-        feature
-      end
-
-      def incomplete?
-        KEYWORD_KEYS.detect{|key| @keywords[key].nil?}
-      end
-
-      def feature_keywords
-        keywords('feature')
-      end
-
-      def scenario_keywords
-        keywords('scenario')
-      end
-
-      def scenario_outline_keywords
-        keywords('scenario_outline')
-      end
-
-      def background_keywords
-        keywords('background')
-      end
-
-      def examples_keywords
-        keywords('examples')
-      end
-
-      def but_keywords(space=true)
-        keywords('but', space)
-      end
-
-      def and_keywords(space=true)
-        keywords('and', space)
-      end
-
-      def given_keyword
-        keywords('given', false)[1] # The 0th one is a '*', which we don't want
-      end
-
-      def step_keywords
-        %w{given when then and but}.map{|key| keywords(key, true)}.flatten.uniq
-      end
-
-      def keywords(key, space=false)
-        raise "No #{key} in #{@keywords.inspect}" if @keywords[key].nil?
-        @keywords[key].split('|').map{|kw| space ? keyword_space(kw) : kw}.uniq
-      end
-
-      private
-
-      def treetop_keywords(keywords)
-        "(" + keywords.map{|k| %{"#{k}"}}.join(" / ") + ")"
-      end
-
-      def keyword_space(val)
-        (val + ' ').sub(/< $/,'')
-      end
-    end
-  end
-end

data/lib/cucumber/parser/py_string.rb

@@ -1,285 +0,0 @@
-# Autogenerated from a Treetop grammar. Edits may be lost.
-
-
-module Cucumber
-  module Parser
-    # TIP: When you hack on the grammar, just delete py_string.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 PyString
-      include Treetop::Runtime
-
-      def root
-        @root || :py_string
-      end
-
-      include Common
-
-      module PyString0
-      end
-
-      module PyString1
-        def open_py_string
-          elements[0]
-        end
-
-        def s
-          elements[1]
-        end
-
-        def close_py_string
-          elements[2]
-        end
-      end
-
-      module PyString2
-        def at_line?(line)
-          line >= open_py_string.line && line <= close_py_string.line
-        end
-
-        def build(ignored_filter=nil)
-          Ast::PyString.new(open_py_string.line, close_py_string.line, s.text_value, open_py_string.indentation)
-        end
-      end
-
-      def _nt_py_string
-        start_index = index
-        if node_cache[:py_string].has_key?(index)
-          cached = node_cache[:py_string][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        r1 = _nt_open_py_string
-        s0 << r1
-        if r1
-          s2, i2 = [], index
-          loop do
-            i3, s3 = index, []
-            i4 = index
-            r5 = _nt_close_py_string
-            if r5
-              r4 = nil
-            else
-              @index = i4
-              r4 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s3 << r4
-            if r4
-              if index < input_length
-                r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure("any character")
-                r6 = nil
-              end
-              s3 << r6
-            end
-            if s3.last
-              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-              r3.extend(PyString0)
-            else
-              @index = i3
-              r3 = nil
-            end
-            if r3
-              s2 << r3
-            else
-              break
-            end
-          end
-          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-          s0 << r2
-          if r2
-            r7 = _nt_close_py_string
-            s0 << r7
-          end
-        end
-        if s0.last
-          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-          r0.extend(PyString1)
-          r0.extend(PyString2)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:py_string][start_index] = r0
-
-        r0
-      end
-
-      module OpenPyString0
-        def indent
-          elements[0]
-        end
-
-        def eol
-          elements[3]
-        end
-      end
-
-      module OpenPyString1
-        def indentation
-          indent.text_value
-        end
-
-        def line
-          indent.line
-        end
-      end
-
-      def _nt_open_py_string
-        start_index = index
-        if node_cache[:open_py_string].has_key?(index)
-          cached = node_cache[:open_py_string][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        s1, i1 = [], index
-        loop do
-          r2 = _nt_space
-          if r2
-            s1 << r2
-          else
-            break
-          end
-        end
-        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-        s0 << r1
-        if r1
-          if has_terminal?('"""', false, index)
-            r3 = instantiate_node(SyntaxNode,input, index...(index + 3))
-            @index += 3
-          else
-            terminal_parse_failure('"""')
-            r3 = nil
-          end
-          s0 << r3
-          if r3
-            s4, i4 = [], index
-            loop do
-              r5 = _nt_space
-              if r5
-                s4 << r5
-              else
-                break
-              end
-            end
-            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-            s0 << r4
-            if r4
-              r6 = _nt_eol
-              s0 << r6
-            end
-          end
-        end
-        if s0.last
-          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-          r0.extend(OpenPyString0)
-          r0.extend(OpenPyString1)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:open_py_string][start_index] = r0
-
-        r0
-      end
-
-      module ClosePyString0
-        def eol
-          elements[0]
-        end
-
-        def quotes
-          elements[2]
-        end
-
-        def white
-          elements[3]
-        end
-      end
-
-      module ClosePyString1
-        def line
-          quotes.line
-        end
-      end
-
-      def _nt_close_py_string
-        start_index = index
-        if node_cache[:close_py_string].has_key?(index)
-          cached = node_cache[:close_py_string][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        r1 = _nt_eol
-        s0 << r1
-        if r1
-          s2, i2 = [], index
-          loop do
-            r3 = _nt_space
-            if r3
-              s2 << r3
-            else
-              break
-            end
-          end
-          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-          s0 << r2
-          if r2
-            if has_terminal?('"""', false, index)
-              r4 = instantiate_node(SyntaxNode,input, index...(index + 3))
-              @index += 3
-            else
-              terminal_parse_failure('"""')
-              r4 = nil
-            end
-            s0 << r4
-            if r4
-              r5 = _nt_white
-              s0 << r5
-            end
-          end
-        end
-        if s0.last
-          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-          r0.extend(ClosePyString0)
-          r0.extend(ClosePyString1)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:close_py_string][start_index] = r0
-
-        r0
-      end
-
-    end
-
-    class PyStringParser < Treetop::Runtime::CompiledParser
-      include PyString
-    end
-
-  end
-end