gherkin 2.1.5-i386-mingw32 → 2.2.0-i386-mingw32

data/lib/gherkin/formatter/line_filter.rb

@@ -5,9 +5,9 @@ module Gherkin
         @lines = lines
       end
 
-      def eval(ranges)
-        @lines.detect do |line|
-          ranges.detect do |range|
+      def eval(tags, names, ranges)
+        ranges.detect do |range|
+          @lines.detect do |line|
             range.include?(line)
           end
         end

data/lib/gherkin/formatter/model.rb

@@ -3,7 +3,159 @@ require 'gherkin/native'
 module Gherkin
   module Formatter
     module Model
-      class Comment
+      class Hashable
+        def to_hash
+          instance_variables.inject({}) do |hash, ivar|
+            value = instance_variable_get(ivar)
+            value = value.to_hash if value.respond_to?(:to_hash)
+            if Array === value
+              value = value.map do |e|
+                e.respond_to?(:to_hash) ? e.to_hash : e
+              end
+            end
+            hash[ivar[1..-1]] = value unless [[], nil].index(value)
+            hash
+          end
+        end
+      end
+      
+      class BasicStatement < Hashable
+        attr_reader :comments, :keyword, :name, :description, :line
+        
+        def initialize(comments, keyword, name, description, line)
+          @comments, @keyword, @name, @description, @line = comments, keyword, name, description, line
+        end
+
+        def line_range
+          first = @comments.any? ? @comments[0].line : first_non_comment_line
+          first..line
+        end
+
+        def first_non_comment_line
+          @line
+        end
+      end
+
+      class TagStatement < BasicStatement
+        attr_reader :tags
+
+        def initialize(comments, tags, keyword, name, description, line)
+          super(comments, keyword, name, description, line)
+          @tags = tags
+        end
+
+        def first_non_comment_line
+          @tags.any? ? @tags[0].line : @line
+        end
+      end
+
+      class Feature < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line)
+          super(comments, tags, keyword, name, description, line)
+        end
+
+        def replay(formatter)
+          formatter.feature(self)
+        end
+      end
+
+      class Background < BasicStatement
+        native_impl('gherkin')
+
+        def initialize(comments, keyword, name, description, line)
+          super(comments, keyword, name, description, line)
+          @type = "background"
+        end
+
+        def replay(formatter)
+          formatter.background(self)
+        end
+      end
+
+      class Scenario < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line)
+          super(comments, tags, keyword, name, description, line)
+          @type = "scenario"
+        end
+
+        def replay(formatter)
+          formatter.scenario(self)
+        end
+      end
+
+      class ScenarioOutline < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line)
+          super(comments, tags, keyword, name, description, line)
+          @type = "scenario_outline"
+        end
+
+        def replay(formatter)
+          formatter.scenario_outline(self)
+        end
+      end
+
+      class Examples < TagStatement
+        native_impl('gherkin')
+
+        attr_accessor :rows
+
+        def initialize(comments, tags, keyword, name, description, line, rows=nil)
+          super(comments, tags, keyword, name, description, line)
+          @rows = rows
+        end
+
+        def replay(formatter)
+          formatter.examples(self)
+        end
+      end
+
+      class Step < BasicStatement
+        native_impl('gherkin')
+
+        attr_accessor :multiline_arg, :result
+
+        def initialize(comments, keyword, name, description, line, multiline_arg=nil, result=nil)
+          super(comments, keyword, name, nil, line)
+          @multiline_arg = multiline_arg
+          @result = result
+        end
+
+        def line_range
+          range = super
+          case multiline_arg
+          when Array
+            range = range.first..multiline_arg[-1].line
+          when Model::PyString
+            range = range.first..multiline_arg.line_range.last
+          end
+          range
+        end
+
+        def replay(formatter)
+          formatter.step(self)
+        end
+
+        def to_hash
+          hash = super
+          if Array === @multiline_arg
+            hash['multiline_arg'] = {
+              'type' => 'table',
+              'value' => hash['multiline_arg']
+            }
+          elsif PyString === @multiline_arg
+            hash['multiline_arg']['type'] = 'py_string'
+          end
+          hash
+        end
+      end
+
+      class Comment < Hashable
         native_impl('gherkin')
 
         attr_reader :value, :line
@@ -13,7 +165,7 @@ module Gherkin
         end
       end
 
-      class Tag
+      class Tag < Hashable
         native_impl('gherkin')
 
         attr_reader :name, :line
@@ -31,7 +183,7 @@ module Gherkin
         end
       end
 
-      class PyString
+      class PyString < Hashable
         native_impl('gherkin')
 
         attr_reader :value, :line
@@ -46,7 +198,7 @@ module Gherkin
         end
       end
 
-      class Row
+      class Row < Hashable
         native_impl('gherkin')
 
         attr_reader :comments, :cells, :line
@@ -56,21 +208,6 @@ module Gherkin
         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')
 

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -20,12 +20,15 @@ module Gherkin
         @format = MonochromeFormat.new #@monochrome ? MonochromeFormat.new : AnsiColorFormat.new
       end
 
-      def feature(statement, uri)
+      def uri(uri)
         @uri = uri
-        print_comments(statement.comments, '')
-        print_tags(statement.tags, '')
-        @io.puts "#{statement.keyword}: #{statement.name}"
-        print_description(statement.description, '  ', false)
+      end
+
+      def feature(feature)
+        print_comments(feature.comments, '')
+        print_tags(feature.tags, '')
+        @io.puts "#{feature.keyword}: #{feature.name}"
+        print_description(feature.description, '  ', false)
       end
 
       def background(statement)
@@ -43,35 +46,32 @@ module Gherkin
         print_description(statement.description, '    ')
       end
 
-      def scenario_outline(statement)
-        scenario(statement)
+      def scenario_outline(scenario_outline)
+        scenario(scenario_outline)
       end
 
-      def examples(statement, examples_rows)
+      def examples(examples)
         @io.puts
-        print_comments(statement.comments, '    ')
-        print_tags(statement.tags, '    ')
-        @io.puts "    #{statement.keyword}: #{statement.name}"
-        print_description(statement.description, '    ')
-        table(examples_rows)
+        print_comments(examples.comments, '    ')
+        print_tags(examples.tags, '    ')
+        @io.puts "    #{examples.keyword}: #{examples.name}"
+        print_description(examples.description, '    ')
+        table(examples.rows)
       end
 
-      def step(statement, multiline_arg, result)
-        name = Gherkin::Formatter::Argument.format(statement.name, @format, (result ? result.arguments : []))
+      def step(step)
+        name = Gherkin::Formatter::Argument.format(step.name, @format, (step.result ? step.result.arguments : []))
 
-        step = "#{statement.keyword}#{statement.name}"
-        step = self.__send__(result.status, step, @monochrome) if result
+        step_text = "#{step.keyword}#{step.name}"
+        step_text = self.__send__(step.result.status, step_text, @monochrome) if step.result
 
-        print_comments(statement.comments, '    ')
-        @io.puts("    #{step}#{indented_step_location!(result ? result.stepdef_location : nil)}")
-        case multiline_arg
+        print_comments(step.comments, '    ')
+        @io.puts("    #{step_text}#{indented_step_location!(step.result ? step.result.stepdef_location : nil)}")
+        case step.multiline_arg
         when Model::PyString
-          py_string(multiline_arg)
+          py_string(step.multiline_arg)
         when Array
-          table(multiline_arg)
-        when NilClass
-        else
-          raise "Bad multiline_arg: #{multiline_arg.inspect}"
+          table(step.multiline_arg)
         end
       end
 

data/lib/gherkin/formatter/regexp_filter.rb

@@ -5,13 +5,17 @@ module Gherkin
         @regexen = regexen
       end
 
-      def eval(names)
+      def eval(tags, names, ranges)
         @regexen.detect do |regexp| 
           names.detect do |name|
             name =~ regexp
           end
         end
       end
+
+      def filter_table_body_rows(rows)
+        rows
+      end
     end
   end
 end

data/lib/gherkin/formatter/tag_count_formatter.rb

@@ -6,25 +6,28 @@ module Gherkin
         @tag_counts = tag_counts
       end
 
-      def feature(statement, uri)
-        @feature_tags = statement.tags
+      def uri(uri)
         @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)
+      def feature(feature)
+        @feature_tags = feature.tags
+        @formatter.feature(feature)
       end
 
-      def scenario_outline(statement)
-        @scenario_outline_tags = statement.tags
-        @formatter.scenario_outline(statement)
+      def scenario(scenario)
+        record_tags((@feature_tags.to_a + scenario.tags.to_a).uniq, scenario.line)
+        @formatter.scenario(scenario)
       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)
+      def scenario_outline(scenario_outline)
+        @scenario_outline_tags = scenario_outline.tags
+        @formatter.scenario_outline(scenario_outline)
+      end
+
+      def examples(examples)
+        record_tags((@feature_tags.to_a + @scenario_outline_tags.to_a + examples.tags.to_a).uniq, examples.line)
+        @formatter.examples(examples)
       end
 
     private

data/lib/gherkin/formatter/tag_filter.rb

@@ -0,0 +1,19 @@
+require 'gherkin/tag_expression'
+
+module Gherkin
+  module Formatter
+    class TagFilter
+      def initialize(tags)
+        @tag_expression = TagExpression.new(tags)
+      end
+
+      def eval(tags, names, ranges)
+        @tag_expression.eval(tags.uniq.map{|tag| tag.name})
+      end
+
+      def filter_table_body_rows(rows)
+        rows
+      end
+    end
+  end
+end

data/lib/gherkin/json_parser.rb

@@ -1,102 +1,86 @@
 require 'json'
-require 'gherkin/listener/formatter_listener'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
 
 module Gherkin
   class JSONParser
+    native_impl('gherkin')
 
     def initialize(formatter)
       @formatter = formatter
     end
 
     def parse(src, feature_uri='unknown.json', line_offset=0)
-      @listener = Listener::FormatterListener.new(@formatter)
-      _parse(src, feature_uri, line_offset)
-    end
+      @formatter.uri(feature_uri)
+      o = JSON.parse(src)
+
+      Formatter::Model::Feature.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o)).replay(@formatter)
+      (o["elements"] || []).each do |feature_element|
+        feature_element(feature_element).replay(@formatter)
+        (feature_element["steps"] || []).each do |step|
+          step(step).replay(@formatter)
+        end
+        (feature_element["examples"] || []).each do |eo|
+          Formatter::Model::Examples.new(comments(eo), tags(eo), keyword(eo), name(eo), description(eo), line(eo), rows(eo['rows'])).replay(@formatter)
+        end
+      end
 
-    def parse_with_listener(src, listener)
-      @listener = listener
-      _parse(src, 'unknown.json', 0)
+      @formatter.eof
     end
 
-    private
-
-    def _parse(src, feature_uri, line_offset)
-      @listener.location(feature_uri)
-      feature = JSON.parse(src)
-
-      comments_for(feature)
-      tags_for(feature)
-      multiline_event(feature)
-
-      (feature["elements"] || []).each do |feature_element|
-        parse_element(feature_element) 
+    def feature_element(o)
+      case o['type']
+      when 'background'
+        Formatter::Model::Background.new(comments(o), keyword(o), name(o), description(o), line(o))
+      when 'scenario'
+        Formatter::Model::Scenario.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o))
+      when 'scenario_outline'
+        Formatter::Model::ScenarioOutline.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o))
       end
-
-      @listener.eof
     end
 
-    def parse_element(feature_element)
-      comments_for(feature_element)
-      tags_for(feature_element)
-      multiline_event(feature_element)
-      steps_for(feature_element)
-
-      if feature_element["type"] == "scenario_outline"
-        (feature_element["examples"] || []).each do |examples|
-          comments_for(examples)
-          tags_for(examples)
-          multiline_event(examples)
-          rows_for(examples['table'])
+    def step(o)
+      multiline_arg = nil
+      if(ma = o['multiline_arg'])
+        if(ma['type'] == 'table')
+          multiline_arg = rows(ma['value'])
+        else
+          multiline_arg = Formatter::Model::PyString.new(ma['value'], ma['line'])
         end
       end
+      Formatter::Model::Step.new(comments(o), keyword(o), name(o), nil, line(o), multiline_arg)
     end
 
-    def comments_for(element)
-      (element["comments"] || []).each do |comment|
-        @listener.comment(comment['value'], comment['line'])
-      end
+    def rows(o)
+      o.map{|row| Formatter::Model::Row.new(comments(row), row['cells'], row['line'])}
     end
 
-    def tags_for(element)
-      (element["tags"] || []).each do |tag|
-        @listener.tag(tag['name'], tag['line'])
+    def comments(o)
+      (o['comments'] || []).map do |comment|
+        Formatter::Model::Comment.new(comment['value'], comment['line'])
       end
     end
 
-    def steps_for(element)
-      element["steps"].each do |step|
-        comments_for(step)
-        @listener.step(step["keyword"], step["name"], step['line'])
-        multiline_arg_for(step)    
+    def tags(o)
+      (o['tags'] || []).map do |tag|
+        Formatter::Model::Tag.new(tag['name'], tag['line'])
       end
     end
 
-    def multiline_arg_for(element)
-      if ma = element["multiline_arg"]
-        case ma["type"]
-        when "py_string"
-          @listener.py_string(ma["value"], ma["line"])
-        when "table"
-          rows_for(ma["value"])
-        end
-      end
+    def keyword(o)
+      o['keyword']
     end
 
-    def rows_for(rows)
-      (rows || []).each do |row|
-        comments_for(row)
-        @listener.row(cells_for(row), row['line'])
-      end
+    def name(o)
+      o['name']
     end
 
-    def cells_for(row)
-      row["cells"]
+    def description(o)
+      o['description']
     end
 
-    def multiline_event(element)
-      if element["keyword"] 
-        @listener.__send__(element['type'].to_sym, element["keyword"], element["name"] || "", element["description"] || "", element['line'])
-      end
+    def line(o)
+      o['line']
     end
   end
 end