activesupport 2.3.18 → 3.0.0.beta

data/lib/active_support/vendor/i18n-0.4.1/i18n/backend.rb

@@ -1,20 +0,0 @@
-module I18n
-  module Backend
-    autoload :ActiveRecord,          'i18n/backend/active_record'
-    autoload :Base,                  'i18n/backend/base'
-    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
-    autoload :Cache,                 'i18n/backend/cache'
-    autoload :Cascade,               'i18n/backend/cascade'
-    autoload :Chain,                 'i18n/backend/chain'
-    autoload :Cldr,                  'i18n/backend/cldr'
-    autoload :Fallbacks,             'i18n/backend/fallbacks'
-    autoload :Flatten,               'i18n/backend/flatten'
-    autoload :Gettext,               'i18n/backend/gettext'
-    autoload :KeyValue,              'i18n/backend/key_value'
-    autoload :Memoize,               'i18n/backend/memoize'
-    autoload :Metadata,              'i18n/backend/metadata'
-    autoload :Pluralization,         'i18n/backend/pluralization'
-    autoload :Simple,                'i18n/backend/simple'
-    autoload :Transliterator,        'i18n/backend/transliterator'
-  end
-end

data/lib/active_support/vendor/i18n-0.4.1/i18n/backend/active_record.rb

@@ -1,61 +0,0 @@
-require 'i18n/backend/base'
-require 'i18n/backend/active_record/translation'
-
-module I18n
-  module Backend
-    class ActiveRecord
-      autoload :Missing,     'i18n/backend/active_record/missing'
-      autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
-      autoload :Translation, 'i18n/backend/active_record/translation'
-
-      module Implementation
-        include Base, Flatten
-
-        def available_locales
-          begin
-            Translation.available_locales
-          rescue ::ActiveRecord::StatementInvalid
-            []
-          end
-        end
-
-        def store_translations(locale, data, options = {})
-          escape = options.fetch(:escape, true)
-          flatten_translations(locale, data, escape, false).each do |key, value|
-            Translation.locale(locale).lookup(expand_keys(key)).delete_all
-            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
-          end
-        end
-
-      protected
-
-        def lookup(locale, key, scope = [], options = {})
-          key = normalize_flat_keys(locale, key, scope, options[:separator])
-          result = Translation.locale(locale).lookup(key).all
-
-          if result.empty?
-            nil
-          elsif result.first.key == key
-            result.first.value
-          else
-            chop_range = (key.size + FLATTEN_SEPARATOR.size)..-1
-            result = result.inject({}) do |hash, r|
-              hash[r.key.slice(chop_range)] = r.value
-              hash
-            end
-            result.deep_symbolize_keys
-          end
-        end
-
-        # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
-        def expand_keys(key)
-          key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
-            keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
-          end
-        end
-      end
-
-      include Implementation
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-#  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.normalize_keys(locale, key, scope, separator)[1..-1]
-          key = keys.join(separator || I18n.default_separator)
-
-          unless ActiveRecord::Translation.locale(locale).lookup(key).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.4.1/i18n/backend/active_record/store_procs.rb

@@ -1,38 +0,0 @@
-# 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) if method(:to_s).respond_to?(:to_ruby)
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-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.text   :value
-    #     t.text   :interpolations
-    #     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
-
-        scope_method = ::ActiveRecord::VERSION::MAJOR == 2 ? :named_scope : :scope
-
-        send scope_method, :locale, lambda { |locale|
-          { :conditions => { :locale => locale.to_s } }
-        }
-
-        send scope_method, :lookup, lambda { |keys, *separator|
-          column_name = connection.quote_column_name('key')
-          keys = Array(keys).map! { |key| key.to_s }
-
-          unless separator.empty?
-            warn "[DEPRECATION] Giving a separator to Translation.lookup is deprecated. " <<
-              "You can change the internal separator by overwriting FLATTEN_SEPARATOR."
-          end
-
-          namespace = "#{keys.last}#{I18n::Backend::Flatten::FLATTEN_SEPARATOR}%"
-          { :conditions => ["#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace] }
-        }
-
-        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.4.1/i18n/backend/base.rb

@@ -1,237 +0,0 @@
-# encoding: utf-8
-
-require 'yaml'
-require 'i18n/core_ext/hash'
-
-module I18n
-  module Backend
-    module Base
-      include I18n::Backend::Transliterator
-
-      RESERVED_KEYS = [:scope, :default, :separator, :resolve]
-      RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
-      DEPRECATED_INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
-      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 = I18n.load_path.flatten if filenames.empty?
-        filenames.each { |filename| load_file(filename) }
-      end
-
-      # This method receives a locale, a data hash and options for storing translations.
-      # Should be implemented
-      def store_translations(locale, data, options = {})
-        raise NotImplementedError
-      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)
-
-        entry = key && lookup(locale, key, options[:scope], options)
-
-        if options.empty?
-          entry = resolve(locale, key, entry, options)
-        else
-          count, default = options.values_at(:count, :default)
-          values = options.except(*RESERVED_KEYS)
-          entry = entry.nil? && default ?
-            default(locale, key, default, options) : resolve(locale, key, entry, options)
-        end
-
-        raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
-        entry = entry.dup if entry.is_a?(String)
-
-        entry = pluralize(locale, entry, count) if count
-        entry = interpolate(locale, entry, values) if values
-        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 = I18n.t(:"#{type}.formats.#{key}", options.merge(:raise => true, :object => object, :locale => locale))
-        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
-
-      # Returns an array of locales for which translations are available
-      # ignoring the reserved translation meta data key :i18n.
-      def available_locales
-        raise NotImplementedError
-      end
-
-      def reload!
-        @skip_syntax_deprecation = false
-      end
-
-      protected
-
-        # The method which actually looks up for the translation in the store.
-        def lookup(locale, key, scope = [], options = {})
-          raise NotImplementedError
-        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)
-          return subject if options[:resolve] == false
-          case subject
-          when Symbol
-            I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
-          when Proc
-            date_or_time = options.delete(:object) || object
-            resolve(locale, object, subject.call(date_or_time, 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) && 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?
-          original_values = values.dup
-
-          preserve_encoding(string) do
-            string = string.gsub(DEPRECATED_INTERPOLATION_SYNTAX_PATTERN) do
-              escaped, key = $1, $2.to_sym
-              if escaped
-                "{{#{key}}}"
-              else
-                warn_syntax_deprecation!
-                "%{#{key}}"
-              end
-            end
-
-            keys = string.scan(INTERPOLATION_SYNTAX_PATTERN).flatten
-            return string if keys.empty?
-
-            values.each do |key, value|
-              if keys.include?(key.to_s)
-                value = value.call(values) if interpolate_lambda?(value, string, key)
-                value = value.to_s unless value.is_a?(::String)
-                values[key] = value
-              else
-                values.delete(key)
-              end
-            end
-
-            string % values
-          end
-        rescue KeyError => e
-          if string =~ RESERVED_KEYS_PATTERN
-            raise ReservedInterpolationKey.new($1.to_sym, string)
-          else
-            raise MissingInterpolationArgument.new(original_values, string)
-          end
-        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| store_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
-
-        def warn_syntax_deprecation! #:nodoc:
-          return if @skip_syntax_deprecation
-          warn "The {{key}} interpolation syntax in I18n messages is deprecated. Please use %{key} instead.\n#{caller.join("\n")}"
-          @skip_syntax_deprecation = true
-        end
-    end
-  end
-end