ric 0.11.19 → 0.14.0

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+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 != nil ? @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
+
+    # Returns true if the available_locales have been initialized
+    def available_locales_initialized?
+      ( !!defined?(@@available_locales) && !!@@available_locales )
+    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
+
+    # Returns the current interpolation patterns. Defaults to
+    # I18n::DEFAULT_INTERPOLATION_PATTERNS.
+    def interpolation_patterns
+      @@interpolation_patterns ||= I18n::DEFAULT_INTERPOLATION_PATTERNS.dup
+    end
+
+    # Sets the current interpolation patterns. Used to set a interpolation
+    # patterns.
+    #
+    # E.g. using {{}} as a placeholder like "{{hello}}, world!":
+    #
+    #   I18n.config.interpolation_patterns << /\{\{(\w+)\}\}/
+    def interpolation_patterns=(interpolation_patterns)
+      @@interpolation_patterns = interpolation_patterns
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/lib/i18n/core_ext/hash.rb

@@ -0,0 +1,59 @@
+module I18n
+  module HashRefinements
+    refine Hash do
+      using I18n::HashRefinements
+      def except(*keys)
+        dup.except!(*keys)
+      end unless method_defined?(:except)
+
+      def except!(*keys)
+        keys.each { |key| delete(key) }
+        self
+      end
+
+      def deep_symbolize_keys
+        each_with_object({}) do |(key, value), result|
+          result[symbolize_key(key)] = deep_symbolize_keys_in_object(value)
+          result
+        end
+      end
+
+      # deep_merge from activesupport 5
+      # Copyright (c) 2005-2019 David Heinemeier Hansson
+      def deep_merge(other_hash, &block)
+        dup.deep_merge!(other_hash, &block)
+      end
+
+      # deep_merge! from activesupport 5
+      # Copyright (c) 2005-2019 David Heinemeier Hansson
+      def deep_merge!(other_hash, &block)
+        merge!(other_hash) do |key, this_val, other_val|
+          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+            this_val.deep_merge(other_val, &block)
+          elsif block_given?
+            block.call(key, this_val, other_val)
+          else
+            other_val
+          end
+        end
+      end
+
+      def symbolize_key(key)
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+
+      private
+
+      def deep_symbolize_keys_in_object(value)
+        case value
+        when Hash
+          value.deep_symbolize_keys
+        when Array
+          value.map { |e| deep_symbolize_keys_in_object(e) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module I18n
+  class ExceptionHandler
+    def call(exception, _locale, _key, _options)
+      if exception.is_a?(MissingTranslation)
+        exception.message
+      else
+        raise exception
+      end
+    end
+  end
+
+  class ArgumentError < ::ArgumentError; end
+
+  class Disabled < ArgumentError
+    def initialize(method)
+      super(<<~MESSAGE)
+        I18n.#{method} is currently disabled, likely because your application is still in its loading phase.
+
+        This method is meant to display text in the user locale, so calling it before the user locale has
+        been set is likely to display text from the wrong locale to some users.
+
+        If you have a legitimate reason to access i18n data outside of the user flow, you can do so by passing
+        the desired locale explictly with the `locale` argument, e.g. `I18n.#{method}(..., locale: :en)`
+      MESSAGE
+    end
+  end
+
+  class InvalidLocale < ArgumentError
+    attr_reader :locale
+    def initialize(locale)
+      @locale = locale
+      super "#{locale.inspect} is not a valid locale"
+    end
+  end
+
+  class InvalidLocaleData < ArgumentError
+    attr_reader :filename
+    def initialize(filename, exception_message)
+      @filename, @exception_message = filename, exception_message
+      super "can not load translations from #{filename}: #{exception_message}"
+    end
+  end
+
+  class MissingTranslation < ArgumentError
+    module Base
+      attr_reader :locale, :key, :options
+
+      def initialize(locale, key, options = EMPTY_HASH)
+        @key, @locale, @options = key, locale, options.dup
+        options.each { |k, v| self.options[k] = v.inspect if v.is_a?(Proc) }
+      end
+
+      def keys
+        @keys ||= I18n.normalize_keys(locale, key, options[:scope]).tap do |keys|
+          keys << 'no key' if keys.size < 2
+        end
+      end
+
+      def message
+        "translation missing: #{keys.join('.')}"
+      end
+      alias :to_s :message
+
+      def to_exception
+        MissingTranslationData.new(locale, key, options)
+      end
+    end
+
+    include Base
+  end
+
+  class MissingTranslationData < ArgumentError
+    include MissingTranslation::Base
+  end
+
+  class InvalidPluralizationData < ArgumentError
+    attr_reader :entry, :count, :key
+    def initialize(entry, count, key)
+      @entry, @count, @key = entry, count, key
+      super "translation data #{entry.inspect} can not be used with :count => #{count}. key '#{key}' is missing."
+    end
+  end
+
+  class MissingInterpolationArgument < ArgumentError
+    attr_reader :key, :values, :string
+    def initialize(key, values, string)
+      @key, @values, @string = key, values, string
+      super "missing interpolation argument #{key.inspect} 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/vendor/bundle/ruby/2.7.0/gems/i18n-1.8.11/lib/i18n/gettext/helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+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::Gettext::Helpers
+    module Helpers
+      # Makes dynamic translation messages readable for the gettext parser.
+      # <tt>_(fruit)</tt> cannot be understood by the gettext parser. To help the parser find all your translations,
+      # you can add <tt>fruit = N_("Apple")</tt> which does not translate, but tells the parser: "Apple" needs translation.
+      # * msgid: the message id.
+      # * Returns: msgid.
+      def N_(msgsid)
+        msgsid
+      end
+
+      def gettext(msgid, options = EMPTY_HASH)
+        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