bryanl-gherkin 2.11.1.1-java

data/lib/gherkin/formatter/json_formatter.rb

@@ -0,0 +1,122 @@
+require 'json'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
+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
+      
+      def initialize(io)
+        raise "Must be writeable" unless io.respond_to?(:write)
+        @io = io
+        @feature_hashes = []
+        @current_step_or_hook = nil
+      end
+
+      def done
+        @io.write(@feature_hashes.to_json)
+      end
+
+      def uri(uri)
+        @uri = uri
+      end
+
+      def feature(feature)
+        @feature_hash = feature.to_hash
+        @feature_hash['uri'] = @uri
+        @feature_hashes << @feature_hash
+      end
+
+      def background(background)
+        feature_elements << background.to_hash
+      end
+
+      def scenario(scenario)
+        feature_elements << scenario.to_hash
+      end
+
+      def scenario_outline(scenario_outline)
+        feature_elements << scenario_outline.to_hash
+      end
+
+      def examples(examples)
+        all_examples << examples.to_hash
+      end
+
+      def step(step)
+        @current_step_or_hook = step.to_hash
+        steps << @current_step_or_hook
+      end
+
+      def match(match)
+        @current_step_or_hook['match'] = match.to_hash
+      end
+
+      def result(result)
+        @current_step_or_hook['result'] = result.to_hash
+      end
+
+      def before(match, result)
+        add_hook(match, result, "before")
+      end
+
+      def after(match, result)
+        add_hook(match, result, "after")
+      end
+
+      def embedding(mime_type, data)
+        embeddings << {'mime_type' => mime_type, 'data' => encode64s(data)}
+      end
+
+      def write(text)
+        output << text
+      end
+
+      def eof
+      end
+
+    private
+
+      def add_hook(match, result, hook)
+        hooks = feature_element[hook] ||= []
+        hooks << {'match' => match.to_hash, 'result' => result.to_hash}
+      end
+
+      def feature_elements
+        @feature_hash['elements'] ||= []
+      end
+
+      def feature_element
+        feature_elements[-1]
+      end
+
+      def all_examples
+        feature_element['examples'] ||= []
+      end
+
+      def steps
+        feature_element['steps'] ||= []
+      end
+
+      def embeddings
+        @current_step_or_hook['embeddings'] ||= []
+      end
+
+      def output
+        @current_step_or_hook['output'] ||= []
+      end
+
+      def encode64s(data)
+        # Strip newlines
+        Base64.encode64(data).gsub(/\n/, '')
+      end
+    end
+  end
+end
+

data/lib/gherkin/formatter/line_filter.rb

@@ -0,0 +1,26 @@
+module Gherkin
+  module Formatter
+    class LineFilter
+      def initialize(lines)
+        @lines = lines
+      end
+
+      def eval(tags, names, ranges)
+        ranges.detect do |range|
+          @lines.detect do |line|
+            range.include?(line)
+          end
+        end
+      end
+
+      def filter_table_body_rows(rows)
+        body = rows.to_a[1..-1].select do |row|
+          @lines.detect do |line|
+            row.line == line
+          end
+        end
+        [rows[0]] + body
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/model.rb

@@ -0,0 +1,281 @@
+require 'gherkin/native'
+require 'gherkin/formatter/hashable'
+
+module Gherkin
+  module Formatter
+    module Model
+      class BasicStatement < Hashable
+        attr_reader :comments, :keyword, :name, :line
+        
+        def initialize(comments, keyword, name, line)
+          @comments, @keyword, @name, @line = comments, keyword, name, line
+        end
+
+        def line_range
+          first = @comments.any? ? @comments[0].line : first_non_comment_line
+          first..line
+        end
+
+        def first_non_comment_line
+          @line
+        end
+      end
+
+      class DescribedStatement < BasicStatement
+        attr_reader :description
+
+        def initialize(comments, keyword, name, description, line)
+          super(comments, keyword, name, line)
+          @description = description
+        end
+      end
+
+      class TagStatement < DescribedStatement
+        attr_reader :tags, :id
+
+        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
+          @tags.any? ? @tags[0].line : @line
+        end
+      end
+
+      class Feature < TagStatement
+        native_impl('gherkin')
+
+        def replay(formatter)
+          formatter.feature(self)
+        end
+      end
+
+      class Background < DescribedStatement
+        native_impl('gherkin')
+
+        def initialize(comments, keyword, name, description, line)
+          super(comments, keyword, name, description, line)
+          @type = "background"
+        end
+
+        def replay(formatter)
+          formatter.background(self)
+        end
+      end
+
+      class Scenario < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, tags, keyword, name, description, line, id)
+          @type = "scenario"
+        end
+
+        def replay(formatter)
+          formatter.scenario(self)
+        end
+      end
+
+      class ScenarioOutline < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, tags, keyword, name, description, line, id)
+          @type = "scenario_outline"
+        end
+
+        def replay(formatter)
+          formatter.scenario_outline(self)
+        end
+      end
+
+      class Examples < TagStatement
+        native_impl('gherkin')
+
+        attr_accessor :rows # needs to remain mutable for filters
+
+        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_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
+          if(rows)
+            range = range.first..rows[-1].line
+          elsif(doc_string)
+            range = range.first..doc_string.line_range.last
+          end
+          range
+        end
+
+        def replay(formatter)
+          formatter.step(self)
+        end
+
+        def outline_args
+          offset = 0
+          name.scan(/<[^<]*>/).map do |val|
+            offset = name.index(val, offset)
+            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
+        native_impl('gherkin')
+
+        attr_reader :value, :line
+        
+        def initialize(value, line)
+          @value, @line = value, line
+        end
+      end
+
+      class Tag < Hashable
+        native_impl('gherkin')
+
+        attr_reader :name, :line
+        
+        def initialize(name, line)
+          @name, @line = name, line
+        end
+        
+        def eql?(tag)
+          @name.eql?(tag.name)
+        end
+
+        def hash
+          @name.hash
+        end
+      end
+
+      class DocString < Hashable
+        native_impl('gherkin')
+
+        attr_reader :value, :content_type, :line
+        
+        def initialize(value, content_type, line)
+          @value, @content_type, @line = value, content_type, line
+        end
+
+        def line_range
+          line_count = value.split(/\r?\n/).length
+          line..(line+line_count+1)
+        end
+      end
+
+      class Row < Hashable
+        attr_reader :comments, :cells, :line
+
+        def initialize(comments, cells, line)
+          @comments, @cells, @line = comments, cells, line
+        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')
+
+        attr_reader :arguments, :location
+        
+        def initialize(arguments, location)
+          @arguments, @location = arguments, location
+        end
+
+        def replay(formatter)
+          formatter.match(self)
+        end
+      end
+
+      class Result < Hashable
+        native_impl('gherkin')
+
+        attr_reader :status, :duration, :error_message
+        
+        def initialize(status, duration, error_message)
+          @status, @duration, @error_message = status, duration, error_message
+        end
+
+        def replay(formatter)
+          formatter.result(self)
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -0,0 +1,244 @@
+# encoding: utf-8
+require 'gherkin/formatter/ansi_escapes'
+require 'gherkin/formatter/step_printer'
+require 'gherkin/formatter/argument'
+require 'gherkin/formatter/escaping'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    class PrettyFormatter
+      native_impl('gherkin')
+
+      include AnsiEscapes
+      include Escaping
+
+      def initialize(io, monochrome, executing)
+        @io = io
+        @step_printer = StepPrinter.new
+        @monochrome = monochrome
+        @executing = executing
+        @background = nil
+        @tag_statement = nil
+        @steps = []
+      end
+
+      def uri(uri)
+        @uri = uri
+      end
+
+      def feature(feature)
+        print_comments(feature.comments, '')
+        print_tags(feature.tags, '')
+        @io.puts "#{feature.keyword}: #{feature.name}"
+        print_description(feature.description, '  ', false)
+      end
+
+      def background(background)
+        replay
+        @statement = background
+      end
+
+      def scenario(scenario)
+        replay
+        @statement = scenario
+      end
+
+      def scenario_outline(scenario_outline)
+        replay
+        @statement = scenario_outline
+      end
+      
+      def replay
+        print_statement
+        print_steps
+      end
+      
+      def print_statement
+        return if @statement.nil?
+        calculate_location_indentations
+        @io.puts
+        print_comments(@statement.comments, '  ')
+        print_tags(@statement.tags, '  ') if @statement.respond_to?(:tags) # Background doesn't
+        @io.write "  #{@statement.keyword}: #{@statement.name}"
+        location = @executing ? "#{@uri}:#{@statement.line}" : nil
+        @io.puts indented_location(location, true)
+        print_description(@statement.description, '    ')
+        @statement = nil
+      end
+
+      def print_steps
+        while(@steps.any?)
+          print_step('skipped', [], nil, true)
+        end
+      end
+
+      def examples(examples)
+        replay
+        @io.puts
+        print_comments(examples.comments, '    ')
+        print_tags(examples.tags, '    ')
+        @io.puts "    #{examples.keyword}: #{examples.name}"
+        print_description(examples.description, '      ')
+        table(examples.rows)
+      end
+
+      def step(step)
+        @steps << step
+      end
+
+      def match(match)
+        @match = match
+        print_statement
+        print_step('executing', @match.arguments, @match.location, false)
+      end
+
+      def result(result)
+        @io.write(up(1))
+        print_step(result.status, @match.arguments, @match.location, true)
+      end
+
+      def print_step(status, arguments, location, proceed)
+        step = proceed ? @steps.shift : @steps[0]
+        
+        text_format = format(status)
+        arg_format = arg_format(status)
+        
+        print_comments(step.comments, '    ')
+        @io.write('    ')
+        @io.write(text_format.text(step.keyword))
+        @step_printer.write_step(@io, text_format, arg_format, step.name, arguments)
+        @io.puts(indented_location(location, proceed))
+        
+        doc_string(step.doc_string) if step.doc_string
+        table(step.rows) if step.rows
+      end
+
+      class MonochromeFormat
+        def text(text)
+          text
+        end
+      end
+
+      class ColorFormat
+        include AnsiEscapes
+        
+        def initialize(status)
+          @status = status
+        end
+
+        def text(text)
+          self.__send__(@status) + text + reset
+        end
+      end
+
+      def arg_format(key)
+        format("#{key}_arg")
+      end
+
+      def format(key)
+        if @formats.nil?
+          if @monochrome
+            @formats = Hash.new(MonochromeFormat.new)
+          else
+            @formats = Hash.new do |formats, status|
+              formats[status] = ColorFormat.new(status)
+            end
+          end
+        end
+        @formats[key]
+      end
+
+      def eof
+        replay
+        # NO-OP
+      end
+
+      def done
+        # NO-OP
+      end
+
+      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|
+          row.comments.each do |comment|
+            @io.puts "      #{comment.value}"
+          end
+          j = -1
+          @io.puts '      | ' + row.cells.zip(max_lengths).map { |cell, max_length|
+            j += 1
+            color(cell, nil, j) + ' ' * (max_length - cell_lengths[i][j])
+          }.join(' | ') + ' |'
+        end
+      end
+
+    private
+
+      def doc_string(doc_string)
+        @io.puts "      \"\"\"" + doc_string.content_type + "\n" + escape_triple_quotes(indent(doc_string.value, '      ')) + "\n      \"\"\""
+      end
+
+      def exception(exception)
+        exception_text = "#{exception.message} (#{exception.class})\n#{(exception.backtrace || []).join("\n")}".gsub(/^/, '      ')
+        @io.puts(failed(exception_text))
+      end
+
+      def color(cell, statuses, col)
+        if statuses
+          self.__send__(statuses[col], escape_cell(cell)) + reset
+        else
+          escape_cell(cell)
+        end
+      end
+
+      if(RUBY_VERSION =~ /^1\.9/)
+        START = /#{'^'.encode('UTF-8')}/
+        TRIPLE_QUOTES = /#{'"""'.encode('UTF-8')}/
+      else
+        START = /^/
+        TRIPLE_QUOTES = /"""/
+      end
+
+      def indent(string, indentation)
+        string.gsub(START, indentation)
+      end
+
+      def escape_triple_quotes(s)
+        s.gsub(TRIPLE_QUOTES, '\"\"\"')
+      end
+
+      def print_tags(tags, indent)
+        @io.write(tags.empty? ? '' : indent + tags.map{|tag| tag.name}.join(' ') + "\n")
+      end
+
+      def print_comments(comments, indent)
+        @io.write(comments.empty? ? '' : indent + comments.map{|comment| comment.value}.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_location(location, proceed)
+        indentation = proceed ? @indentations.shift : @indentations[0]
+        location ? (' ' * indentation + ' ' + comments + "# #{location}" + reset) : ''
+      end
+
+      def calculate_location_indentations
+        line_widths = ([@statement] + @steps).map {|step| (step.keyword+step.name).unpack("U*").length}
+        max_line_width = line_widths.max
+        @indentations = line_widths.map{|w| max_line_width - w}
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/regexp_filter.rb

@@ -0,0 +1,21 @@
+module Gherkin
+  module Formatter
+    class RegexpFilter
+      def initialize(regexen)
+        @regexen = regexen
+      end
+
+      def eval(tags, names, ranges)
+        @regexen.detect do |regexp| 
+          names.detect do |name|
+            name =~ regexp
+          end
+        end
+      end
+
+      def filter_table_body_rows(rows)
+        rows
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/step_printer.rb

@@ -0,0 +1,21 @@
+module Gherkin
+  module Formatter
+    class StepPrinter
+      def write_step(io, text_format, arg_format, step_name, arguments)
+        unpacked_step_name = step_name.unpack("U*")
+        
+        text_start = 0
+        arguments.each do |arg|
+          if(arg.offset != 0 && !arg.offset.nil?)
+            io.write(text_format.text(unpacked_step_name[text_start..arg.offset-1].pack("U*")))
+          end
+          if(!arg.val.nil?)
+            io.write(arg_format.text(arg.val))
+            text_start = arg.offset + arg.val.unpack("U*").length
+          end
+        end
+        io.write(text_format.text(unpacked_step_name[text_start..-1].pack("U*"))) unless text_start == unpacked_step_name.length
+      end
+    end
+  end
+end