gherkin 1.0.30-universal-dotnet

data/lib/gherkin/cli/main.rb

@@ -0,0 +1,33 @@
+begin
+  require 'trollop'
+rescue LoadError
+  require 'rubygems'
+  require 'trollop'
+end
+require 'gherkin/tools'
+
+module Gherkin
+  module Cli
+    class Main
+      def self.run(args)
+        Trollop::options(args) do
+          banner "Super fast gherkin parser"
+          stop_on Tools::SUB_COMMANDS
+        end
+
+        cmd_name = args.shift
+        die("Missing command") if cmd_name.nil?
+        begin
+          cmd = Tools.const_get(cmd_name.capitalize.to_sym).new(args)
+          cmd.run
+        rescue => e
+          Trollop::die(e.message + "\nCommand: #{cmd_name}")
+        end
+      end
+
+      def self.die(msg)
+        Trollop::die("#{msg}\nusage: gherkin COMMAND [ARGS]\nAvailable commands: #{Tools::SUB_COMMANDS.join(' ')}")
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/argument.rb

@@ -0,0 +1,27 @@
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    class Argument
+      native_impl('gherkin')
+      attr_reader :byte_offset, :val
+
+      def initialize(byte_offset, val)
+        @byte_offset, @val = byte_offset, val
+      end
+      
+      def self.format(string, argument_format, arguments)
+        s = string.dup
+        offset = past_offset = 0
+        arguments.each do |arg|
+          next if arg.byte_offset.nil? || arg.byte_offset < past_offset
+          replacement = argument_format.format_argument(arg.val)
+          s[arg.byte_offset + offset, arg.val.length] = replacement
+          offset += replacement.unpack("U*").length - arg.val.unpack("U*").length
+          past_offset = arg.byte_offset + arg.val.length
+        end
+        s
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/colors.rb

@@ -0,0 +1,119 @@
+require 'term/ansicolor'
+
+module Gherkin
+  module Formatter
+    # Defines aliases for coloured output. You don't invoke any methods from this
+    # module directly, but you can change the output colours by defining
+    # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # * <tt>undefined</tt>     - defaults to <tt>yellow</tt>
+    # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>comment</tt>       - defaults to <tt>grey</tt>
+    # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export GHERKIN_COLORS="passed=white"
+    #   export GHERKIN_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module Colors
+      include Term::ANSIColor
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comments'  => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+        ENV['GHERKIN_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.each do |method, color|
+        unless method =~ /.*_param/
+          code = <<-EOF
+          def #{method}(string=nil, monochrome=false, &proc)
+            return string if monochrome
+            #{ALIASES[method].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method}_param(string=nil, monochrome=false, &proc)
+            return string if monochrome
+            #{ALIASES[method+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method+'_param'].split(",").length} + #{ALIASES[method].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        end
+      end
+    
+      def self.define_grey #:nodoc:
+        begin
+          gem 'genki-ruby-terminfo'
+          require 'terminfo'
+          case TermInfo.default_object.tigetnum("colors")
+          when 0
+            raise "Your terminal doesn't support colours"
+          when 1
+            ::Term::ANSIColor.coloring = false
+            alias grey white
+          when 2..8
+            alias grey white
+          else
+            define_real_grey
+          end
+        rescue Exception => e
+          if e.class.name == 'TermInfo::TermInfoError'
+            STDERR.puts "*** WARNING ***"
+            STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
+            STDERR.puts "Try setting it to TERM=xterm-256color to get grey colour in output"
+            STDERR.puts "\n"
+            alias grey white
+          else
+            define_real_grey
+          end
+        end
+      end
+    
+      def self.define_real_grey #:nodoc:
+        def grey(m) #:nodoc:
+          "\e[90m#{m}\e[0m"
+        end
+      end
+    
+      define_grey
+    end
+  end
+end

data/lib/gherkin/formatter/escaping.rb

@@ -0,0 +1,15 @@
+module Gherkin
+  module Formatter
+    module Escaping
+      # Escapes a pipes and backslashes:
+      #
+      # * | becomes \|
+      # * \ becomes \\
+      #
+      # This is used in the pretty formatter.
+      def escape_cell(s)
+        s.gsub(/\|/, "\\|").gsub(/\\(?!\|)/, "\\\\\\\\")
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/monochrome_format.rb

@@ -0,0 +1,9 @@
+module Gherkin
+  module Formatter
+    class MonochromeFormat
+      def format_argument(arg)
+        arg
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/pretty_formatter.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+require 'gherkin/formatter/colors'
+require 'gherkin/formatter/monochrome_format'
+require 'gherkin/formatter/argument'
+require 'gherkin/formatter/escaping'
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    class PrettyFormatter
+      native_impl('gherkin')
+
+      include Colors
+      include Escaping
+
+      def initialize(io, monochrome=false)
+        @io = io
+        @monochrome = monochrome
+        @format = MonochromeFormat.new #@monochrome ? MonochromeFormat.new : AnsiColorFormat.new
+        @tags = nil
+        @comments = nil
+      end
+
+      def tag(name, line)
+        @tags ||= []
+        @tags << name
+      end
+
+      def comment(content, line)
+        @comments ||= []
+        @comments << content
+      end
+
+      def feature(keyword, name, line)
+        @io.puts "#{grab_comments!('')}#{grab_tags!('')}#{keyword}: #{indent(name, '  ')}"
+      end
+
+      def background(keyword, name, line)
+        @io.puts "\n#{grab_comments!('  ')}  #{keyword}: #{indent(name, '    ')}"
+      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)}"
+      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
+        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 = 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      \"\"\""
+      end
+
+      def syntax_error(state, event, legal_events, line)
+        raise "SYNTAX ERROR"
+      end
+
+      def eof
+        flush_table
+      end
+
+      # This method can be invoked before a #scenario, to ensure location arguments are aligned
+      def steps(steps)
+        @step_lengths = steps.map {|keyword, name| (keyword+name).unpack("U*").length}
+        @max_step_length = @step_lengths.max
+        @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 }}
+        max_lengths = cell_lengths.transpose.map { |col_lengths| col_lengths.max }.flatten
+
+        @rows.each_with_index do |row, i|
+          j = -1
+          @io.puts '      | ' + row.zip(max_lengths).map { |cell, max_length|
+            j += 1
+            color(cell, statuses, j) + ' ' * (max_length - cell_lengths[i][j])
+          }.join(' | ') + ' |'
+          exception(exception) if exception
+        end
+        @rows = nil
+      end
+
+      private
+
+      def color(cell, statuses, col)
+        if statuses
+          self.__send__(statuses[col], cell, @monochrome) + (@monochrome ? '' : reset)
+        else
+          cell
+        end
+      end
+
+      if(RUBY_VERSION =~ /^1\.9/)
+        START = /#{"^".encode('UTF-8')}/
+        NL    = Regexp.new("\n".encode('UTF-8'))
+      else
+        START = /^/
+        NL    = /\n/n
+      end
+
+      def indent(string, indentation)
+        indent = ""
+        string.split(NL).map do |l|
+          s = "#{indent}#{l}"
+          indent = indentation
+          s
+        end.join("\n")
+      end
+
+      def grab_tags!(indent)
+        tags = @tags ? indent + @tags.join(' ') + "\n" : ''
+        @tags = nil
+        tags
+      end
+
+      def grab_comments!(indent)
+        comments = @comments ? indent + @comments.join("\n#{indent}") + "\n" : ''
+        @comments = nil
+        comments
+      end
+
+      def indented_scenario_location!(keyword, name, location)
+        return "" if location.nil?
+        l = (keyword+name).unpack("U*").length
+        @max_step_length = [@max_step_length, l].max
+        indent = @max_step_length - l
+        ' ' * indent + ' ' + comments("# #{location}", @monochrome)
+      end
+
+      def indented_step_location!(location)
+        return "" if location.nil?
+        indent = @max_step_length - @step_lengths[@step_index+=1]
+        ' ' * indent + ' ' + comments("# #{location}", @monochrome)
+      end
+    end
+  end
+end

data/lib/gherkin/i18n.rb

@@ -0,0 +1,176 @@
+require 'yaml'
+require 'gherkin/rubify'
+require 'gherkin/native'
+
+module Gherkin
+  class I18n
+    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
+            else
+              i18n.keywords(keyword)
+            end
+          end
+        end
+        
+        unique_keywords.flatten.compact.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'
+        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
+        if defined?(JRUBY_VERSION)
+          io.getBuffer.toString
+        else
+          io.rewind
+          io.read
+        end
+      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)
+      begin
+        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 I18nLexerNotFound, "No lexer was found for #{i18n_language_name} (#{e.message}). Supported languages are listed in gherkin/i18n.yml."
+      end
+    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 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(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)}
+    end
+
+    def keyword_table
+      require 'stringio'
+      require 'gherkin/formatter/pretty_formatter'
+      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)
+      end
+      STEP_KEYWORD_KEYS.each 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)
+      end
+      
+      pf.flush_table
+      io.rewind
+      io.read
+    end
+
+    private
+
+    def real_keyword(iso_code, keyword)
+      if(STEP_KEYWORD_KEYS.index(iso_code))
+        (keyword + ' ').sub(/< $/, '')
+      else
+        keyword
+      end
+    end
+  end
+end