kosmas58-cucumber 0.2.2.1 → 0.2.3.3

data/lib/cucumber/parser/feature.tt

@@ -20,25 +20,42 @@ module Cucumber
         bg:background? 
         feature_elements
         comment? {
-          def build
-            background = bg.respond_to?(:build) ? bg.build : nil
-            Ast::Feature.new(
-              background, 
-              comment.build, 
-              tags.build, 
-              header.text_value, 
-              feature_elements.build(background)
-            )
+          def has_tags?(tag_names)
+            tags.has_tags?(tag_names)
+          end
+          
+          def build(filter)
+            if(filter.nil? || feature_elements.accept?(filter))
+              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 has_tags?(tags)
+            tag_names.detect{|tag_name| tags.index(tag_name)}
+          end
+
           def build
-            tag_names = ts.elements.map{|e| e.tag.tag_name.text_value}
             Ast::Tags.new(ts.line, tag_names)
           end
+          
+          def tag_names
+            ts.elements.map{|e| e.tag.tag_name.text_value}
+          end
         }
       end
 
@@ -59,12 +76,13 @@ module Cucumber
       end
 
       rule background
-         comment white background_keyword space* (eol+ / eof) steps {
+         comment white background_keyword space* name:line_to_eol? (eol+ / eof) steps {
            def build
              Ast::Background.new(
                comment.build, 
                background_keyword.line,
-               background_keyword.text_value, 
+               background_keyword.text_value,
+               name.text_value, 
                steps.build
              )
             end
@@ -73,15 +91,38 @@ module Cucumber
 
       rule feature_elements
         (scenario / scenario_outline)* {
-          def build(background)
-            elements.map{|s| s.build(background)}
+          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:line_to_eol white steps white {
-          def build(background)
+          def at_line?(line)
+            scenario_keyword.line == line ||
+            steps.at_line?(line) ||
+            tags.at_line?(line)
+          end
+
+          def has_tags?(tag_names)
+            feature_tags = self.parent.parent.tags
+            tags.has_tags?(tag_names) || feature_tags.has_tags?(tag_names)
+          end
+
+          def matches_name?(name_to_match)
+            name.text_value == name_to_match
+          end
+
+          def build(background, filter)
             Ast::Scenario.new(
               background,
               comment.build, 
@@ -97,7 +138,27 @@ module Cucumber
 
       rule scenario_outline
         comment tags white scenario_outline_keyword space* name:line_to_eol white steps examples_sections white {
-          def build(background)
+          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 has_tags?(tag_names)
+            feature_tags = self.parent.parent.tags
+            tags.has_tags?(tag_names) || feature_tags.has_tags?(tag_names)
+          end
+
+          def matches_name?(name_to_match)
+            name.text_value == name_to_match
+          end
+
+          def build(background, filter)
             Ast::ScenarioOutline.new(
               background,
               comment.build, 
@@ -106,7 +167,7 @@ module Cucumber
               scenario_outline_keyword.text_value, 
               name.text_value, 
               steps.build, 
-              examples_sections.build
+              examples_sections.build(filter, self)
             )
           end
         }
@@ -114,6 +175,10 @@ module Cucumber
 
       rule steps
         step* {
+          def at_line?(line)
+            elements.detect{|e| e.at_line?(line)}
+          end
+
           def build
             elements.map{|e| e.build}
           end
@@ -121,7 +186,12 @@ module Cucumber
       end
 
       rule step
-        comment space* step_keyword space* name:line_to_eol (eol+ / eof) multi:multiline_arg? white {
+        comment space* step_keyword 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, name.text_value.strip, multi.build)
@@ -134,16 +204,37 @@ module Cucumber
 
       rule examples_sections
         examples* {
-          def build
-            elements.map{|e| e.build}
+          def at_line?(line)
+            elements.detect { |e| e.at_line?(line) }
+          end
+
+          def build(filter, scenario_outline)
+            elements.map do |e|
+              if(filter.nil? || filter.accept?(e) || filter.outline_at_line?(scenario_outline))
+                e.build(filter, scenario_outline)
+              end
+            end.compact
           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]
+          def at_line?(line)
+            examples_keyword.line == line ||
+            table.at_line?(line)
+          end
+
+          def has_tags?(tag_names)
+            true
+          end
+
+          def outline_at_line?(line)
+            true
+          end
+
+          def build(filter, scenario_outline)
+            [examples_keyword.line, examples_keyword.text_value, name.text_value, table.raw(filter, scenario_outline)]
           end
         }
       end
@@ -158,6 +249,10 @@ module Cucumber
 
       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

data/lib/cucumber/parser/i18n.tt

@@ -22,6 +22,10 @@ module Cucumber
         (<%= keywords('but') %>)
       end
 
+      rule keyword_space
+        <%= keywords('space_after_keyword', true) ? 'space+' : 'space*' %>
+      end
+
       rule examples_keyword
         (<%= keywords('examples') %>) ':'?
       end

data/lib/cucumber/parser/table.rb

@@ -14,12 +14,20 @@ module Cucumber
       end
 
       module Table0
-        def build
+        def at_line?(line)
+          elements.detect{|table_row| table_row.at_line?(line)}
+        end
+
+        def build(filter=nil)
           Ast::Table.new(raw)
         end
 
-        def raw
-          elements.map{|e| e.build}
+        def raw(filter=nil, scenario_outline=nil)
+          elements.map do |table_row|
+            if(filter.nil? || table_row == elements[0] || filter.at_line?(table_row) || (scenario_outline && filter.outline_at_line?(scenario_outline)))
+              table_row.build
+            end
+          end.compact
         end
       end
 
@@ -44,7 +52,7 @@ module Cucumber
           self.index = i0
           r0 = nil
         else
-          r0 = SyntaxNode.new(input, i0...index, s0)
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
           r0.extend(Table0)
         end
 
@@ -68,6 +76,10 @@ module Cucumber
       end
 
       module TableRow2
+        def at_line?(line)
+          cells.line == line
+        end
+
         def build
           row = cells.elements.map do |elt| 
             value = elt.cell.text_value.strip
@@ -101,11 +113,11 @@ module Cucumber
             break
           end
         end
-        r1 = SyntaxNode.new(input, i1...index, s1)
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
         s0 << r1
         if r1
           if input.index('|', index) == index
-            r3 = (SyntaxNode).new(input, index...(index + 1))
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
             @index += 1
           else
             terminal_parse_failure('|')
@@ -120,7 +132,7 @@ module Cucumber
               s5 << r6
               if r6
                 if input.index('|', index) == index
-                  r7 = (SyntaxNode).new(input, index...(index + 1))
+                  r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
                   @index += 1
                 else
                   terminal_parse_failure('|')
@@ -129,7 +141,7 @@ module Cucumber
                 s5 << r7
               end
               if s5.last
-                r5 = (SyntaxNode).new(input, i5...index, s5)
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
                 r5.extend(TableRow0)
               else
                 self.index = i5
@@ -145,7 +157,7 @@ module Cucumber
               self.index = i4
               r4 = nil
             else
-              r4 = SyntaxNode.new(input, i4...index, s4)
+              r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
             end
             s0 << r4
             if r4
@@ -158,7 +170,7 @@ module Cucumber
                   break
                 end
               end
-              r8 = SyntaxNode.new(input, i8...index, s8)
+              r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
               s0 << r8
               if r8
                 i10 = index
@@ -175,7 +187,7 @@ module Cucumber
                   self.index = i11
                   r11 = nil
                 else
-                  r11 = SyntaxNode.new(input, i11...index, s11)
+                  r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
                 end
                 if r11
                   r10 = r11
@@ -194,7 +206,7 @@ module Cucumber
           end
         end
         if s0.last
-          r0 = (SyntaxNode).new(input, i0...index, s0)
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
           r0.extend(TableRow1)
           r0.extend(TableRow2)
         else
@@ -224,7 +236,7 @@ module Cucumber
           i2 = index
           i3 = index
           if input.index('|', index) == index
-            r4 = (SyntaxNode).new(input, index...(index + 1))
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
             @index += 1
           else
             terminal_parse_failure('|')
@@ -245,12 +257,12 @@ module Cucumber
             r2 = nil
           else
             self.index = i2
-            r2 = SyntaxNode.new(input, index...index)
+            r2 = instantiate_node(SyntaxNode,input, index...index)
           end
           s1 << r2
           if r2
             if index < input_length
-              r6 = (SyntaxNode).new(input, index...(index + 1))
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
               @index += 1
             else
               terminal_parse_failure("any character")
@@ -259,7 +271,7 @@ module Cucumber
             s1 << r6
           end
           if s1.last
-            r1 = (SyntaxNode).new(input, i1...index, s1)
+            r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
             r1.extend(Cell0)
           else
             self.index = i1
@@ -271,7 +283,7 @@ module Cucumber
             break
           end
         end
-        r0 = SyntaxNode.new(input, i0...index, s0)
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
 
         node_cache[:cell][start_index] = r0
 
@@ -287,7 +299,7 @@ module Cucumber
         end
 
         if input.index(Regexp.new('[ \\t]'), index) == index
-          r0 = (SyntaxNode).new(input, index...(index + 1))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
           @index += 1
         else
           r0 = nil
@@ -311,7 +323,7 @@ module Cucumber
 
         i0 = index
         if input.index("\n", index) == index
-          r1 = (SyntaxNode).new(input, index...(index + 1))
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
           @index += 1
         else
           terminal_parse_failure("\n")
@@ -322,7 +334,7 @@ module Cucumber
         else
           i2, s2 = index, []
           if input.index("\r", index) == index
-            r3 = (SyntaxNode).new(input, index...(index + 1))
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
             @index += 1
           else
             terminal_parse_failure("\r")
@@ -331,7 +343,7 @@ module Cucumber
           s2 << r3
           if r3
             if input.index("\n", index) == index
-              r5 = (SyntaxNode).new(input, index...(index + 1))
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
               @index += 1
             else
               terminal_parse_failure("\n")
@@ -340,12 +352,12 @@ module Cucumber
             if r5
               r4 = r5
             else
-              r4 = SyntaxNode.new(input, index...index)
+              r4 = instantiate_node(SyntaxNode,input, index...index)
             end
             s2 << r4
           end
           if s2.last
-            r2 = (SyntaxNode).new(input, i2...index, s2)
+            r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
             r2.extend(Eol0)
           else
             self.index = i2
@@ -374,7 +386,7 @@ module Cucumber
 
         i0 = index
         if index < input_length
-          r1 = (SyntaxNode).new(input, index...(index + 1))
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
           @index += 1
         else
           terminal_parse_failure("any character")
@@ -384,7 +396,7 @@ module Cucumber
           r0 = nil
         else
           self.index = i0
-          r0 = SyntaxNode.new(input, index...index)
+          r0 = instantiate_node(SyntaxNode,input, index...index)
         end
 
         node_cache[:eof][start_index] = r0

data/lib/cucumber/parser/table.tt

@@ -10,18 +10,30 @@ module Cucumber
 
       rule table
         table_row+ {
-          def build
+          def at_line?(line)
+            elements.detect{|table_row| table_row.at_line?(line)}
+          end
+
+          def build(filter=nil)
             Ast::Table.new(raw)
           end
 
-          def raw
-            elements.map{|e| e.build}
+          def raw(filter=nil, scenario_outline=nil)
+            elements.map do |table_row|
+              if(filter.nil? || table_row == elements[0] || filter.at_line?(table_row) || (scenario_outline && filter.outline_at_line?(scenario_outline)))
+                table_row.build
+              end
+            end.compact
           end
         }
       end
 
       rule table_row
         space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def at_line?(line)
+            cells.line == line
+          end
+
           def build
             row = cells.elements.map do |elt| 
               value = elt.cell.text_value.strip

data/lib/cucumber/parser/treetop_ext.rb

@@ -12,37 +12,76 @@ end
 
 module Cucumber
   module Parser
-    module TreetopExt
+    class Filter
+      def initialize(lines, options)
+        @lines = lines
+        @include_tags = options[:include_tags] || []
+        @exclude_tags = options[:exclude_tags] || []
+        @names        = options[:scenario_names] || []
+      end
+
+      def accept?(syntax_node)
+        at_line?(syntax_node) &&
+        matches_tags?(syntax_node) &&
+        matches_names?(syntax_node)
+      end
+
+      def at_line?(syntax_node)
+        @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.at_line?(line)}
+      end
+
+      def outline_at_line?(syntax_node)
+         @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.outline_at_line?(line)}
+      end
+
+      def matches_tags?(syntax_node)
+        !excluded_by_tags?(syntax_node) &&
+        included_by_tags?(syntax_node)
+      end
+
+      def included_by_tags?(syntax_node)
+        @include_tags.empty? || syntax_node.has_tags?(@include_tags)
+      end
+
+      def excluded_by_tags?(syntax_node)
+        @exclude_tags.any? && syntax_node.has_tags?(@exclude_tags)
+      end
+      
+      def matches_names?(syntax_node)
+        @names.nil? || @names.empty? || @names.detect{|name| syntax_node.matches_name?(name)}
+      end
+    end
+
+    module TreetopExt      
       FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
 
       # Parses a file and returns a Cucumber::Ast
-      def parse_file(file)
+      def parse_file(file, options)
         _, path, lines = *FILE_COLON_LINE_PATTERN.match(file)
         if path
           lines = lines.split(':').map { |line| line.to_i }
         else
           path = file
-          lines = []
         end
+        filter = Filter.new(lines, options)
 
-        loader = lambda { |io| parse_or_fail(io.read, path) }
+        loader = lambda { |io| parse_or_fail(io.read, filter, path) }
         feature = if path =~ /^http/
           require 'open-uri'
           open(path, &loader)
         else
           File.open(path, Cucumber.file_mode('r'), &loader) 
         end
-        feature.lines = lines
         feature
       end
 
-      def parse_or_fail(s, file=nil, line_offset=0)
-        parse_tree = parse(s)
+      def parse_or_fail(string, filter=nil, file=nil, line_offset=0)
+        parse_tree = parse(string)
         if parse_tree.nil?
           raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
         else
-          ast = parse_tree.build
-          ast.file = file
+          ast = parse_tree.build(filter) # may return nil if it doesn't match filter.
+          ast.file = file unless ast.nil?
           ast
         end
       end

data/lib/cucumber/parser.rb

@@ -13,12 +13,6 @@ module Cucumber
   #
   # The AST classes are defined in the Cucumber::Ast module.
   module Parser
-    translator = Module.new do
-      def keywordz(key)
-        'Scenario'
-      end
-    end
-
     def self.load_parser(keywords)
       Loader.new(keywords)
     end
@@ -34,7 +28,8 @@ module Cucumber
         require 'cucumber/parser/feature'
       end
 
-      def keywords(key)
+      def keywords(key, raw=false)
+        return @keywords[key] if raw
         values = @keywords[key].split('|')
         values.map{|value| "'#{value}'"}.join(" / ")
       end

data/lib/cucumber/step_definition.rb

@@ -56,24 +56,23 @@ module Cucumber
   #   end
   #
   class StepDefinition
-    def self.snippet_text(step_keyword, step_name)
+    PARAM_PATTERN = /"([^\"]*)"/
+    ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
+    
+    def self.snippet_text(step_keyword, step_name, multiline_arg_class = nil)
       escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
-      param_pattern = /"([^\"]*)"/
+      escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
 
-      match = escaped.match(param_pattern)
-      if match
-        n = 0
-        block_args = match.captures.map do |a|
-          n += 1
-          "arg#{n}"
-        end
-        block_arg_string = " |#{block_args.join(", ")}|"
-      else
-        block_arg_string = ""
+      n = 0
+      block_args = escaped.scan(ESCAPED_PARAM_PATTERN).map do |a|
+        n += 1
+        "arg#{n}"
       end
+      block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
+      block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+      multiline_class_string = multiline_arg_class ? "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  " : ""
 
-      escaped = escaped.gsub(param_pattern, '"([^\\"]*)"')
-      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  pending\nend"
+      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_string}pending\nend"
     end
 
     class MissingProc < StandardError