bryanl-gherkin 2.11.1.1

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

data/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/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)
+      end
+
+      def filter_table_body_rows(rows)
+        rows
+      end
+    end
+  end
+end

data/lib/gherkin/i18n.rb

@@ -0,0 +1,180 @@
+require 'yaml'
+require 'gherkin/rubify'
+require 'gherkin/native'
+
+module Gherkin
+  class I18n
+    LexerNotFound = Class.new(LoadError)
+
+    native_impl('gherkin') unless defined?(BYPASS_NATIVE_IMPL)
+
+    FEATURE_ELEMENT_KEYS = %w{feature background scenario scenario_outline examples}
+    STEP_KEYWORD_KEYS    = %w{given when then and but}
+    KEYWORD_KEYS         = FEATURE_ELEMENT_KEYS + STEP_KEYWORD_KEYS
+    LANGUAGES            = YAML.load_file(File.dirname(__FILE__) + '/i18n.yml')
+
+    class << self
+      include Rubify
+
+      # Used by code generators for other lexer tools like pygments lexer and textmate bundle
+      def all
+        LANGUAGES.keys.sort.map{|iso_code| get(iso_code)}
+      end
+
+      def get(iso_code)
+        languages[iso_code] ||= new(iso_code)
+      end
+
+      # Returns all keyword translations and aliases of +keywords+, escaped and joined with <tt>|</tt>.
+      # This method is convenient for editor support and syntax highlighting engines for Gherkin, where
+      # there is typically a code generation tool to generate regular expressions for recognising the
+      # various I18n translations of Gherkin's keywords.
+      #
+      # The +keywords+ arguments can be one of <tt>:feature</tt>, <tt>:background</tt>, <tt>:scenario</tt>, 
+      # <tt>:scenario_outline</tt>, <tt>:examples</tt>, <tt>:step</tt>.
+      def keyword_regexp(*keywords)
+        unique_keywords = all.map do |i18n|
+          keywords.map do |keyword|
+            if keyword.to_s == 'step'
+              i18n.step_keywords.to_a
+            else
+              i18n.keywords(keyword).to_a
+            end
+          end
+        end
+        
+        unique_keywords.flatten.compact.map{|kw| kw.to_s}.sort.reverse.uniq.join('|').gsub(/\*/, '\*')
+      end
+
+      def code_keywords
+        rubify(all.map{|i18n| i18n.code_keywords}).flatten.uniq.sort
+      end
+
+      def code_keyword_for(gherkin_keyword)
+        gherkin_keyword.gsub(/[\s',!]/, '').strip
+      end
+
+      def language_table
+        require 'stringio'
+        require 'gherkin/formatter/pretty_formatter'
+        require 'gherkin/formatter/model'
+        io = StringIO.new
+        pf = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
+        table = all.map do |i18n|
+          Formatter::Model::DataTableRow.new([], [i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], nil)
+        end
+        pf.table(table)
+        io.string
+      end
+
+      def unicode_escape(word, prefix="\\u")
+        word = word.unpack("U*").map do |c|
+          if c > 127 || c == 32
+            "#{prefix}%04x" % c
+          else
+            c.chr
+          end
+        end.join
+      end
+
+      private
+
+      def languages
+        @languages ||= {}
+      end
+    end
+
+    attr_reader :iso_code
+
+    def initialize(iso_code)
+      @iso_code = iso_code
+      @keywords = LANGUAGES[iso_code]
+      raise "Language not supported: #{iso_code.inspect}" if @iso_code.nil?
+      @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
+    end
+
+    def lexer(listener, force_ruby=false)
+      if force_ruby
+        rb(listener)
+      else
+        begin
+          c(listener)
+        rescue NameError, LoadError => e
+          warn("WARNING: #{e.message}. Reverting to Ruby lexer.")
+          rb(listener)
+        end
+      end
+    rescue LoadError => e
+      raise LexerNotFound, "No lexer was found for #{iso_code} (#{e.message}). Supported languages are listed in gherkin/i18n.yml."
+    end
+
+    def c(listener)
+      require 'gherkin/c_lexer'
+      CLexer[underscored_iso_code].new(listener)
+    end
+
+    def rb(listener)
+      require 'gherkin/rb_lexer'
+      RbLexer[underscored_iso_code].new(listener)
+    end
+
+    def js(listener)
+      require 'gherkin/js_lexer'
+      JsLexer[underscored_iso_code].new(listener)
+    end
+
+    def underscored_iso_code
+      @iso_code.gsub(/[\s-]/, '_').downcase
+    end
+
+    # Keywords that can be used in Gherkin source
+    def step_keywords
+      STEP_KEYWORD_KEYS.map{|iso_code| keywords(iso_code)}.flatten.uniq
+    end
+
+    # Keywords that can be used in code
+    def code_keywords
+      result = step_keywords.map{|keyword| self.class.code_keyword_for(keyword)}
+      result.delete('*')
+      result
+    end
+
+    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/formatter/model'
+      io = StringIO.new
+      pf = Gherkin::Formatter::PrettyFormatter.new(io, false, false)
+
+      gherkin_keyword_table = KEYWORD_KEYS.map do |key|
+        Formatter::Model::Row.new([], [key, keywords(key).map{|keyword| %{"#{keyword}"}}.join(', ')], nil)
+      end
+      
+      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(', ')
+        Formatter::Model::Row.new([], ["#{key} (code)", code_keywords], nil)
+      end
+      
+      pf.table(gherkin_keyword_table + code_keyword_table)
+      io.string
+    end
+
+    private
+
+    def real_keyword(key, keyword)
+      if(STEP_KEYWORD_KEYS.index(key))
+        (keyword + ' ').sub(/< $/, '')
+      else
+        keyword
+      end
+    end
+  end
+end