gherkin 2.0.2-i386-mingw32 → 2.1.0-i386-mingw32

data/lib/gherkin/formatter/json_formatter.rb

@@ -11,47 +11,33 @@ module Gherkin
         @io = io
       end
 
-      def feature(comments, tags, keyword, name, description, uri)
-        @json_hash = {
-          'comments' => comments.to_a, 
-          'tags' => tags.to_a, 
-          'keyword' => keyword, 
-          'name' => name, 
-          'description' => description, 
-          'uri' => uri
-        }
+      def feature(statement, uri)
+        @json_hash = statement_hash(nil, statement)
+        @json_hash['uri'] = uri
       end
 
-      def background(comments, keyword, name, description, line)
-        background = {
-          'comments' => comments.to_a, 
-          'keyword' => keyword, 
-          'name' => name, 
-          'description' => description,
-          'line' => line,
-          'steps' => [],
-        }
-        @json_hash['background'] = background 
+      def background(statement)
+        @json_hash['background'] = statement_hash(nil, statement) 
         @in_background = true
       end
 
-      def scenario(comments, tags, keyword, name, description, line)
+      def scenario(statement)
         @in_background = false
-        add_step_container(comments, tags, keyword, name, description, line, 'scenario')
+        add_step_container('scenario', statement)
       end
 
-      def scenario_outline(comments, tags, keyword, name, description, line)
+      def scenario_outline(statement)
         @in_background = false
-        add_step_container(comments, tags, keyword, name, description, line, 'scenario_outline')
+        add_step_container('scenario_outline', statement)
       end
 
-      def examples(comments, tags, keyword, name, description, line, table)
-        @table_container = add_examples(comments, tags, keyword, name, description, line)
-        @table_container['table'] = to_hash_array(table)
+      def examples(statement, examples_rows)
+        @table_container = add_examples(statement)
+        @table_container['table'] = to_hash_array(examples_rows)
       end
 
-      def step(comments, keyword, name, line, multiline_arg, status, exception, arguments, stepdef_location)
-        @table_container = {'comments' => comments.to_a, 'keyword' => keyword, 'name' => name, 'line' => line}.merge(step_arg_to_hash(multiline_arg))
+      def step(statement, multiline_arg, result)
+        @table_container = statement_hash(nil, statement).merge(step_arg_to_hash(multiline_arg))
         last_element['steps'] ||= []
         last_element['steps'] << @table_container
       end
@@ -62,35 +48,35 @@ module Gherkin
 
     private
 
-      def element_hash(comments, tags, keyword, name, description, line, type=nil)
+      def statement_hash(type, statement)
         element = {
-          'comments' => comments.to_a, 
-          'tags' => tags.to_a, 
-          'keyword' => keyword, 
-          'name' => name, 
-          'description' => description,
-          'line' => line,
+          'comments' => statement.comments.map{|comment| comment.value}, 
+          'tags' => statement.tags.map{|tag| tag.name}, 
+          'keyword' => statement.keyword, 
+          'name' => statement.name, 
+          'description' => statement.description,
+          'line' => statement.line,
         }
-        element['type'] = type if type
-        element
+        element['type'] = type
+        compact(element)
       end
 
-      def add_element(comments, tags, keyword, name, description, line, type)
-        element = element_hash(comments, tags, keyword, name, description, line, type)
+      def add_element(type, statement)
+        element = statement_hash(type, statement)
         @json_hash['elements'] ||= []
         @json_hash['elements'] << element
         element
       end
 
-      def add_examples(comments, tags, keyword, name, description, line)
-        element = element_hash(comments, tags, keyword, name, description, line)
+      def add_examples(statement)
+        element = statement_hash(nil, statement)
         last_element['examples'] ||= []
         last_element['examples'] << element
         element
       end
 
-      def add_step_container(type, comments, tags, keyword, name, description, line)
-        add_element(type, comments, tags, keyword, name, description, line)
+      def add_step_container(type, statement)
+        add_element(type, statement)
         last_element['steps'] = []
       end
 
@@ -104,14 +90,18 @@ module Gherkin
 
       def to_hash_array(rows)
         rows.map do |row|
-          {"cells" => row.cells.to_a, "comments" => row.comments.to_a, "line" => row.line}
+          compact({"cells" => row.cells.to_a, "comments" => row.comments.map{|comment| comment.value}, "line" => row.line})
         end
       end
 
       def step_arg_to_hash(multiline_arg)
         return {} if multiline_arg.nil?
         multiline_arg = rubify(multiline_arg)
-        Array === multiline_arg ? {"table" => to_hash_array(multiline_arg) } : { "py_string" => multiline_arg }
+        Array === multiline_arg ? {"table" => to_hash_array(multiline_arg) } : { "py_string" => multiline_arg.value }
+      end
+
+      def compact(hash)
+        hash.reject{|k,v| [[], "", nil].index(v)}
       end
     end
   end

data/lib/gherkin/formatter/line_filter.rb

@@ -0,0 +1,26 @@
+module Gherkin
+  module Formatter
+    class LineFilter
+      def initialize(lines)
+        @lines = lines
+      end
+
+      def eval(ranges)
+        @lines.detect do |line|
+          ranges.detect do |range|
+            range.include?(line)
+          end
+        end
+      end
+
+      def filter_table_body_rows(rows)
+        body = rows.to_a[1..-1].select do |row|
+          @lines.detect do |line|
+            row.line == line
+          end
+        end
+        [rows[0]] + body
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/model.rb

@@ -0,0 +1,85 @@
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    module Model
+      class Comment
+        native_impl('gherkin')
+
+        attr_reader :value, :line
+        
+        def initialize(value, line)
+          @value, @line = value, line
+        end
+      end
+
+      class Tag
+        native_impl('gherkin')
+
+        attr_reader :name, :line
+        
+        def initialize(name, line)
+          @name, @line = name, line
+        end
+        
+        def eql?(tag)
+          @name.eql?(tag.name)
+        end
+
+        def hash
+          @name.hash
+        end
+      end
+
+      class PyString
+        native_impl('gherkin')
+
+        attr_reader :value, :line
+        
+        def initialize(value, line)
+          @value, @line = value, line
+        end
+
+        def line_range
+          line_count = value.split(/\r?\n/).length
+          line..(line+line_count+1)
+        end
+      end
+
+      class Row
+        native_impl('gherkin')
+
+        attr_reader :comments, :cells, :line
+
+        def initialize(comments, cells, line)
+          @comments, @cells, @line = comments, cells, line
+        end
+      end
+
+      class Statement
+        native_impl('gherkin')
+
+        attr_reader :comments, :tags, :keyword, :name, :description, :line
+        
+        def initialize(comments, tags, keyword, name, description, line)
+          @comments, @tags, @keyword, @name, @description, @line = comments, tags, keyword, name, description, line
+        end
+
+        def line_range
+          first = @comments[0] ? @comments[0].line : (@tags[0] ? @tags[0].line : line)
+          first..line
+        end
+      end
+
+      class Result
+        native_impl('gherkin')
+
+        attr_reader :status, :error_message, :arguments, :stepdef_location
+        
+        def initialize(status, error_message, arguments, stepdef_location)
+          @status, @error_message, @arguments, @stepdef_location = status, error_message, arguments, stepdef_location
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -3,6 +3,7 @@ require 'gherkin/formatter/colors'
 require 'gherkin/formatter/monochrome_format'
 require 'gherkin/formatter/argument'
 require 'gherkin/formatter/escaping'
+require 'gherkin/formatter/model'
 require 'gherkin/native'
 
 module Gherkin
@@ -19,53 +20,52 @@ module Gherkin
         @format = MonochromeFormat.new #@monochrome ? MonochromeFormat.new : AnsiColorFormat.new
       end
 
-      def feature(comments, tags, keyword, name, description, uri)
+      def feature(statement, uri)
         @uri = uri
-        print_comments(comments, '')
-        print_tags(tags, '')
-        @io.puts "#{keyword}: #{name}"
-        print_description(description, '  ', false)
+        print_comments(statement.comments, '')
+        print_tags(statement.tags, '')
+        @io.puts "#{statement.keyword}: #{statement.name}"
+        print_description(statement.description, '  ', false)
       end
 
-      def background(comments, keyword, name, description, line)
+      def background(statement)
         @io.puts
-        print_comments(comments, '  ')
-        @io.puts "  #{keyword}: #{name}#{indented_element_uri!(keyword, name, line)}"
-        print_description(description, '    ')
+        print_comments(statement.comments, '  ')
+        @io.puts "  #{statement.keyword}: #{statement.name}#{indented_element_uri!(statement.keyword, statement.name, statement.line)}"
+        print_description(statement.description, '    ')
       end
 
-      def scenario(comments, tags, keyword, name, description, line)
+      def scenario(statement)
         @io.puts
-        print_comments(comments, '  ')
-        print_tags(tags, '  ')
-        @io.puts "  #{keyword}: #{name}#{indented_element_uri!(keyword, name, line)}"
-        print_description(description, '    ')
+        print_comments(statement.comments, '  ')
+        print_tags(statement.tags, '  ')
+        @io.puts "  #{statement.keyword}: #{statement.name}#{indented_element_uri!(statement.keyword, statement.name, statement.line)}"
+        print_description(statement.description, '    ')
       end
 
-      def scenario_outline(comments, tags, keyword, name, description, line)
-        scenario(comments, tags, keyword, name, description, line)
+      def scenario_outline(statement)
+        scenario(statement)
       end
 
-      def examples(comments, tags, keyword, name, description, line, examples_table)
+      def examples(statement, examples_rows)
         @io.puts
-        print_comments(comments, '    ')
-        print_tags(tags, '    ')
-        @io.puts "    #{keyword}: #{name}"
-        print_description(description, '    ')
-        table(examples_table)
+        print_comments(statement.comments, '    ')
+        print_tags(statement.tags, '    ')
+        @io.puts "    #{statement.keyword}: #{statement.name}"
+        print_description(statement.description, '    ')
+        table(examples_rows)
       end
 
-      def step(comments, keyword, name, line, multiline_arg, status, exception, arguments, stepdef_location)
-        status_param = "#{status}_param" if status
-        name = Gherkin::Formatter::Argument.format(name, @format, (arguments || [])) 
+      def step(statement, multiline_arg, result)
+        name = Gherkin::Formatter::Argument.format(statement.name, @format, (result ? result.arguments : []))
 
-        step = "#{keyword}#{name}"
-        step = self.__send__(status, step, @monochrome) if status
+        step = "#{statement.keyword}#{statement.name}"
+        step = self.__send__(result.status, step, @monochrome) if result
 
-        print_comments(comments, '    ')
-        @io.puts("    #{step}#{indented_step_location!(stepdef_location)}")
+        print_comments(statement.comments, '    ')
+        @io.puts("    #{step}#{indented_step_location!(result ? result.stepdef_location : nil)}")
         case multiline_arg
-        when String
+        when Model::PyString
           py_string(multiline_arg)
         when Array
           table(multiline_arg)
@@ -75,11 +75,8 @@ module Gherkin
         end
       end
 
-      def syntax_error(state, event, legal_events, line)
-        raise "SYNTAX ERROR"
-      end
-
       def eof
+        # NO-OP
       end
 
       # This method can be invoked before a #scenario, to ensure location arguments are aligned
@@ -99,7 +96,7 @@ module Gherkin
 
         rows.each_with_index do |row, i|
           row.comments.each do |comment|
-            @io.puts "      #{comment}"
+            @io.puts "      #{comment.value}"
           end
           j = -1
           @io.puts '      | ' + row.cells.zip(max_lengths).map { |cell, max_length|
@@ -111,8 +108,8 @@ module Gherkin
 
     private
 
-      def py_string(string)
-        @io.puts "      \"\"\"\n" + escape_triple_quotes(indent(string, '      ')) + "\n      \"\"\""
+      def py_string(py_string)
+        @io.puts "      \"\"\"\n" + escape_triple_quotes(indent(py_string.value, '      ')) + "\n      \"\"\""
       end
 
       def exception(exception)
@@ -145,11 +142,11 @@ module Gherkin
       end
 
       def print_tags(tags, indent)
-        @io.write(tags.empty? ? '' : indent + tags.join(' ') + "\n")
+        @io.write(tags.empty? ? '' : indent + tags.map{|tag| tag.name}.join(' ') + "\n")
       end
 
       def print_comments(comments, indent)
-        @io.write(comments.empty? ? '' : indent + comments.join("\n#{indent}") + "\n")
+        @io.write(comments.empty? ? '' : indent + comments.map{|comment| comment.value}.join("\n#{indent}") + "\n")
       end
 
       def print_description(description, indent, newline=true)

data/lib/gherkin/formatter/regexp_filter.rb

@@ -0,0 +1,17 @@
+module Gherkin
+  module Formatter
+    class RegexpFilter
+      def initialize(regexen)
+        @regexen = regexen
+      end
+
+      def eval(names)
+        @regexen.detect do |regexp| 
+          names.detect do |name|
+            name =~ regexp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/tag_count_formatter.rb

@@ -0,0 +1,44 @@
+module Gherkin
+  module Formatter
+    class TagCountFormatter
+      def initialize(formatter, tag_counts)
+        @formatter = formatter
+        @tag_counts = tag_counts
+      end
+
+      def feature(statement, uri)
+        @feature_tags = statement.tags
+        @uri = uri
+        @formatter.feature(statement, uri)
+      end
+
+      def scenario(statement)
+        record_tags((@feature_tags.to_a + statement.tags.to_a).uniq, statement.line)
+        @formatter.scenario(statement)
+      end
+
+      def scenario_outline(statement)
+        @scenario_outline_tags = statement.tags
+        @formatter.scenario_outline(statement)
+      end
+
+      def examples(statement, examples_rows)
+        record_tags((@feature_tags.to_a + @scenario_outline_tags.to_a + statement.tags.to_a).uniq, statement.line)
+        @formatter.examples(statement, examples_rows)
+      end
+
+    private
+
+      def record_tags(tags, line)
+        tags.each do |tag|
+          @tag_counts[tag.name] ||= []
+          @tag_counts[tag.name] << "#{@uri}:#{line}"
+        end
+      end
+
+      def method_missing(*args)
+        @formatter.__send__(*args)
+      end
+    end
+  end
+end

data/lib/gherkin/i18n.rb

@@ -55,11 +55,11 @@ module Gherkin
       def language_table
         require 'stringio'
         require 'gherkin/formatter/pretty_formatter'
-        require 'gherkin/parser/row'
+        require 'gherkin/formatter/model'
         io = defined?(JRUBY_VERSION) ? Java.java.io.StringWriter.new : StringIO.new
         pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
         table = all.map do |i18n|
-          Parser::Row.new([i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], [], nil)
+          Formatter::Model::Row.new([], [i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], nil)
         end
         pf.table(table)
         if defined?(JRUBY_VERSION)
@@ -147,19 +147,19 @@ module Gherkin
     def keyword_table
       require 'stringio'
       require 'gherkin/formatter/pretty_formatter'
-      require 'gherkin/parser/row'
+      require 'gherkin/formatter/model'
       io = StringIO.new
       pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
 
       gherkin_keyword_table = KEYWORD_KEYS.map do |key|
-        Parser::Row.new([key, keywords(key).map{|keyword| %{"#{keyword}"}}.join(', ')], [], nil)
+        Formatter::Model::Row.new([], [key, keywords(key).map{|keyword| %{"#{keyword}"}}.join(', ')], nil)
       end
       
       code_keyword_table = STEP_KEYWORD_KEYS.map do |key|
         code_keywords = keywords(key).reject{|keyword| keyword == '* '}.map do |keyword|
           %{"#{self.class.code_keyword_for(keyword)}"}
         end.join(', ')
-        Parser::Row.new(["#{key} (code)", code_keywords], [], nil)
+        Formatter::Model::Row.new([], ["#{key} (code)", code_keywords], nil)
       end
       
       pf.table(gherkin_keyword_table + code_keyword_table)