lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/i18n-0.8.1/lib/i18n/backend/memoize.rb

@@ -1,46 +0,0 @@
-# Memoize module simply memoizes the values returned by lookup using
-# a flat hash and can tremendously speed up the lookup process in a backend.
-#
-# To enable it you can simply include the Memoize module to your backend:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Memoize)
-#
-# Notice that it's the responsibility of the backend to define whenever the
-# cache should be cleaned.
-module I18n
-  module Backend
-    module Memoize
-      def available_locales
-        @memoized_locales ||= super
-      end
-
-      def store_translations(locale, data, options = {})
-        reset_memoizations!(locale)
-        super
-      end
-
-      def reload!
-        reset_memoizations!
-        super
-      end
-
-      protected
-
-        def lookup(locale, key, scope = nil, options = {})
-          flat_key  = I18n::Backend::Flatten.normalize_flat_keys(locale,
-            key, scope, options[:separator]).to_sym
-          flat_hash = memoized_lookup[locale.to_sym]
-          flat_hash.key?(flat_key) ? flat_hash[flat_key] : (flat_hash[flat_key] = super)
-        end
-
-        def memoized_lookup
-          @memoized_lookup ||= Hash.new { |h, k| h[k] = {} }
-        end
-
-        def reset_memoizations!(locale=nil)
-          @memoized_locales = nil
-          (locale ? memoized_lookup[locale.to_sym] : memoized_lookup).clear
-        end
-    end
-  end
-end

data/vendor/bundle/gems/i18n-0.8.1/lib/i18n/backend/metadata.rb

@@ -1,69 +0,0 @@
-# I18n translation metadata is useful when you want to access information
-# about how a translation was looked up, pluralized or interpolated in
-# your application.
-#
-#   msg = I18n.t(:message, :default => 'Hi!', :scope => :foo)
-#   msg.translation_metadata
-#   # => { :key => :message, :scope => :foo, :default => 'Hi!' }
-#
-# If a :count option was passed to #translate it will be set to the metadata.
-# Likewise, if any interpolation variables were passed they will also be set.
-#
-# To enable translation metadata you can simply include the Metadata module
-# into the Simple backend class - or whatever other backend you are using:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Metadata)
-#
-module I18n
-  module Backend
-    module Metadata
-      class << self
-        def included(base)
-          Object.class_eval do
-            def translation_metadata
-              unless self.frozen?
-                @translation_metadata ||= {}
-              else
-                {}
-              end
-            end
-
-            def translation_metadata=(translation_metadata)
-              @translation_metadata = translation_metadata unless self.frozen?
-            end
-          end unless Object.method_defined?(:translation_metadata)
-        end
-      end
-
-      def translate(locale, key, options = {})
-        metadata = {
-          :locale    => locale,
-          :key       => key,
-          :scope     => options[:scope],
-          :default   => options[:default],
-          :separator => options[:separator],
-          :values    => options.reject { |name, value| RESERVED_KEYS.include?(name) }
-        }
-        with_metadata(metadata) { super }
-      end
-
-      def interpolate(locale, entry, values = {})
-        metadata = entry.translation_metadata.merge(:original => entry)
-        with_metadata(metadata) { super }
-      end
-
-      def pluralize(locale, entry, count)
-        with_metadata(:count => count) { super }
-      end
-
-      protected
-
-        def with_metadata(metadata, &block)
-          result = yield
-          result.translation_metadata = result.translation_metadata.merge(metadata) if result
-          result
-        end
-
-    end
-  end
-end

data/vendor/bundle/gems/i18n-0.8.1/lib/i18n/backend/pluralization.rb

@@ -1,53 +0,0 @@
-# I18n Pluralization are useful when you want your application to
-# customize pluralization rules.
-#
-# To enable locale specific pluralizations you can simply include the
-# Pluralization module to the Simple backend - or whatever other backend you
-# are using.
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Pluralization)
-#
-# You also need to make sure to provide pluralization algorithms to the
-# backend, i.e. include them to your I18n.load_path accordingly.
-module I18n
-  module Backend
-    module Pluralization
-      # Overwrites the Base backend translate method so that it will check the
-      # translation meta data space (:i18n) for a locale specific pluralization
-      # rule and use it to pluralize the given entry. I.e. the library expects
-      # pluralization rules to be stored at I18n.t(:'i18n.plural.rule')
-      #
-      # Pluralization rules are expected to respond to #call(count) and
-      # return a pluralization key. Valid keys depend on the translation data
-      # hash (entry) but it is generally recommended to follow CLDR's style,
-      # i.e., return one of the keys :zero, :one, :few, :many, :other.
-      #
-      # The :zero key is always picked directly when count equals 0 AND the
-      # translation data has the key :zero. This way translators are free to
-      # either pick a special :zero translation even for languages where the
-      # pluralizer does not return a :zero key.
-      def pluralize(locale, entry, count)
-        return entry unless entry.is_a?(Hash) and count
-
-        pluralizer = pluralizer(locale)
-        if pluralizer.respond_to?(:call)
-          key = count == 0 && entry.has_key?(:zero) ? :zero : pluralizer.call(count)
-          raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
-          entry[key]
-        else
-          super
-        end
-      end
-
-      protected
-
-        def pluralizers
-          @pluralizers ||= {}
-        end
-
-        def pluralizer(locale)
-          pluralizers[locale] ||= I18n.t(:'i18n.plural.rule', :locale => locale, :resolve => false)
-        end
-    end
-  end
-end

data/vendor/bundle/gems/i18n-0.8.1/lib/i18n/backend/simple.rb

@@ -1,87 +0,0 @@
-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.include(I18n::Backend::Pluralization)
-    class Simple
-      (class << self; self; end).class_eval { public :include }
-
-      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
-        # either 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/vendor/bundle/gems/i18n-0.8.1/lib/i18n/backend/transliterator.rb

@@ -1,106 +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"
-        }.freeze
-
-        def initialize(rule = nil)
-          @rule = rule
-          add_default_approximations
-          add rule if rule
-        end
-
-        def transliterate(string, replacement = nil)
-          replacement ||= DEFAULT_REPLACEMENT_CHAR
-          string.gsub(/[^\x00-\x7f]/u) do |char|
-            approximations[char] || replacement
-          end
-        end
-
-        private
-
-        def approximations
-          @approximations ||= {}
-        end
-
-        def add_default_approximations
-          DEFAULT_APPROXIMATIONS.each do |key, value|
-            approximations[key] = value
-          end
-        end
-
-        # Add transliteration rules to the approximations hash.
-        def add(hash)
-          hash.each do |key, value|
-            approximations[key.to_s] = value.to_s
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/i18n-0.8.1/lib/i18n/config.rb

@@ -1,142 +0,0 @@
-require 'set'
-
-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
-      defined?(@locale) && @locale ? @locale : default_locale
-    end
-
-    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
-    def locale=(locale)
-      I18n.enforce_available_locales!(locale)
-      @locale = locale && locale.to_sym
-    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)
-      I18n.enforce_available_locales!(locale)
-      @@default_locale = locale && locale.to_sym
-    end
-
-    # Returns an array of locales for which translations are available.
-    # Unless you explicitely set these through I18n.available_locales=
-    # the call will be delegated to the backend.
-    def available_locales
-      @@available_locales ||= nil
-      @@available_locales || backend.available_locales
-    end
-
-    # Caches the available locales list as both strings and symbols in a Set, so
-    # that we can have faster lookups to do the available locales enforce check.
-    def available_locales_set #:nodoc:
-      @@available_locales_set ||= available_locales.inject(Set.new) do |set, locale|
-        set << locale.to_s << locale.to_sym
-      end
-    end
-
-    # Sets the available locales.
-    def available_locales=(locales)
-      @@available_locales = Array(locales).map { |locale| locale.to_sym }
-      @@available_locales = nil if @@available_locales.empty?
-      @@available_locales_set = nil
-    end
-
-    # Clears the available locales set so it can be recomputed again after I18n
-    # gets reloaded.
-    def clear_available_locales_set #:nodoc:
-      @@available_locales_set = nil
-    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
-
-    # Returns the current exception handler. Defaults to an instance of
-    # I18n::ExceptionHandler.
-    def exception_handler
-      @@exception_handler ||= ExceptionHandler.new
-    end
-
-    # Sets the exception handler.
-    def exception_handler=(exception_handler)
-      @@exception_handler = exception_handler
-    end
-
-    # Returns the current handler for situations when interpolation argument
-    # is missing. MissingInterpolationArgument will be raised by default.
-    def missing_interpolation_argument_handler
-      @@missing_interpolation_argument_handler ||= lambda do |missing_key, provided_hash, string|
-        raise MissingInterpolationArgument.new(missing_key, provided_hash, string)
-      end
-    end
-
-    # Sets the missing interpolation argument handler. It can be any
-    # object that responds to #call. The arguments that will be passed to #call
-    # are the same as for MissingInterpolationArgument initializer. Use +Proc.new+
-    # if you don't care about arity.
-    #
-    # == Example:
-    # You can supress raising an exception and return string instead:
-    #
-    #   I18n.config.missing_interpolation_argument_handler = Proc.new do |key|
-    #     "#{key} is missing"
-    #   end
-    def missing_interpolation_argument_handler=(exception_handler)
-      @@missing_interpolation_argument_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
-      @@available_locales_set = nil
-      backend.reload!
-    end
-
-    # Whether or not to verify if locales are in the list of available locales.
-    # Defaults to true.
-    @@enforce_available_locales = true
-    def enforce_available_locales
-      @@enforce_available_locales
-    end
-
-    def enforce_available_locales=(enforce_available_locales)
-      @@enforce_available_locales = enforce_available_locales
-    end
-  end
-end