activesupport 2.3.5 → 2.3.6.pre

data/lib/active_support/vendor/i18n-0.3.3/lib/i18n/backend/active_record/missing.rb

@@ -0,0 +1,67 @@
+#  This extension stores translation stub records for missing translations to
+#  the database.
+#
+#  This is useful if you have a web based translation tool. It will populate
+#  the database with untranslated keys as the application is being used. A
+#  translator can then go through these and add missing translations.
+#
+#  Example usage:
+#
+#     I18n::Backend::Chain.send(:include, I18n::Backend::ActiveRecord::Missing)
+#     I18n.backend = I18nChainBackend.new(I18n::Backend::ActiveRecord.new, I18n::Backend::Simple.new)
+#
+#  Stub records for pluralizations will also be created for each key defined
+#  in i18n.plural.keys.
+#
+#  For example:
+#
+#    # en.yml
+#    en:
+#      i18n:
+#        plural:
+#          keys: [:zero, :one, :other]
+#
+#    # pl.yml
+#    pl:
+#      i18n:
+#        plural:
+#          keys: [:zero, :one, :few, :other]
+#
+#  It will also persist interpolation keys in Translation#interpolations so
+#  translators will be able to review and use them.
+module I18n
+  module Backend
+    class ActiveRecord
+      module Missing
+        def store_default_translations(locale, key, options = {})
+          count, scope, default, separator = options.values_at(:count, *Base::RESERVED_KEYS)
+          separator ||= I18n.default_separator
+
+          keys = I18n.send(:normalize_translation_keys, locale, key, scope, separator)[1..-1]
+          key = keys.join(separator || I18n.default_separator)
+
+          unless ActiveRecord::Translation.locale(locale).lookup(key, separator).exists?
+            interpolations = options.reject { |name, value| Base::RESERVED_KEYS.include?(name) }.keys
+            keys = count ? I18n.t('i18n.plural.keys', :locale => locale).map { |k| [key, k].join(separator) } : [key]
+            keys.each { |key| store_default_translation(locale, key, interpolations) }
+          end
+        end
+
+        def store_default_translation(locale, key, interpolations)
+          translation = ActiveRecord::Translation.new :locale => locale.to_s, :key => key
+          translation.interpolations = interpolations
+          translation.save
+        end
+
+        def translate(locale, key, options = {})
+          super
+
+          rescue I18n::MissingTranslationData => e
+            self.store_default_translations(locale, key, options)
+
+            raise e
+        end
+      end
+    end
+  end
+end

data/lib/active_support/vendor/i18n-0.3.3/lib/i18n/backend/active_record/store_procs.rb

@@ -0,0 +1,38 @@
+# This module is intended to be mixed into the ActiveRecord backend to allow
+# storing Ruby Procs as translation values in the database.
+#
+#   I18n.backend = I18n::Backend::ActiveRecord.new
+#   I18n::Backend::ActiveRecord::Translation.send(:include, I18n::Backend::ActiveRecord::StoreProcs)
+#
+# The StoreProcs module requires the ParseTree and ruby2ruby gems and therefor
+# was extracted from the original backend.
+#
+# ParseTree is not compatible with Ruby 1.9.
+
+begin
+  require 'ruby2ruby'
+  require 'parse_tree'
+  require 'parse_tree_extensions'
+rescue LoadError => e
+  puts "can't use StoreProcs because: #{e.message}"
+end
+
+module I18n
+  module Backend
+    class ActiveRecord
+      module StoreProcs
+        def value=(v)
+          case v
+            when Proc
+              write_attribute(:value, v.to_ruby)
+              write_attribute(:is_proc, true)
+            else
+              write_attribute(:value, v)
+          end
+        end
+
+        Translation.send(:include, self) unless RUBY_VERSION >= '1.9'
+      end
+    end
+  end
+end

data/lib/active_support/vendor/i18n-0.3.3/lib/i18n/backend/active_record/translation.rb

@@ -0,0 +1,83 @@
+require 'active_record'
+
+module I18n
+  module Backend
+    # ActiveRecord model used to store actual translations to the database.
+    #
+    # This model expects a table like the following to be already set up in
+    # your the database:
+    #
+    #   create_table :translations do |t|
+    #     t.string :locale
+    #     t.string :key
+    #     t.string :value
+    #     t.boolean :is_proc, :default => false
+    #   end
+    #
+    # This model supports to named scopes :locale and :lookup. The :locale
+    # scope simply adds a condition for a given locale:
+    #
+    #   I18n::Backend::ActiveRecord::Translation.locale(:en).all
+    #   # => all translation records that belong to the :en locale
+    #
+    # The :lookup scope adds a condition for looking up all translations
+    # that either start with the given keys (joined by an optionally given
+    # separator or I18n.default_separator) or that exactly have this key.
+    #
+    #   # with translations present for :"foo.bar" and :"foo.baz"
+    #   I18n::Backend::ActiveRecord::Translation.lookup(:foo)
+    #   # => an array with both translation records :"foo.bar" and :"foo.baz"
+    #
+    #   I18n::Backend::ActiveRecord::Translation.lookup([:foo, :bar])
+    #   I18n::Backend::ActiveRecord::Translation.lookup(:"foo.bar")
+    #   # => an array with the translation record :"foo.bar"
+    #
+    # When the StoreProcs module was mixed into this model then Procs will
+    # be stored to the database as Ruby code and evaluated when :value is
+    # called.
+    #
+    #   Translation = I18n::Backend::ActiveRecord::Translation
+    #   Translation.create \
+    #     :locale => 'en'
+    #     :key    => 'foo'
+    #     :value  => lambda { |key, options| 'FOO' }
+    #   Translation.find_by_locale_and_key('en', 'foo').value
+    #   # => 'FOO'
+    class ActiveRecord
+      class Translation < ::ActiveRecord::Base
+        set_table_name 'translations'
+        attr_protected :is_proc, :interpolations
+        
+        serialize :value
+        serialize :interpolations, Array
+
+        named_scope :locale, lambda { |locale|
+          { :conditions => { :locale => locale.to_s } }
+        }
+
+        named_scope :lookup, lambda { |keys, *separator|
+          keys = Array(keys).map! { |key| key.to_s }
+          separator = separator.first || I18n.default_separator
+          { :conditions => ["`key` IN (?) OR `key` LIKE '#{keys.last}#{separator}%'", keys] }
+        }
+
+        def self.available_locales
+          Translation.find(:all, :select => 'DISTINCT locale').map { |t| t.locale.to_sym }
+        end
+        
+        def interpolates?(key)
+          self.interpolations.include?(key) if self.interpolations
+        end
+
+        def value
+          if is_proc
+            Kernel.eval read_attribute(:value)
+          else
+            value = read_attribute(:value)
+            value == 'f' ? false : value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/vendor/i18n-0.3.3/lib/i18n/backend/base.rb

@@ -0,0 +1,259 @@
+# encoding: utf-8
+
+require 'yaml'
+
+module I18n
+  module Backend
+    module Base
+      include I18n::Backend::Helpers
+
+      RESERVED_KEYS = [:scope, :default, :separator]
+      INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
+
+      # Accepts a list of paths to translation files. Loads translations from
+      # plain Ruby (*.rb) or YAML files (*.yml). See #load_rb and #load_yml
+      # for details.
+      def load_translations(*filenames)
+        filenames.each { |filename| load_file(filename) }
+      end
+
+      # Stores translations for the given locale in memory.
+      # This uses a deep merge for the translations hash, so existing
+      # translations will be overwritten by new ones only at the deepest
+      # level of the hash.
+      def store_translations(locale, data, options = {})
+        merge_translations(locale, data)
+      end
+
+      def translate(locale, key, options = {})
+        raise InvalidLocale.new(locale) unless locale
+        return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
+
+        if options.empty?
+          entry = resolve(locale, key, lookup(locale, key), options)
+          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+        else
+          count, scope, default, separator = options.values_at(:count, :scope, :default, :separator)
+          values = options.reject { |name, value| RESERVED_KEYS.include?(name) }
+
+          entry = lookup(locale, key, scope, separator)
+          entry = entry.nil? && default ? default(locale, key, default, options) : resolve(locale, key, entry, options)
+          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+
+          entry = pluralize(locale, entry, count)    if count
+          entry = interpolate(locale, entry, values) if values
+        end
+
+        entry
+      end
+
+      # Acts the same as +strftime+, but uses a localized version of the
+      # format string. Takes a key from the date/time formats translations as
+      # a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
+      def localize(locale, object, format = :default, options = {})
+        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
+
+        if Symbol === format
+          key = format
+          type = object.respond_to?(:sec) ? 'time' : 'date'
+          format = lookup(locale, :"#{type}.formats.#{key}")
+          raise(MissingTranslationData.new(locale, key, options)) if format.nil?
+        end
+
+        format = resolve(locale, object, format, options)
+        format = format.to_s.gsub(/%[aAbBp]/) do |match|
+          case match
+          when '%a' then I18n.t(:"date.abbr_day_names",                  :locale => locale, :format => format)[object.wday]
+          when '%A' then I18n.t(:"date.day_names",                       :locale => locale, :format => format)[object.wday]
+          when '%b' then I18n.t(:"date.abbr_month_names",                :locale => locale, :format => format)[object.mon]
+          when '%B' then I18n.t(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
+          when '%p' then I18n.t(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format) if object.respond_to? :hour
+          end
+        end
+
+        object.strftime(format)
+      end
+
+      def initialized?
+        @initialized ||= false
+      end
+
+      # Returns an array of locales for which translations are available
+      # ignoring the reserved translation meta data key :i18n.
+      def available_locales
+        init_translations unless initialized?
+        translations.inject([]) do |locales, (locale, data)|
+          locales << locale unless (data.keys - [:i18n]).empty?
+          locales
+        end
+      end
+
+      def reload!
+        @initialized = false
+        @translations = nil
+      end
+
+      protected
+        def init_translations
+          load_translations(*I18n.load_path.flatten)
+          @initialized = true
+        end
+
+        def translations
+          @translations ||= {}
+        end
+
+        # Looks up a translation from the translations hash. Returns nil if
+        # eiher key is nil, or locale, scope or key do not exist as a key in the
+        # nested translations hash. Splits keys or scopes containing dots
+        # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same as
+        # <tt>%w(currency format)</tt>.
+        def lookup(locale, key, scope = [], separator = nil)
+          return unless key
+          init_translations unless initialized?
+          keys = I18n.send(:normalize_translation_keys, locale, key, scope, separator)
+          keys.inject(translations) do |result, key|
+            key = key.to_sym
+            return nil unless result.is_a?(Hash) && result.has_key?(key)
+            result = result[key]
+            result = resolve(locale, key, result, :separator => separator) if result.is_a?(Symbol)
+            result
+          end
+        end
+
+        # Evaluates defaults.
+        # If given subject is an Array, it walks the array and returns the
+        # first translation that can be resolved. Otherwise it tries to resolve
+        # the translation directly.
+        def default(locale, object, subject, options = {})
+          options = options.dup.reject { |key, value| key == :default }
+          case subject
+          when Array
+            subject.each do |item|
+              result = resolve(locale, object, item, options) and return result
+            end and nil
+          else
+            resolve(locale, object, subject, options)
+          end
+        end
+
+        # Resolves a translation.
+        # If the given subject is a Symbol, it will be translated with the
+        # given options. If it is a Proc then it will be evaluated. All other
+        # subjects will be returned directly.
+        def resolve(locale, object, subject, options = nil)
+          case subject
+          when Symbol
+            I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
+          when Proc
+            resolve(locale, object, subject.call(object, options), options = {})
+          else
+            subject
+          end
+        rescue MissingTranslationData
+          nil
+        end
+
+        # Picks a translation from an array according to English pluralization
+        # rules. It will pick the first translation if count is not equal to 1
+        # and the second translation if it is equal to 1. Other backends can
+        # implement more flexible or complex pluralization rules.
+        def pluralize(locale, entry, count)
+          return entry unless entry.is_a?(Hash) and count
+
+          key = :zero if count == 0 && entry.has_key?(:zero)
+          key ||= count == 1 ? :one : :other
+          raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
+          entry[key]
+        end
+
+        # Interpolates values into a given string.
+        #
+        #   interpolate "file {{file}} opened by \\{{user}}", :file => 'test.txt', :user => 'Mr. X'
+        #   # => "file test.txt opened by {{user}}"
+        #
+        # Note that you have to double escape the <tt>\\</tt> when you want to escape
+        # the <tt>{{...}}</tt> key in a string (once for the string and once for the
+        # interpolation).
+        def interpolate(locale, string, values = {})
+          return string unless string.is_a?(String) && !values.empty?
+
+          preserve_encoding(string) do
+            s = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
+              escaped, key = $1, $2.to_sym
+              if escaped
+                "{{#{key}}}"
+              elsif RESERVED_KEYS.include?(key)
+                raise ReservedInterpolationKey.new(key, string)
+              else
+                "%{#{key}}"
+              end
+            end
+
+            values.each do |key, value|
+              value = value.call(values) if interpolate_lambda?(value, s, key)
+              value = value.to_s unless value.is_a?(String)
+              values[key] = value
+            end
+
+            s % values
+          end
+
+        rescue KeyError => e
+          raise MissingInterpolationArgument.new(values, string)
+        end
+
+        def preserve_encoding(string)
+          if string.respond_to?(:encoding)
+            encoding = string.encoding
+            result = yield
+            result.force_encoding(encoding) if result.respond_to?(:force_encoding)
+            result
+          else
+            yield
+          end
+        end
+
+        # returns true when the given value responds to :call and the key is
+        # an interpolation placeholder in the given string
+        def interpolate_lambda?(object, string, key)
+          object.respond_to?(:call) && string =~ /%\{#{key}\}|%\<#{key}>.*?\d*\.?\d*[bBdiouxXeEfgGcps]\}/
+        end
+
+        # Loads a single translations file by delegating to #load_rb or
+        # #load_yml depending on the file extension and directly merges the
+        # data to the existing translations. Raises I18n::UnknownFileType
+        # for all other file extensions.
+        def load_file(filename)
+          type = File.extname(filename).tr('.', '').downcase
+          raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}")
+          data = send :"load_#{type}", filename # TODO raise a meaningful exception if this does not yield a Hash
+          data.each { |locale, d| merge_translations(locale, d) }
+        end
+
+        # Loads a plain Ruby translations file. eval'ing the file must yield
+        # a Hash containing translation data with locales as toplevel keys.
+        def load_rb(filename)
+          eval(IO.read(filename), binding, filename)
+        end
+
+        # Loads a YAML translations file. The data must have locales as
+        # toplevel keys.
+        def load_yml(filename)
+          YAML::load(IO.read(filename))
+        end
+
+        # Deep merges the given translations hash with the existing translations
+        # for the given locale
+        def merge_translations(locale, data)
+          locale = locale.to_sym
+          translations[locale] ||= {}
+          data = deep_symbolize_keys(data)
+
+          # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+          merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+          translations[locale].merge!(data, &merger)
+        end
+    end
+  end
+end