ric 0.14.2 → 0.14.6

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

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    # Backend that chains multiple other backends and checks each of them when
-    # a translation needs to be looked up. This is useful when you want to use
-    # standard translations with a Simple backend but store custom application
-    # translations in a database or other backends.
-    #
-    # To use the Chain backend instantiate it and set it to the I18n module.
-    # You can add chained backends through the initializer or backends
-    # accessor:
-    #
-    #   # preserves the existing Simple backend set to I18n.backend
-    #   I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.new, I18n.backend)
-    #
-    # The implementation assumes that all backends added to the Chain implement
-    # a lookup method with the same API as Simple backend does.
-    class Chain
-      using I18n::HashRefinements
-
-      module Implementation
-        include Base
-
-        attr_accessor :backends
-
-        def initialize(*backends)
-          self.backends = backends
-        end
-
-        def initialized?
-          backends.all? do |backend|
-            backend.instance_eval do
-              return false unless initialized?
-            end
-          end
-          true
-        end
-
-        def reload!
-          backends.each { |backend| backend.reload! }
-        end
-
-        def eager_load!
-          backends.each { |backend| backend.eager_load! }
-        end
-
-        def store_translations(locale, data, options = EMPTY_HASH)
-          backends.first.store_translations(locale, data, options)
-        end
-
-        def available_locales
-          backends.map { |backend| backend.available_locales }.flatten.uniq
-        end
-
-        def translate(locale, key, default_options = EMPTY_HASH)
-          namespace = nil
-          options = default_options.except(:default)
-
-          backends.each do |backend|
-            catch(:exception) do
-              options = default_options if backend == backends.last
-              translation = backend.translate(locale, key, options)
-              if namespace_lookup?(translation, options)
-                namespace = _deep_merge(translation, namespace || {})
-              elsif !translation.nil? || (options.key?(:default) && options[:default].nil?)
-                return translation
-              end
-            end
-          end
-
-          return namespace if namespace
-          throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-        end
-
-        def exists?(locale, key, options = EMPTY_HASH)
-          backends.any? do |backend|
-            backend.exists?(locale, key, options)
-          end
-        end
-
-        def localize(locale, object, format = :default, options = EMPTY_HASH)
-          backends.each do |backend|
-            catch(:exception) do
-              result = backend.localize(locale, object, format, options) and return result
-            end
-          end
-          throw(:exception, I18n::MissingTranslation.new(locale, format, options))
-        end
-
-        protected
-          def init_translations
-            backends.each do |backend|
-              backend.send(:init_translations)
-            end
-          end
-
-          def translations
-            backends.reverse.each_with_object({}) do |backend, memo|
-              partial_translations = backend.instance_eval do
-                init_translations unless initialized?
-                translations
-              end
-              memo.deep_merge!(partial_translations) { |_, a, b| b || a }
-            end
-          end
-
-          def namespace_lookup?(result, options)
-            result.is_a?(Hash) && !options.has_key?(:count)
-          end
-
-        private
-          # This is approximately what gets used in ActiveSupport.
-          # However since we are not guaranteed to run in an ActiveSupport context
-          # it is wise to have our own copy. We underscore it
-          # to not pollute the namespace of the including class.
-          def _deep_merge(hash, other_hash)
-            copy = hash.dup
-            other_hash.each_pair do |k,v|
-              value_from_other = hash[k]
-              copy[k] = value_from_other.is_a?(Hash) && v.is_a?(Hash) ? _deep_merge(value_from_other, v) : v
-            end
-            copy
-          end
-      end
-
-      include Implementation
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-# 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 fallbacks you can simply include the Fallbacks module to
-# the Simple backend - or whatever other backend you are using:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
-module I18n
-  @@fallbacks = nil
-
-  class << self
-    # Returns the current fallbacks implementation. Defaults to +I18n::Locale::Fallbacks+.
-    def fallbacks
-      @@fallbacks ||= I18n::Locale::Fallbacks.new
-      Thread.current[:i18n_fallbacks] || @@fallbacks
-    end
-
-    # Sets the current fallbacks implementation. Use this to set a different fallbacks implementation.
-    def fallbacks=(fallbacks)
-      @@fallbacks = fallbacks.is_a?(Array) ? I18n::Locale::Fallbacks.new(fallbacks) : fallbacks
-      Thread.current[:i18n_fallbacks] = @@fallbacks
-    end
-  end
-
-  module Backend
-    module Fallbacks
-      # Overwrites the Base backend translate method so that it will try each
-      # locale given by I18n.fallbacks for the given locale. E.g. for the
-      # locale :"de-DE" it might try the locales :"de-DE", :de and :en
-      # (depends on the fallbacks implementation) until it finds a result with
-      # the given options. If it does not find any result for any of the
-      # locales it will then throw MissingTranslation as usual.
-      #
-      # The default option takes precedence over fallback locales only when
-      # it's a Symbol. When the default contains a String, Proc or Hash
-      # it is evaluated last after all the fallback locales have been tried.
-      def translate(locale, key, options = EMPTY_HASH)
-        return super unless options.fetch(:fallback, true)
-        return super if options[:fallback_in_progress]
-        default = extract_non_symbol_default!(options) if options[:default]
-
-        fallback_options = options.merge(:fallback_in_progress => true)
-        I18n.fallbacks[locale].each do |fallback|
-          begin
-            catch(:exception) do
-              result = super(fallback, key, fallback_options)
-              unless result.nil?
-                on_fallback(locale, fallback, key, options) if locale.to_s != fallback.to_s
-                return result
-              end
-            end
-          rescue I18n::InvalidLocale
-            # we do nothing when the locale is invalid, as this is a fallback anyways.
-          end
-        end
-
-        return if options.key?(:default) && options[:default].nil?
-
-        return super(locale, nil, options.merge(:default => default)) if default
-        throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-      end
-
-      def extract_non_symbol_default!(options)
-        defaults = [options[:default]].flatten
-        first_non_symbol_default = defaults.detect{|default| !default.is_a?(Symbol)}
-        if first_non_symbol_default
-          options[:default] = defaults[0, defaults.index(first_non_symbol_default)]
-        end
-        return first_non_symbol_default
-      end
-
-      def exists?(locale, key, options = EMPTY_HASH)
-        return super unless options.fetch(:fallback, true)
-        I18n.fallbacks[locale].each do |fallback|
-          begin
-            return true if super(fallback, key)
-          rescue I18n::InvalidLocale
-            # we do nothing when the locale is invalid, as this is a fallback anyways.
-          end
-        end
-
-        false
-      end
-
-      private
-
-        # Overwrite on_fallback to add specified logic when the fallback succeeds.
-        def on_fallback(_original_locale, _fallback_locale, _key, _optoins)
-          nil
-        end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    # This module contains several helpers to assist flattening translations.
-    # You may want to flatten translations for:
-    #
-    #   1) speed up lookups, as in the Memoize backend;
-    #   2) In case you want to store translations in a data store, as in ActiveRecord backend;
-    #
-    # You can check both backends above for some examples.
-    # This module also keeps all links in a hash so they can be properly resolved when flattened.
-    module Flatten
-      SEPARATOR_ESCAPE_CHAR = "\001"
-      FLATTEN_SEPARATOR = "."
-
-      # normalize_keys the flatten way. This method is significantly faster
-      # and creates way less objects than the one at I18n.normalize_keys.
-      # It also handles escaping the translation keys.
-      def self.normalize_flat_keys(locale, key, scope, separator)
-        keys = [scope, key]
-        keys.flatten!
-        keys.compact!
-
-        separator ||= I18n.default_separator
-
-        if separator != FLATTEN_SEPARATOR
-          from_str = "#{FLATTEN_SEPARATOR}#{separator}"
-          to_str = "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}"
-
-          keys.map! { |k| k.to_s.tr from_str, to_str }
-        end
-
-        keys.join(".")
-      end
-
-      # Receives a string and escape the default separator.
-      def self.escape_default_separator(key) #:nodoc:
-        key.to_s.tr(FLATTEN_SEPARATOR, SEPARATOR_ESCAPE_CHAR)
-      end
-
-      # Shortcut to I18n::Backend::Flatten.normalize_flat_keys
-      # and then resolve_links.
-      def normalize_flat_keys(locale, key, scope, separator)
-        key = I18n::Backend::Flatten.normalize_flat_keys(locale, key, scope, separator)
-        resolve_link(locale, key)
-      end
-
-      # Store flattened links.
-      def links
-        @links ||= I18n.new_double_nested_cache
-      end
-
-      # Flatten keys for nested Hashes by chaining up keys:
-      #
-      #   >> { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}.wind
-      #   => { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
-      #
-      def flatten_keys(hash, escape, prev_key=nil, &block)
-        hash.each_pair do |key, value|
-          key = escape_default_separator(key) if escape
-          curr_key = [prev_key, key].compact.join(FLATTEN_SEPARATOR).to_sym
-          yield curr_key, value
-          flatten_keys(value, escape, curr_key, &block) if value.is_a?(Hash)
-        end
-      end
-
-      # Receives a hash of translations (where the key is a locale and
-      # the value is another hash) and return a hash with all
-      # translations flattened.
-      #
-      # Nested hashes are included in the flattened hash just if subtree
-      # is true and Symbols are automatically stored as links.
-      def flatten_translations(locale, data, escape, subtree)
-        hash = {}
-        flatten_keys(data, escape) do |key, value|
-          if value.is_a?(Hash)
-            hash[key] = value if subtree
-          else
-            store_link(locale, key, value) if value.is_a?(Symbol)
-            hash[key] = value
-          end
-        end
-        hash
-      end
-
-      protected
-
-        def store_link(locale, key, link)
-          links[locale.to_sym][key.to_s] = link.to_s
-        end
-
-        def resolve_link(locale, key)
-          key, locale = key.to_s, locale.to_sym
-          links = self.links[locale]
-
-          if links.key?(key)
-            links[key]
-          elsif link = find_link(locale, key)
-            store_link(locale, key, key.gsub(*link))
-          else
-            key
-          end
-        end
-
-        def find_link(locale, key) #:nodoc:
-          links[locale].each_pair do |from, to|
-            return [from, to] if key[0, from.length] == from
-          end && nil
-        end
-
-        def escape_default_separator(key) #:nodoc:
-          I18n::Backend::Flatten.escape_default_separator(key)
-        end
-
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n/gettext'
-require 'i18n/gettext/po_parser'
-
-module I18n
-  module Backend
-    # Experimental support for using Gettext po files to store translations.
-    #
-    # To use this you can simply include the module to the Simple backend - or
-    # whatever other backend you are using.
-    #
-    #  I18n::Backend::Simple.include(I18n::Backend::Gettext)
-    #
-    # Now you should be able to include your Gettext translation (*.po) files to
-    # the +I18n.load_path+ so they're loaded to the backend and you can use them as
-    # usual:
-    #
-    #  I18n.load_path += Dir["path/to/locales/*.po"]
-    #
-    # Following the Gettext convention this implementation expects that your
-    # translation files are named by their locales. E.g. the file en.po would
-    # contain the translations for the English locale.
-    #
-    # To translate text <b>you must use</b> one of the translate methods provided by
-    # I18n::Gettext::Helpers.
-    #
-    #  include I18n::Gettext::Helpers
-    #  puts _("some string")
-    #
-    # Without it strings containing periods (".") will not be translated.
-
-    module Gettext
-      using I18n::HashRefinements
-
-      class PoData < Hash
-        def set_comment(msgid_or_sym, comment)
-          # ignore
-        end
-      end
-
-      protected
-        def load_po(filename)
-          locale = ::File.basename(filename, '.po').to_sym
-          data = normalize(locale, parse(filename))
-          { locale => data }
-        end
-
-        def parse(filename)
-          GetText::PoParser.new.parse(::File.read(filename), PoData.new)
-        end
-
-        def normalize(locale, data)
-          data.inject({}) do |result, (key, value)|
-            unless key.nil? || key.empty?
-              key = key.gsub(I18n::Gettext::CONTEXT_SEPARATOR, '|')
-              key, value = normalize_pluralization(locale, key, value) if key.index("\000")
-
-              parts = key.split('|').reverse
-              normalized = parts.inject({}) do |_normalized, part|
-                { part => _normalized.empty? ? value : _normalized }
-              end
-
-              result.deep_merge!(normalized)
-            end
-            result
-          end
-        end
-
-        def normalize_pluralization(locale, key, value)
-          # FIXME po_parser includes \000 chars that can not be turned into Symbols
-          key = key.gsub("\000", I18n::Gettext::PLURAL_SEPARATOR).split(I18n::Gettext::PLURAL_SEPARATOR).first
-
-          keys = I18n::Gettext.plural_keys(locale)
-          values = value.split("\000")
-          raise "invalid number of plurals: #{values.size}, keys: #{keys.inspect} on #{locale} locale for msgid #{key.inspect} with values #{values.inspect}" if values.size != keys.size
-
-          result = {}
-          values.each_with_index { |_value, ix| result[keys[ix]] = _value }
-          [key, result]
-        end
-
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-# The InterpolationCompiler module contains optimizations that can tremendously
-# speed up the interpolation process on the Simple backend.
-#
-# It works by defining a pre-compiled method on stored translation Strings that
-# already bring all the knowledge about contained interpolation variables etc.
-# so that the actual recurring interpolation will be very fast.
-#
-# To enable pre-compiled interpolations you can simply include the
-# InterpolationCompiler module to the Simple backend:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::InterpolationCompiler)
-#
-# Note that InterpolationCompiler does not yield meaningful results and consequently
-# should not be used with Ruby 1.9 (YARV) but improves performance everywhere else
-# (jRuby, Rubinius).
-module I18n
-  module Backend
-    module InterpolationCompiler
-      module Compiler
-        extend self
-
-        TOKENIZER                    = /(%%\{[^\}]+\}|%\{[^\}]+\})/
-        INTERPOLATION_SYNTAX_PATTERN = /(%)?(%\{([^\}]+)\})/
-
-        def compile_if_an_interpolation(string)
-          if interpolated_str?(string)
-            string.instance_eval <<-RUBY_EVAL, __FILE__, __LINE__
-              def i18n_interpolate(v = {})
-                "#{compiled_interpolation_body(string)}"
-              end
-            RUBY_EVAL
-          end
-
-          string
-        end
-
-        def interpolated_str?(str)
-          str.kind_of?(::String) && str =~ INTERPOLATION_SYNTAX_PATTERN
-        end
-
-        protected
-        # tokenize("foo %{bar} baz %%{buz}") # => ["foo ", "%{bar}", " baz ", "%%{buz}"]
-        def tokenize(str)
-          str.split(TOKENIZER)
-        end
-
-        def compiled_interpolation_body(str)
-          tokenize(str).map do |token|
-            (matchdata = token.match(INTERPOLATION_SYNTAX_PATTERN)) ? handle_interpolation_token(token, matchdata) : escape_plain_str(token)
-          end.join
-        end
-
-        def handle_interpolation_token(interpolation, matchdata)
-          escaped, pattern, key = matchdata.values_at(1, 2, 3)
-          escaped ? pattern : compile_interpolation_token(key.to_sym)
-        end
-
-        def compile_interpolation_token(key)
-          "\#{#{interpolate_or_raise_missing(key)}}"
-        end
-
-        def interpolate_or_raise_missing(key)
-          escaped_key = escape_key_sym(key)
-          RESERVED_KEYS.include?(key) ? reserved_key(escaped_key) : interpolate_key(escaped_key)
-        end
-
-        def interpolate_key(key)
-          [direct_key(key), nil_key(key), missing_key(key)].join('||')
-        end
-
-        def direct_key(key)
-          "((t = v[#{key}]) && t.respond_to?(:call) ? t.call : t)"
-        end
-
-        def nil_key(key)
-          "(v.has_key?(#{key}) && '')"
-        end
-
-        def missing_key(key)
-          "I18n.config.missing_interpolation_argument_handler.call(#{key}, v, self)"
-        end
-
-        def reserved_key(key)
-          "raise(ReservedInterpolationKey.new(#{key}, self))"
-        end
-
-        def escape_plain_str(str)
-          str.gsub(/"|\\|#/) {|x| "\\#{x}"}
-        end
-
-        def escape_key_sym(key)
-          # rely on Ruby to do all the hard work :)
-          key.to_sym.inspect
-        end
-      end
-
-      def interpolate(locale, string, values)
-        if string.respond_to?(:i18n_interpolate)
-          string.i18n_interpolate(values)
-        elsif values
-          super
-        else
-          string
-        end
-      end
-
-      def store_translations(locale, data, options = EMPTY_HASH)
-        compile_all_strings_in(data)
-        super
-      end
-
-      protected
-      def compile_all_strings_in(data)
-        data.each_value do |value|
-          Compiler.compile_if_an_interpolation(value)
-          compile_all_strings_in(value) if value.kind_of?(Hash)
-        end
-      end
-    end
-  end
-end