ric 0.12.0 → 0.14.1

data/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/README.md

@@ -0,0 +1,122 @@
+# Ruby I18n
+
+[![Build Status](https://github.com/ruby-i18n/i18n/workflows/Ruby/badge.svg)](https://github.com/ruby-i18n/i18n/actions?query=workflow%3ARuby)
+
+Ruby internationalization and localization (i18n) solution.
+
+Currently maintained by @radar.
+
+## Usage
+
+### Rails
+
+You will most commonly use this library within a Rails app.
+
+[See the Rails Guide](https://guides.rubyonrails.org/i18n.html) for an example of its usage.
+
+### Ruby (without Rails)
+
+If you want to use this library without Rails, you can simply add `i18n` to your `Gemfile`:
+
+```ruby
+gem 'i18n'
+```
+
+Then configure I18n with some translations, and a default locale:
+
+```ruby
+I18n.load_path << Dir[File.expand_path("config/locales") + "/*.yml"]
+I18n.default_locale = :en # (note that `en` is already the default!)
+```
+
+A simple translation file in your project might live at `config/locales/en.yml` and look like:
+
+```yml
+en:
+  test: "This is a test"
+```
+
+You can then access this translation by doing:
+
+```ruby
+I18n.t(:test)
+```
+
+You can switch locales in your project by setting `I18n.locale` to a different value:
+
+```ruby
+I18n.locale = :de
+I18n.t(:test) # => "Dies ist ein Test"
+```
+
+## Features
+
+* Translation and localization
+* Interpolation of values to translations
+* Pluralization (CLDR compatible)
+* Customizable transliteration to ASCII
+* Flexible defaults
+* Bulk lookup
+* Lambdas as translation data
+* Custom key/scope separator
+* Custom exception handlers
+* Extensible architecture with a swappable backend
+
+## Pluggable Features
+
+* Cache
+* Pluralization: lambda pluralizers stored as translation data
+* Locale fallbacks, RFC4647 compliant (optionally: RFC4646 locale validation)
+* [Gettext support](https://github.com/ruby-i18n/i18n/wiki/Gettext)
+* Translation metadata
+
+## Alternative Backend
+
+* Chain
+* ActiveRecord (optionally: ActiveRecord::Missing and ActiveRecord::StoreProcs)
+* KeyValue (uses active_support/json and cannot store procs)
+
+For more information and lots of resources see [the 'Resources' page on the wiki](https://github.com/ruby-i18n/i18n/wiki/Resources).
+
+## Tests
+
+You can run tests both with
+
+* `rake test` or just `rake`
+* run any test file directly, e.g. `ruby -Ilib:test test/api/simple_test.rb`
+
+You can run all tests against all Gemfiles with
+
+* `ruby test/run_all.rb`
+
+The structure of the test suite is a bit unusual as it uses modules to reuse
+particular tests in different test cases.
+
+The reason for this is that we need to enforce the I18n API across various
+combinations of extensions. E.g. the Simple backend alone needs to support
+the same API as any combination of feature and/or optimization modules included
+to the Simple backend. We test this by reusing the same API definition (implemented
+as test methods) in test cases with different setups.
+
+You can find the test cases that enforce the API in test/api. And you can find
+the API definition test methods in test/api/tests.
+
+All other test cases (e.g. as defined in test/backend, test/core_ext) etc.
+follow the usual test setup and should be easy to grok.
+
+## More Documentation
+
+Additional documentation can be found here: https://github.com/ruby-i18n/i18n/wiki
+
+## Contributors
+
+* @radar
+* @carlosantoniodasilva
+* @josevalim
+* @knapo
+* @tigrish
+* [and many more](https://github.com/ruby-i18n/i18n/graphs/contributors)
+
+## License
+
+MIT License. See the included MIT-LICENSE file.

data/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/lib/i18n/backend/base.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+require 'i18n/core_ext/hash'
+
+module I18n
+  module Backend
+    module Base
+      using I18n::HashRefinements
+      include I18n::Backend::Transliterator
+
+      # Accepts a list of paths to translation files. Loads translations from
+      # plain Ruby (*.rb), YAML files (*.yml), or JSON files (*.json). See #load_rb, #load_yml, and #load_json
+      # for details.
+      def load_translations(*filenames)
+        filenames = I18n.load_path if filenames.empty?
+        filenames.flatten.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 = EMPTY_HASH)
+        raise NotImplementedError
+      end
+
+      def translate(locale, key, options = EMPTY_HASH)
+        raise I18n::ArgumentError if (key.is_a?(String) || key.is_a?(Symbol)) && key.empty?
+        raise InvalidLocale.new(locale) unless locale
+        return nil if key.nil? && !options.key?(:default)
+
+        entry = lookup(locale, key, options[:scope], options) unless key.nil?
+
+        if entry.nil? && options.key?(:default)
+          entry = default(locale, key, options[:default], options)
+        else
+          entry = resolve(locale, key, entry, options)
+        end
+
+        count = options[:count]
+
+        if entry.nil? && (subtrees? || !count)
+          if (options.key?(:default) && !options[:default].nil?) || !options.key?(:default)
+            throw(:exception, I18n::MissingTranslation.new(locale, key, options))
+          end
+        end
+
+        entry = entry.dup if entry.is_a?(String)
+        entry = pluralize(locale, entry, count) if count
+
+        if entry.nil? && !subtrees?
+          throw(:exception, I18n::MissingTranslation.new(locale, key, options))
+        end
+
+        deep_interpolation = options[:deep_interpolation]
+        values = options.except(*RESERVED_KEYS)
+        if values
+          entry = if deep_interpolation
+            deep_interpolate(locale, entry, values)
+          else
+            interpolate(locale, entry, values)
+          end
+        end
+        entry
+      end
+
+      def exists?(locale, key, options = EMPTY_HASH)
+        lookup(locale, key) != nil
+      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 = EMPTY_HASH)
+        if object.nil? && options.include?(:default)
+          return options[:default]
+        end
+        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'
+          options = options.merge(:raise => true, :object => object, :locale => locale)
+          format  = I18n.t(:"#{type}.formats.#{key}", **options)
+        end
+
+        format = translate_localization_format(locale, object, format, options)
+        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!
+        eager_load! if eager_loaded?
+      end
+
+      def eager_load!
+        @eager_loaded = true
+      end
+
+      protected
+
+        def eager_loaded?
+          @eager_loaded ||= false
+        end
+
+        # The method which actually looks up for the translation in the store.
+        def lookup(locale, key, scope = [], options = EMPTY_HASH)
+          raise NotImplementedError
+        end
+
+        def subtrees?
+          true
+        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 = EMPTY_HASH)
+          options = options.reject { |key, value| key == :default }
+          case subject
+          when Array
+            subject.each do |item|
+              result = resolve(locale, object, item, options)
+              return result unless result.nil?
+            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 = EMPTY_HASH)
+          return subject if options[:resolve] == false
+          result = catch(:exception) do
+            case subject
+            when Symbol
+              I18n.translate(subject, **options.merge(:locale => locale, :throw => true))
+            when Proc
+              date_or_time = options.delete(:object) || object
+              resolve(locale, object, subject.call(date_or_time, **options))
+            else
+              subject
+            end
+          end
+          result unless result.is_a?(MissingTranslation)
+        end
+
+        # Picks a translation from a pluralized mnemonic subkey according to English
+        # pluralization rules :
+        # - It will pick the :one subkey if count is equal to 1.
+        # - It will pick the :other subkey otherwise.
+        # - It will pick the :zero subkey in the special case where count is
+        #   equal to 0 and there is a :zero subkey present. This behaviour is
+        #   not standard with regards to the CLDR pluralization rules.
+        # Other backends can implement more flexible or complex pluralization rules.
+        def pluralize(locale, entry, count)
+          entry = entry.reject { |k, _v| k == :attributes } if entry.is_a?(Hash)
+          return entry unless entry.is_a?(Hash) && count && entry.values.none? { |v| v.is_a?(Hash) }
+
+          key = pluralization_key(entry, count)
+          raise InvalidPluralizationData.new(entry, count, key) unless entry.has_key?(key)
+          entry[key]
+        end
+
+        # Interpolates values into a given subject.
+        #
+        #   if the given subject is a string then:
+        #   method interpolates "file %{file} opened by %%{user}", :file => 'test.txt', :user => 'Mr. X'
+        #   # => "file test.txt opened by %{user}"
+        #
+        #   if the given subject is an array then:
+        #   each element of the array is recursively interpolated (until it finds a string)
+        #   method interpolates ["yes, %{user}", ["maybe no, %{user}, "no, %{user}"]], :user => "bartuz"
+        #   # => "["yes, bartuz",["maybe no, bartuz", "no, bartuz"]]"
+        def interpolate(locale, subject, values = EMPTY_HASH)
+          return subject if values.empty?
+
+          case subject
+          when ::String then I18n.interpolate(subject, values)
+          when ::Array then subject.map { |element| interpolate(locale, element, values) }
+          else
+            subject
+          end
+        end
+
+        # Deep interpolation
+        #
+        #   deep_interpolate { people: { ann: "Ann is %{ann}", john: "John is %{john}" } },
+        #                    ann: 'good', john: 'big'
+        #   #=> { people: { ann: "Ann is good", john: "John is big" } }
+        def deep_interpolate(locale, data, values = EMPTY_HASH)
+          return data if values.empty?
+
+          case data
+          when ::String
+            I18n.interpolate(data, values)
+          when ::Hash
+            data.each_with_object({}) do |(k, v), result|
+              result[k] = deep_interpolate(locale, v, values)
+            end
+          when ::Array
+            data.map do |v|
+              deep_interpolate(locale, v, values)
+            end
+          else
+            data
+          end
+        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}", true)
+          data = send(:"load_#{type}", filename)
+          unless data.is_a?(Hash)
+            raise InvalidLocaleData.new(filename, 'expects it to return a hash, but does not')
+          end
+          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)
+          begin
+            if YAML.respond_to?(:unsafe_load_file) # Psych 4.0 way
+              YAML.unsafe_load_file(filename)
+            else
+              YAML.load_file(filename)
+            end
+          rescue TypeError, ScriptError, StandardError => e
+            raise InvalidLocaleData.new(filename, e.inspect)
+          end
+        end
+        alias_method :load_yaml, :load_yml
+
+        # Loads a JSON translations file. The data must have locales as
+        # toplevel keys.
+        def load_json(filename)
+          begin
+            ::JSON.parse(File.read(filename))
+          rescue TypeError, StandardError => e
+            raise InvalidLocaleData.new(filename, e.inspect)
+          end
+        end
+
+        def translate_localization_format(locale, object, format, options)
+          format.to_s.gsub(/%(|\^)[aAbBpP]/) 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.abbr_day_names",                 :locale => locale, :format => format)[object.wday].upcase
+            when '%A' then I18n.t!(:"date.day_names",                       :locale => locale, :format => format)[object.wday]
+            when '%^A' then I18n.t!(:"date.day_names",                      :locale => locale, :format => format)[object.wday].upcase
+            when '%b' then I18n.t!(:"date.abbr_month_names",                :locale => locale, :format => format)[object.mon]
+            when '%^b' then I18n.t!(:"date.abbr_month_names",               :locale => locale, :format => format)[object.mon].upcase
+            when '%B' then I18n.t!(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
+            when '%^B' then I18n.t!(:"date.month_names",                    :locale => locale, :format => format)[object.mon].upcase
+            when '%p' then I18n.t!(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format).upcase if object.respond_to? :hour
+            when '%P' then I18n.t!(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format).downcase if object.respond_to? :hour
+            end
+          end
+        rescue MissingTranslationData => e
+          e.message
+        end
+
+        def pluralization_key(entry, count)
+          key = :zero if count == 0 && entry.has_key?(:zero)
+          key ||= count == 1 ? :one : :other
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/lib/i18n/backend/cache.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# This module allows you to easily cache all responses from the backend - thus
+# speeding up the I18n aspects of your application quite a bit.
+#
+# To enable caching you can simply include the Cache module to the Simple
+# backend - or whatever other backend you are using:
+#
+#   I18n::Backend::Simple.send(:include, I18n::Backend::Cache)
+#
+# You will also need to set a cache store implementation that you want to use:
+#
+#   I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+#
+# You can use any cache implementation you want that provides the same API as
+# ActiveSupport::Cache (only the methods #fetch and #write are being used).
+#
+# The cache_key implementation by default assumes you pass values that return
+# a valid key from #hash (see
+# https://www.ruby-doc.org/core/classes/Object.html#M000337). However, you can
+# configure your own digest method via which responds to #hexdigest (see
+# https://ruby-doc.org/stdlib/libdoc/openssl/rdoc/OpenSSL/Digest.html):
+#
+#   I18n.cache_key_digest = OpenSSL::Digest::SHA256.new
+#
+# If you use a lambda as a default value in your translation like this:
+#
+#   I18n.t(:"date.order", :default => lambda {[:month, :day, :year]})
+#
+# Then you will always have a cache miss, because each time this method
+# is called the lambda will have a different hash value. If you know
+# the result of the lambda is a constant as in the example above, then
+# to cache this you can make the lambda a constant, like this:
+#
+#   DEFAULT_DATE_ORDER = lambda {[:month, :day, :year]}
+#   ...
+#   I18n.t(:"date.order", :default => DEFAULT_DATE_ORDER)
+#
+# If the lambda may result in different values for each call then consider
+# also using the Memoize backend.
+#
+module I18n
+  class << self
+    @@cache_store = nil
+    @@cache_namespace = nil
+    @@cache_key_digest = nil
+
+    def cache_store
+      @@cache_store
+    end
+
+    def cache_store=(store)
+      @@cache_store = store
+    end
+
+    def cache_namespace
+      @@cache_namespace
+    end
+
+    def cache_namespace=(namespace)
+      @@cache_namespace = namespace
+    end
+
+    def cache_key_digest
+      @@cache_key_digest
+    end
+
+    def cache_key_digest=(key_digest)
+      @@cache_key_digest = key_digest
+    end
+
+    def perform_caching?
+      !cache_store.nil?
+    end
+  end
+
+  module Backend
+    # TODO Should the cache be cleared if new translations are stored?
+    module Cache
+      def translate(locale, key, options = EMPTY_HASH)
+        I18n.perform_caching? ? fetch(cache_key(locale, key, options)) { super } : super
+      end
+
+      protected
+
+        def fetch(cache_key, &block)
+          result = _fetch(cache_key, &block)
+          throw(:exception, result) if result.is_a?(MissingTranslation)
+          result = result.dup if result.frozen? rescue result
+          result
+        end
+
+        def _fetch(cache_key, &block)
+          result = I18n.cache_store.read(cache_key)
+          return result unless result.nil?
+          result = catch(:exception, &block)
+          I18n.cache_store.write(cache_key, result) unless result.is_a?(Proc)
+          result
+        end
+
+        def cache_key(locale, key, options)
+          # This assumes that only simple, native Ruby values are passed to I18n.translate.
+          "i18n/#{I18n.cache_namespace}/#{locale}/#{digest_item(key)}/#{digest_item(options)}"
+        end
+
+      private
+
+        def digest_item(key)
+          I18n.cache_key_digest ? I18n.cache_key_digest.hexdigest(key.to_s) : key.to_s.hash
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/lib/i18n/backend/cache_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module I18n
+  module Backend
+    # Overwrites the Base load_file method to cache loaded file contents.
+    module CacheFile
+      # Optionally provide path_roots array to normalize filename paths,
+      # to make the cached i18n data portable across environments.
+      attr_accessor :path_roots
+
+      protected
+
+      # Track loaded translation files in the `i18n.load_file` scope,
+      # and skip loading the file if its contents are still up-to-date.
+      def load_file(filename)
+        initialized = !respond_to?(:initialized?) || initialized?
+        key = I18n::Backend::Flatten.escape_default_separator(normalized_path(filename))
+        old_mtime, old_digest = initialized && lookup(:i18n, key, :load_file)
+        return if (mtime = File.mtime(filename).to_i) == old_mtime ||
+                  (digest = OpenSSL::Digest::SHA256.file(filename).hexdigest) == old_digest
+        super
+        store_translations(:i18n, load_file: { key => [mtime, digest] })
+      end
+
+      # Translate absolute filename to relative path for i18n key.
+      def normalized_path(file)
+        return file unless path_roots
+        path = path_roots.find(&file.method(:start_with?)) ||
+               raise(InvalidLocaleData.new(file, 'outside expected path roots'))
+        file.sub(path, path_roots.index(path).to_s)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/lib/i18n/backend/cascade.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# The Cascade module adds the ability to do cascading lookups to backends that
+# are compatible to the Simple backend.
+#
+# By cascading lookups we mean that for any key that can not be found the
+# Cascade module strips one segment off the scope part of the key and then
+# tries to look up the key in that scope.
+#
+# E.g. when a lookup for the key :"foo.bar.baz" does not yield a result then
+# the segment :bar will be stripped off the scope part :"foo.bar" and the new
+# scope :foo will be used to look up the key :baz. If that does not succeed
+# then the remaining scope segment :foo will be omitted, too, and again the
+# key :baz will be looked up (now with no scope).
+#
+# To enable a cascading lookup one passes the :cascade option:
+#
+#   I18n.t(:'foo.bar.baz', :cascade => true)
+#
+# This will return the first translation found for :"foo.bar.baz", :"foo.baz"
+# or :baz in this order.
+#
+# The cascading lookup takes precedence over resolving any given defaults.
+# I.e. defaults will kick in after the cascading lookups haven't succeeded.
+#
+# This behavior is useful for libraries like ActiveRecord validations where
+# the library wants to give users a bunch of more or less fine-grained options
+# of scopes for a particular key.
+#
+# Thanks to Clemens Kofler for the initial idea and implementation! See
+# http://github.com/clemens/i18n-cascading-backend
+
+module I18n
+  module Backend
+    module Cascade
+      def lookup(locale, key, scope = [], options = EMPTY_HASH)
+        return super unless cascade = options[:cascade]
+
+        cascade   = { :step => 1 } unless cascade.is_a?(Hash)
+        step      = cascade[:step]   || 1
+        offset    = cascade[:offset] || 1
+        separator = options[:separator] || I18n.default_separator
+        skip_root = cascade.has_key?(:skip_root) ? cascade[:skip_root] : true
+
+        scope = I18n.normalize_keys(nil, key, scope, separator)
+        key   = (scope.slice!(-offset, offset) || []).join(separator)
+
+        begin
+          result = super
+          return result unless result.nil?
+          scope = scope.dup
+        end while (!scope.empty? || !skip_root) && scope.slice!(-step, step)
+      end
+    end
+  end
+end