activesupport 2.3.18 → 3.0.0.beta

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

@@ -1,87 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Backend
-    # A simple backend that reads translations from YAML files and stores them in
-    # an in-memory hash. Relies on the Base backend.
-    #
-    # The implementation is provided by a Implementation module allowing to easily
-    # extend Simple backend's behavior by including modules. E.g.:
-    #
-    # module I18n::Backend::Pluralization
-    #   def pluralize(*args)
-    #     # extended pluralization logic
-    #     super
-    #   end
-    # end
-    #
-    # I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
-    class Simple
-      module Implementation
-        include Base
-
-        def initialized?
-          @initialized ||= false
-        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 = {})
-          locale = locale.to_sym
-          translations[locale] ||= {}
-          data = data.deep_symbolize_keys
-          translations[locale].deep_merge!(data)
-        end
-
-        # Get available locales from the translations hash
-        def available_locales
-          init_translations unless initialized?
-          translations.inject([]) do |locales, (locale, data)|
-            locales << locale unless (data.keys - [:i18n]).empty?
-            locales
-          end
-        end
-
-        # Clean up translations hash and set initialized to false on reload!
-        def reload!
-          @initialized = false
-          @translations = nil
-          super
-        end
-
-      protected
-
-        def init_translations
-          load_translations
-          @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 = [], options = {})
-          init_translations unless initialized?
-          keys = I18n.normalize_keys(locale, key, scope, options[: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, options.merge(:scope => nil)) if result.is_a?(Symbol)
-            result
-          end
-        end
-      end
-
-      include Implementation
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# encoding: utf-8
-module I18n
-  module Backend
-    module Transliterator
-      DEFAULT_REPLACEMENT_CHAR = "?"
-
-      # Given a locale and a UTF-8 string, return the locale's ASCII
-      # approximation for the string.
-      def transliterate(locale, string, replacement = nil)
-        @transliterators ||= {}
-        @transliterators[locale] ||= Transliterator.get I18n.t(:'i18n.transliterate.rule',
-          :locale => locale, :resolve => false, :default => {})
-        @transliterators[locale].transliterate(string, replacement)
-      end
-
-      # Get a transliterator instance.
-      def self.get(rule = nil)
-        if !rule || rule.kind_of?(Hash)
-          HashTransliterator.new(rule)
-        elsif rule.kind_of? Proc
-          ProcTransliterator.new(rule)
-        else
-          raise I18n::ArgumentError, "Transliteration rule must be a proc or a hash."
-        end
-      end
-
-      # A transliterator which accepts a Proc as its transliteration rule.
-      class ProcTransliterator
-        def initialize(rule)
-          @rule = rule
-        end
-
-        def transliterate(string, replacement = nil)
-          @rule.call(string)
-        end
-      end
-
-      # A transliterator which accepts a Hash of characters as its translation
-      # rule.
-      class HashTransliterator
-        DEFAULT_APPROXIMATIONS = {
-          "À"=>"A", "Á"=>"A", "Â"=>"A", "Ã"=>"A", "Ä"=>"A", "Å"=>"A", "Æ"=>"AE",
-          "Ç"=>"C", "È"=>"E", "É"=>"E", "Ê"=>"E", "Ë"=>"E", "Ì"=>"I", "Í"=>"I",
-          "Î"=>"I", "Ï"=>"I", "Ð"=>"D", "Ñ"=>"N", "Ò"=>"O", "Ó"=>"O", "Ô"=>"O",
-          "Õ"=>"O", "Ö"=>"O", "×"=>"x", "Ø"=>"O", "Ù"=>"U", "Ú"=>"U", "Û"=>"U",
-          "Ü"=>"U", "Ý"=>"Y", "Þ"=>"Th", "ß"=>"ss", "à"=>"a", "á"=>"a", "â"=>"a",
-          "ã"=>"a", "ä"=>"a", "å"=>"a", "æ"=>"ae", "ç"=>"c", "è"=>"e", "é"=>"e",
-          "ê"=>"e", "ë"=>"e", "ì"=>"i", "í"=>"i", "î"=>"i", "ï"=>"i", "ð"=>"d",
-          "ñ"=>"n", "ò"=>"o", "ó"=>"o", "ô"=>"o", "õ"=>"o", "ö"=>"o", "ø"=>"o",
-          "ù"=>"u", "ú"=>"u", "û"=>"u", "ü"=>"u", "ý"=>"y", "þ"=>"th", "ÿ"=>"y",
-          "Ā"=>"A", "ā"=>"a", "Ă"=>"A", "ă"=>"a", "Ą"=>"A", "ą"=>"a", "Ć"=>"C",
-          "ć"=>"c", "Ĉ"=>"C", "ĉ"=>"c", "Ċ"=>"C", "ċ"=>"c", "Č"=>"C", "č"=>"c",
-          "Ď"=>"D", "ď"=>"d", "Đ"=>"D", "đ"=>"d", "Ē"=>"E", "ē"=>"e", "Ĕ"=>"E",
-          "ĕ"=>"e", "Ė"=>"E", "ė"=>"e", "Ę"=>"E", "ę"=>"e", "Ě"=>"E", "ě"=>"e",
-          "Ĝ"=>"G", "ĝ"=>"g", "Ğ"=>"G", "ğ"=>"g", "Ġ"=>"G", "ġ"=>"g", "Ģ"=>"G",
-          "ģ"=>"g", "Ĥ"=>"H", "ĥ"=>"h", "Ħ"=>"H", "ħ"=>"h", "Ĩ"=>"I", "ĩ"=>"i",
-          "Ī"=>"I", "ī"=>"i", "Ĭ"=>"I", "ĭ"=>"i", "Į"=>"I", "į"=>"i", "İ"=>"I",
-          "ı"=>"i", "IJ"=>"IJ", "ij"=>"ij", "Ĵ"=>"J", "ĵ"=>"j", "Ķ"=>"K", "ķ"=>"k",
-          "ĸ"=>"k", "Ĺ"=>"L", "ĺ"=>"l", "Ļ"=>"L", "ļ"=>"l", "Ľ"=>"L", "ľ"=>"l",
-          "Ŀ"=>"L", "ŀ"=>"l", "Ł"=>"L", "ł"=>"l", "Ń"=>"N", "ń"=>"n", "Ņ"=>"N",
-          "ņ"=>"n", "Ň"=>"N", "ň"=>"n", "ʼn"=>"'n", "Ŋ"=>"NG", "ŋ"=>"ng",
-          "Ō"=>"O", "ō"=>"o", "Ŏ"=>"O", "ŏ"=>"o", "Ő"=>"O", "ő"=>"o", "Œ"=>"OE",
-          "œ"=>"oe", "Ŕ"=>"R", "ŕ"=>"r", "Ŗ"=>"R", "ŗ"=>"r", "Ř"=>"R", "ř"=>"r",
-          "Ś"=>"S", "ś"=>"s", "Ŝ"=>"S", "ŝ"=>"s", "Ş"=>"S", "ş"=>"s", "Š"=>"S",
-          "š"=>"s", "Ţ"=>"T", "ţ"=>"t", "Ť"=>"T", "ť"=>"t", "Ŧ"=>"T", "ŧ"=>"t",
-          "Ũ"=>"U", "ũ"=>"u", "Ū"=>"U", "ū"=>"u", "Ŭ"=>"U", "ŭ"=>"u", "Ů"=>"U",
-          "ů"=>"u", "Ű"=>"U", "ű"=>"u", "Ų"=>"U", "ų"=>"u", "Ŵ"=>"W", "ŵ"=>"w",
-          "Ŷ"=>"Y", "ŷ"=>"y", "Ÿ"=>"Y", "Ź"=>"Z", "ź"=>"z", "Ż"=>"Z", "ż"=>"z",
-          "Ž"=>"Z", "ž"=>"z"
-        }
-
-        def initialize(rule = nil)
-          @rule = rule
-          add DEFAULT_APPROXIMATIONS
-          add rule if rule
-        end
-
-        def transliterate(string, replacement = nil)
-          string.gsub(/[^\x00-\x7f]/u) do |char|
-            approximations[char] || replacement || DEFAULT_REPLACEMENT_CHAR
-          end
-        end
-
-        private
-
-          def approximations
-            @approximations ||= {}
-          end
-
-          # Add transliteration rules to the approximations hash.
-          def add(hash)
-            hash.keys.each {|key| hash[key.to_s] = hash.delete(key).to_s}
-            approximations.merge! hash
-          end
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-module I18n
-  class Config
-    # The only configuration value that is not global and scoped to thread is :locale.
-    # It defaults to the default_locale.
-    def locale
-      @locale ||= default_locale
-    end
-
-    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
-    def locale=(locale)
-      @locale = locale.to_sym rescue nil
-    end
-
-    # Returns the current backend. Defaults to +Backend::Simple+.
-    def backend
-      @@backend ||= Backend::Simple.new
-    end
-
-    # Sets the current backend. Used to set a custom backend.
-    def backend=(backend)
-      @@backend = backend
-    end
-
-    # Returns the current default locale. Defaults to :'en'
-    def default_locale
-      @@default_locale ||= :en
-    end
-
-    # Sets the current default locale. Used to set a custom default locale.
-    def default_locale=(locale)
-      @@default_locale = locale.to_sym rescue nil
-    end
-
-    # Returns an array of locales for which translations are available.
-    # Unless you explicitely set the these through I18n.available_locales=
-    # the call will be delegated to the backend and memoized on the I18n module.
-    def available_locales
-      @@available_locales ||= backend.available_locales
-    end
-
-    # Sets the available locales.
-    def available_locales=(locales)
-      @@available_locales = locales
-    end
-
-    # Returns the current default scope separator. Defaults to '.'
-    def default_separator
-      @@default_separator ||= '.'
-    end
-
-    # Sets the current default scope separator.
-    def default_separator=(separator)
-      @@default_separator = separator
-    end
-
-    # Return the current exception handler. Defaults to :default_exception_handler.
-    def exception_handler
-      @@exception_handler ||= :default_exception_handler
-    end
-
-    # Sets the exception handler.
-    def exception_handler=(exception_handler)
-      @@exception_handler = exception_handler
-    end
-
-    # Allow clients to register paths providing translation data sources. The
-    # backend defines acceptable sources.
-    #
-    # E.g. the provided SimpleBackend accepts a list of paths to translation
-    # files which are either named *.rb and contain plain Ruby Hashes or are
-    # named *.yml and contain YAML data. So for the SimpleBackend clients may
-    # register translation files like this:
-    #   I18n.load_path << 'path/to/locale/en.yml'
-    def load_path
-      @@load_path ||= []
-    end
-
-    # Sets the load path instance. Custom implementations are expected to
-    # behave like a Ruby Array.
-    def load_path=(load_path)
-      @@load_path = load_path
-    end
-  end
-end

data/lib/active_support/vendor/i18n-0.4.1/i18n/core_ext/hash.rb

@@ -1,29 +0,0 @@
-class Hash
-  def slice(*keep_keys)
-    h = {}
-    keep_keys.each { |key| h[key] = fetch(key) }
-    h
-  end unless Hash.method_defined?(:slice)
-
-  def except(*less_keys)
-    slice(*keys - less_keys)
-  end unless Hash.method_defined?(:except)
-
-  def deep_symbolize_keys
-    inject({}) { |result, (key, value)|
-      value = value.deep_symbolize_keys if value.is_a?(Hash)
-      result[(key.to_sym rescue key) || key] = value
-      result
-    }
-  end unless Hash.method_defined?(:deep_symbolize_keys)
-
-  # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-  MERGER = proc do |key, v1, v2|
-    Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : v2
-  end
-  
-  def deep_merge!(data)
-    merge!(data, &MERGER)
-  end unless Hash.method_defined?(:deep_merge!)
-end
-

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

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-class KeyError < IndexError
-  def initialize(message = nil)
-    super(message || "key not found")
-  end
-end unless defined?(KeyError)
-
-module I18n
-  class ArgumentError < ::ArgumentError; end
-
-  class InvalidLocale < ArgumentError
-    attr_reader :locale
-    def initialize(locale)
-      @locale = locale
-      super "#{locale.inspect} is not a valid locale"
-    end
-  end
-
-  class MissingTranslationData < ArgumentError
-    attr_reader :locale, :key, :options
-    def initialize(locale, key, opts = nil)
-      @key, @locale, @options = key, locale, opts || {}
-      keys = I18n.normalize_keys(locale, key, options[:scope])
-      keys << 'no key' if keys.size < 2
-      super "translation missing: #{keys.join(', ')}"
-    end
-  end
-
-  class InvalidPluralizationData < ArgumentError
-    attr_reader :entry, :count
-    def initialize(entry, count)
-      @entry, @count = entry, count
-      super "translation data #{entry.inspect} can not be used with :count => #{count}"
-    end
-  end
-
-  class MissingInterpolationArgument < ArgumentError
-    attr_reader :values, :string
-    def initialize(values, string)
-      @values, @string = values, string
-      super "missing interpolation argument in #{string.inspect} (#{values.inspect} given)"
-    end
-  end
-
-  class ReservedInterpolationKey < ArgumentError
-    attr_reader :key, :string
-    def initialize(key, string)
-      @key, @string = key, string
-      super "reserved key #{key.inspect} used in #{string.inspect}"
-    end
-  end
-
-  class UnknownFileType < ArgumentError
-    attr_reader :type, :filename
-    def initialize(type, filename)
-      @type, @filename = type, filename
-      super "can not load translations from #{filename}, the file type #{type} is not known"
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Gettext
-    PLURAL_SEPARATOR  = "\001"
-    CONTEXT_SEPARATOR = "\004"
-
-    autoload :Helpers, 'i18n/gettext/helpers'
-
-    @@plural_keys = { :en => [:one, :other] }
-
-    class << self
-      # returns an array of plural keys for the given locale so that we can
-      # convert from gettext's integer-index based style
-      # TODO move this information to the pluralization module
-      def plural_keys(locale)
-        @@plural_keys[locale] || @@plural_keys[:en]
-      end
-
-      def extract_scope(msgid, separator)
-        scope = msgid.to_s.split(separator)
-        msgid = scope.pop
-        [scope, msgid]
-      end
-    end
-  end
-end

data/lib/active_support/vendor/i18n-0.4.1/i18n/gettext/helpers.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-require 'i18n/gettext'
-
-module I18n
-  module Gettext
-    # Implements classical Gettext style accessors. To use this include the
-    # module to the global namespace or wherever you want to use it.
-    #
-    #   include I18n::Helpers::Gettext
-    module Helpers
-      def gettext(msgid, options = {})
-        I18n.t(msgid, { :default => msgid, :separator => '|' }.merge(options))
-      end
-      alias _ gettext
-
-      def sgettext(msgid, separator = '|')
-        scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        I18n.t(msgid, :scope => scope, :default => msgid, :separator => separator)
-      end
-      alias s_ sgettext
-
-      def pgettext(msgctxt, msgid)
-        separator = I18n::Gettext::CONTEXT_SEPARATOR
-        sgettext([msgctxt, msgid].join(separator), separator)
-      end
-      alias p_ pgettext
-
-      def ngettext(msgid, msgid_plural, n = 1)
-        nsgettext(msgid, msgid_plural, n)
-      end
-      alias n_ ngettext
-
-      # Method signatures:
-      #   nsgettext('Fruits|apple', 'apples', 2)
-      #   nsgettext(['Fruits|apple', 'apples'], 2)
-      def nsgettext(msgid, msgid_plural, n = 1, separator = '|')
-        if msgid.is_a?(Array)
-          msgid, msgid_plural, n, separator = msgid[0], msgid[1], msgid_plural, n
-          separator = '|' unless separator.is_a?(::String)
-        end
-
-        scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        default = { :one => msgid, :other => msgid_plural }
-        I18n.t(msgid, :default => default, :count => n, :scope => scope, :separator => separator)
-      end
-      alias ns_ nsgettext
-
-      # Method signatures:
-      #   npgettext('Fruits', 'apple', 'apples', 2)
-      #   npgettext('Fruits', ['apple', 'apples'], 2)
-      def npgettext(msgctxt, msgid, msgid_plural, n = 1)
-        separator = I18n::Gettext::CONTEXT_SEPARATOR
-
-        if msgid.is_a?(Array)
-          msgid_plural, msgid, n = msgid[1], [msgctxt, msgid[0]].join(separator), msgid_plural
-        else
-          msgid = [msgctxt, msgid].join(separator)
-        end
-
-        nsgettext(msgid, msgid_plural, n, separator)
-      end
-      alias np_ npgettext
-    end
-  end
-end