air18n 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.log
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p125@air18n"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.12.3 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in air18n.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jason Katz-Brown
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,29 @@
+# Air18n
+
+Rails plugin for amazing internationalization.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'air18n'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install air18n
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+Bundler::GemHelper.install_tasks

data/air18n.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/air18n/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jason Katz-Brown", "Nick Grandy", "Naseem Hakim", "Horace Ko", "Matt Baker"]
+  gem.email         = ["jason@airbnb.com", "nick@airbnb.com", "naseem@airbnb.com", "horace@airbnb.com", "matt.baker@airbnb.com"]
+  gem.summary       = %q{Dynamic I18n backend}
+  gem.description   = %q{Rails plugin with dyanmic I18n backend for amazing internationalization.}
+  gem.homepage      = "http://www.github.com/airbnb/air18n"
+
+  gem.add_runtime_dependency 'i18n', '>= 0.5.0'
+  gem.add_runtime_dependency 'activerecord', '~> 3.0'
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'factory_girl', '~> 3.0'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "air18n"
+  gem.require_paths = ["lib"]
+  gem.version       = Air18n::VERSION
+end

data/lib/air18n.rb

@@ -0,0 +1,83 @@
+require "i18n"
+
+require 'air18n/class_methods'
+require 'air18n/backend'
+require 'air18n/priority'
+
+require 'air18n/reflection'
+
+module Air18n
+  AIR18N_RESERVED_KEYS = [:routes_context, :suppress_ct, :default_is_low_priority, :disable_xss_check]
+
+  def self.included(base)
+    base.class_eval do
+      # Currencies that correspond to users who want distance unit to be
+      # miles.
+      self.const_set(:MILES_CURRENCIES, ['USD', 'GBP'])
+
+      class << self
+        extend ActiveSupport::Memoizable
+
+        module_eval do
+          include ClassMethods
+        end
+
+        # Country, as a symbol. This is separate from locale, and should set based
+        # only on the domain name or IP address or some other kind of geographic
+        # location.
+        attr_accessor :country
+
+        # Like country; set it to :US if we're on the global domain to show
+        # correct terms/conditions
+        attr_accessor :legal_country
+
+        # An instance of I18n::Locale::Fallbacks for computing locale fallbacks.
+        attr_reader :fallbacks
+
+        # Manages prioritization of translation keys. If set, must implement
+        # methods of Air18n::Priority.
+        attr_accessor :priority
+
+        # Used as routes context if not specified in options passed to translate().
+        attr_accessor :fallback_routes_context
+
+        # Currency for the current request.
+        @currency = 'USD'
+        attr_reader :currency
+
+        # Distance unit, 'MI' or 'KM'.
+        @distance_unit = 'KM'
+        attr_reader :distance_unit
+
+        # Whether to wrap phrases in HTML that allows them to be translated by
+        # the user from directly on the page.
+        @contextual_translation = false
+
+        alias_method :t_with_routes_context, :translate_with_routes_context
+        alias_method_chain :t, :routes_context
+        alias_method_chain :translate, :routes_context
+
+        memoize :localized_path_explicit_locale
+        memoize :language_from_locale
+      end
+    end
+  end
+end
+
+# Make sure we don't try to interpolate our Air18n-specific reserved keys.
+I18n::Backend::Base.module_eval do
+  def interpolate_with_new_reserved_keys(locale, string, values = {})
+    interpolate_without_new_reserved_keys(locale, string, values.except(*Air18n::AIR18N_RESERVED_KEYS))
+  end
+  alias_method_chain :interpolate, :new_reserved_keys
+end
+
+I18n.send(:include, Air18n)
+I18n.reset(:en)
+
+# This should really be done by default! Make the simple backend also use
+# fallbacks.
+I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+
+# Use the fancy version of I18n locale tags.
+I18n::Locale::Tag.implementation = I18n::Locale::Tag::Rfc4646

data/lib/air18n/backend.rb

@@ -0,0 +1,194 @@
+require 'i18n'
+
+require 'air18n/logging_helper'
+require 'air18n/prim_and_proper'
+require 'air18n/pseudo_locales'
+
+module Air18n
+  class Backend
+    include I18n::Backend::Base
+
+    attr_accessor :translation_data, :initialized, :phrase_screenshots
+
+    # Stores translations for a given locale.
+    def store_translations locale, data, options = {}
+      @translation_data ||= {}
+      @translation_data[locale.to_sym] = data
+    end
+
+    def available_locales
+      if @translation_data
+        @translation_data.inject([]) do |carry, (locale, translations)|
+          carry << locale unless translations.empty?
+          carry
+        end
+      else
+        []
+      end
+    end
+
+    def reload_translations(locales)
+      # We don't want to load translations of unused phrases, so we exclude
+      # unused from the set of translations we initialize.
+      translations_hash = PhraseTranslation.translations_for_locales(locales, :exclude_unused => true)
+
+      # In development, people might not be running the counter server to keep
+      # track of which phrases are used. In this ase, load all phrases, except UGC.
+      if translations_hash.all? { |locale, translations| translations.empty? }
+        translations_hash = PhraseTranslation.translations_for_locales(locales, :exclude_ugc => true)
+      end
+
+      num_translations = translations_hash.inject(0) { |carry, (locale, translations)| carry + translations.size }
+      LoggingHelper.info "Loaded #{num_translations} translations for locales #{locales.inspect}."
+
+      number_of_translations = 0
+      translations_hash.each_pair do |locale, data|
+        store_translations(locale, data)
+        number_of_translations += data.size
+
+        @translations_last_loaded_at ||= {}
+        @translations_last_loaded_at[locale] = Time.now
+      end
+
+      LoggingHelper.info "Translation data size: #{Marshal.dump(@translation_data).size}"
+    end
+
+    def init_translations(locale)
+      @phrase_screenshots ||= PhraseScreenshot.all_phrase_urls
+      if @translation_data.nil? || !@translation_data.include?(locale)
+        reload_translations([locale])
+      end
+    end
+
+    def check_for_new_translations(locale)
+      # When TranslateController makes a new translation, it sets
+      # translations_last_updated_at to the current time in the cache.
+      # If we haven't reset the i18n backends since then, we take the opportunity to reset them.
+      last_updated_at = Rails.cache.read("#{locale}_translations_last_updated_at")
+      if last_updated_at && last_updated_at.to_i > @translations_last_loaded_at[locale].to_i
+        reload_translations([locale])
+      end
+    end
+
+    def guess_translation(text, orig_locale, other_locale)
+      @prim_and_proper ||= PrimAndProper.new
+      @prim_and_proper.guess(text, orig_locale, other_locale)
+    end
+
+    # We will only take 10 screenshots per Rails instance per key.
+    # This is to avoid having to moderate 200 screenshots for every new site-wide
+    # phrase.
+    # Because this is a per-Rails-thread cap, we call it approximate.
+    APPROX_MAX_SCREENSHOTS_PER_KEY = 10
+
+    # This method does the meat of Air18n functionality.
+    # 1) Finds the translations for specified key and locale, falling back to
+    #    appropriate locales if necessary based on I18n.fallbacks.
+    # 2) Queues up screenshot-taking jobs if we don't have a screenshot for a
+    #    (key, options[:routes_context])
+    # 3) Populates the phrases database if key and options[:default] aren't
+    #    already in there.
+    # 4) Updates the phrases database if options[:default] doesn't match the
+    #    English text in the database. Alternatively, you can use
+    #    options[:default_is_low_priority] if you don't want this behavior.
+    # 5) Makes the :xx locale translations.
+    # 6) Asks PrimAndProper to make en-GB translations and other best-guess
+    #    translations if appropriate.
+    def lookup(locale, key, scope = [], options = {})
+      # Useful i18n logging for debugging translation lookup problems.
+      # LoggingHelper.info "Lookup! key is #{key.inspect}, options are #{options.inspect}"
+      # caller.each { |l| LoggingHelper.info "    " + l }
+
+      # Sometimes translate() is called with an array of keys. We don't handle that case.
+      if key.blank? || !key.is_a?(String)
+        return nil
+      end
+
+      # Force locale to symbol to allow e.g.
+      #   I18n.t('foo', :default => 'Foo', :locale => @current_user.preferred_locale)
+      locale = locale.to_sym
+
+      default = options[:default] && options[:default].is_a?(String) && options[:default]
+      overrides_previous_default = !options[:default_is_low_priority]
+
+      init_translations(locale)
+
+      # Only create new screenshots while using default locale, and ignore keys
+      # that come in hash format or with a wacky namespace
+      if options[:routes_context] && locale == I18n.default_locale
+        # Check to see if we have screenshot for this phrase/routes context combo
+        unless @phrase_screenshots[key] && (@phrase_screenshots[key].include?(options[:routes_context]) || @phrase_screenshots[key].size >= APPROX_MAX_SCREENSHOTS_PER_KEY)
+          I18n.phrase_needs_screenshot(options[:routes_context], {key => @translation_data[I18n.default_locale][key] || default || key})
+          @phrase_screenshots[key] = (@phrase_screenshots[key] || []) << options[:routes_context]
+        end
+      end
+
+      fallback_chain = I18n.fallbacks_for(locale)
+      result = nil
+      locale_fallen_back_to = nil
+      for fallback_locale in fallback_chain
+        if @translation_data.include?(fallback_locale)
+          result = @translation_data[fallback_locale][key]
+          locale_fallen_back_to = fallback_locale
+          break if result
+        end
+      end
+
+      if result && locale_fallen_back_to != locale
+        # See if we can guess a translation instead of using the fallback
+        # translation.
+        guess = guess_translation(result, locale_fallen_back_to, locale)
+        result = guess if guess
+      end
+
+      # If there was a default-language translation, check if it matches the default.
+      # If the phrase is not in the phrases table, it will be created.
+      if locale == I18n.default_locale && default && result != default
+        # If it doesn't, we need to update the 'phrases' table so that
+        # the 'value' column reflects the latest English default text.
+        LoggingHelper.info "Default English text for key '#{key}' changed! Old default '#{result}' != new default '#{default}'. Route context: #{options[:routes_context]}"
+        phrase = Phrase.find_or_create_by_key(key)
+        if phrase
+          if (overrides_previous_default && phrase.value != default) ||
+            (!overrides_previous_default && phrase.value != default && phrase.value.blank?)
+            phrase.value = default
+
+            begin
+              phrase.save
+            rescue Exception => e
+              # If many requests happen simultaneously for a page with a new
+              # phrase, a "duplicate entry" exception will happen naturally.
+              # And if phrase creation fails for some other reason, we will try
+              # again to create it next time automatically.
+            end
+          end
+        end
+
+        @translation_data[locale][key] = default
+        result = default
+      end
+
+      # Helps debug translation loading and default setting.
+      # LoggingHelper.info "Airbnb Backend looking up key #{key.inspect}. result is #{result.inspect}. Default is #{default.inspect}"
+
+      # if a default is given, use it here
+      if result.nil? && default
+        result = default
+      end
+
+      unless options[:disable_xss_check]
+        xss_detection = XssDetector::safe?(default, result)
+        if !xss_detection[:safe]
+          # Kill the translation if the result is unsafe.
+          LoggingHelper.error "Killing unsafe translation! Default is #{default.inspect}, result is #{result.inspect}, reason for kill is #{xss_detection[:result]}"
+          result = default
+        end
+      end
+
+      # Handle pseudo-locales.
+      result = PseudoLocales.translate(locale, result)
+
+      result
+    end
+  end
+end

data/lib/air18n/class_methods.rb

@@ -0,0 +1,292 @@
+require 'air18n/less_silly_chain'
+require 'air18n/logging_helper'
+require 'air18n/xss_detector'
+
+module Air18n
+  module ClassMethods
+    # Returns only the language part of the current locale, as a symbol.
+    # E.g. "pt" if the locale is pt-BR.
+    def language
+      language_from_locale full_locale
+    end
+
+    # Returns the language code of I18n.default_locale, as a symbol.
+    def default_language
+      language_from_locale default_locale
+    end
+
+    # Deprecated.
+    # This returns the same as language().
+    # TODO(jason) Switch all use of locale() to either language() or
+    # full_locale().
+    def locale_with_language_hack
+      language
+    end
+
+    # Returns full locale as a symbol, like :es, :en, :"es-419" (Latin-American
+    # Spanish) or :"pt-BR" or :"en-GB".
+    def full_locale
+      config.locale
+    end
+
+    # The one true way to set the locale.
+    def full_locale=(locale)
+      config.locale = locale.to_sym
+    end
+
+    # Deprecated.
+    # Sets locale. Using full_locale= is preferable.
+    def locale=(locale)
+      LoggingHelper.info "I18n.locale=() is deprecated. Use I18n.full_locale=()."
+      self.full_locale = locale
+    end
+
+    # For a locale (like :en, :en-GB, :pt-PT), returns the "language"
+    # part (like :en or :pt).
+    # If locale is invalid or nil, returns the default language.
+    def language_from_locale locale
+      tags = I18n::Locale::Tag.tag(locale)
+      tags ? tags.language.to_sym : language_from_locale(I18n.default_locale)
+    end
+
+    # Gets a hash containing phrases that need to be screenshot in the
+    # specified routes_context.
+    # After this method returns the phrases, it forgets about them, so you
+    # can only retrieve them once.
+    def retrieve_phrases_needing_screenshot(routes_context)
+      return {} unless @phrases_needing_screenshot && @phrases_needing_screenshot.include?(routes_context)
+      @phrases_needing_screenshot.delete(routes_context)
+    end
+
+    def phrase_needs_screenshot(routes_context, phrase)
+      @phrases_needing_screenshot ||= Hash.new { |h, routes_context| h[routes_context] = {} }
+      @phrases_needing_screenshot[routes_context].merge!(phrase)
+    end
+
+    def contextual_translation
+      if full_locale != default_locale
+        @contextual_translation
+      else
+        false
+      end
+    end
+
+    def contextual_translation= x
+      @contextual_translation= x
+    end
+
+    # Returns OrderedHash mapping key => times looked up today or in the last week.
+    def still_used_keys_hash
+      # If you want to test with the full allotment of still-used phrases from
+      # production, do this on mainframe:
+      # File.open('/tmp/still_used', 'w') { |f| f.write Counter.retrieve_counts_from_today_and_last_week("t").to_json }
+      # Then copy /tmp/still_used to your local machine, and uncomment the next line.
+      # @still_used_keys ||= File.open('/tmp/still_used') { |f| JSON.parse(f.read()) }
+
+      @priority ? @priority.key_usage : {}
+    end
+
+    # Returns list of keys looked up today or in the last week.
+    def still_used_keys
+      still_used_keys_hash.keys
+    end
+
+    # Returns list of phrase IDs that are still used.
+    def still_used_phrase_ids
+      @still_used_phrase_ids ||= begin
+        key_to_phrase_id = {}
+        # Uses raw SQL for speed.
+        Phrase.connection.select_all("SELECT `id`, `key` FROM phrases").each do |record|
+          key_to_phrase_id[record['key']] = record['id']
+        end
+
+        still_used_keys.map do |key|
+          LoggingHelper.error "Mystery phrase key: #{key}" if !key_to_phrase_id.include? key
+          key_to_phrase_id[key]
+        end
+      end
+    end
+
+    # Phrases that are from user-generated content (like hosting names) have a
+    # key prefixed with "ugc.".
+    def phrase_key_is_ugc?(key)
+      key.starts_with?('ugc.')
+    end
+
+    # Returns true if key should be translated.
+    # A key needs to be translated if it is either UGC or was looked up by t()
+    # today or in the last week.
+    def needs_translation?(key)
+      phrase_key_is_ugc?(key) || still_used_keys_hash.include?(key)
+    end
+
+    # Create Air18n backend with given default_locale and translation prioritizer.
+    def reset(default_locale)
+      self.default_locale = default_locale
+
+      # Use locale fallbacks that always include default locale as the last
+      # fallback.
+      @fallbacks = I18n::Locale::Fallbacks.new(default_locale)
+
+      # Make the single instance of Air18n::Backend.
+      @air18n_backend = Air18n::Backend.new
+
+      # This activates Air18n by putting Air18n::Backend before I18n.backend.
+      self.backend = Air18n::LessSillyChain.new(@air18n_backend, I18n::Backend::Simple.new)
+    end
+
+    # Return the fallback locales for the_locale.
+    # If opts[:exclude_default] is set, the default locale, which is otherwise
+    # always the last one in the returned list, will be excluded.
+    #
+    # For example, fallbacks_for(:"pt-BR") is [:"pt-BR", :pt, :en] with
+    # exclude_default = false and [:"pt-BR", :pt] with exclude_default = true.
+    def fallbacks_for(the_locale, opts = {})
+      # We dup() because otherwise the fallbacks hash might itself be modified
+      # by the user of this method, and that would be terrible.
+      ret = @fallbacks[the_locale].dup
+
+      # We make two assumptions here:
+      # 1) There is only one default locale (that is, it has no less-specific
+      #    children)
+      # 1) The default locale is just a language. (Like :en, and not :"en-US".)
+      if opts[:exclude_default] && ret.last == self.default_locale && ret.last != language_from_locale(the_locale)
+        ret.pop
+      end
+
+      ret
+    end
+
+    # Returns whether the_locale has other_locale in its non-default fallbacks.
+    def falls_back_to?(the_locale, other_locale)
+      fallbacks_for(the_locale, :exclude_default => true).include?(other_locale)
+    end
+
+    def check_for_new_translations
+      @air18n_backend.check_for_new_translations(I18n.full_locale)
+    end
+
+    def currency=(c)
+      @currency = c
+      @distance_unit = self::MILES_CURRENCIES.include?(c) ? "MI" : "KM"
+    end
+
+    # Parses a date using the current locale setting.
+    # 2-digit years are interpreted as 19XX (>= 69) or 20XX (< 69).
+    def parse_date s, locale = nil
+      return s if s.nil?
+
+      if /\A[0-9]{4}-[0-9]{2}-[0-9]{2}\Z/.match s
+        # If this looks like an ISO date, YYYY-mm-dd, let [Date.parse] handle
+        # parsing since [Date.strptime] varies by platform (darwin vs. linux)
+        Date.parse(s, true)
+      else
+        locale ||= I18n.full_locale
+        s = s.to_str
+        format = I18n.t('date.formats.default', :locale => locale.to_sym)
+        begin
+          date = Date.strptime(s, format)
+          if date.year < 100
+            date = Date.strptime(s, format.gsub("%Y", "%y"))
+          end
+        rescue
+          # When date is not parsable in user's locale attempt default
+          # date handling for cases like booking where dates can be
+          # in the international format "%Y-%m-%d". Failure to parse
+          # after this will raise an error.
+          date = Date.parse(s, true)
+        end
+        date
+      end
+    end
+
+    # Use when formatted string will be used by jQuery UI or calendar text fields
+    def format_date d, locale = nil
+      # temp handle iso date strings
+      if d.is_a?(String)
+        d = Date.parse(d)
+      end
+
+      locale ||= I18n.full_locale
+      format = I18n.t('date.formats.default', :locale => locale.to_sym)
+      if d.nil?
+        format.gsub('%m', 'mm').gsub('%d', 'dd').gsub('%Y', 'yy')
+      else
+        I18n.l(d, :format => format)
+      end
+    end
+
+    # Replaces LOCALE and COUNTRY, if they are present in path, with
+    # I18n.locale and I18n.country. You can explicitly set the locale and
+    # country with options[:locale] and options[:country].
+    #
+    # Use this if the resource you reference lives under public/. For example,
+    # to reference an image file, pass just call e.g.
+    # localized_public_path("/images/buttons/awesome-LOCALE.png").
+    def localized_public_path(path_relative_to_public, options = {})
+      localized_path(path_relative_to_public, options.merge({:absolute_prefix_on_disk => Rails.public_path}))
+    end
+
+    # Replaces LOCALE and COUNTRY, if they are present in path, with
+    # I18n.locale and I18n.country. You can explicitly set the locale and
+    # country with options[:locale] and options[:country].
+    #
+    # If path is not absolute, you must also set
+    # options[:absolute_prefix_on_disk] so that absolute_prefix_on_disk+path is
+    # a valid absolute path (after locale or country interpolations).
+    # If you are referencing something in public/, you should use
+    # localized_public_path.
+    #
+    # If the file does not exist after interpolation, LOCALE will be replaced
+    # with "en" and COUNTRY will be replaced with "us".
+    def localized_path(path, options = {})
+      options[:locale] ||= I18n.locale
+      options[:country] ||= I18n.country
+      localized_path_explicit_locale(path, options)
+    end
+
+    # Same as localized_path but explicitly uses options[:locale] and
+    # options[:country] so that it can be memoized.
+    def localized_path_explicit_locale(path, options = {})
+      replaced = path.gsub('LOCALE', options[:locale].to_s).gsub('COUNTRY', options[:country].to_s)
+
+      # TODO(jason) Use full locale and its fallbacks.
+      absolute_path = options[:absolute_prefix_on_disk] ? File.join(options[:absolute_prefix_on_disk], "images", replaced) : replaced
+      if File.exist?(absolute_path)
+        replaced
+      else
+        path.gsub('COUNTRY', "US").gsub('LOCALE', "en")
+      end
+    end
+
+    # Add :routes_context option, which is used for translation screenshotting.
+    # I18n.fallback_routes_context is set by an ApplicationController
+    # before_filter.
+    def translate_with_routes_context(key, options = {})
+      if !options.include?(:routes_context) && I18n.fallback_routes_context
+        options = options.merge(:routes_context => I18n.fallback_routes_context)
+      end
+      result = translate_without_routes_context(key, options)
+
+      # Handle contextual translation.
+      if result && I18n.contextual_translation && (!options[:suppress_ct])
+        phrase = Phrase.by_key(key)
+
+        if phrase
+          # Provides styling to wrap a string into a div so that it can be
+          # clicked on for easy translation.
+          result = "<phrase id='#{Digest::MD5.hexdigest(result + rand(1000).to_s)[0..8]}' data-phrase-id='#{phrase.id}'>#{result}</phrase>"
+        end
+      end
+
+      if key.is_a?(String)
+        # Handle bookkeeping of which translation keys are still used.
+        @priority.key_used(key) if @priority
+      end
+
+      result = result.html_safe if result && result.respond_to?(:html_safe)
+
+      result
+    end
+  end
+end