Gherkin::I18n

    # File lib/gherkin/i18n.rb, line 18
18:       def all
19:         LANGUAGES.keys.sort.map{|iso_code| get(iso_code)}
20:       end

    # File lib/gherkin/i18n.rb, line 51
51:       def code_keyword_for(gherkin_keyword)
52:         gherkin_keyword.gsub(/[\s',!]/, '').strip
53:       end

    # File lib/gherkin/i18n.rb, line 47
47:       def code_keywords
48:         rubify(all.map{|i18n| i18n.code_keywords}).flatten.uniq.sort
49:       end

    # File lib/gherkin/i18n.rb, line 22
22:       def get(iso_code)
23:         languages[iso_code] ||= new(iso_code)
24:       end

    # File lib/gherkin/i18n.rb, line 33
33:       def keyword_regexp(*keywords)
34:         unique_keywords = all.map do |i18n|
35:           keywords.map do |keyword|
36:             if keyword.to_s == 'step'
37:               i18n.step_keywords.to_a
38:             else
39:               i18n.keywords(keyword).to_a
40:             end
41:           end
42:         end
43:         
44:         unique_keywords.flatten.compact.map{|kw| kw.to_s}.sort.reverse.uniq.join('|').gsub(/\*/, '\*')
45:       end

    # File lib/gherkin/i18n.rb, line 55
55:       def language_table
56:         require 'stringio'
57:         require 'gherkin/formatter/pretty_formatter'
58:         require 'gherkin/formatter/model'
59:         io = defined?(JRUBY_VERSION) ? Java.java.io.StringWriter.new : StringIO.new
60:         pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
61:         table = all.map do |i18n|
62:           Formatter::Model::Row.new([], [i18n.iso_code, i18n.keywords('name')[0], i18n.keywords('native')[0]], nil)
63:         end
64:         pf.table(table)
65:         if defined?(JRUBY_VERSION)
66:           io.getBuffer.toString
67:         else
68:           io.string
69:         end
70:       end

    # File lib/gherkin/i18n.rb, line 91
91:     def initialize(iso_code)
92:       @iso_code = iso_code
93:       @keywords = LANGUAGES[iso_code]
94:       raise "Language not supported: #{iso_code.inspect}" if @iso_code.nil?
95:       @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
96:     end

    # File lib/gherkin/i18n.rb, line 72
72:       def unicode_escape(word, prefix="\\u")
73:         word = word.unpack("U*").map do |c|
74:           if c > 127 || c == 32
75:             "#{prefix}%04x" % c
76:           else
77:             c.chr
78:           end
79:         end.join
80:       end

    # File lib/gherkin/i18n.rb, line 84
84:       def languages
85:         @languages ||= {}
86:       end

     # File lib/gherkin/i18n.rb, line 115
115:     def c(listener)
116:       require 'gherkin/c_lexer'
117:       CLexer[underscored_iso_code].new(listener)
118:     end

     # File lib/gherkin/i18n.rb, line 135
135:     def code_keywords
136:       result = step_keywords.map{|keyword| self.class.code_keyword_for(keyword)}
137:       result.delete('*')
138:       result
139:     end

     # File lib/gherkin/i18n.rb, line 147
147:     def keyword_table
148:       require 'stringio'
149:       require 'gherkin/formatter/pretty_formatter'
150:       require 'gherkin/formatter/model'
151:       io = StringIO.new
152:       pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
153: 
154:       gherkin_keyword_table = KEYWORD_KEYS.map do |key|
155:         Formatter::Model::Row.new([], [key, keywords(key).map{|keyword| %{"#{keyword}"}}.join(', ')], nil)
156:       end
157:       
158:       code_keyword_table = STEP_KEYWORD_KEYS.map do |key|
159:         code_keywords = keywords(key).reject{|keyword| keyword == '* '}.map do |keyword|
160:           %{"#{self.class.code_keyword_for(keyword)}"}
161:         end.join(', ')
162:         Formatter::Model::Row.new([], ["#{key} (code)", code_keywords], nil)
163:       end
164:       
165:       pf.table(gherkin_keyword_table + code_keyword_table)
166:       io.rewind
167:       io.read
168:     end

     # File lib/gherkin/i18n.rb, line 141
141:     def keywords(key)
142:       key = key.to_s
143:       raise "No #{key.inspect} in #{@keywords.inspect}" if @keywords[key].nil?
144:       @keywords[key].split('|').map{|keyword| real_keyword(key, keyword)}
145:     end

     # File lib/gherkin/i18n.rb, line 98
 98:     def lexer(listener, force_ruby=false)
 99:       begin
100:         if force_ruby
101:           rb(listener)
102:         else
103:           begin
104:             c(listener)
105:           rescue NameError, LoadError => e
106:             warn("WARNING: #{e.message}. Reverting to Ruby lexer.")
107:             rb(listener)
108:           end
109:         end
110:       rescue LoadError => e
111:         raise I18nLexerNotFound, "No lexer was found for #{i18n_language_name} (#{e.message}). Supported languages are listed in gherkin/i18n.yml."
112:       end
113:     end

     # File lib/gherkin/i18n.rb, line 120
120:     def rb(listener)
121:       require 'gherkin/rb_lexer'
122:       RbLexer[underscored_iso_code].new(listener)
123:     end

     # File lib/gherkin/i18n.rb, line 130
130:     def step_keywords
131:       STEP_KEYWORD_KEYS.map{|iso_code| keywords(iso_code)}.flatten.uniq
132:     end

     # File lib/gherkin/i18n.rb, line 125
125:     def underscored_iso_code
126:       @iso_code.gsub(/[\s-]/, '_').downcase
127:     end

     # File lib/gherkin/i18n.rb, line 172
172:     def real_keyword(key, keyword)
173:       if(STEP_KEYWORD_KEYS.index(key))
174:         (keyword + ' ').sub(/< $/, '')
175:       else
176:         keyword
177:       end
178:     end