vim-jar 0.0.3 → 0.1.0

data/bundler/ruby/1.8/gems/gherkin-2.2.9/lib/gherkin/formatter/model.rb

@@ -0,0 +1,239 @@
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    module Model
+      class Hashable
+        def to_hash
+          instance_variables.inject({}) do |hash, ivar|
+            value = instance_variable_get(ivar)
+            value = value.to_hash if value.respond_to?(:to_hash)
+            if Array === value
+              value = value.map do |e|
+                e.respond_to?(:to_hash) ? e.to_hash : e
+              end
+            end
+            hash[ivar[1..-1]] = value unless [[], nil].index(value)
+            hash
+          end
+        end
+      end
+      
+      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
+
+        def initialize(comments, tags, keyword, name, description, line)
+          super(comments, keyword, name, description, line)
+          @tags = tags
+        end
+
+        def first_non_comment_line
+          @tags.any? ? @tags[0].line : @line
+        end
+      end
+
+      class Feature < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line)
+          super(comments, tags, keyword, name, description, line)
+        end
+
+        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)
+          super(comments, tags, keyword, name, description, line)
+          @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)
+          super(comments, tags, keyword, name, description, line)
+          @type = "scenario_outline"
+        end
+
+        def replay(formatter)
+          formatter.scenario_outline(self)
+        end
+      end
+
+      class Examples < TagStatement
+        native_impl('gherkin')
+
+        attr_accessor :rows
+
+        def initialize(comments, tags, keyword, name, description, line, rows=nil)
+          super(comments, tags, keyword, name, description, line)
+          @rows = rows
+        end
+
+        def replay(formatter)
+          formatter.examples(self)
+        end
+      end
+
+      class Step < BasicStatement
+        native_impl('gherkin')
+
+        attr_accessor :multiline_arg, :result
+
+        def initialize(comments, keyword, name, line, multiline_arg=nil, result=nil)
+          super(comments, keyword, name, line)
+          @multiline_arg = multiline_arg
+          @result = result
+        end
+
+        def line_range
+          range = super
+          case multiline_arg
+          when Array
+            range = range.first..multiline_arg[-1].line
+          when Model::PyString
+            range = range.first..multiline_arg.line_range.last
+          end
+          range
+        end
+
+        def replay(formatter)
+          formatter.step(self)
+        end
+
+        def status
+          result ? result.status : 'undefined'
+        end
+
+        def arguments
+          result ? result.arguments : []
+        end
+
+        def to_hash
+          hash = super
+          if Array === @multiline_arg
+            hash['multiline_arg'] = {
+              'type' => 'table',
+              'value' => hash['multiline_arg']
+            }
+          elsif PyString === @multiline_arg
+            hash['multiline_arg']['type'] = 'py_string'
+          end
+          hash
+        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 PyString < Hashable
+        native_impl('gherkin')
+
+        attr_reader :value, :line
+        
+        def initialize(value, line)
+          @value, @line = value, line
+        end
+
+        def line_range
+          line_count = value.split(/\r?\n/).length
+          line..(line+line_count+1)
+        end
+      end
+
+      class Row < Hashable
+        native_impl('gherkin')
+
+        attr_reader :comments, :cells, :line
+
+        def initialize(comments, cells, line)
+          @comments, @cells, @line = comments, cells, line
+        end
+      end
+
+      class Result
+        native_impl('gherkin')
+
+        attr_reader :status, :error_message, :arguments, :stepdef_location
+        
+        def initialize(status, error_message, arguments, stepdef_location)
+          @status, @error_message, @arguments, @stepdef_location = status, error_message, arguments, stepdef_location
+        end
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/lib/gherkin/formatter/pretty_formatter.rb

@@ -0,0 +1,217 @@
+# encoding: utf-8
+require 'gherkin/formatter/colors'
+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 Colors
+      include Escaping
+
+      def initialize(io, monochrome=false)
+        @io = io
+        @step_printer = StepPrinter.new
+        @monochrome = monochrome
+      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(statement)
+        @io.puts
+        print_comments(statement.comments, '  ')
+        @io.puts "  #{statement.keyword}: #{statement.name}#{indented_element_uri!(statement.keyword, statement.name, statement.line)}"
+        print_description(statement.description, '    ')
+      end
+
+      def scenario(statement)
+        @io.puts
+        print_comments(statement.comments, '  ')
+        print_tags(statement.tags, '  ')
+        @io.puts "  #{statement.keyword}: #{statement.name}#{indented_element_uri!(statement.keyword, statement.name, statement.line)}"
+        print_description(statement.description, '    ')
+      end
+
+      def scenario_outline(scenario_outline)
+        scenario(scenario_outline)
+      end
+
+      def examples(examples)
+        @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)
+        print_step(step)
+        case step.multiline_arg
+        when Model::PyString
+          py_string(step.multiline_arg)
+        when Array
+          table(step.multiline_arg)
+        end
+      end
+
+      def print_step(step)
+        print_comments(step.comments, '    ')
+        @io.write('    ')
+        text_format(step).write_text(@io, step.keyword)
+        @step_printer.write_step(@io, text_format(step), arg_format(step), step.name, step.arguments)
+        print_indented_stepdef_location!(step.result.stepdef_location) if step.result
+        # TODO: Print error message
+        @io.puts
+      end
+
+      class MonochromeFormat
+        def write_text(io, text)
+          io.write(text)
+        end
+      end
+
+      class ColorFormat
+        include Colors
+        
+        def initialize(status)
+          @status = status
+        end
+
+        def write_text(io, text)
+          io.write(self.__send__(@status, text))
+        end
+      end
+
+      def text_format(step)
+        format(step.status)
+      end
+
+      def arg_format(step)
+        format(step.status + '_param')
+      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
+        # NO-OP
+      end
+
+      # This method can be invoked before a #scenario, to ensure location arguments are aligned
+      def steps(steps)
+        @step_lengths = steps.map {|step| (step.keyword+step.name).unpack("U*").length}
+        @max_step_length = @step_lengths.max
+        @step_index = -1
+      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 py_string(py_string)
+        @io.puts "      \"\"\"\n" + escape_triple_quotes(indent(py_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_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("# #{@uri}:#{line}")
+      end
+
+      def print_indented_stepdef_location!(location)
+        indent = @max_step_length - @step_lengths[@step_index+=1]
+        return if location.nil?
+        @io.write(' ' * indent + ' ' + comments("# #{location}"))
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/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/bundler/ruby/1.8/gems/gherkin-2.2.9/lib/gherkin/formatter/step_printer.rb

@@ -0,0 +1,17 @@
+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|
+          text_format.write_text(io, unpacked_step_name[text_start..arg.offset-1].pack("U*")) unless arg.offset == 0
+          arg_format.write_text(io, arg.val)
+          text_start = arg.offset + arg.val.unpack("U*").length
+        end
+        text_format.write_text(io, unpacked_step_name[text_start..-1].pack("U*")) unless text_start == unpacked_step_name.length
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/lib/gherkin/formatter/tag_count_formatter.rb

@@ -0,0 +1,47 @@
+module Gherkin
+  module Formatter
+    class TagCountFormatter
+      def initialize(formatter, tag_counts)
+        @formatter = formatter
+        @tag_counts = tag_counts
+      end
+
+      def uri(uri)
+        @uri = uri
+      end
+
+      def feature(feature)
+        @feature_tags = feature.tags
+        @formatter.feature(feature)
+      end
+
+      def scenario(scenario)
+        record_tags((@feature_tags.to_a + scenario.tags.to_a).uniq, scenario.line)
+        @formatter.scenario(scenario)
+      end
+
+      def scenario_outline(scenario_outline)
+        @scenario_outline_tags = scenario_outline.tags
+        @formatter.scenario_outline(scenario_outline)
+      end
+
+      def examples(examples)
+        record_tags((@feature_tags.to_a + @scenario_outline_tags.to_a + examples.tags.to_a).uniq, examples.line)
+        @formatter.examples(examples)
+      end
+
+    private
+
+      def record_tags(tags, line)
+        tags.each do |tag|
+          @tag_counts[tag.name] ||= []
+          @tag_counts[tag.name] << "#{@uri}:#{line}"
+        end
+      end
+
+      def method_missing(*args)
+        @formatter.__send__(*args)
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/lib/gherkin/formatter/tag_filter.rb

@@ -0,0 +1,19 @@
+require 'gherkin/tag_expression'
+
+module Gherkin
+  module Formatter
+    class TagFilter
+      def initialize(tags)
+        @tag_expression = TagExpression.new(tags)
+      end
+
+      def eval(tags, names, ranges)
+        @tag_expression.eval(tags.uniq.map{|tag| tag.name})
+      end
+
+      def filter_table_body_rows(rows)
+        rows
+      end
+    end
+  end
+end