module ActionView::Helpers::TranslationHelper

def html_safe_translation_key?(key) 

def html_safe_translation_key?(key)
  key.to_s =~ /(\b|_|\.)html$/
end

def localize(*args)

for more information.
See http://rubydoc.info/github/svenfuchs/i18n/master/I18n/Backend/Base:localize

Delegates to I18n.localize with no additional functionality. 
def localize(*args)
  I18n.localize(*args)
end

def scope_key_by_partial(key) 

def scope_key_by_partial(key)
  if key.to_s.first == "."
    if @virtual_path
      @virtual_path.gsub(%r{/_?}, ".") + key.to_s
    else
      raise "Cannot use t(#{key.inspect}) shortcut because path is not available"
    end
  else
    key
  end
end

def translate(key, options = {})

you know what kind of output to expect when you call translate in a template.
naming convention helps to identify translations that include HTML tags so that
a safe HTML string that won't be escaped by other HTML helper methods. This
calling translate("footer_html") or translate("footer.html") will return
"_html" or the last element of the key is the word "html". For example,
Third, it'll mark the translation as safe HTML if the key has the suffix

nothing is converted.
for scoping them consistently. If you don't prepend the key with a period,
to translate many keys within the same partials and gives you a simple framework
I18n.translate("people.index.foo"). This makes it less repetitive
people/index.html.erb template, you'll actually be calling
with a period. So if you call translate(".foo") from the
Second, it'll scope the key by the current partial if the key starts

be easy to spot missing translations.
This way your views will display rather reasonable strings but it will still
Title.
E.g. the value returned for a missing translation key :"blog.post.title" will be

* a titleized version of the last key segment as a text.
* contain the missing key as a title attribute and
* have a "translation-missing" class set,

into inline spans that:
First, it will ensure that any thrown +MissingTranslation+ messages will be turned

Delegates to I18n#translate but also performs three additional functions. 
def translate(key, options = {})
  options = options.dup
  has_default = options.has_key?(:default)
  remaining_defaults = Array(options.delete(:default)).compact
  if has_default && !remaining_defaults.first.kind_of?(Symbol)
    options[:default] = remaining_defaults
  end
  # If the user has explicitly decided to NOT raise errors, pass that option to I18n.
  # Otherwise, tell I18n to raise an exception, which we rescue further in this method.
  # Note: `raise_error` refers to us re-raising the error in this method. I18n is forced to raise by default.
  if options[:raise] == false || (options.key?(:rescue_format) && options[:rescue_format].nil?)
    raise_error = false
    i18n_raise = false
  else
    raise_error = options[:raise] || options[:rescue_format] || ActionView::Base.raise_on_missing_translations
    i18n_raise = true
  end
  if html_safe_translation_key?(key)
    html_safe_options = options.dup
    options.except(*I18n::RESERVED_KEYS).each do |name, value|
      unless name == :count && value.is_a?(Numeric)
        html_safe_options[name] = ERB::Util.html_escape(value.to_s)
      end
    end
    translation = I18n.translate(scope_key_by_partial(key), html_safe_options.merge(raise: i18n_raise))
    translation.respond_to?(:html_safe) ? translation.html_safe : translation
  else
    I18n.translate(scope_key_by_partial(key), options.merge(raise: i18n_raise))
  end
rescue I18n::MissingTranslationData => e
  if remaining_defaults.present?
    translate remaining_defaults.shift, options.merge(default: remaining_defaults)
  else
    raise e if raise_error
    keys = I18n.normalize_keys(e.locale, e.key, e.options[:scope])
    content_tag('span', keys.last.to_s.titleize, :class => 'translation_missing', :title => "translation missing: #{keys.join('.')}")
  end
end