Class: Gherkin::I18n

Inherits:
Object
  • Object
show all
Extended by:
Rubify
Defined in:
lib/gherkin/i18n.rb

Constant Summary collapse

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')

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Rubify

rubify

Constructor Details

#initialize(iso_code) ⇒ I18n

Returns a new instance of I18n.



91
92
93
94
95
96
 
# File 'lib/gherkin/i18n.rb', line 91

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

Instance Attribute Details

#iso_code ⇒ Object (readonly)

Returns the value of attribute iso_code.



89
90
91
 
# File 'lib/gherkin/i18n.rb', line 89

def iso_code
  @iso_code
end

Class Method Details

.all ⇒ Object

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



18
19
20
 
# File 'lib/gherkin/i18n.rb', line 18

def all
  LANGUAGES.keys.sort.map{|iso_code| get(iso_code)}
end

.code_keyword_for(gherkin_keyword) ⇒ Object 



51
52
53
 
# File 'lib/gherkin/i18n.rb', line 51

def code_keyword_for(gherkin_keyword)
  gherkin_keyword.gsub(/[\s',!]/, '').strip
end

.code_keywords ⇒ Object 



47
48
49
 
# File 'lib/gherkin/i18n.rb', line 47

def code_keywords
  rubify(all.map{|i18n| i18n.code_keywords}).flatten.uniq.sort
end

.get(iso_code) ⇒ Object 



22
23
24
 
# File 'lib/gherkin/i18n.rb', line 22

def get(iso_code)
  languages[iso_code] ||= new(iso_code)
end

.keyword_regexp(*keywords) ⇒ Object

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.



33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/gherkin/i18n.rb', line 33

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 ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/gherkin/i18n.rb', line 55

def language_table
  require 'stringio'
  require 'gherkin/formatter/pretty_formatter'
  require 'gherkin/formatter/model'
  io = defined?(JRUBY_VERSION) ? Java.java.io.StringWriter.new : StringIO.new
  pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
  table = all.map do |i18n|
    Formatter::Model::Row.new([], [i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], nil)
  end
  pf.table(table)
  if defined?(JRUBY_VERSION)
    io.getBuffer.toString
  else
    io.string
  end
end

.unicode_escape(word, prefix = "\\u") ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/gherkin/i18n.rb', line 72

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

Instance Method Details

#c(listener) ⇒ Object 



115
116
117
118
 
# File 'lib/gherkin/i18n.rb', line 115

def c(listener)
  require 'gherkin/c_lexer'
  CLexer[underscored_iso_code].new(listener)
end

#code_keywords ⇒ Object

Keywords that can be used in code



135
136
137
138
139
 
# File 'lib/gherkin/i18n.rb', line 135

def code_keywords
  result = step_keywords.map{|keyword| self.class.code_keyword_for(keyword)}
  result.delete('*')
  result
end

#keyword_table ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/gherkin/i18n.rb', line 147

def keyword_table
  require 'stringio'
  require 'gherkin/formatter/pretty_formatter'
  require 'gherkin/formatter/model'
  io = StringIO.new
  pf = Gherkin::Formatter::PrettyFormatter.new(io, true)

  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.rewind
  io.read
end

#keywords(key) ⇒ Object 



141
142
143
144
145
 
# File 'lib/gherkin/i18n.rb', line 141

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) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/gherkin/i18n.rb', line 98

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

#rb(listener) ⇒ Object 



120
121
122
123
 
# File 'lib/gherkin/i18n.rb', line 120

def rb(listener)
  require 'gherkin/rb_lexer'
  RbLexer[underscored_iso_code].new(listener)
end

#step_keywords ⇒ Object

Keywords that can be used in Gherkin source



130
131
132
 
# File 'lib/gherkin/i18n.rb', line 130

def step_keywords
  STEP_KEYWORD_KEYS.map{|iso_code| keywords(iso_code)}.flatten.uniq
end

#underscored_iso_code ⇒ Object 



125
126
127
 
# File 'lib/gherkin/i18n.rb', line 125

def underscored_iso_code
  @iso_code.gsub(/[\s-]/, '_').downcase
end