kbaum-cucumber 0.4.5.pre

data/lib/cucumber/parser/feature.tt

@@ -0,0 +1,317 @@
+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_names)
+            Ast::Tags.matches?(self.parent.tags.tag_names, 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_names)
+            feature_tag_names = self.parent.parent.tags.tag_names
+            source_tag_names = (feature_tag_names + tags.tag_names).uniq
+            Ast::Tags.matches?(source_tag_names, 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_names)
+            feature_tag_names = self.parent.parent.tags.tag_names
+            source_tag_names = (feature_tag_names + tags.tag_names).uniq
+            Ast::Tags.matches?(source_tag_names, 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 py_string
+        open_py_string s:(!close_py_string .)* close_py_string {
+          def at_line?(line)
+            line >= open_py_string.line && line <= close_py_string.line
+          end
+
+          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
+        indent:space* '"""' space* eol {
+          def indentation
+            indent.text_value.length
+          end
+
+          def line
+            indent.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,34 @@
+module Cucumber
+  module Parser
+    module I18n
+      grammar <%= keywords('grammar_name')[0] %>
+        include Feature
+        include Table
+
+        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

@@ -0,0 +1,108 @@
+# 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?
+        @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
+        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)
+        Treetop.load_from_string(grammar)
+        @parser = Parser::I18n.const_get("#{@keywords['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 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}
+      end
+
+      private
+
+      def treetop_keywords(keywords)
+        "(" + keywords.map{|k| %{"#{k}"}}.join(" / ") + ")"
+      end
+
+      def keyword_space(val)
+        (val + ' ').sub(/< $/,'')
+      end
+    end
+  end
+end