gherkin 2.1.4-i386-mingw32 → 2.1.5-i386-mingw32

data/History.txt

@@ -1,3 +1,11 @@
+== 2.1.5 (2010-07-17)
+
+=== Bugfixes
+* Line filter works on JRuby with Scenarios without steps. (Aslak Hellesøy)
+
+=== Changed Features
+* The JSON schema now puts background inside the "elements" Array. Makes parsing simpler. (Aslak Hellesøy)
+
 == 2.1.4 (2010-07-14)
 
 === Bugfixes

data/Rakefile

@@ -19,8 +19,9 @@ begin
     gem.authors = ["Mike Sassak", "Gregory Hnatiuk", "Aslak Hellesøy"]
     gem.executables = ["gherkin"]
     gem.add_dependency "trollop", "~> 1.16.2"
-    gem.add_development_dependency 'rspec', '~> 2.0.0.beta.15'
-    gem.add_development_dependency "cucumber", "~> 0.8.4"
+    gem.add_development_dependency 'awesome_print', '~> 0.2.1'
+    gem.add_development_dependency 'rspec', '~> 2.0.0.beta.17'
+    gem.add_development_dependency "cucumber", "~> 0.8.5"
     gem.add_development_dependency "rake-compiler", "~> 0.7.0" unless defined?(JRUBY_VERSION)
 
     gem.files -= FileList['ikvm/**/*']

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 2
 :minor: 1
-:patch: 4
+:patch: 5
 :build: 

data/features/json_formatter.feature

@@ -16,9 +16,11 @@ Feature: JSON formatter
     Then the outputted JSON should be:
       """
       {
-        "comments": ["# language: no", "# Another comment"],
+        "type": "feature", 
+        "comments": [{"value": "# language: no", "line": 1}, {"value": "# Another comment", "line": 2}],
         "keyword": "Egenskap",
         "name": "Kjapp",
+        "description": "",
         "line": 3,
         "uri": "test.feature"
       }
@@ -71,16 +73,19 @@ Feature: JSON formatter
     Then the outputted JSON should be:
       """
       {
+        "type": "feature", 
+        "tags": [{"name": "@one", "line":1}],
         "keyword": "Feature",
         "name": "OH HAI",
-        "tags": ["@one"],
+        "description": "",
         "line": 2,
         "uri": "test.feature",
         "elements":[
           {
+            "type": "scenario",
             "keyword": "Scenario",
             "name": "Fujin",
-            "type": "scenario",
+            "description": "",
             "line": 4,
             "steps": [
               {
@@ -96,10 +101,11 @@ Feature: JSON formatter
             ]
           },
           {
-            "tags": ["@two"],
+            "type": "scenario",
+            "tags": [{"name": "@two", "line":8}],
             "keyword": "Scenario",
             "name": "_why",
-            "type": "scenario",
+            "description": "",
             "line": 9,
             "steps": [
               {
@@ -115,10 +121,11 @@ Feature: JSON formatter
             ]
           },
           {
-            "tags": ["@three", "@four"],
+            "type": "scenario_outline",
+            "tags": [{"name": "@three", "line":13}, {"name": "@four", "line":13}],
             "keyword": "Scenario Outline",
             "name": "Life",
-            "type": "scenario_outline",
+            "description": "",
             "line": 14,
             "steps": [
               {
@@ -129,9 +136,11 @@ Feature: JSON formatter
             ],
             "examples": [
               {
-                "tags": ["@five"],
+                "type": "examples", 
+                "tags": [{"name": "@five", "line":17}],
                 "keyword": "Examples",
                 "name": "Real life",
+                "description": "",
                 "line": 18,
                 "table": [
                   {
@@ -151,39 +160,48 @@ Feature: JSON formatter
             ]
           },
           {
+            "type": "scenario",
             "keyword": "Scenario",
             "name": "who stole my mojo?",
-            "type": "scenario",
+            "description": "",
             "line": 23,
             "steps": [
               {
                 "keyword": "When ",
                 "name": "I was",
                 "line": 24,
-                "table": [
-                  {
-                    "line": 25,
-                    "cells": ["asleep"]
-                  }
-                ]
+                "multiline_arg": {
+                  "type": "table",
+                  "value": [
+                    {
+                      "line": 25,
+                      "cells": ["asleep"]
+                    }
+                  ]
+                }
               },
               {
                 "keyword": "And ",
                 "name": "so",
                 "line": 26,
-                "py_string": "innocent"
+                "multiline_arg": {
+                  "type": "py_string",
+                  "value": "innocent",
+                  "line": 27
+                }
               }
             ]
           },
           {
-            "comments": ["# The"],
-            "keyword": "Scenario Outline",
             "type": "scenario_outline",
-            "line": 32,
+            "comments": [{"value": "# The", "line":31}],
+            "keyword": "Scenario Outline",
             "name": "with",
+            "description": "",
+            "line": 32,
             "steps": [
               {
-                "comments": ["# all"],
+                "comments": [{"value": "# all", "line":33}],
                 "keyword": "Then ",
                 "line": 34,
                 "name": "nice"
@@ -191,13 +209,15 @@ Feature: JSON formatter
             ],
             "examples": [
               {
-                "comments": ["# comments", "# everywhere"],
+                "type": "examples", 
+                "comments": [{"value": "# comments", "line": 36}, {"value": "# everywhere", "line": 37}],
                 "keyword": "Examples",
                 "name": "An example",
+                "description": "",
                 "line": 38,
                 "table": [
                   {
-                    "comments": ["# I mean"],
+                    "comments": [{"value": "# I mean", "line": 39}],
                     "line": 40,
                     "cells": ["partout"]
                   }
@@ -224,27 +244,33 @@ Feature: JSON formatter
     Then the outputted JSON should be:
       """
       {
+        "type": "feature", 
         "keyword": "Feature",
         "name": "Kjapp",
+        "description": "",
         "line": 1,
         "uri": "test.feature",
-        "background": {
-          "keyword": "Background",
-          "line": 3,
-          "name": "No idea what Kjapp means",
-          "steps": [
-            {
-              "keyword": "Given ",
-              "line": 4,
-              "name": "I Google it"
-            }
-          ]
-        },
         "elements": [
           {
-            "comments": ["# Writing JSON by hand sucks"],
-            "keyword": "Scenario",
+            "type": "background",
+            "keyword": "Background",
+            "line": 3,
+            "name": "No idea what Kjapp means",
+            "description": "",
+            "steps": [
+              {
+                "keyword": "Given ",
+                "line": 4,
+                "name": "I Google it"
+              }
+            ]
+          },
+          {
             "type": "scenario",
+            "comments": [{"value": "# Writing JSON by hand sucks", "line": 6}],
+            "keyword": "Scenario",
+            "name": "",
+            "description": "",
             "line": 7,
             "steps": [
               {

data/features/json_parser.feature

@@ -10,7 +10,11 @@ Feature: JSON lexer
     Given the following JSON is parsed:
       """
       {
-        "comments": ["# language: no", "# Another comment"],
+        "type": "feature",
+        "comments": [
+          {"value": "# language: no"}, 
+          {"value": "# Another comment"}
+        ],
         "description": "",
         "keyword": "Egenskap",
         "name": "Kjapp",
@@ -29,10 +33,11 @@ Feature: JSON lexer
     Given the following JSON is parsed:
       """
       {
+        "type": "feature",
         "comments": [],
         "keyword": "Feature",
         "name": "OH HAI",
-        "tags": ["@one"],
+        "tags": [{"name": "@one"}],
         "uri": "test.feature",
         "description": "",
         "elements":[
@@ -61,7 +66,7 @@ Feature: JSON lexer
           },
           {
             "comments": [],
-            "tags": ["@two"],
+            "tags": [{"name": "@two"}],
             "keyword": "Scenario",
             "name": "_why",
             "description": "",
@@ -84,7 +89,7 @@ Feature: JSON lexer
           },
           {
             "comments": [],
-            "tags": ["@three", "@four"],
+            "tags": [{"name": "@three"}, {"name": "@four"}],
             "keyword": "Scenario Outline",
             "name": "Life",
             "description": "",
@@ -100,8 +105,9 @@ Feature: JSON lexer
             ],
             "examples": [
               {
+                "type": "examples",
                 "comments": [],
-                "tags": ["@five"],
+                "tags": [{"name": "@five"}],
                 "keyword": "Examples",
                 "name": "Real life",
                 "description": "",
@@ -140,25 +146,32 @@ Feature: JSON lexer
                 "keyword": "When ",
                 "name": "I was",
                 "line": 24,
-                "table": [
-                  {
-                    "comments": [],
-                    "line": 25,
-                    "cells": ["asleep"]
-                  }
-                ]
+                "multiline_arg": {
+                  "type": "table",
+                  "value": [
+                    {
+                      "comments": [],
+                      "line": 25,
+                      "cells": ["asleep"]
+                    }
+                  ]
+                }
               },
               {
                 "comments": [],
                 "keyword": "And ",
                 "name": "so",
                 "line": 26,
-                "py_string": "innocent"
+                "multiline_arg": {
+                  "type": "py_string",
+                  "value": "innocent",
+                  "line": 27
+                }
               }
             ]
           },
           {
-            "comments": ["# The"],
+            "comments": [{"value": "# The"}],
             "tags": [],
             "keyword": "Scenario Outline",
             "description": "",
@@ -167,7 +180,7 @@ Feature: JSON lexer
             "name": "with",
             "steps": [
               {
-                "comments": ["# all"],
+                "comments": [{"value": "# all"}],
                 "keyword": "Then ",
                 "line": 34,
                 "name": "nice"
@@ -175,22 +188,21 @@ Feature: JSON lexer
             ],
             "examples": [
               {
-                "comments": ["# comments", "# everywhere"],
+                "type": "examples",
+                "comments": [{"value": "# comments"}, {"value": "# everywhere"}],
                 "tags": [],
                 "keyword": "Examples",
                 "name": "An example",
-                // TODO - the description should now be the comment
-                // It should be on the first row of the examples_table!
                 "description": "",
                 "line": 38,
                 "table": [
                   {
-                    "comments": ["# I mean"],
+                    "comments": [{"value": "# I mean"}],
                     "line": 40,
                     "cells": ["partout"]
                   },
                   {
-                    "comments": ["# I really mean"],
+                    "comments": [{"value": "# I really mean"}],
                     "line": 40,
                     "cells": ["bartout"]
                   }
@@ -251,35 +263,37 @@ Feature: JSON lexer
     Given the following JSON is parsed:
       """
       {
+        "type": "feature",
         "comments": [],
         "description": "",
         "keyword": "Feature",
         "name": "Kjapp",
         "tags": [],
         "uri": "test.feature",
-        "background": {
-          "comments": [],
-          "description": "",
-          "keyword": "Background",
-          "line": 2,
-          "name": "No idea what Kjapp means",
-          "steps": [
-            {
-              "comments": [],
-              "keyword": "Given ",
-              "line": 3,
-              "name": "I Google it"
-            }
-          ]
-        },
         "elements": [
           {
-            "comments": ["# Writing JSON by hand sucks"],
+            "type": "background",
+            "comments": [],
+            "description": "",
+            "keyword": "Background",
+            "line": 2,
+            "name": "No idea what Kjapp means",
+            "steps": [
+              {
+                "comments": [],
+                "keyword": "Given ",
+                "line": 3,
+                "name": "I Google it"
+              }
+            ]
+          },
+          {
+            "type": "scenario",
+            "comments": [{"value": "# Writing JSON by hand sucks"}],
             "tags": [],
             "keyword": "Scenario",
             "name": "",
             "description": "",
-            "type": "scenario",
             "line": 6,
             "steps": [
               {

data/features/step_definitions/json_formatter_steps.rb

@@ -1,3 +1,4 @@
+require 'ap' # awesome_print gem
 require 'stringio'
 require 'gherkin/formatter/json_formatter'
 require 'gherkin/listener/formatter_listener'
@@ -17,16 +18,10 @@ end
 
 Then /^the outputted JSON should be:$/ do |expected_json|
   require 'json'
-  expected = JSON.pretty_generate(JSON.parse(expected_json))
-  actual   = JSON.pretty_generate(JSON.parse(@io.string))
-  announce actual
-  begin
-    actual.should == expected
-  rescue # Haven't figured out how to order Hash on JRuby (JSON pure). Retry with possibly worse error message.
-    expected = JSON.parse(expected_json)
-    actual   = JSON.parse(@io.string)
-    actual.should == expected
-  end
+  announce JSON.pretty_generate(JSON.parse(@io.string))
+  expected = JSON.parse(expected_json).ai
+  actual   = JSON.parse(@io.string).ai
+  actual.should == expected
 end
 
 

data/lib/gherkin/formatter/filter_formatter.rb

@@ -109,28 +109,23 @@ module Gherkin
       def replay!
         case @filter
         when TagExpression
-          background_ok      = false
           feature_element_ok = @filter.eval(tag_names(@feature_tags.to_a + @feature_element_tags.to_a))
           examples_ok        = @filter.eval(tag_names(@feature_tags.to_a + @feature_element_tags.to_a + @examples_tags.to_a)) if @examples_tags
         when RegexpFilter
-          background_ok      = @filter.eval([@background_name]) if @background_name
           feature_element_ok = @filter.eval([@feature_element_name])
           examples_ok        = @filter.eval([@feature_element_name, @examples_name]) if @examples_name
         when LineFilter
-          background_ok      = @filter.eval([@background_range]) if @background_range
           feature_element_ok = @filter.eval([@feature_element_range]) if @feature_element_range
           examples_ok        = @filter.eval([@feature_element_range, @examples_range]) if @examples_range
         end
 
-        if background_ok || feature_element_ok || examples_ok
+        if feature_element_ok || examples_ok
           replay_events!(@feature_events)
           replay_events!(@background_events)
+          replay_events!(@feature_element_events)
 
-          if feature_element_ok || examples_ok
-            replay_events!(@feature_element_events)
-            if examples_ok
-              replay_events!(@examples_events)
-            end
+          if examples_ok
+            replay_events!(@examples_events)
           end
         end
       end

data/lib/gherkin/formatter/json_formatter.rb

@@ -1,6 +1,7 @@
 require 'json'
 require 'json/pure' # Needed to make JSON.generate work.
 require 'gherkin/rubify'
+require 'gherkin/formatter/model'
 
 module Gherkin
   module Formatter
@@ -12,22 +13,19 @@ module Gherkin
       end
 
       def feature(statement, uri)
-        @json_hash = statement_hash(nil, statement)
+        @json_hash = statement_hash('feature', statement)
         @json_hash['uri'] = uri
       end
 
       def background(statement)
-        @json_hash['background'] = statement_hash(nil, statement) 
-        @in_background = true
+        add_step_container('background', statement)
       end
 
       def scenario(statement)
-        @in_background = false
         add_step_container('scenario', statement)
       end
 
       def scenario_outline(statement)
-        @in_background = false
         add_step_container('scenario_outline', statement)
       end
 
@@ -50,15 +48,31 @@ module Gherkin
 
       def statement_hash(type, statement)
         element = {
-          '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
-        compact(element)
+        element['type'] = type if type
+        add_comments(element, statement)
+        add_tags(element, statement)
+        element['description'] = statement.description if statement.description
+        element
+      end
+
+      def add_comments(element, comment_holder)
+        if comment_holder.comments && comment_holder.comments.any?
+          element['comments'] = comment_holder.comments.map do |comment|
+            {'value' => comment.value, 'line' => comment.line}
+          end
+        end
+      end
+
+      def add_tags(element, statement)
+        if statement.tags && statement.tags.any?
+          element['tags'] = statement.tags.map do |tag|
+            {'name' => tag.name, 'line' => tag.line}
+          end
+        end
       end
 
       def add_element(type, statement)
@@ -69,7 +83,7 @@ module Gherkin
       end
 
       def add_examples(statement)
-        element = statement_hash(nil, statement)
+        element = statement_hash('examples', statement)
         last_element['examples'] ||= []
         last_element['examples'] << element
         element
@@ -81,27 +95,38 @@ module Gherkin
       end
 
       def last_element
-        if @in_background
-          @json_hash['background']
-        else
-          @json_hash['elements'][-1]
-        end
+        @json_hash['elements'][-1]
       end
 
       def to_hash_array(rows)
         rows.map do |row|
-          compact({"cells" => row.cells.to_a, "comments" => row.comments.map{|comment| comment.value}, "line" => row.line})
+          e = {"cells" => row.cells.to_a, "line" => row.line}
+          add_comments(e, row)
+          e
         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.value }
-      end
-
-      def compact(hash)
-        hash.reject{|k,v| [[], "", nil].index(v)}
+        case multiline_arg
+        when Array
+          {
+            "multiline_arg" => {
+              "type" => "table",
+              "value" => to_hash_array(multiline_arg)
+            }
+          }
+        when Model::PyString
+          {
+            "multiline_arg" => {
+              "type" => "py_string",
+              "value" => multiline_arg.value,
+              "line" => multiline_arg.line
+            }
+          }
+        else
+          {}
+        end
       end
     end
   end

data/lib/gherkin/i18n.rb

@@ -49,7 +49,7 @@ module Gherkin
       end
 
       def code_keyword_for(gherkin_keyword)
-        gherkin_keyword.gsub(/[\s',]/, '').strip
+        gherkin_keyword.gsub(/[\s',!]/, '').strip
       end
 
       def language_table

data/lib/gherkin/json_parser.rb

@@ -26,17 +26,11 @@ module Gherkin
 
       comments_for(feature)
       tags_for(feature)
-      multiline_event(:feature, feature)
+      multiline_event(feature)
 
-      if feature["background"]
-        comments_for(feature["background"])
-        multiline_event(:background, feature["background"])
-        steps_for(feature["background"])
-      end
-
-      feature["elements"].each do |feature_element|
+      (feature["elements"] || []).each do |feature_element|
         parse_element(feature_element) 
-      end if feature["elements"]
+      end
 
       @listener.eof
     end
@@ -44,71 +38,64 @@ module Gherkin
     def parse_element(feature_element)
       comments_for(feature_element)
       tags_for(feature_element)
-      case feature_element["type"]
-      when "scenario" then parse_scenario(feature_element)
-      when "scenario_outline" then parse_outline(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'])
+        end
       end
     end
 
-    def parse_outline(scenario_outline)
-      multiline_event(:scenario_outline, scenario_outline)
-      steps_for(scenario_outline)
-      scenario_outline["examples"].each do |examples|
-        comments_for(examples)
-        tags_for(examples)
-        multiline_event(:examples, examples)
-        rows_for(examples)
-      end
-    end
-
-    def parse_scenario(scenario)
-      multiline_event(:scenario, scenario)
-      steps_for(scenario)
-    end
-
     def comments_for(element)
-      element["comments"].each do |comment|
-        @listener.comment(comment, line_for(comment))
-      end if element["comments"]
+      (element["comments"] || []).each do |comment|
+        @listener.comment(comment['value'], comment['line'])
+      end
     end
 
     def tags_for(element)
-      element["tags"].each do |tag|
-        @listener.tag(tag, line_for(tag))
-      end if element["tags"]
+      (element["tags"] || []).each do |tag|
+        @listener.tag(tag['name'], tag['line'])
+      end
     end
 
     def steps_for(element)
       element["steps"].each do |step|
         comments_for(step)
-        @listener.step(step["keyword"], step["name"], line_for(step))
-        py_string_for(step)    
-        rows_for(step)
+        @listener.step(step["keyword"], step["name"], step['line'])
+        multiline_arg_for(step)    
       end
     end
 
-    def py_string_for(element)
-      @listener.py_string(element["py_string"], 0) if element["py_string"]
+    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
     end
 
-    def rows_for(element)
-      element["table"].each do |row|
+    def rows_for(rows)
+      (rows || []).each do |row|
         comments_for(row)
-        @listener.row(cells_for(row), 0)
-      end if element["table"]
+        @listener.row(cells_for(row), row['line'])
+      end
     end
 
     def cells_for(row)
       row["cells"]
     end
 
-    def line_for(element)
-      element["line"].to_i || 0
-    end
-
-    def multiline_event(type, element)
+    def multiline_event(element)
       if element["keyword"] 
-        @listener.__send__(type, element["keyword"], element["name"] || "", element["description"] || "", line_for(element))
+        @listener.__send__(element['type'].to_sym, element["keyword"], element["name"] || "", element["description"] || "", element['line'])
       end
     end
   end

data/spec/gherkin/fixtures/complex.json

@@ -1,40 +1,48 @@
-{ "name": "Feature Text",
+{ 
+  "type": "feature",
+  "name": "Feature Text",
   "keyword": "Feature",
   "description": "In order to test multiline forms",
   "tags": [
-    "@tag1",
-    "@tag2"
+    {"name": "@tag1"},
+    {"name": "@tag2"}
   ],
-  "background" : {
-    "description": "",
-    "name": "", 
-    "keyword": "Background",
-    "steps": [
-      { "name": "this is a background step",
-        "keyword": "Given " },
-      { "name": "this is another one",
-        "keyword": "When ",
-        "line": 412 }
-    ]
-  },
   "elements": [
+    { "type": "background",
+      "description": "",
+      "name": "", 
+      "keyword": "Background",
+      "steps": [
+        { "name": "this is a background step",
+          "keyword": "Given " },
+        { "name": "this is another one",
+          "keyword": "When ",
+          "line": 412 }
+      ]
+    },
     { "type": "scenario_outline",
       "keyword": "Scenario Outline",
       "name": "An Scenario Outline",
       "description": "",
-      "tags": [ "@foo" ],
+      "tags": [
+        {"name": "@foo"}
+      ],
       "steps": [
         { "name": "A step with a table",
           "keyword": "Given ",
-          "table" : [
-            {"cells":
-              [ "a","row","for","a","step" ]
-            }
-          ]
+          "multiline_arg": {
+            "type": "table",
+            "value" : [
+              {"cells":
+                [ "a","row","for","a","step" ]
+              }
+            ]
+          }
         }
       ],
       "examples": [
-        { "name": "Sweet Example", 
+        { "type": "examples",
+          "name": "Sweet Example", 
           "keyword": "Examples",
           "description": "",
           "table" : [
@@ -45,7 +53,7 @@
               [ "The","Blanks" ]
             }
           ],
-          "tags" : [ "@exampletag" ]
+          "tags" : [ {"name": "@exampletag"} ]
         }
       ]
     },
@@ -54,8 +62,8 @@
       "name" : "Reading a Scenario",
       "description": "",
       "tags" : [
-        "@tag3",
-        "@tag4"
+        {"name": "@tag3"},
+        {"name": "@tag4"}
       ],
       "steps" : [
         { "name" : "there is a step",
@@ -68,38 +76,45 @@
       "keyword": "Scenario",
       "name" : "Reading a second scenario",
       "description": "With two lines of text",
-      "tags" : [ "@tag3" ],
+      "tags" : [ {"name": "@tag3"} ],
       "steps" : [
         { "name" : "a third step with a table",
           "keyword": "Given ",
-          "table" : [
-            { "cells" :
-              [ "a","b" ]
-            },
-            { "cells" :
-              [ "c","d" ]
-            },
-            { "cells" :
-              [ "e", "f" ]
-            }
-          ]
+          "multiline_arg": {
+            "type": "table",
+            "value": [
+              {
+                "cells" : [ "a","b" ],
+                "line" : 987
+              },
+              { "cells" :
+                [ "c","d" ]
+              },
+              { "cells" :
+                [ "e", "f" ]
+              }
+            ]
+          }
         },
         { "name" : "I am still testing things",
           "keyword": "Given ",
-          "table" : [
-            { "cells" :
-              [ "g","h" ]
-            },
-            { "cells" :
-              [ "e","r" ]
-            },
-            { "cells" :
-              [ "k", "i" ]
-            },
-            { "cells" :
-              [ "n", "" ]
-            }
-          ]
+          "multiline_arg": {
+            "type": "table",
+            "value": [
+              { "cells" :
+                [ "g","h" ]
+              },
+              { "cells" :
+                [ "e","r" ]
+              },
+              { "cells" :
+                [ "k", "i" ]
+              },
+              { "cells" :
+                [ "n", "" ]
+              }
+            ]
+          }
         },
         { "name" : "I am done testing these tables",
           "keyword": "Given " },
@@ -114,7 +129,12 @@
       "steps" : [
         { "name" : "All work and no play", 
           "keyword": "Given ",
-          "py_string" : "Makes Homer something something\nAnd something else" },
+          "multiline_arg": {
+            "type": "py_string",
+            "value": "Makes Homer something something\nAnd something else",
+            "line": 777
+          }
+        },
         { "name" : "crazy",
           "keyword": "Given " }
       ]

data/spec/gherkin/fixtures/scenario_without_steps.feature

@@ -0,0 +1,5 @@
+Feature: f
+
+  Scenario: a
+
+  Scenario: b

data/spec/gherkin/formatter/filter_formatter_spec.rb

@@ -92,6 +92,11 @@ module Gherkin
 
       context "lines" do
         context "on the same line as feature element keyword" do
+          it "should filter on scenario without line" do
+            self.file = 'scenario_without_steps.feature'
+            verify_filter([3], 1..4)
+          end
+
           it "should filter on scenario line" do
             verify_filter([16], 1..19)
           end

data/spec/gherkin/json_parser_spec.rb

@@ -22,7 +22,7 @@ module Gherkin
 
     describe "A barely empty feature" do
       it "should scan a feature with no elements" do
-        @parser.parse_with_listener('{ "keyword": "Feature", "name": "One", "description": "", "line" : 3 }', @listener)
+        @parser.parse_with_listener('{ "type": "feature", "keyword": "Feature", "name": "One", "description": "", "line" : 3 }', @listener)
         @listener.to_sexp.should == [
           [:location, "unknown.json"],
           [:feature, "Feature", "One", "", 3],
@@ -31,23 +31,12 @@ module Gherkin
       end
     end
 
-    describe "Missing line numbers" do
-      it "should indicate a line number of 0 if a line attribute doesn't exist" do
-        @parser.parse_with_listener('{ "name": "My Sweet Featur", "keyword": "Feature", "description": "" }', @listener)
-        @listener.to_sexp.should == [
-          [:location, "unknown.json"],
-          [:feature, "Feature", "My Sweet Featur", "", 0],
-          [:eof]
-        ]
-      end
-    end
-
     describe "Keywords" do
       it "should use the keyword from the source when provided" do
-        @parser.parse_with_listener('{ "name" : "My Sweet Featur", "language": "fr", "keyword": "Feature", "description": "" }', @listener)
+        @parser.parse_with_listener('{ "type": "feature", "name" : "My Sweet Featur", "language": "fr", "keyword": "Feature", "description": "" }', @listener)
         @listener.to_sexp.should == [
           [:location, "unknown.json"],
-          [:feature, "Feature", "My Sweet Featur", "",  0],
+          [:feature, "Feature", "My Sweet Featur", "",  nil],
           [:eof]
         ]
       end
@@ -58,42 +47,42 @@ module Gherkin
         @parser.parse_with_listener(fixture("complex.json"), @listener)
         @listener.to_sexp.should == [
           [:location, "unknown.json"],
-          [:tag, "@tag1", 0],
-          [:tag, "@tag2", 0],
-          [:feature, "Feature", "Feature Text","In order to test multiline forms", 0],
-          [:background, "Background", "", "", 0],
-          [:step, "Given ", "this is a background step", 0],
+          [:tag, "@tag1", nil],
+          [:tag, "@tag2", nil],
+          [:feature, "Feature", "Feature Text","In order to test multiline forms", nil],
+          [:background, "Background", "", "", nil],
+          [:step, "Given ", "this is a background step", nil],
           [:step, "When ", "this is another one", 412],
-          [:tag, "@foo", 0],
-          [:scenario_outline, "Scenario Outline", "An Scenario Outline","", 0],
-          [:step, "Given ", "A step with a table", 0],
-          [:row, %w{a row for a step}, 0],
-          [:tag, "@exampletag", 0],
-          [:examples, "Examples", "Sweet Example", "", 0],
-          [:row, %w{Fill In}, 0],
-          [:row, %w{The Blanks}, 0],
-          [:tag, "@tag3", 0],
-          [:tag, "@tag4", 0],
-          [:scenario, "Scenario", "Reading a Scenario", "", 0],
-          [:step, "Given ", "there is a step", 0],
-          [:step, "But ", "not another step", 0],
-          [:tag, "@tag3", 0],
-          [:scenario, "Scenario", "Reading a second scenario", "With two lines of text", 0],
-          [:step, "Given ", "a third step with a table", 0],
-          [:row, %w{a b}, 0],
-          [:row, %w{c d}, 0],
-          [:row, %w{e f}, 0],
-          [:step, "Given ", "I am still testing things", 0],
-          [:row, %w{g h}, 0],
-          [:row, %w{e r}, 0],
-          [:row, %w{k i}, 0],
-          [:row, ['n', ''], 0], 
-          [:step, "Given ", "I am done testing these tables", 0],
-          [:step, "Given ", "I am happy", 0],
-          [:scenario, "Scenario", "Hammerzeit", "", 0],
-          [:step, "Given ", "All work and no play", 0],
-          [:py_string, "Makes Homer something something\nAnd something else", 0 ],
-          [:step, "Given ", "crazy", 0],
+          [:tag, "@foo", nil],
+          [:scenario_outline, "Scenario Outline", "An Scenario Outline","", nil],
+          [:step, "Given ", "A step with a table", nil],
+          [:row, %w{a row for a step}, nil],
+          [:tag, "@exampletag", nil],
+          [:examples, "Examples", "Sweet Example", "", nil],
+          [:row, %w{Fill In}, nil],
+          [:row, %w{The Blanks}, nil],
+          [:tag, "@tag3", nil],
+          [:tag, "@tag4", nil],
+          [:scenario, "Scenario", "Reading a Scenario", "", nil],
+          [:step, "Given ", "there is a step", nil],
+          [:step, "But ", "not another step", nil],
+          [:tag, "@tag3", nil],
+          [:scenario, "Scenario", "Reading a second scenario", "With two lines of text", nil],
+          [:step, "Given ", "a third step with a table", nil],
+          [:row, %w{a b}, 987],
+          [:row, %w{c d}, nil],
+          [:row, %w{e f}, nil],
+          [:step, "Given ", "I am still testing things", nil],
+          [:row, %w{g h}, nil],
+          [:row, %w{e r}, nil],
+          [:row, %w{k i}, nil],
+          [:row, ['n', ''], nil], 
+          [:step, "Given ", "I am done testing these tables", nil],
+          [:step, "Given ", "I am happy", nil],
+          [:scenario, "Scenario", "Hammerzeit", "", nil],
+          [:step, "Given ", "All work and no play", nil],
+          [:py_string, "Makes Homer something something\nAnd something else", 777],
+          [:step, "Given ", "crazy", nil],
           [:eof]
         ]
       end        

data/tasks/release.rake

@@ -20,7 +20,7 @@ namespace :release do
 
   task :push_jar do
     Dir.chdir('java') do
-      sh("mvn deploy")
+      sh("mvn -Dmaven.wagon.provider.http=httpclient deploy")
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gherkin
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: false
   segments: 
   - 2
   - 1
-  - 4
-  version: 2.1.4
+  - 5
+  version: 2.1.5
 platform: i386-mingw32
 authors: 
 - Mike Sassak
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-14 00:00:00 +02:00
+date: 2010-07-17 00:00:00 +02:00
 default_executable: gherkin
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,43 +37,59 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: awesome_print
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 62196477
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 62196417
         segments: 
         - 2
         - 0
         - 0
         - beta
-        - 15
-        version: 2.0.0.beta.15
+        - 17
+        version: 2.0.0.beta.17
   type: :development
-  version_requirements: *id002
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: cucumber
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 55
+        hash: 53
         segments: 
         - 0
         - 8
-        - 4
-        version: 0.8.4
+        - 5
+        version: 0.8.5
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: rake-compiler
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -85,7 +101,7 @@ dependencies:
         - 0
         version: 0.7.0
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
 description: A fast Gherkin lexer/parser based on the Ragel State Machine Compiler.
 email: cukes@googlegroups.com
 executables: 
@@ -272,6 +288,7 @@ files:
 - spec/gherkin/fixtures/i18n_no.feature
 - spec/gherkin/fixtures/i18n_zh-CN.feature
 - spec/gherkin/fixtures/scenario_outline_with_tags.feature
+- spec/gherkin/fixtures/scenario_without_steps.feature
 - spec/gherkin/fixtures/simple_with_comments.feature
 - spec/gherkin/fixtures/simple_with_tags.feature
 - spec/gherkin/fixtures/with_bom.feature