gherkin 2.5.4-x86-mingw32 → 2.6.0-x86-mingw32

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

data/spec/gherkin/fixtures/complex.json

@@ -1,4 +1,6 @@
-{ 
+{
+  "id": "feature-text",
+  "uri": "some/nice.feature",
   "name": "Feature Text",
   "keyword": "Feature",
   "description": "In order to test multiline forms",
@@ -20,6 +22,7 @@
       ]
     },
     { "type": "scenario_outline",
+      "id": "feature-text/a-scenario-outline",
       "keyword": "Scenario Outline",
       "name": "An Scenario Outline",
       "description": "",
@@ -36,6 +39,7 @@
       ],
       "examples": [
         {
+          "id": "feature-text/a-scenario-outline/sweet-example",
           "name": "Sweet Example", 
           "keyword": "Examples",
           "description": "",
@@ -52,6 +56,7 @@
       ]
     },
     { "type" : "scenario",
+      "id": "feature-text/reading-a-scenario",
       "keyword": "Scenario",
       "name" : "Reading a Scenario",
       "description": "",
@@ -67,6 +72,7 @@
       ]
     },
     { "type" : "scenario",
+      "id": "feature-text/reading-a-second-scenario",
       "keyword": "Scenario",
       "name" : "Reading a second scenario",
       "description": "With two lines of text",
@@ -111,6 +117,7 @@
       ]
     },
     { "type" : "scenario",
+      "id": "feature-text/hammerzeit",
       "keyword": "Scenario",
       "name" : "Hammerzeit", 
       "description": "",

data/spec/gherkin/formatter/json_formatter_spec.rb

@@ -10,10 +10,10 @@ module Gherkin
         io = StringIO.new
         f = JSONFormatter.new(io)
         f.uri("f.feature")
-        f.feature(Model::Feature.new([], [], "Feature", "f", "", 1))
-        f.scenario(Model::Scenario.new([], [], "Feature", "f", "", 2))
-        f.step(Model::Step.new([], "Given ", "g", 3))
-        f.step(Model::Step.new([], "When ", "w", 4))
+        f.feature(Model::Feature.new([], [], "Feature", "ff", "", 1, "ff"))
+        f.scenario(Model::Scenario.new([], [], "Scenario", "ss", "", 2, "ff/ss"))
+        f.step(Model::Step.new([], "Given ", "g", 3, nil, nil))
+        f.step(Model::Step.new([], "When ", "w", 4, nil, nil))
 
         f.match(Model::Match.new([], "def.rb:33"))
         f.result(Model::Result.new(:passed, 1, nil))
@@ -22,49 +22,55 @@ module Gherkin
         f.result(Model::Result.new(:passed, 1, nil))
 
         f.eof
+        f.close
         
         expected = %{
-          {
-            "keyword": "Feature",
-            "name": "f",
-            "line": 1,
-            "description": "",
-            "elements": [
-              {
-                "keyword": "Feature",
-                "name": "f",
-                "line": 2,
-                "description": "",
-                "type": "scenario",
-                "steps": [
-                  {
-                    "keyword": "Given ",
-                    "name": "g",
-                    "line": 3,
-                    "match": {
-                      "location": "def.rb:33"
+          [
+            {
+              "id": "ff",
+              "uri": "f.feature",
+              "keyword": "Feature",
+              "name": "ff",
+              "line": 1,
+              "description": "",
+              "elements": [
+                {
+                  "id": "ff/ss",
+                  "keyword": "Scenario",
+                  "name": "ss",
+                  "line": 2,
+                  "description": "",
+                  "type": "scenario",
+                  "steps": [
+                    {
+                      "keyword": "Given ",
+                      "name": "g",
+                      "line": 3,
+                      "match": {
+                        "location": "def.rb:33"
+                      },
+                      "result": {
+                        "status": "passed",
+                        "duration": 1
+                      }
                     },
-                    "result": {
-                      "status": "passed",
-                      "duration": 1
+                    {
+                      "keyword": "When ",
+                      "name": "w",
+                      "line": 4,
+                      "match": {
+                        "location": "def.rb:44"
+                      },
+                      "result": {
+                        "status": "passed",
+                        "duration": 1
+                      }
                     }
-                  },
-                  {
-                    "keyword": "When ",
-                    "name": "w",
-                    "line": 4,
-                    "match": {
-                      "location": "def.rb:44"
-                    },
-                    "result": {
-                      "status": "passed",
-                      "duration": 1
-                    }
-                  }
-                ]
-              }
-            ]
-          }
+                  ]
+                }
+              ]
+            }
+          ]
         }
 
         JSON.parse(expected).should == JSON.parse(io.string)

data/spec/gherkin/formatter/model_spec.rb

@@ -14,12 +14,12 @@ module Gherkin
 
       describe Step do
         it "should provide arguments for outline tokens" do
-          step = Step.new([], 'Given ', "I have <number> cukes in <whose> belly", 10)
+          step = Step.new([], 'Given ', "I have <number> cukes in <whose> belly", 10, nil, nil)
           step.outline_args.map{|arg| [arg.offset, arg.val]}.should == [[7, "<number>"], [25, "<whose>"]]
         end
 
         it "should provide no arguments when there are no outline tokens" do
-          step = Step.new([], 'Given ', "I have 33 cukes in my belly", 10)
+          step = Step.new([], 'Given ', "I have 33 cukes in my belly", 10, nil, nil)
           step.outline_args.to_a.should == []
         end
       end