gherkin 2.0.1-i386-mingw32 → 2.0.2-i386-mingw32

data/features/pretty_formatter.feature

@@ -4,6 +4,12 @@ Feature: Pretty Formatter
 
   Scenario: Parse all the features in Cucumber
     Given I have Cucumber's source code next to Gherkin's
-    When I find all of the .feature files
-    And I parse the prettified representation of each of them
-    Then they should all be identical to the pretty output
+    And I find all of the .feature files
+    When I send each prettified original through the "pretty" machinery
+    Then the machinery output should be identical to the prettified original
+
+  Scenario: Parse all the features in Cucumber with JSON
+    Given I have Cucumber's source code next to Gherkin's
+    And I find all of the .feature files
+    When I send each prettified original through the "json" machinery
+    Then the machinery output should be identical to the prettified original

data/features/step_definitions/json_lexer_steps.rb

@@ -0,0 +1,20 @@
+require 'stringio'
+require 'gherkin/formatter/pretty_formatter'
+require 'gherkin/json_lexer'
+
+Given /^a PrettyFormatter$/ do
+  @io = StringIO.new
+  @formatter = Gherkin::Parser::FormatterListener.new(Gherkin::Formatter::PrettyFormatter.new(@io, true))
+end
+
+Given /^a JSON lexer$/ do
+  @json_parser = Gherkin::JSONLexer.new(@formatter)
+end
+
+Given /^the following JSON is parsed:$/ do |text|
+  @json_parser.scan(JSON.pretty_generate(JSON.parse(text)))
+end
+
+Then /^the outputted text should be:$/ do |expected_text|
+  expected_text.should == @io.string.strip
+end

data/features/step_definitions/pretty_formatter_steps.rb

@@ -1,17 +1,50 @@
 require 'stringio'
+require 'fileutils'
 require 'gherkin'
 require 'gherkin/formatter/pretty_formatter'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin/json_lexer'
 
 module PrettyPlease
-  def pretty(source)
+  def pretty_machinery(gherkin, feature_path)
     io        = StringIO.new
     formatter = Gherkin::Formatter::PrettyFormatter.new(io, false)
     listener  = Gherkin::Parser::FormatterListener.new(formatter)
     parser    = Gherkin::Parser::Parser.new(listener, true)
     lexer     = Gherkin::I18nLexer.new(parser)
-    lexer.scan(source, "test.feature", 0)
+    scan(lexer, gherkin, feature_path)
     io.string
   end
+
+  def json_machinery(gherkin, feature_path)
+    json                = StringIO.new
+    json_formatter      = Gherkin::Formatter::JSONFormatter.new(json)
+    formatter_listener  = Gherkin::Parser::FormatterListener.new(json_formatter)
+    gherkin_lexer       = Gherkin::I18nLexer.new(formatter_listener)
+    scan(gherkin_lexer, gherkin, feature_path)
+
+    result              = StringIO.new
+    pretty_formatter    = Gherkin::Formatter::PrettyFormatter.new(result, false)
+    formatter_listener  = Gherkin::Parser::FormatterListener.new(pretty_formatter)
+    json_lexer          = Gherkin::JSONLexer.new(formatter_listener)
+    json_lexer.scan(json.string)
+    
+    result.string
+  end
+  
+  def scan(lexer, gherkin, feature_path)
+    begin
+      lexer.scan(gherkin, feature_path, 0)
+    rescue => e
+      if e.message =~ /Lexing error/
+        FileUtils.mkdir "tmp" unless File.directory?("tmp")
+        written_path = "tmp/#{File.basename(feature_path)}"
+        File.open(written_path, "w") {|io| io.write(gherkin)}
+        e.message << "\nSee #{written_path}"
+      end
+      raise e
+    end
+  end
 end
 
 World(PrettyPlease)
@@ -21,36 +54,33 @@ Given /^I have Cucumber's source code next to Gherkin's$/ do
   raise "No Cucumber source in #{@cucumber_home}" unless File.file?(@cucumber_home + '/bin/cucumber')
 end
 
-When /^I find all of the \.feature files$/ do
+Given /^I find all of the \.feature files$/ do
   @feature_paths = Dir["#{@cucumber_home}/**/*.feature"].sort
 end
 
-When /^I parse the prettified representation of each of them$/ do
+When /^I send each prettified original through the "([^"]*)" machinery$/ do |machinery|
   @error = false
   @feature_paths.each do |feature_path|
-    pretty1 = nil
-    pretty2 = nil
     begin
-      pretty1 = pretty(IO.read(feature_path))
-      pretty2 = pretty(pretty1)
-      pretty2.should == pretty1
+      original = pretty_machinery(IO.read(feature_path), feature_path)
+      via_machinery = self.__send__("#{machinery}_machinery", original, feature_path)
+      via_machinery.should == original
     rescue RSpec::Expectations::ExpectationNotMetError => e
       announce "=========="
       announce feature_path
       if(e.message =~ /(@@.*)/m)
         announce $1
         @error = true
-        File.open("p1.feature", "wb") {|io| io.write(pretty1)}
-        File.open("p2.feature", "wb") {|io| io.write(pretty2)}
       else
         announce "Identical, except for newlines"
       end
     rescue => e
-      e.message << "\nFatal error happened when parsing #{feature_path}"
+      e.message << "\nFatal error happened when parsing #{feature_path}."
+      raise e
     end
   end
 end
 
-Then /^they should all be identical to the pretty output$/ do
-  raise "Some features didn't do pretty well" if @error
+Then /^the machinery output should be identical to the prettified original$/ do
+  raise "Some features didn't make it through the machinery" if @error
 end

data/lib/gherkin/cli/main.rb

@@ -21,7 +21,7 @@ module Gherkin
           cmd = Tools.const_get(cmd_name.capitalize.to_sym).new(args)
           cmd.run
         rescue => e
-          Trollop::die(e.message + "\nCommand: #{cmd_name}")
+          Trollop::die(e.message + "\n#{e.backtrace.join("\n")}\n\nCommand: #{cmd_name}")
         end
       end
 

data/lib/gherkin/formatter/json_formatter.rb

@@ -22,23 +22,36 @@ module Gherkin
         }
       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 
+        @in_background = true
+      end
+
       def scenario(comments, tags, keyword, name, description, line)
-        add_step_container(comments, tags, keyword, name, description, line)
+        @in_background = false
+        add_step_container(comments, tags, keyword, name, description, line, 'scenario')
       end
 
       def scenario_outline(comments, tags, keyword, name, description, line)
-        add_step_container(comments, tags, keyword, name, description, line)
+        @in_background = false
+        add_step_container(comments, tags, keyword, name, description, line, 'scenario_outline')
       end
 
       def examples(comments, tags, keyword, name, description, line, table)
-        @table_container = add_element(comments, tags, keyword, name, description, line)
-        @table_container['examples_table'] = to_hash_array(table)
+        @table_container = add_examples(comments, tags, keyword, name, description, line)
+        @table_container['table'] = to_hash_array(table)
       end
 
       def step(comments, keyword, name, line, multiline_arg, status, exception, arguments, stepdef_location)
-        multiline_arg = rubify(multiline_arg)
-        multiline_arg = to_hash_array(multiline_arg) if Array === multiline_arg
-        @table_container = {'comments' => comments.to_a, 'keyword' => keyword, 'name' => name, 'line' => line, 'multiline_arg' => multiline_arg}
+        @table_container = {'comments' => comments.to_a, 'keyword' => keyword, 'name' => name, 'line' => line}.merge(step_arg_to_hash(multiline_arg))
         last_element['steps'] ||= []
         last_element['steps'] << @table_container
       end
@@ -49,27 +62,44 @@ module Gherkin
 
     private
 
-      def add_element(comments, tags, keyword, name, description, line)
+      def element_hash(comments, tags, keyword, name, description, line, type=nil)
         element = {
           'comments' => comments.to_a, 
           'tags' => tags.to_a, 
           'keyword' => keyword, 
           'name' => name, 
           'description' => description,
-          'line' => line
+          'line' => line,
         }
+        element['type'] = type if type
+        element
+      end
+
+      def add_element(comments, tags, keyword, name, description, line, type)
+        element = element_hash(comments, tags, keyword, name, description, line, type)
         @json_hash['elements'] ||= []
         @json_hash['elements'] << element
         element
       end
 
-      def add_step_container(comments, tags, keyword, name, description, line)
-        add_element(comments, tags, keyword, name, description, line)
+      def add_examples(comments, tags, keyword, name, description, line)
+        element = element_hash(comments, tags, keyword, name, description, line)
+        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)
         last_element['steps'] = []
       end
 
       def last_element
-        @json_hash['elements'][-1]
+        if @in_background
+          @json_hash['background']
+        else
+          @json_hash['elements'][-1]
+        end
       end
 
       def to_hash_array(rows)
@@ -77,6 +107,13 @@ module Gherkin
           {"cells" => row.cells.to_a, "comments" => row.comments.to_a, "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 }
+      end
     end
   end
-end
+end
+

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -24,14 +24,14 @@ module Gherkin
         print_comments(comments, '')
         print_tags(tags, '')
         @io.puts "#{keyword}: #{name}"
-        @io.puts indent(description, '  ') unless description == ""
+        print_description(description, '  ', false)
       end
 
       def background(comments, keyword, name, description, line)
         @io.puts
         print_comments(comments, '  ')
         @io.puts "  #{keyword}: #{name}#{indented_element_uri!(keyword, name, line)}"
-        @io.puts indent(description, '    ') unless description == ""
+        print_description(description, '    ')
       end
 
       def scenario(comments, tags, keyword, name, description, line)
@@ -39,7 +39,7 @@ module Gherkin
         print_comments(comments, '  ')
         print_tags(tags, '  ')
         @io.puts "  #{keyword}: #{name}#{indented_element_uri!(keyword, name, line)}"
-        @io.puts indent(description, '    ') unless description == ""
+        print_description(description, '    ')
       end
 
       def scenario_outline(comments, tags, keyword, name, description, line)
@@ -51,7 +51,7 @@ module Gherkin
         print_comments(comments, '    ')
         print_tags(tags, '    ')
         @io.puts "    #{keyword}: #{name}"
-        @io.puts indent(description, '    ') unless description == ""
+        print_description(description, '    ')
         table(examples_table)
       end
 
@@ -98,6 +98,9 @@ module Gherkin
         max_lengths = cell_lengths.transpose.map { |col_lengths| col_lengths.max }.flatten
 
         rows.each_with_index do |row, i|
+          row.comments.each do |comment|
+            @io.puts "      #{comment}"
+          end
           j = -1
           @io.puts '      | ' + row.cells.zip(max_lengths).map { |cell, max_length|
             j += 1
@@ -109,7 +112,7 @@ module Gherkin
     private
 
       def py_string(string)
-        @io.puts "      \"\"\"\n" + string.gsub(START, '      ').gsub(/"""/,'\"\"\"') + "\n      \"\"\""
+        @io.puts "      \"\"\"\n" + escape_triple_quotes(indent(string, '      ')) + "\n      \"\"\""
       end
 
       def exception(exception)
@@ -126,15 +129,19 @@ module Gherkin
       end
 
       if(RUBY_VERSION =~ /^1\.9/)
-        START = /#{"^".encode('UTF-8')}/
-        CRLF  = Regexp.new("\r\n".encode('UTF-8'))
+        START = /#{'^'.encode('UTF-8')}/
+        TRIPLE_QUOTES = /#{'"""'.encode('UTF-8')}/
       else
         START = /^/
-        CRLF  = /\r\n/n
+        TRIPLE_QUOTES = /"""/
       end
 
       def indent(string, indentation)
-        string.gsub(/^/, indentation)
+        string.gsub(START, indentation)
+      end
+
+      def escape_triple_quotes(s)
+        s.gsub(TRIPLE_QUOTES, '\"\"\"')
       end
 
       def print_tags(tags, indent)
@@ -145,6 +152,13 @@ module Gherkin
         @io.write(comments.empty? ? '' : indent + comments.join("\n#{indent}") + "\n")
       end
 
+      def print_description(description, indent, newline=true)
+        if description != ""
+          @io.puts indent(description, indent)
+          @io.puts if newline
+        end
+      end
+
       def indented_element_uri!(keyword, name, line)
         return '' if @max_step_length.nil?
         l = (keyword+name).unpack("U*").length

data/lib/gherkin/i18n.rb

@@ -58,7 +58,7 @@ module Gherkin
         require 'gherkin/parser/row'
         io = defined?(JRUBY_VERSION) ? Java.java.io.StringWriter.new : StringIO.new
         pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
-        table = all.map do |i18n| 
+        table = all.map do |i18n|
           Parser::Row.new([i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], [], nil)
         end
         pf.table(table)

data/lib/gherkin/json_lexer.rb

@@ -0,0 +1,103 @@
+require 'json'
+
+module Gherkin
+  class JSONLexer
+
+    def initialize(listener)
+      @listener = listener
+    end
+
+    def scan(src, uri='unknown.json', offset=0)
+      feature = JSON.parse(src)
+
+      comments_for(feature)
+      tags_for(feature)
+      multiline_event(:feature, feature)
+
+      if feature["background"]
+        comments_for(feature["background"])
+        multiline_event(:background, feature["background"])
+        steps_for(feature["background"])
+      end
+
+      feature["elements"].each do |feature_element|
+        parse_element(feature_element) 
+      end if feature["elements"]
+
+      @listener.eof
+    end
+
+    private
+
+    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)
+      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"]
+    end
+
+    def tags_for(element)
+      element["tags"].each do |tag|
+        @listener.tag(tag, line_for(tag))
+      end if element["tags"]
+    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)
+      end
+    end
+
+    def py_string_for(element)
+      @listener.py_string(element["py_string"], 0) if element["py_string"]
+    end
+
+    def rows_for(element)
+      element["table"].each do |row|
+        comments_for(row)
+        @listener.row(cells_for(row), 0)
+      end if element["table"]
+    end
+
+    def cells_for(row)
+      row["cells"]
+    end
+
+    def line_for(element)
+      element["line"].to_i || 0
+    end
+
+    def multiline_event(type, element)
+      if element["keyword"] 
+        @listener.__send__(type, element["keyword"], element["name"] || "", element["description"] || "", line_for(element))
+      end
+    end
+  end
+end