Class: Tml::Language

Inherits:
Base
  • Object
show all
Defined in:
lib/tml/language.rb

Overview

– Copyright © 2016 Translation Exchange, Inc

_______                  _       _   _             ______          _

|__ __| | | | | (_) | __| | |

| |_ __ __ _ _ __  ___| | __ _| |_ _  ___  _ __ | |__  __  _____| |__   __ _ _ __   __ _  ___
| | '__/ _` | '_ \/ __| |/ _` | __| |/ _ \| '_ \|  __| \ \/ / __| '_ \ / _` | '_ \ / _` |/ _ \
| | | | (_| | | | \__ \ | (_| | |_| | (_) | | | | |____ >  < (__| | | | (_| | | | | (_| |  __/
|_|_|  \__,_|_| |_|___/_|\__,_|\__|_|\___/|_| |_|______/_/\_\___|_| |_|\__,_|_| |_|\__, |\___|
                                                                                    __/ |
                                                                                   |___/

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++

Instance Attribute Summary

Attributes inherited from Base

#attributes

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

attributes, belongs_to, has_many, hash_value, #hash_value, #initialize, #method_missing, #to_hash

Constructor Details

This class inherits a constructor from Tml::Base

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Tml::Base

Class Method Details

.cache_key(locale) ⇒ Object

Returns language cache key



39
40
41
 
# File 'lib/tml/language.rb', line 39

def self.cache_key(locale)
  File.join(locale, 'language')
end

Instance Method Details

#align(dest) ⇒ Object 



101
102
103
104
 
# File 'lib/tml/language.rb', line 101

def align(dest)
  return dest unless right_to_left?
  dest.to_s == 'left' ? 'right' : 'left'
end

#case_by_keyword(keyword) ⇒ Object 



84
85
86
 
# File 'lib/tml/language.rb', line 84

def case_by_keyword(keyword)
  cases[keyword]
end

#context_by_keyword(keyword) ⇒ Object 



76
77
78
 
# File 'lib/tml/language.rb', line 76

def context_by_keyword(keyword)
  hash_value(contexts, keyword)
end

#context_by_token_name(token_name) ⇒ Object 



80
81
82
 
# File 'lib/tml/language.rb', line 80

def context_by_token_name(token_name)
  contexts.values.detect{|ctx| ctx.applies_to_token?(token_name)}
end

#current_source(options) ⇒ Object 



111
112
113
 
# File 'lib/tml/language.rb', line 111

def current_source(options)
  (options[:source] || Tml.session.block_option(:source) || Tml.session.current_source || 'undefined').to_s
end

#default? ⇒ Boolean 



92
93
94
95
 
# File 'lib/tml/language.rb', line 92

def default?
  return true unless application
  application.default_locale == locale
end

#dir ⇒ Object 



97
98
99
 
# File 'lib/tml/language.rb', line 97

def dir
  right_to_left? ? 'rtl' : 'ltr'
end

#fetch ⇒ Object

Loads language definition from the service



44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/tml/language.rb', line 44

def fetch
  update_attributes(application.api_client.get(
    "language/#{locale}/definition",
    {},
    {
        cache_key: self.class.cache_key(locale)
    }
  ))
rescue Tml::Exception => ex
  Tml.logger.error("Failed to load language: #{ex}")
  self
end

#full_name ⇒ Object 



106
107
108
109
 
# File 'lib/tml/language.rb', line 106

def full_name
  return english_name if english_name == native_name
  "#{english_name} - #{native_name}"
end

#has_definition? ⇒ Boolean 



88
89
90
 
# File 'lib/tml/language.rb', line 88

def has_definition?
  contexts.any?
end

#source_path ⇒ Object

build source path to the block



209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/tml/language.rb', line 209

def source_path
  sp = []

  Tml.session.block_options_queue.each do |opts|
    next unless hash_value(opts, :source)
    sp << hash_value(opts, :source)
  end

  sp = sp.reverse
  sp.unshift(Tml.session.current_source)

  sp.join(Tml.config.source_separator)
end

#translate(label, description = nil, tokens = {}, options = {}) ⇒ Object Also known as: tr

Translation Methods

Note - when inline translation mode is enable, cache will not be used and translators will always hit the live service to get the most recent translations

Some cache adapters cache by source, others by key. Some are read-only, some are built on the fly.

There are three ways to call the tr method

tr(label, description = “”, tokens = {}, options = {})

or

tr(label, tokens = {}, options = {})

or

tr(:label => label, :description => “”, :tokens => {}, :options => {})



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/tml/language.rb', line 131

def translate(label, description = nil, tokens = {}, options = {})
  params = Tml::Utils.normalize_tr_params(label, description, tokens, options)
  return params[:label] if params[:label].to_s.strip == '' or params[:label].index('tml:label')
  return params[:label] if params[:label].tml_translated?

  translation_key = Tml::TranslationKey.new({
    :application  => application,
    :label        => params[:label],
    :description  => params[:description],
    :locale       => hash_value(params[:options], :locale) || Tml.session.block_option(:locale) || Tml.config.default_locale,
    :level        => hash_value(params[:options], :level) || Tml.session.block_option(:level) || Tml.config.default_level,
    :translations => []
  })

  # pp "Translating #{params[:label]} from: #{translation_key.locale.inspect} to #{locale.inspect}"
  # Tml.logger.info("Translating #{params[:label]} from: #{translation_key.locale.inspect} to #{locale.inspect}")

  params[:tokens] ||= {}
  params[:tokens][:viewing_user] ||= Tml.session.current_user

  if Tml.config.disabled? or application.nil?
    return translation_key.substitute_tokens(params[:label], params[:tokens], self, params[:options]).tml_translated
  end

  # check if key was ignored on the application level
  if application.ignored_key?(translation_key.key)
    return translation_key.substitute_tokens(params[:label], params[:tokens], self, params[:options]).tml_translated
  end

  # if translations have already been cached in the application, use them
  cached_translations = application.cached_translations(locale, translation_key.key)
  if cached_translations
    translation_key.set_translations(locale, cached_translations)
    return translation_key.translate(self, params[:tokens], params[:options]).tml_translated
  end

  # each key translations will be loaded directly from the API, and registered against "manual" source
  if Tml.session.block_option(:by_key)
    application.register_missing_key(:manual, translation_key)
    translation_key.fetch_translations(locale)
    return translation_key.translate(self, params[:tokens], params[:options]).tml_translated
  end

  # fetch translations grouped by source
  source_key = current_source(options)
  current_source_path = source_path

  # Dynamic sources are never registered under the parent source for fast retrieval
  if Tml.session.block_option(:dynamic)
    current_source_path = source_key
  else
    application.verify_source_path(source_key, current_source_path)
  end

  # Tml.logger.debug("#{self.locale} :  #{params[:label]} : #{source_key}")

  source = application.source(source_key, locale)

  # check if a key was ignored on the source level
  if source.ignored_key?(translation_key.key)
    return translation_key.substitute_tokens(params[:label], params[:tokens], self, params[:options]).tml_translated
  end

  cached_translations = source.cached_translations(locale, translation_key.key)

  if cached_translations
    translation_key.set_translations(locale, cached_translations)
  else
    params[:options] ||= {}
    params[:options][:pending] = true
    application.register_missing_key(current_source_path, translation_key)
  end

  translation_key.translate(self, params[:tokens], params[:options]).tml_translated
end

#update_attributes(attrs) ⇒ Object

update language attributes



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/tml/language.rb', line 58

def update_attributes(attrs)
  super

  self.attributes[:contexts] = {}
  if hash_value(attrs, :contexts)
    hash_value(attrs, :contexts).each do |key, context|
      self.attributes[:contexts][key] = Tml::LanguageContext.new(context.merge(:keyword => key, :language => self))
    end
  end

  self.attributes[:cases] = {}
  if hash_value(attrs, :cases)
    hash_value(attrs, :cases).each do |key, lcase|
      self.attributes[:cases][key] = Tml::LanguageCase.new(lcase.merge(:keyword => key, :language => self))
    end
  end
end