polish 0.0.5 → 0.1.0

data/lib/vendor/i18n/lib/i18n/backend/pluralization.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-
-# I18n locale fallbacks are useful when you want your application to use
-# translations from other locales when translations for the current locale are
-# missing. E.g. you might want to use :en translations when translations in
-# your applications main locale :de are missing.
-#
-# 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.send(: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 locale specific pluralizers
-      # and use them to pluralize the given entry.
-      #
-      # Pluralizers are expected to respond to #call(entry, 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] ||= lookup(locale, :"i18n.pluralize")
-        end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/backend/simple.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'i18n/backend/base'
-
-# Stub class for the Simple backend. The actual implementation is provided by
-# the backend Base class. This makes it easier to extend the Simple backend's
-# behaviour 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)
-
-module I18n
-  module Backend
-    class Simple < Base
-    end
-  end
-end

data/lib/vendor/i18n/lib/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, options)
-      @key, @locale, @options = key, locale, options
-      keys = I18n.send(:normalize_translation_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/vendor/i18n/lib/i18n/gettext.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Gettext
-    PLURAL_SEPARATOR  = "\001"
-    CONTEXT_SEPARATOR = "\004"
-
-    @@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 = nil)
-        scope = msgid.to_s.split(separator || '|')
-        msgid = scope.pop
-        [scope, msgid]
-      end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/helpers/gettext.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Helpers
-    # 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 Gettext
-      def _(msgid, options = {})
-        I18n.t(msgid, { :default => msgid, :separator => '|' }.merge(options))
-      end
-
-      def sgettext(msgid, separator = '|')
-        scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        I18n.t(msgid, :scope => scope, :default => msgid)
-      end
-
-      def pgettext(msgctxt, msgid, separator = I18n::Gettext::CONTEXT_SEPARATOR)
-        sgettext([msgctxt, msgid].join(separator), separator)
-      end
-
-      def ngettext(msgid, msgid_plural, n = 1)
-        nsgettext(msgid, msgid_plural, n, nil)
-      end
-
-      def nsgettext(msgid, msgid_plural, n = 1, separator = nil)
-        scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        default = { :one => msgid, :other => msgid_plural }
-        msgid = [msgid, I18n::Gettext::PLURAL_SEPARATOR, msgid_plural].join
-        I18n.t(msgid, :default => default, :count => n, :scope => scope)
-      end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/locale/fallbacks.rb

@@ -1,100 +0,0 @@
-# encoding: utf-8
-
-require 'i18n/locale/tag'
-
-# Locale Fallbacks
-#
-# Extends the I18n module to hold a fallbacks instance which is set to an
-# instance of I18n::Locale::Fallbacks by default but can be swapped with a
-# different implementation.
-#
-# Locale fallbacks will compute a number of fallback locales for a given locale.
-# For example:
-#
-# <pre><code>
-# I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :en] </code></pre>
-#
-# Locale fallbacks always fall back to
-#
-#   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
-#   * the current default locales and all of their parents second
-#
-# The default locales are set to [I18n.default_locale] by default but can be
-# set to something else.
-#
-# One can additionally add any number of additional fallback locales manually.
-# These will be added before the default locales to the fallback chain. For
-# example:
-#
-#   # using the default locale as default fallback locale
-#
-#   I18n.default_locale = :"en-US"
-#   I18n.fallbacks = I18n::Fallbacks.new(:"de-AT" => :"de-DE")
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :"de-DE", :de, :"en-US", :en]
-#
-#   # using a custom locale as default fallback locale
-#
-#   I18n.fallbacks = I18n::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"en-GB", :en]
-#   I18n.fallbacks[:"de-CH"] # => [:"de-CH", :de, :"en-GB", :en]
-#
-#   # mapping fallbacks to an existing instance
-#
-#   # people speaking Catalan also speak Spanish as spoken in Spain
-#   fallbacks = I18n.fallbacks
-#   fallbacks.map(:ca => :"es-ES") 
-#   fallbacks[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
-#
-#   # people speaking Arabian as spoken in Palestine also speak Hebrew as spoken in Israel
-#   fallbacks.map(:"ar-PS" => :"he-IL")
-#   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
-#   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
-#
-#   # people speaking Sami as spoken in Finnland also speak Swedish and Finnish as spoken in Finnland
-#   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
-#   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
-
-module I18n
-  module Locale
-    class Fallbacks < Hash
-      def initialize(*mappings)
-        @map = {}
-        map(mappings.pop) if mappings.last.is_a?(Hash)
-        self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
-      end
-
-      def defaults=(defaults)
-        @defaults = defaults.map { |default| compute(default, false) }.flatten
-      end
-      attr_reader :defaults
-
-      def [](locale)
-        raise InvalidLocale.new(locale) if locale.nil?
-        locale = locale.to_sym
-        super || store(locale, compute(locale))
-      end
-
-      def map(mappings)
-        mappings.each do |from, to|
-          from, to = from.to_sym, Array(to)
-          to.each do |to|
-            @map[from] ||= []
-            @map[from] << to.to_sym
-          end
-        end
-      end
-
-      protected
-
-      def compute(tags, include_defaults = true)
-        result = Array(tags).collect do |tag|
-          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym }
-          tags.each { |tag| tags += compute(@map[tag]) if @map[tag] }
-          tags
-        end.flatten
-        result.push(*defaults) if include_defaults
-        result.uniq
-      end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/locale/tag.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-require 'i18n/locale/tag/simple'
-require 'i18n/locale/tag/rfc4646'
-
-module I18n
-  module Locale
-    module Tag
-      class << self
-        # Returns the current locale tag implementation. Defaults to +I18n::Locale::Tag::Simple+.
-        def implementation
-          @@implementation ||= Simple
-        end
-  
-        # Sets the current locale tag implementation. Use this to set a different locale tag implementation.
-        def implementation=(implementation)
-          @@implementation = implementation
-        end
-  
-        # Factory method for locale tags. Delegates to the current locale tag implementation.
-        def tag(tag)
-          implementation.tag(tag)
-        end
-      end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/locale/tag/parents.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Locale
-    module Tag
-      module Parents
-        def parent
-          @parent ||= begin
-            segs = to_a.compact
-            segs.length > 1 ? self.class.tag(*segs[0..(segs.length-2)].join('-')) : nil
-          end
-        end
-      
-        def self_and_parents
-          @self_and_parents ||= [self] + parents
-        end
-      
-        def parents
-          @parents ||= ([parent] + (parent ? parent.parents : [])).compact
-        end
-      end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/locale/tag/rfc4646.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-
-# RFC 4646/47 compliant Locale tag implementation that parses locale tags to 
-# subtags such as language, script, region, variant etc.
-#
-# For more information see by http://en.wikipedia.org/wiki/IETF_language_tag
-#
-# Rfc4646::Parser does not implement grandfathered tags.
-
-require 'i18n/locale/tag/parents'
-
-module I18n
-  module Locale
-    module Tag
-      RFC4646_SUBTAGS = [ :language, :script, :region, :variant, :extension, :privateuse, :grandfathered ]
-      RFC4646_FORMATS = { :language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase }
-
-      class Rfc4646 < Struct.new(*RFC4646_SUBTAGS)
-        class << self
-          # Parses the given tag and returns a Tag instance if it is valid. 
-          # Returns false if the given tag is not valid according to RFC 4646.
-          def tag(tag)
-            matches = parser.match(tag)
-            new(*matches) if matches
-          end
-
-          def parser
-            @@parser ||= Rfc4646::Parser
-          end
-  
-          def parser=(parser)
-            @@parser = parser
-          end
-        end
-
-        include Parents
-
-        RFC4646_FORMATS.each do |name, format|
-          define_method(name) { self[name].send(format) unless self[name].nil? }
-        end
-      
-        def to_sym
-          to_s.to_sym
-        end
-      
-        def to_s
-          @tag ||= to_a.compact.join("-")
-        end
-  
-        def to_a
-          members.collect { |attr| self.send(attr) }
-        end
-  
-        module Parser
-          PATTERN = %r{\A(?:
-            ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
-            (?:-([a-z]{4}))?                                        # script
-            (?:-([a-z]{2}|\d{3}))?                                  # region
-            (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
-            (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
-            (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
-            (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
-            /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
-            )\z}xi 
-
-          class << self
-            def match(tag)
-              c = PATTERN.match(tag.to_s).captures
-              c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
-            rescue
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vendor/i18n/lib/i18n/locale/tag/simple.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-require 'i18n/locale/tag/parents'
-
-# Simple Locale tag implementation that computes subtags by simply splitting
-# the locale tag at '-' occurences.
-
-module I18n
-  module Locale
-    module Tag
-      class Simple
-        class << self
-          def tag(tag)
-            new(tag)
-          end
-        end
-
-        include Parents
-
-        attr_reader :tag
-
-        def initialize(*tag)
-          @tag = tag.join('-').to_sym
-        end
-
-        def subtags
-          @subtags = tag.to_s.split('-').map { |subtag| subtag.to_s }
-        end
-
-        def to_sym
-          tag
-        end
-
-        def to_s
-          tag.to_s
-        end
-
-        def to_a
-          subtags
-        end
-      end
-    end
-  end
-end