gherkin 1.0.30-i386-mingw32 → 2.0.0-i386-mingw32

data/lib/gherkin/formatter/json_formatter.rb

@@ -0,0 +1,82 @@
+require 'json'
+require 'json/pure' # Needed to make JSON.generate work.
+require 'gherkin/rubify'
+
+module Gherkin
+  module Formatter
+    class JSONFormatter
+      include Rubify
+      
+      def initialize(io)
+        @io = io
+      end
+
+      def feature(comments, tags, keyword, name, description, uri)
+        @json_hash = {
+          'comments' => comments.to_a, 
+          'tags' => tags.to_a, 
+          'keyword' => keyword, 
+          'name' => name, 
+          'description' => description, 
+          'uri' => uri
+        }
+      end
+
+      def scenario(comments, tags, keyword, name, description, line)
+        add_step_container(comments, tags, keyword, name, description, line)
+      end
+
+      def scenario_outline(comments, tags, keyword, name, description, line)
+        add_step_container(comments, tags, keyword, name, description, line)
+      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)
+      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}
+        last_element['steps'] ||= []
+        last_element['steps'] << @table_container
+      end
+
+      def eof
+        @io.write(@json_hash.to_json)
+      end
+
+    private
+
+      def add_element(comments, tags, keyword, name, description, line)
+        element = {
+          'comments' => comments.to_a, 
+          'tags' => tags.to_a, 
+          'keyword' => keyword, 
+          'name' => name, 
+          'description' => description,
+          'line' => line
+        }
+        @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)
+        last_element['steps'] = []
+      end
+
+      def last_element
+        @json_hash['elements'][-1]
+      end
+
+      def to_hash_array(rows)
+        rows.map do |row|
+          {"cells" => row.cells.to_a, "comments" => row.comments.to_a, "line" => row.line}
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -13,66 +13,66 @@ module Gherkin
       include Colors
       include Escaping
 
-      def initialize(io, monochrome=false)
+      def initialize(io, monochrome)
         @io = io
         @monochrome = monochrome
         @format = MonochromeFormat.new #@monochrome ? MonochromeFormat.new : AnsiColorFormat.new
-        @tags = nil
-        @comments = nil
       end
 
-      def tag(name, line)
-        @tags ||= []
-        @tags << name
+      def feature(comments, tags, keyword, name, description, uri)
+        @uri = uri
+        print_comments(comments, '')
+        print_tags(tags, '')
+        @io.puts "#{keyword}: #{name}"
+        @io.puts indent(description, '  ') unless description == ""
       end
 
-      def comment(content, line)
-        @comments ||= []
-        @comments << content
+      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 == ""
       end
 
-      def feature(keyword, name, line)
-        @io.puts "#{grab_comments!('')}#{grab_tags!('')}#{keyword}: #{indent(name, '  ')}"
+      def scenario(comments, tags, keyword, name, description, line)
+        @io.puts
+        print_comments(comments, '  ')
+        print_tags(tags, '  ')
+        @io.puts "  #{keyword}: #{name}#{indented_element_uri!(keyword, name, line)}"
+        @io.puts indent(description, '    ') unless description == ""
       end
 
-      def background(keyword, name, line)
-        @io.puts "\n#{grab_comments!('  ')}  #{keyword}: #{indent(name, '    ')}"
+      def scenario_outline(comments, tags, keyword, name, description, line)
+        scenario(comments, tags, keyword, name, description, line)
       end
 
-      def scenario(keyword, name, line, location=nil)
-        flush_table
-        @io.puts "\n#{grab_comments!('  ')}#{grab_tags!('  ')}  #{keyword}: #{indent(name, '    ')}#{indented_scenario_location!(keyword, name, location)}"
+      def examples(comments, tags, keyword, name, description, line, examples_table)
+        @io.puts
+        print_comments(comments, '    ')
+        print_tags(tags, '    ')
+        @io.puts "    #{keyword}: #{name}"
+        @io.puts indent(description, '    ') unless description == ""
+        table(examples_table)
       end
 
-      def scenario_outline(keyword, name, line)
-        flush_table
-        @io.puts "\n#{grab_comments!('  ')}#{grab_tags!('  ')}  #{keyword}: #{indent(name, '    ')}"
-      end
-
-      def examples(keyword, name, line)
-        flush_table
-        @io.puts "\n#{grab_comments!('    ')}#{grab_tags!('    ')}    #{keyword}: #{indent(name, '    ')}"
-      end
-
-      def step(keyword, name, line, status=nil, exception=nil, arguments=nil, location=nil)
-        flush_table
+      def step(comments, keyword, name, line, multiline_arg, status, exception, arguments, stepdef_location)
         status_param = "#{status}_param" if status
         name = Gherkin::Formatter::Argument.format(name, @format, (arguments || [])) 
-        #{|arg| status_param ? self.__send__(status_param, arg, @monochrome) : arg} if arguments
 
-        step = "#{keyword}#{indent(name, '    ')}"
+        step = "#{keyword}#{name}"
         step = self.__send__(status, step, @monochrome) if status
 
-        @io.puts("#{grab_comments!('    ')}    #{step}#{indented_step_location!(location)}")
-      end
-
-      def row(row, line)
-        @rows ||= []
-        @rows << row.map{|cell| escape_cell(cell)}
-      end
-
-      def py_string(string, line)
-        @io.puts "      \"\"\"\n" + string.gsub(START, '      ').gsub(/"""/,'\"\"\"') + "\n      \"\"\""
+        print_comments(comments, '    ')
+        @io.puts("    #{step}#{indented_step_location!(stepdef_location)}")
+        case multiline_arg
+        when String
+          py_string(multiline_arg)
+        when Array
+          table(multiline_arg)
+        when NilClass
+        else
+          raise "Bad multiline_arg: #{multiline_arg.inspect}"
+        end
       end
 
       def syntax_error(state, event, legal_events, line)
@@ -80,7 +80,6 @@ module Gherkin
       end
 
       def eof
-        flush_table
       end
 
       # This method can be invoked before a #scenario, to ensure location arguments are aligned
@@ -90,79 +89,75 @@ module Gherkin
         @step_index = -1
       end
 
-      def exception(exception)
-        exception_text = "#{exception.message} (#{exception.class})\n#{(exception.backtrace || []).join("\n")}".gsub(/^/, '      ')
-        @io.puts(failed(exception_text, @monochrome))
-      end
-
-      def flush_table(exception=nil, statuses=nil)
-        return if @rows.nil?
-        cell_lengths = @rows.map { |col| col.map { |cell| cell.unpack("U*").length }}
+      def table(rows)
+        cell_lengths = rows.map do |row| 
+          row.cells.map do |cell| 
+            escape_cell(cell).unpack("U*").length
+          end
+        end
         max_lengths = cell_lengths.transpose.map { |col_lengths| col_lengths.max }.flatten
 
-        @rows.each_with_index do |row, i|
+        rows.each_with_index do |row, i|
           j = -1
-          @io.puts '      | ' + row.zip(max_lengths).map { |cell, max_length|
+          @io.puts '      | ' + row.cells.zip(max_lengths).map { |cell, max_length|
             j += 1
-            color(cell, statuses, j) + ' ' * (max_length - cell_lengths[i][j])
+            color(cell, nil, j) + ' ' * (max_length - cell_lengths[i][j])
           }.join(' | ') + ' |'
-          exception(exception) if exception
         end
-        @rows = nil
       end
 
-      private
+    private
+
+      def py_string(string)
+        @io.puts "      \"\"\"\n" + string.gsub(START, '      ').gsub(/"""/,'\"\"\"') + "\n      \"\"\""
+      end
+
+      def exception(exception)
+        exception_text = "#{exception.message} (#{exception.class})\n#{(exception.backtrace || []).join("\n")}".gsub(/^/, '      ')
+        @io.puts(failed(exception_text, @monochrome))
+      end
 
       def color(cell, statuses, col)
         if statuses
-          self.__send__(statuses[col], cell, @monochrome) + (@monochrome ? '' : reset)
+          self.__send__(statuses[col], escape_cell(cell), @monochrome) + (@monochrome ? '' : reset)
         else
-          cell
+          escape_cell(cell)
         end
       end
 
       if(RUBY_VERSION =~ /^1\.9/)
         START = /#{"^".encode('UTF-8')}/
-        NL    = Regexp.new("\n".encode('UTF-8'))
+        CRLF  = Regexp.new("\r\n".encode('UTF-8'))
       else
         START = /^/
-        NL    = /\n/n
+        CRLF  = /\r\n/n
       end
 
       def indent(string, indentation)
-        indent = ""
-        string.split(NL).map do |l|
-          s = "#{indent}#{l}"
-          indent = indentation
-          s
-        end.join("\n")
+        string.gsub(/^/, indentation)
       end
 
-      def grab_tags!(indent)
-        tags = @tags ? indent + @tags.join(' ') + "\n" : ''
-        @tags = nil
-        tags
+      def print_tags(tags, indent)
+        @io.write(tags.empty? ? '' : indent + tags.join(' ') + "\n")
       end
 
-      def grab_comments!(indent)
-        comments = @comments ? indent + @comments.join("\n#{indent}") + "\n" : ''
-        @comments = nil
-        comments
+      def print_comments(comments, indent)
+        @io.write(comments.empty? ? '' : indent + comments.join("\n#{indent}") + "\n")
       end
 
-      def indented_scenario_location!(keyword, name, location)
-        return "" if location.nil?
+      def indented_element_uri!(keyword, name, line)
+        return '' if @max_step_length.nil?
         l = (keyword+name).unpack("U*").length
         @max_step_length = [@max_step_length, l].max
         indent = @max_step_length - l
-        ' ' * indent + ' ' + comments("# #{location}", @monochrome)
+        ' ' * indent + ' ' + comments("# #{@uri}:#{line}", @monochrome)
       end
 
       def indented_step_location!(location)
-        return "" if location.nil?
+        return '' if location.nil?
         indent = @max_step_length - @step_lengths[@step_index+=1]
         ' ' * indent + ' ' + comments("# #{location}", @monochrome)
       end
     end
   end
-end
+end

data/lib/gherkin/i18n.rb

@@ -34,14 +34,14 @@ module Gherkin
         unique_keywords = all.map do |i18n|
           keywords.map do |keyword|
             if keyword.to_s == 'step'
-              i18n.step_keywords
+              i18n.step_keywords.to_a
             else
-              i18n.keywords(keyword)
+              i18n.keywords(keyword).to_a
             end
           end
         end
         
-        unique_keywords.flatten.compact.sort.reverse.uniq.join('|').gsub(/\*/, '\*')
+        unique_keywords.flatten.compact.map{|kw| kw.to_s}.sort.reverse.uniq.join('|').gsub(/\*/, '\*')
       end
 
       def code_keywords
@@ -55,15 +55,17 @@ module Gherkin
       def language_table
         require 'stringio'
         require 'gherkin/formatter/pretty_formatter'
+        require 'gherkin/parser/row'
         io = defined?(JRUBY_VERSION) ? Java.java.io.StringWriter.new : StringIO.new
         pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
-        all.each{|i18n| pf.row([i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], 0)}
-        pf.flush_table
+        table = all.map do |i18n| 
+          Parser::Row.new([i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], [], nil)
+        end
+        pf.table(table)
         if defined?(JRUBY_VERSION)
           io.getBuffer.toString
         else
-          io.rewind
-          io.read
+          io.string
         end
       end
 
@@ -136,37 +138,39 @@ module Gherkin
       result
     end
 
-    def keywords(iso_code)
-      iso_code = iso_code.to_s
-      raise "No #{iso_code.inspect} in #{@keywords.inspect}" if @keywords[iso_code].nil?
-      @keywords[iso_code].split('|').map{|keyword| real_keyword(iso_code, keyword)}
+    def keywords(key)
+      key = key.to_s
+      raise "No #{key.inspect} in #{@keywords.inspect}" if @keywords[key].nil?
+      @keywords[key].split('|').map{|keyword| real_keyword(key, keyword)}
     end
 
     def keyword_table
       require 'stringio'
       require 'gherkin/formatter/pretty_formatter'
+      require 'gherkin/parser/row'
       io = StringIO.new
       pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
 
-      KEYWORD_KEYS.each do |key|
-        pf.row([key, keywords(key).map{|keyword| %{"#{keyword}"}}.join(', ')], 0)
+      gherkin_keyword_table = KEYWORD_KEYS.map do |key|
+        Parser::Row.new([key, keywords(key).map{|keyword| %{"#{keyword}"}}.join(', ')], [], nil)
       end
-      STEP_KEYWORD_KEYS.each do |key|
+      
+      code_keyword_table = STEP_KEYWORD_KEYS.map do |key|
         code_keywords = keywords(key).reject{|keyword| keyword == '* '}.map do |keyword|
           %{"#{self.class.code_keyword_for(keyword)}"}
         end.join(', ')
-        pf.row(["#{key} (code)", code_keywords], 0)
+        Parser::Row.new(["#{key} (code)", code_keywords], [], nil)
       end
       
-      pf.flush_table
+      pf.table(gherkin_keyword_table + code_keyword_table)
       io.rewind
       io.read
     end
 
     private
 
-    def real_keyword(iso_code, keyword)
-      if(STEP_KEYWORD_KEYS.index(iso_code))
+    def real_keyword(key, keyword)
+      if(STEP_KEYWORD_KEYS.index(key))
         (keyword + ' ').sub(/< $/, '')
       else
         keyword

data/lib/gherkin/i18n.yml

@@ -269,8 +269,8 @@
   scenario: Forgatókönyv
   scenario_outline: Forgatókönyv vázlat
   examples: Példák
-  given: "*|Ha"
-  when: "*|Majd"
+  given: "*|Amennyiben|Adott"
+  when: "*|Majd|Ha|Amikor"
   then: "*|Akkor"
   and: "*|És"
   but: "*|De"
@@ -451,9 +451,9 @@
   scenario: Сценарий
   scenario_outline: Структура сценария
   examples: Значения
-  given: "*|Допустим"
-  when: "*|Если"
-  then: "*|То"
+  given: "*|Допустим|Дано|Пусть"
+  when: "*|Если|Когда"
+  then: "*|То|Тогда"
   and: "*|И|К тому же"
   but: "*|Но|А"
 "sv":
@@ -529,10 +529,10 @@
   scenario: Сценарій
   scenario_outline: Структура сценарію
   examples: Приклади
-  given: "*|Припустимо|Припустимо, що|Нехай"
-  when: "*|Якщо"
-  then: "*|То"
-  and: "*|І"
+  given: "*|Припустимо|Припустимо, що|Нехай|Дано"
+  when: "*|Якщо|Коли"
+  then: "*|То|Тоді"
+  and: "*|І|А також|Та"
   but: "*|Але"
 "uz":
   name: Uzbek

data/lib/gherkin/i18n_lexer.rb

@@ -17,8 +17,8 @@ module Gherkin
       @force_ruby = force_ruby
     end
 
-    def scan(source)
-      create_delegate(source).scan(source)
+    def scan(source, uri, offset)
+      create_delegate(source).scan(source, uri, offset)
     end
 
   private