gherkin 2.5.4-universal-dotnet → 2.6.0-universal-dotnet

data/features/step_definitions/json_formatter_steps.rb

@@ -11,15 +11,18 @@ class Hash
 end
 
 Given /^a JSON formatter$/ do
-  @io = StringIO.new
-  @formatter = Gherkin::Formatter::JSONFormatter.new(@io)
+  @out = StringIO.new
+  @formatter = Gherkin::Formatter::JSONFormatter.new(@out)
 end
 
 Then /^the outputted JSON should be:$/ do |expected_json|
   require 'json'
-  puts JSON.pretty_generate(JSON.parse(@io.string))
+  @formatter.close
+  actual_json = @out.string
+  puts actual_json
+  puts JSON.pretty_generate(JSON.parse(actual_json))
   expected = JSON.parse(expected_json)
-  actual   = JSON.parse(@io.string)
+  actual   = JSON.parse(actual_json)
   actual.should == expected
 end
 

data/features/step_definitions/json_parser_steps.rb

@@ -12,7 +12,7 @@ Given /^a JSON lexer$/ do
 end
 
 Given /^the following JSON is parsed:$/ do |text|
-  @json_parser.parse(JSON.pretty_generate(JSON.parse(text)), "unknown.json", 0)
+  @json_parser.parse(JSON.pretty_generate(JSON.parse(text)))
 end
 
 Then /^the outputted text should be:$/ do |expected_text|

data/features/step_definitions/pretty_formatter_steps.rb

@@ -20,11 +20,12 @@ module PrettyPlease
     json_formatter      = Gherkin::Formatter::JSONFormatter.new(json)
     gherkin_parser      = Gherkin::Parser::Parser.new(json_formatter, true)
     parse(gherkin_parser, gherkin, feature_path)
+    json_formatter.close
 
     io                  = StringIO.new
     pretty_formatter    = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
     json_parser         = Gherkin::JSONParser.new(pretty_formatter, pretty_formatter)
-    json_parser.parse(json.string, "#{feature_path}.json", 0)
+    json_parser.parse(json.string)
     
     io.string
   end

data/gherkin.gemspec

@@ -2,7 +2,8 @@
 
 Gem::Specification.new do |s|
   s.name        = "gherkin"
-  s.version     = "2.5.4"
+  # If bumping the major version here, comment out the cucumber dependency below and uncomment in the Gemfile to build against a local cucumber.
+  s.version     = "2.6.0"
   s.authors     = ["Mike Sassak", "Gregory Hnatiuk", "Aslak Hellesøy"]
   s.description = "A fast Gherkin lexer/parser based on the Ragel State Machine Compiler."
   s.summary     = "#{s.name}-#{s.version}"
@@ -45,10 +46,10 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency('json', '>= 1.4.6')
 
-  s.add_development_dependency('cucumber', '>= 1.1.0')
+  s.add_development_dependency('cucumber', '>= 1.1.1')
   s.add_development_dependency('rake', '>= 0.9.2')
   s.add_development_dependency('bundler', '>= 1.0.21')
-  s.add_development_dependency('rspec', '>= 2.6.0')
+  s.add_development_dependency('rspec', '>= 2.7.0')
 
   unless ENV['RUBY_CC_VERSION'] || defined?(JRUBY_VERSION)
     s.add_development_dependency('therubyracer', '>= 0.9.8') if ENV['GHERKIN_JS']

data/lib/gherkin/formatter/json_formatter.rb

@@ -5,26 +5,31 @@ require 'base64'
 
 module Gherkin
   module Formatter
+    # This class doesn't really generate JSON - instead it populates an Array that can easily
+    # be turned into JSON.
     class JSONFormatter
       native_impl('gherkin')
       
       include Base64
-      attr_reader :gherkin_object
       
-      # Creates a new instance that writes the resulting JSON to +io+.
-      # If +io+ is nil, the JSON will not be written, but instead a Ruby
-      # object can be retrieved with #gherkin_object
       def initialize(io)
+        raise "Must be writeable" unless io.respond_to?(:write)
         @io = io
+        @feature_hashes = []
+      end
+
+      def close
+        @io.write(@feature_hashes.to_json)
       end
 
       def uri(uri)
-        # We're ignoring the uri - we don't want it as part of the JSON
-        # (The pretty formatter uses it just for visual niceness - comments)
+        @uri = uri
       end
 
       def feature(feature)
-        @gherkin_object = feature.to_hash
+        @feature_hash = feature.to_hash
+        @feature_hash['uri'] = @uri
+        @feature_hashes << @feature_hash
       end
 
       def background(background)
@@ -68,13 +73,12 @@ module Gherkin
       end
 
       def eof
-        @io.write(@gherkin_object.to_json) if @io
       end
 
     private
 
       def feature_elements
-        @gherkin_object['elements'] ||= []
+        @feature_hash['elements'] ||= []
       end
 
       def feature_element

data/lib/gherkin/formatter/model.rb

@@ -31,11 +31,12 @@ module Gherkin
       end
 
       class TagStatement < DescribedStatement
-        attr_reader :tags
+        attr_reader :tags, :id
 
-        def initialize(comments, tags, keyword, name, description, line)
+        def initialize(comments, tags, keyword, name, description, line, id)
           super(comments, keyword, name, description, line)
           @tags = tags
+          @id = id
         end
 
         def first_non_comment_line
@@ -46,10 +47,6 @@ module Gherkin
       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
@@ -71,8 +68,8 @@ module Gherkin
       class Scenario < TagStatement
         native_impl('gherkin')
 
-        def initialize(comments, tags, keyword, name, description, line)
-          super(comments, tags, keyword, name, description, line)
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, tags, keyword, name, description, line, id)
           @type = "scenario"
         end
 
@@ -84,8 +81,8 @@ module Gherkin
       class ScenarioOutline < TagStatement
         native_impl('gherkin')
 
-        def initialize(comments, tags, keyword, name, description, line)
-          super(comments, tags, keyword, name, description, line)
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, tags, keyword, name, description, line, id)
           @type = "scenario_outline"
         end
 
@@ -97,23 +94,47 @@ module Gherkin
       class Examples < TagStatement
         native_impl('gherkin')
 
-        attr_accessor :rows
+        attr_accessor :rows # needs to remain mutable for filters
 
-        def initialize(comments, tags, keyword, name, description, line, rows)
-          super(comments, tags, keyword, name, description, line)
+        def initialize(comments, tags, keyword, name, description, line, id, rows)
+          super(comments, tags, keyword, name, description, line, id)
           @rows = rows
         end
 
         def replay(formatter)
           formatter.examples(self)
         end
+        
+        class Builder
+          def initialize(*args)
+            @args = *args
+            @rows = nil
+          end
+        
+          def row(comments, cells, line, id)
+            @rows ||= []
+            @rows << ExamplesTableRow.new(comments, cells, line, id)
+          end
+        
+          def replay(formatter)
+            build.replay(formatter)
+          end
+          
+          def build
+            Examples.new(*(@args << @rows))
+          end
+        end
       end
 
       class Step < BasicStatement
         native_impl('gherkin')
 
-        attr_accessor :rows
-        attr_accessor :doc_string
+        attr_reader :rows, :doc_string
+        
+        def initialize(comments, keyword, name, line, rows, doc_string)
+          super(comments, keyword, name, line)
+          @rows, @doc_string = rows, doc_string
+        end
 
         def line_range
           range = super
@@ -136,6 +157,31 @@ module Gherkin
             Argument.new(offset, val)
           end
         end
+        
+        class Builder
+          def initialize(*args)
+            @args = *args
+            @rows = nil
+            @doc_string = nil
+          end
+        
+          def row(comments, cells, line, id)
+            @rows ||= []
+            @rows << DataTableRow.new(comments, cells, line)
+          end
+          
+          def doc_string(string, content_type, line)
+            @doc_string = Formatter::Model::DocString.new(string, content_type, line)
+          end
+        
+          def replay(formatter)
+            build.replay(formatter)
+          end
+          
+          def build
+            Step.new(*(@args << @rows << @doc_string))
+          end
+        end
       end
 
       class Comment < Hashable
@@ -169,10 +215,10 @@ module Gherkin
       class DocString < Hashable
         native_impl('gherkin')
 
-        attr_reader :content_type, :value, :line
+        attr_reader :value, :content_type, :line
         
-        def initialize(content_type, value, line)
-          @content_type, @value, @line = content_type, value, line
+        def initialize(value, content_type, line)
+          @value, @content_type, @line = value, content_type, line
         end
 
         def line_range
@@ -182,8 +228,6 @@ module Gherkin
       end
 
       class Row < Hashable
-        native_impl('gherkin')
-
         attr_reader :comments, :cells, :line
 
         def initialize(comments, cells, line)
@@ -191,6 +235,20 @@ module Gherkin
         end
       end
 
+      class DataTableRow < Row
+        native_impl('gherkin')
+      end
+
+      class ExamplesTableRow < Row
+        native_impl('gherkin')
+        attr_reader :id
+
+        def initialize(comments, cells, line, id)
+          super(comments, cells, line)
+          @id = id
+        end
+      end
+
       class Match < Hashable
         native_impl('gherkin')
 

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -177,7 +177,7 @@ module Gherkin
 
     private
 
-      def doc_string(doc_string)
+    def doc_string(doc_string)
         @io.puts "      \"\"\"" + doc_string.content_type + "\n" + escape_triple_quotes(indent(doc_string.value, '      ')) + "\n      \"\"\""
       end
 

data/lib/gherkin/json_parser.rb

@@ -16,21 +16,23 @@ module Gherkin
 
     # Parse a gherkin object +o+, which can either be a JSON String,
     # or a Hash (from a parsed JSON String).
-    def parse(o, feature_uri='unknown.json', line_offset=0)
+    def parse(o)
       o = JSON.parse(o) if String === o
-      @formatter.uri(feature_uri)
-
-      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)
-          match(step)
-          result(step)
-          embeddings(step)
-        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)
+
+      o.each do |f|
+        @formatter.uri(f['uri'])
+        Formatter::Model::Feature.new(comments(f), tags(f), keyword(f), name(f), description(f), line(f), id(f)).replay(@formatter)
+        (f["elements"] || []).each do |feature_element|
+          feature_element(feature_element).replay(@formatter)
+          (feature_element["steps"] || []).each do |step|
+            step(step).replay(@formatter)
+            match(step)
+            result(step)
+            embeddings(step)
+          end
+          (feature_element["examples"] || []).each do |eo|
+            Formatter::Model::Examples.new(comments(eo), tags(eo), keyword(eo), name(eo), description(eo), line(eo), id(eo), examples_rows(eo['rows'])).replay(@formatter)
+          end
         end
       end
 
@@ -44,23 +46,25 @@ module Gherkin
       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))
+        Formatter::Model::Scenario.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o), id(o))
       when 'scenario_outline'
-        Formatter::Model::ScenarioOutline.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o))
+        Formatter::Model::ScenarioOutline.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o), id(o))
       end
     end
 
     def step(o)
-      step = Formatter::Model::Step.new(comments(o), keyword(o), name(o), line(o))
+      builder = Formatter::Model::Step::Builder.new(comments(o), keyword(o), name(o), line(o))
+
+      (o['rows'] || []).each do |row|
+        builder.row comments(row), row['cells'], row['line'], nil
+      end
 
-      if(o['rows'])
-        step.rows = rows(o['rows'])
-      elsif(o['doc_string'])
+      if(o['doc_string'])
         ds = o['doc_string']
-        step.doc_string = Formatter::Model::DocString.new(ds['content_type'].to_s, ds['value'], ds['line'])
+        builder.doc_string ds['value'], ds['content_type'].to_s, ds['line']
       end
 
-      step
+      builder.build
     end
 
     def match(o)
@@ -81,8 +85,8 @@ module Gherkin
       end
     end
 
-    def rows(o)
-      o.map{|row| Formatter::Model::Row.new(comments(row), row['cells'], row['line'])}
+    def examples_rows(o)
+      o.map{|row| Formatter::Model::ExamplesTableRow.new(comments(row), row['cells'], row['line'], row['id'])}
     end
 
     def comments(o)
@@ -113,6 +117,10 @@ module Gherkin
       o['line']
     end
 
+    def id(o)
+      o['id']
+    end
+
     def arguments(m)
       m['arguments'].map{|a| Formatter::Argument.new(a['offset'], a['val'])}
     end

data/lib/gherkin/listener/formatter_listener.rb

@@ -11,54 +11,65 @@ module Gherkin
 
       def initialize(formatter)
         @formatter = formatter
-        @comments = []
-        @tags = []
-        @table = nil
+        @stash = Stash.new
       end
 
       def comment(value, line)
-        @comments << Formatter::Model::Comment.new(value, line)
+        @stash.comment Formatter::Model::Comment.new(value, line)
       end
 
       def tag(name, line)
-        @tags << Formatter::Model::Tag.new(name, line)
+        @stash.tag Formatter::Model::Tag.new(name, line)
       end
 
       def feature(keyword, name, description, line)
-        @formatter.feature(Formatter::Model::Feature.new(grab_comments!, grab_tags!, keyword, name, description, line))
+        @stash.feature(name) do |comments, tags, id|
+          replay Formatter::Model::Feature.new(comments, tags, keyword, name, description, line, id)
+        end
       end
 
       def background(keyword, name, description, line)
-        @formatter.background(Formatter::Model::Background.new(grab_comments!, keyword, name, description, line))
+        @stash.feature_element(name) do |comments, tags, id|
+          replay Formatter::Model::Background.new(comments, keyword, name, description, line)
+        end
       end
 
       def scenario(keyword, name, description, line)
         replay_step_or_examples
-        @formatter.scenario(Formatter::Model::Scenario.new(grab_comments!, grab_tags!, keyword, name, description, line))
+        @stash.feature_element(name) do |comments, tags, id|
+          replay Formatter::Model::Scenario.new(comments, tags, keyword, name, description, line, id)
+        end
       end
 
       def scenario_outline(keyword, name, description, line)
         replay_step_or_examples
-        @formatter.scenario_outline(Formatter::Model::ScenarioOutline.new(grab_comments!, grab_tags!, keyword, name, description, line))
+        @stash.feature_element(name) do |comments, tags, id|
+          replay Formatter::Model::ScenarioOutline.new(comments, tags, keyword, name, description, line, id)
+        end
       end
 
       def examples(keyword, name, description, line)
         replay_step_or_examples
-        @examples_statement = Formatter::Model::Examples.new(grab_comments!, grab_tags!, keyword, name, description, line, nil)
+        @stash.examples(name) do |comments, tags, id|
+          @current_builder = Formatter::Model::Examples::Builder.new(comments, tags, keyword, name, description, line, id)
+        end
       end
 
       def step(keyword, name, line)
         replay_step_or_examples
-        @step_statement = Formatter::Model::Step.new(grab_comments!, keyword, name, line)
+        @stash.basic_statement do |comments|
+          @current_builder = Formatter::Model::Step::Builder.new(comments, keyword, name, line)
+        end
       end
 
       def row(cells, line)
-        @table ||= []
-        @table << Formatter::Model::Row.new(grab_comments!, cells, line)
+        @stash.basic_statement do |comments, id|
+          @current_builder.row(comments, cells, line, id)
+        end
       end
 
-      def doc_string(string, content_type, line)
-        @doc_string = Formatter::Model::DocString.new(string, content_type, line)
+      def doc_string(content_type, value, line)
+        @current_builder.doc_string(value, content_type, line)
       end
 
       def eof
@@ -71,46 +82,61 @@ module Gherkin
       end
 
     private
+    
+      def replay(element)
+        element.replay(@formatter)
+      end
+      
+      class Stash
+        attr_reader :comments, :tags, :ids
+        
+        def initialize
+          @comments, @tags, @ids = [], [], []
+          @row_index = 0
+        end
+        
+        def comment(comment)
+          @comments << comment
+        end
+        
+        def feature(name)
+          @feature_id = id(name)
+          yield @comments, @tags, @feature_id
+          @comments, @tags = [], []
+        end
 
-      def grab_comments!
-        comments = @comments
-        @comments = []
-        comments
-      end
-
-      def grab_tags!
-        tags = @tags
-        @tags = []
-        tags
-      end
-
-      def grab_rows!
-        table = @table
-        @table = nil
-        table
-      end
+        def feature_element(name)
+          @feature_element_id = "#{@feature_id};#{id(name)}"
+          yield @comments, @tags, @feature_element_id
+          @comments, @tags = [], []
+        end
+        
+        def examples(name)
+          @examples_id = "#{@feature_element_id};#{id(name)}"
+          @row_index = 0
+          yield @comments, @tags, @examples_id
+          @comments, @tags = [], []
+        end
+        
+        def basic_statement
+          @row_index += 1
+          yield @comments, "#{@examples_id};#{@row_index}"
+          @comments = []
+        end
+        
+        def tag(tag)
+          @tags << tag
+        end
 
-      def grab_doc_string!
-        doc_string = @doc_string
-        @doc_string = nil
-        doc_string
+        def id(name)
+          (name || '').gsub(/[\s_]/, '-').downcase
+        end
       end
 
       def replay_step_or_examples
-        if(@step_statement)
-          if(doc_string = grab_doc_string!)
-            @step_statement.doc_string = doc_string
-          elsif(rows = grab_rows!)
-            @step_statement.rows = rows
-          end
-          @formatter.step(@step_statement)
-          @step_statement = nil
-        end
-        if(@examples_statement)
-          @examples_statement.rows = grab_rows!
-          @formatter.examples(@examples_statement)
-          @examples_statement = nil
-        end
+        return unless @current_builder
+        replay(@current_builder)
+        @current_builder = nil
       end
     end
   end