class Gherkin::I18n

Constants

FEATURE_ELEMENT_KEYS
KEYWORD_KEYS
LANGUAGES
LexerNotFound
STEP_KEYWORD_KEYS

Attributes

iso_code[R]

Public Class Methods

all() click to toggle source

Used by code generators for other lexer tools like pygments lexer and textmate bundle

# File lib/gherkin/i18n.rb, line 20
def all
  LANGUAGES.keys.sort.map{|iso_code| get(iso_code)}
end
code_keyword_for(gherkin_keyword) click to toggle source
# File lib/gherkin/i18n.rb, line 53
def code_keyword_for(gherkin_keyword)
  gherkin_keyword.gsub(/[\s',!]/, '').strip
end
code_keywords() click to toggle source
# File lib/gherkin/i18n.rb, line 49
def code_keywords
  rubify(all.map{|i18n| i18n.code_keywords}).flatten.uniq.sort
end
get(iso_code) click to toggle source
# File lib/gherkin/i18n.rb, line 24
def get(iso_code)
  languages[iso_code] ||= new(iso_code)
end
keyword_regexp(*keywords) click to toggle source

Returns all keyword translations and aliases of keywords, escaped and joined with |. 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 :feature, :background, :scenario, :scenario_outline, :examples, :step.

# File lib/gherkin/i18n.rb, line 35
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
language_table() click to toggle source
# File lib/gherkin/i18n.rb, line 57
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
new(iso_code) click to toggle source
# File lib/gherkin/i18n.rb, line 89
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
unicode_escape(word, prefix="\\u") click to toggle source
# File lib/gherkin/i18n.rb, line 70
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 Class Methods

languages() click to toggle source
# File lib/gherkin/i18n.rb, line 82
def languages
  @languages ||= {}
end

Public Instance Methods

c(listener) click to toggle source
# File lib/gherkin/i18n.rb, line 111
def c(listener)
  require 'gherkin/c_lexer'
  CLexer[underscored_iso_code].new(listener)
end
code_keywords() click to toggle source

Keywords that can be used in code

# File lib/gherkin/i18n.rb, line 131
def code_keywords
  result = step_keywords.map{|keyword| self.class.code_keyword_for(keyword)}
  result.delete('*')
  result
end
keyword_table() click to toggle source
# File lib/gherkin/i18n.rb, line 143
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| %Q{"#{keyword}"}}.join(', ')], nil)
  end
  
  code_keyword_table = STEP_KEYWORD_KEYS.map do |key|
    code_keywords = keywords(key).reject{|keyword| keyword == '* '}.map do |keyword|
      %Q{"#{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
keywords(key) click to toggle source
# File lib/gherkin/i18n.rb, line 137
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
lexer(listener, force_ruby=false) click to toggle source
# File lib/gherkin/i18n.rb, line 96
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.json."
end
rb(listener) click to toggle source
# File lib/gherkin/i18n.rb, line 116
def rb(listener)
  require "gherkin/lexer/#{underscored_iso_code}"
  Lexer.const_get(underscored_iso_code.capitalize).new(listener)
end
step_keywords() click to toggle source

Keywords that can be used in Gherkin source

# File lib/gherkin/i18n.rb, line 126
def step_keywords
  STEP_KEYWORD_KEYS.map{|iso_code| keywords(iso_code)}.flatten.uniq
end
underscored_iso_code() click to toggle source
# File lib/gherkin/i18n.rb, line 121
def underscored_iso_code
  @iso_code.gsub(/[\s-]/, '_').downcase
end

Private Instance Methods

real_keyword(key, keyword) click to toggle source
# File lib/gherkin/i18n.rb, line 167
def real_keyword(key, keyword)
  if(STEP_KEYWORD_KEYS.index(key))
    (keyword + ' ').sub(/< $/, '')
  else
    keyword
  end
end