lightning_ui_kit 0.3.3 → 0.3.5

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/lib/i18n/backend/interpolation_compiler.rb

@@ -1,121 +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 = /(%%?\{[^}]+\})/
-
-        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 =~ TOKENIZER
-        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|
-            token.match(TOKENIZER) ? handle_interpolation_token(token) : escape_plain_str(token)
-          end.join
-        end
-
-        def handle_interpolation_token(token)
-          token.start_with?('%%') ? token[1..] : compile_interpolation_token(token[2..-2])
-        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

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/lib/i18n/exceptions.rb

@@ -1,157 +0,0 @@
-# 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 explicitly 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
-      PERMITTED_KEYS = [:scope, :default].freeze
-
-      attr_reader :locale, :key, :options
-
-      def initialize(locale, key, options = EMPTY_HASH)
-        @key, @locale, @options = key, locale, options.slice(*PERMITTED_KEYS)
-        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
-        if (default = options[:default]).is_a?(Array) && default.any?
-          other_options = ([key, *default]).map { |k| normalized_option(k).prepend('- ') }.join("\n")
-          "Translation missing. Options considered were:\n#{other_options}"
-        else
-          "Translation missing: #{keys.join('.')}"
-        end
-      end
-
-      def normalized_option(key)
-        I18n.normalize_keys(locale, key, options[:scope]).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
-
-  class UnsupportedMethod < ArgumentError
-    attr_reader :method, :backend_klass, :msg
-    def initialize(method, backend_klass, msg)
-      @method = method
-      @backend_klass = backend_klass
-      @msg = msg
-      super "#{backend_klass} does not support the ##{method} method. #{msg}"
-    end
-  end
-
-  class InvalidFilenames < ArgumentError
-    NUMBER_OF_ERRORS_SHOWN = 20
-    def initialize(file_errors)
-      super <<~MSG
-        Found #{file_errors.count} error(s).
-        The first #{[file_errors.count, NUMBER_OF_ERRORS_SHOWN].min} error(s):
-        #{file_errors.map(&:message).first(NUMBER_OF_ERRORS_SHOWN).join("\n")}
-
-        To use the LazyLoadable backend:
-        1. Filenames must start with the locale.
-        2. An underscore must separate the locale with any optional text that follows.
-        3. The file must only contain translation data for the single locale.
-
-        Example:
-        "/config/locales/fr.yml" which contains:
-        ```yml
-          fr:
-            dog:
-              chien
-        ```
-      MSG
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/lib/i18n/middleware.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  class Middleware
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    ensure
-      Thread.current[:i18n_config] = I18n::Config.new
-    end
-
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/lib/i18n/tests/interpolation.rb

@@ -1,185 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Tests
-    module Interpolation
-      # If no interpolation parameter is not given, I18n should not alter the string.
-      # This behavior is due to three reasons:
-      #
-      #   * Checking interpolation keys in all strings hits performance, badly;
-      #
-      #   * This allows us to retrieve untouched values through I18n. For example
-      #     I could have a middleware that returns I18n lookup results in JSON
-      #     to be processed through Javascript. Leaving the keys untouched allows
-      #     the interpolation to happen at the javascript level;
-      #
-      #   * Security concerns: if I allow users to translate a web site, they can
-      #     insert %{} in messages causing the I18n lookup to fail in every request.
-      #
-      test "interpolation: given no values it does not alter the string" do
-        assert_equal 'Hi %{name}!', interpolate(:default => 'Hi %{name}!')
-      end
-
-      test "interpolation: given values it interpolates them into the string" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
-      end
-
-      test "interpolation: works with a pipe" do
-        assert_equal 'Hi david!', interpolate(:default => 'Hi %{name|lowercase}!', :'name|lowercase' => 'david')
-      end
-
-      test "interpolation: given a nil value it still interpolates it into the string" do
-        assert_equal 'Hi !', interpolate(:default => 'Hi %{name}!', :name => nil)
-      end
-
-      test "interpolation: given a lambda as a value it calls it if the string contains the key" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => lambda { |*args| 'David' })
-      end
-
-      test "interpolation: given a lambda as a value it does not call it if the string does not contain the key" do
-        assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { |*args| raise 'fail' }) }
-      end
-
-      test "interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
-        assert_raises(I18n::MissingInterpolationArgument) do
-          interpolate(:default => '%{foo}', :bar => 'bar')
-        end
-      end
-
-      test "interpolation: it does not raise I18n::MissingInterpolationArgument for escaped variables" do
-        assert_nothing_raised do
-          assert_equal 'Barr %{foo}', interpolate(:default => '%{bar} %%{foo}', :bar => 'Barr')
-        end
-      end
-
-      test "interpolation: it does not change the original, stored translation string" do
-        I18n.backend.store_translations(:en, :interpolate => 'Hi %{name}!')
-        assert_equal 'Hi David!', interpolate(:interpolate, :name => 'David')
-        assert_equal 'Hi Yehuda!', interpolate(:interpolate, :name => 'Yehuda')
-      end
-
-      test "interpolation: given an array interpolates each element" do
-        I18n.backend.store_translations(:en, :array_interpolate => ['Hi', 'Mr. %{name}', 'or sir %{name}'])
-        assert_equal ['Hi', 'Mr. Bartuz', 'or sir Bartuz'], interpolate(:array_interpolate, :name => 'Bartuz')
-      end
-
-      test "interpolation: given the translation is in utf-8 it still works" do
-        assert_equal 'Häi David!', interpolate(:default => 'Häi %{name}!', :name => 'David')
-      end
-
-      test "interpolation: given the value is in utf-8 it still works" do
-        assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi %{name}!', :name => 'ゆきひろ')
-      end
-
-      test "interpolation: given the translation and the value are in utf-8 it still works" do
-        assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、%{name}さん!', :name => 'ゆきひろ')
-      end
-
-      if Object.const_defined?(:Encoding)
-        test "interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
-          assert_raises(Encoding::CompatibilityError) do
-            interpolate(:default => euc_jp('こんにちは、%{name}さん!'), :name => 'ゆきひろ')
-          end
-        end
-
-        test "interpolation: given a utf-8 translation and a euc-jp value it raises Encoding::CompatibilityError" do
-          assert_raises(Encoding::CompatibilityError) do
-            interpolate(:default => 'こんにちは、%{name}さん!', :name => euc_jp('ゆきひろ'))
-          end
-        end
-
-        test "interpolation: ASCII strings in the backend should be encoded to UTF8 if interpolation options are in UTF8" do
-          I18n.backend.store_translations 'en', 'encoding' => ('%{who} let me go'.force_encoding("ASCII"))
-          result = I18n.t 'encoding', :who => "måmmå miå"
-          assert_equal Encoding::UTF_8, result.encoding
-        end
-
-        test "interpolation: UTF8 strings in the backend are still returned as UTF8 with ASCII interpolation" do
-          I18n.backend.store_translations 'en', 'encoding' => 'måmmå miå %{what}'
-          result = I18n.t 'encoding', :what => 'let me go'.force_encoding("ASCII")
-          assert_equal Encoding::UTF_8, result.encoding
-        end
-
-        test "interpolation: UTF8 strings in the backend are still returned as UTF8 even with numbers interpolation" do
-          I18n.backend.store_translations 'en', 'encoding' => '%{count} times: måmmå miå'
-          result = I18n.t 'encoding', :count => 3
-          assert_equal Encoding::UTF_8, result.encoding
-        end
-      end
-
-      test "interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
-        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{exception_handler}') }
-        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{default}') }
-        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{separator}') }
-        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{scope}') }
-        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '%{scope}') }
-
-        I18n.backend.store_translations(:en, :interpolate => 'Hi %{scope}!')
-        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:interpolate) }
-      end
-
-      test "interpolation: it does not raise I18n::ReservedInterpolationKey for escaped variables" do
-        assert_nothing_raised do
-          assert_equal '%{separator}', interpolate(:foo => :bar, :default => '%%{separator}')
-        end
-
-        # Note: The two interpolations below do not remove the escape character (%) because
-        #   I18n should not alter the strings when no interpolation parameters are given,
-        #   see the comment at the top of this file.
-        assert_nothing_raised do
-          assert_equal '%%{scope}', interpolate(:default => '%%{scope}')
-        end
-
-        I18n.backend.store_translations(:en, :interpolate => 'Hi %%{scope}!')
-        assert_nothing_raised do
-          assert_equal 'Hi %%{scope}!', interpolate(:interpolate)
-        end
-      end
-
-      test "interpolation: deep interpolation for default string" do
-        assert_equal 'Hi %{name}!', interpolate(:default => 'Hi %{name}!', :deep_interpolation => true)
-      end
-
-      test "interpolation: deep interpolation for interpolated string" do
-        assert_equal 'Hi Ann!', interpolate(:default => 'Hi %{name}!', :name => 'Ann', :deep_interpolation => true)
-      end
-
-      test "interpolation: deep interpolation for Hash" do
-        people = { :people => { :ann => 'Ann is %{ann}', :john => 'John is %{john}' } }
-        interpolated_people = { :people => { :ann => 'Ann is good', :john => 'John is big' } }
-        assert_equal interpolated_people, interpolate(:default => people, :ann => 'good', :john => 'big', :deep_interpolation => true)
-      end
-
-      test "interpolation: deep interpolation for Array" do
-        people = { :people => ['Ann is %{ann}', 'John is %{john}'] }
-        interpolated_people = { :people => ['Ann is good', 'John is big'] }
-        assert_equal interpolated_people, interpolate(:default => people, :ann => 'good', :john => 'big', :deep_interpolation => true)
-      end
-
-      protected
-
-      def capture(stream)
-        begin
-          stream = stream.to_s
-          eval "$#{stream} = StringIO.new"
-          yield
-          result = eval("$#{stream}").string
-        ensure
-          eval("$#{stream} = #{stream.upcase}")
-        end
-
-        result
-      end
-
-      def euc_jp(string)
-        string.encode!(Encoding::EUC_JP)
-      end
-
-      def interpolate(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        key = args.pop
-        I18n.backend.translate('en', key, options)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/lib/i18n/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  VERSION = "1.14.7"
-end