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 = {})

they can provide HTML values for.
when you call translate in a template and translators know which keys
that include HTML tags so that you know what kind of output to expect
helper methods. This naming convention helps to identify translations
will return an HTML safe string that won't be escaped by other HTML
translate("footer_html") or translate("footer.html")
has the suffix "_html" or the last element of the key is "html". Calling
Third, the translation will be marked as html_safe if the key

a convention to scope keys consistently.
repetitive to translate many keys within the same partial and provides
translate("people.index.foo"). This makes it less
the people/index.html.erb template is equivalent to calling
the key by the current partial. Calling translate(".foo") from
Second, if the key starts with a period translate will scope

translate.
individually by passing raise: true as an option to
ActionView::Base.raise_on_missing_translations = true or
opt out of span-wrapping behavior globally by setting
If you would prefer missing translations to raise an error, you can

giving developers a way to find missing translations.
This allows for views to display rather reasonable strings while still

title="translation missing: en.blog.post.title">Title
class="translation_missing"

"blog.post.title" will be:
For example, the value returned for the missing translation key

* Have a titleized version of the last key segment as text
* Contain the missing key as the value of the +title+ attribute
* Have a translation-missing class applied

be rendered as inline spans that:
First, it will ensure that any thrown +MissingTranslation+ messages will

functions.
Delegates to I18n#translate but also performs three additional 
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
    raise_error = false
    i18n_raise = false
  else
    raise_error = options[:raise] || 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])
    title = "translation missing: #{keys.join('.')}"
    interpolations = options.except(:default, :scope)
    if interpolations.any?
      title << ", " << interpolations.map { |k, v| "#{k}: #{ERB::Util.html_escape(v)}" }.join(', ')
    end
    return title unless ActionView::Base.debug_missing_translation
    content_tag('span', keys.last.to_s.titleize, class: 'translation_missing', title: title)
  end
end