tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/inflector/transliterate.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/multibyte"
-require "active_support/i18n"
-
-module ActiveSupport
-  module Inflector
-    ALLOWED_ENCODINGS_FOR_TRANSLITERATE = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::GB18030].freeze
-
-    # Replaces non-ASCII characters with an ASCII approximation, or if none
-    # exists, a replacement character which defaults to "?".
-    #
-    #    transliterate('Ærøskøbing')
-    #    # => "AEroskobing"
-    #
-    # Default approximations are provided for Western/Latin characters,
-    # e.g, "ø", "ñ", "é", "ß", etc.
-    #
-    # This method is I18n aware, so you can set up custom approximations for a
-    # locale. This can be useful, for example, to transliterate German's "ü"
-    # and "ö" to "ue" and "oe", or to add support for transliterating Russian
-    # to ASCII.
-    #
-    # In order to make your custom transliterations available, you must set
-    # them as the <tt>i18n.transliterate.rule</tt> i18n key:
-    #
-    #   # Store the transliterations in locales/de.yml
-    #   i18n:
-    #     transliterate:
-    #       rule:
-    #         ü: "ue"
-    #         ö: "oe"
-    #
-    #   # Or set them using Ruby
-    #   I18n.backend.store_translations(:de, i18n: {
-    #     transliterate: {
-    #       rule: {
-    #         'ü' => 'ue',
-    #         'ö' => 'oe'
-    #       }
-    #     }
-    #   })
-    #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
-    # maps characters to ASCII approximations as shown above, or, for more
-    # complex requirements, a Proc:
-    #
-    #   I18n.backend.store_translations(:de, i18n: {
-    #     transliterate: {
-    #       rule: ->(string) { MyTransliterator.transliterate(string) }
-    #     }
-    #   })
-    #
-    # Now you can have different transliterations for each locale:
-    #
-    #   transliterate('Jürgen', locale: :en)
-    #   # => "Jurgen"
-    #
-    #   transliterate('Jürgen', locale: :de)
-    #   # => "Juergen"
-    #
-    # Transliteration is restricted to UTF-8, US-ASCII, and GB18030 strings.
-    # Other encodings will raise an ArgumentError.
-    def transliterate(string, replacement = "?", locale: nil)
-      raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
-      raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
-
-      return string.dup if string.ascii_only?
-      string = string.dup if string.frozen?
-
-      input_encoding = string.encoding
-
-      # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if
-      # US-ASCII is given. This way we can let tidy_bytes handle the string
-      # in the same way as we do for UTF-8
-      string.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::US_ASCII
-
-      # GB18030 is Unicode compatible but is not a direct mapping so needs to be
-      # transcoded. Using invalid/undef :replace will result in loss of data in
-      # the event of invalid characters, but since tidy_bytes will replace
-      # invalid/undef with a "?" we're safe to do the same beforehand
-      string.encode!(Encoding::UTF_8, invalid: :replace, undef: :replace) if string.encoding == Encoding::GB18030
-
-      transliterated = I18n.transliterate(
-        ActiveSupport::Multibyte::Unicode.tidy_bytes(string).unicode_normalize(:nfc),
-        replacement: replacement,
-        locale: locale
-      )
-
-      # Restore the string encoding of the input if it was not UTF-8.
-      # Apply invalid/undef :replace as tidy_bytes does
-      transliterated.encode!(input_encoding, invalid: :replace, undef: :replace) if input_encoding != transliterated.encoding
-
-      transliterated
-    end
-
-    # Replaces special characters in a string so that it may be used as part of
-    # a 'pretty' URL.
-    #
-    #   parameterize("Donald E. Knuth") # => "donald-e-knuth"
-    #   parameterize("^très|Jolie-- ")  # => "tres-jolie"
-    #
-    # To use a custom separator, override the +separator+ argument.
-    #
-    #   parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
-    #   parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
-    #
-    # To preserve the case of the characters in a string, use the +preserve_case+ argument.
-    #
-    #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
-    #   parameterize("^très|Jolie-- ", preserve_case: true) # => "tres-Jolie"
-    #
-    # It preserves dashes and underscores unless they are used as separators:
-    #
-    #   parameterize("^très|Jolie__ ")                 # => "tres-jolie__"
-    #   parameterize("^très|Jolie-- ", separator: "_") # => "tres_jolie--"
-    #   parameterize("^très_Jolie-- ", separator: ".") # => "tres_jolie--"
-    #
-    # If the optional parameter +locale+ is specified,
-    # the word will be parameterized as a word of that language.
-    # By default, this parameter is set to <tt>nil</tt> and it will use
-    # the configured <tt>I18n.locale</tt>.
-    def parameterize(string, separator: "-", preserve_case: false, locale: nil)
-      # Replace accented chars with their ASCII equivalents.
-      parameterized_string = transliterate(string, locale: locale)
-
-      # Turn unwanted chars into the separator.
-      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
-
-      unless separator.nil? || separator.empty?
-        if separator == "-"
-          re_duplicate_separator        = /-{2,}/
-          re_leading_trailing_separator = /^-|-$/i
-        else
-          re_sep = Regexp.escape(separator)
-          re_duplicate_separator        = /#{re_sep}{2,}/
-          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
-        end
-        # No more than one of the separator in a row.
-        parameterized_string.gsub!(re_duplicate_separator, separator)
-        # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "")
-      end
-
-      parameterized_string.downcase! unless preserve_case
-      parameterized_string
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/isolated_execution_state.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module IsolatedExecutionState # :nodoc:
-    @isolation_level = nil
-
-    Thread.attr_accessor :active_support_execution_state
-    Fiber.attr_accessor :active_support_execution_state
-
-    class << self
-      attr_reader :isolation_level, :scope
-
-      def isolation_level=(level)
-        return if level == @isolation_level
-
-        unless %i(thread fiber).include?(level)
-          raise ArgumentError, "isolation_level must be `:thread` or `:fiber`, got: `#{level.inspect}`"
-        end
-
-        clear if @isolation_level
-
-        @scope =
-          case level
-          when :thread; Thread
-          when :fiber; Fiber
-          end
-
-        @isolation_level = level
-      end
-
-      def unique_id
-        self[:__id__] ||= Object.new
-      end
-
-      def [](key)
-        state[key]
-      end
-
-      def []=(key, value)
-        state[key] = value
-      end
-
-      def key?(key)
-        state.key?(key)
-      end
-
-      def delete(key)
-        state.delete(key)
-      end
-
-      def clear
-        state.clear
-      end
-
-      def context
-        scope.current
-      end
-
-      def share_with(other)
-        # Action Controller streaming spawns a new thread and copy thread locals.
-        # We do the same here for backward compatibility, but this is very much a hack
-        # and streaming should be rethought.
-        context.active_support_execution_state = other.active_support_execution_state.dup
-      end
-
-      private
-        def state
-          context.active_support_execution_state ||= {}
-        end
-    end
-
-    self.isolation_level = :thread
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/json/decoding.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/module/delegation"
-require "json"
-
-module ActiveSupport
-  # Look for and parse JSON strings that look like ISO 8601 times.
-  mattr_accessor :parse_json_times
-
-  module JSON
-    # matches YAML-formatted dates
-    DATE_REGEX = /\A\d{4}-\d{2}-\d{2}\z/
-    DATETIME_REGEX = /\A(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)\z/
-
-    class << self
-      # Parses a JSON string (JavaScript Object Notation) into a Ruby object.
-      # See http://www.json.org for more info.
-      #
-      #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
-      #   # => {"team" => "rails", "players" => "36"}
-      #   ActiveSupport::JSON.decode("2.39")
-      #   # => 2.39
-      def decode(json)
-        data = ::JSON.parse(json, quirks_mode: true)
-
-        if ActiveSupport.parse_json_times
-          convert_dates_from(data)
-        else
-          data
-        end
-      end
-      alias_method :load, :decode
-
-      # Returns the class of the error that will be raised when there is an
-      # error in decoding JSON. Using this method means you won't directly
-      # depend on the ActiveSupport's JSON implementation, in case it changes
-      # in the future.
-      #
-      #   begin
-      #     obj = ActiveSupport::JSON.decode(some_string)
-      #   rescue ActiveSupport::JSON.parse_error
-      #     Rails.logger.warn("Attempted to decode invalid JSON: #{some_string}")
-      #   end
-      def parse_error
-        ::JSON::ParserError
-      end
-
-      private
-        def convert_dates_from(data)
-          case data
-          when nil
-            nil
-          when DATE_REGEX
-            begin
-              Date.parse(data)
-            rescue ArgumentError
-              data
-            end
-          when DATETIME_REGEX
-            begin
-              Time.zone.parse(data)
-            rescue ArgumentError
-              data
-            end
-          when Array
-            data.map! { |d| convert_dates_from(d) }
-          when Hash
-            data.transform_values! do |value|
-              convert_dates_from(value)
-            end
-          else
-            data
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/json/encoding.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/json"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  class << self
-    delegate :use_standard_json_time_format, :use_standard_json_time_format=,
-      :time_precision, :time_precision=,
-      :escape_html_entities_in_json, :escape_html_entities_in_json=,
-      :json_encoder, :json_encoder=,
-      to: :'ActiveSupport::JSON::Encoding'
-  end
-
-  module JSON
-    class << self
-      # Dumps objects in JSON (JavaScript Object Notation).
-      # See http://www.json.org for more info.
-      #
-      #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
-      #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-      #
-      # Generates JSON that is safe to include in JavaScript as it escapes
-      # U+2028 (Line Separator) and U+2029 (Paragraph Separator):
-      #
-      #   ActiveSupport::JSON.encode({ key: "\u2028" })
-      #   # => "{\"key\":\"\\u2028\"}"
-      #
-      # By default, it also generates JSON that is safe to include in HTML, as
-      # it escapes <tt><</tt>, <tt>></tt>, and <tt>&</tt>:
-      #
-      #   ActiveSupport::JSON.encode({ key: "<>&" })
-      #   # => "{\"key\":\"\\u003c\\u003e\\u0026\"}"
-      #
-      # This can be changed with the +escape_html_entities+ option, or the
-      # global escape_html_entities_in_json configuration option.
-      #
-      #   ActiveSupport::JSON.encode({ key: "<>&" }, escape_html_entities: false)
-      #   # => "{\"key\":\"<>&\"}"
-      def encode(value, options = nil)
-        Encoding.json_encoder.new(options).encode(value)
-      end
-      alias_method :dump, :encode
-    end
-
-    module Encoding # :nodoc:
-      class JSONGemEncoder # :nodoc:
-        attr_reader :options
-
-        def initialize(options = nil)
-          @options = options || {}
-        end
-
-        # Encode the given object into a JSON string
-        def encode(value)
-          unless options.empty?
-            value = value.as_json(options.dup.freeze)
-          end
-          json = stringify(jsonify(value))
-
-          # Rails does more escaping than the JSON gem natively does (we
-          # escape \u2028 and \u2029 and optionally >, <, & to work around
-          # certain browser problems).
-          if @options.fetch(:escape_html_entities, Encoding.escape_html_entities_in_json)
-            json.gsub!(">", '\u003e')
-            json.gsub!("<", '\u003c')
-            json.gsub!("&", '\u0026')
-          end
-          json.gsub!("\u2028", '\u2028')
-          json.gsub!("\u2029", '\u2029')
-          json
-        end
-
-        private
-          # Convert an object into a "JSON-ready" representation composed of
-          # primitives like Hash, Array, String, Symbol, Numeric,
-          # and +true+/+false+/+nil+.
-          # Recursively calls #as_json to the object to recursively build a
-          # fully JSON-ready object.
-          #
-          # This allows developers to implement #as_json without having to
-          # worry about what base types of objects they are allowed to return
-          # or having to remember to call #as_json recursively.
-          #
-          # Note: the +options+ hash passed to +object.to_json+ is only passed
-          # to +object.as_json+, not any of this method's recursive +#as_json+
-          # calls.
-          def jsonify(value)
-            case value
-            when String, Integer, Symbol, nil, true, false
-              value
-            when Numeric
-              value.as_json
-            when Hash
-              result = {}
-              value.each do |k, v|
-                k = k.to_s unless Symbol === k || String === k
-                result[k] = jsonify(v)
-              end
-              result
-            when Array
-              value.map { |v| jsonify(v) }
-            else
-              jsonify value.as_json
-            end
-          end
-
-          # Encode a "jsonified" Ruby data structure using the JSON gem
-          def stringify(jsonified)
-            ::JSON.generate(jsonified, quirks_mode: true, max_nesting: false)
-          end
-      end
-
-      class << self
-        # If true, use ISO 8601 format for dates and times. Otherwise, fall back
-        # to the Active Support legacy format.
-        attr_accessor :use_standard_json_time_format
-
-        # If true, encode >, <, & as escaped unicode sequences (e.g. > as \u003e)
-        # as a safety measure.
-        attr_accessor :escape_html_entities_in_json
-
-        # Sets the precision of encoded time values.
-        # Defaults to 3 (equivalent to millisecond precision)
-        attr_accessor :time_precision
-
-        # Sets the encoder used by \Rails to encode Ruby objects into JSON strings
-        # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
-        attr_accessor :json_encoder
-      end
-
-      self.use_standard_json_time_format = true
-      self.escape_html_entities_in_json  = true
-      self.json_encoder = JSONGemEncoder
-      self.time_precision = 3
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/log_subscriber.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/enumerable"
-require "active_support/subscriber"
-require "active_support/deprecation/proxy_wrappers"
-
-module ActiveSupport
-  # = Active Support Log \Subscriber
-  #
-  # +ActiveSupport::LogSubscriber+ is an object set to consume
-  # ActiveSupport::Notifications with the sole purpose of logging them.
-  # The log subscriber dispatches notifications to a registered object based
-  # on its given namespace.
-  #
-  # An example would be Active Record log subscriber responsible for logging
-  # queries:
-  #
-  #   module ActiveRecord
-  #     class LogSubscriber < ActiveSupport::LogSubscriber
-  #       attach_to :active_record
-  #
-  #       def sql(event)
-  #         info "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
-  #       end
-  #     end
-  #   end
-  #
-  # ActiveRecord::LogSubscriber.logger must be set as well, but it is assigned
-  # automatically in a \Rails environment.
-  #
-  # After configured, whenever a <tt>"sql.active_record"</tt> notification is
-  # published, it will properly dispatch the event
-  # (ActiveSupport::Notifications::Event) to the +sql+ method.
-  #
-  # Being an ActiveSupport::Notifications consumer,
-  # +ActiveSupport::LogSubscriber+ exposes a simple interface to check if
-  # instrumented code raises an exception. It is common to log a different
-  # message in case of an error, and this can be achieved by extending
-  # the previous example:
-  #
-  #   module ActiveRecord
-  #     class LogSubscriber < ActiveSupport::LogSubscriber
-  #       def sql(event)
-  #         exception = event.payload[:exception]
-  #
-  #         if exception
-  #           exception_object = event.payload[:exception_object]
-  #
-  #           error "[ERROR] #{event.payload[:name]}: #{exception.join(', ')} " \
-  #                 "(#{exception_object.backtrace.first})"
-  #         else
-  #           # standard logger code
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  # +ActiveSupport::LogSubscriber+ also has some helpers to deal with
-  # logging. For example, ActiveSupport::LogSubscriber.flush_all! will ensure
-  # that all logs are flushed, and it is called in Rails::Rack::Logger after a
-  # request finishes.
-  class LogSubscriber < Subscriber
-    # ANSI sequence modes
-    MODES = {
-      clear:     0,
-      bold:      1,
-      italic:    3,
-      underline: 4,
-    }
-
-    # ANSI sequence colors
-    BLACK   = "\e[30m"
-    RED     = "\e[31m"
-    GREEN   = "\e[32m"
-    YELLOW  = "\e[33m"
-    BLUE    = "\e[34m"
-    MAGENTA = "\e[35m"
-    CYAN    = "\e[36m"
-    WHITE   = "\e[37m"
-
-    mattr_accessor :colorize_logging, default: true
-    class_attribute :log_levels, instance_accessor: false, default: {} # :nodoc:
-
-    LEVEL_CHECKS = {
-      debug: -> (logger) { !logger.debug? },
-      info: -> (logger) { !logger.info? },
-      error: -> (logger) { !logger.error? },
-    }
-
-    class << self
-      def logger
-        @logger ||= if defined?(Rails) && Rails.respond_to?(:logger)
-          Rails.logger
-        end
-      end
-
-      def attach_to(...) # :nodoc:
-        result = super
-        set_event_levels
-        result
-      end
-
-      attr_writer :logger
-
-      def log_subscribers
-        subscribers
-      end
-
-      # Flush all log_subscribers' logger.
-      def flush_all!
-        logger.flush if logger.respond_to?(:flush)
-      end
-
-      private
-        def fetch_public_methods(subscriber, inherit_all)
-          subscriber.public_methods(inherit_all) - LogSubscriber.public_instance_methods(true)
-        end
-
-        def set_event_levels
-          if subscriber
-            subscriber.event_levels = log_levels.transform_keys { |k| "#{k}.#{namespace}" }
-          end
-        end
-
-        def subscribe_log_level(method, level)
-          self.log_levels = log_levels.merge(method => LEVEL_CHECKS.fetch(level))
-          set_event_levels
-        end
-    end
-
-    def initialize
-      super
-      @event_levels = {}
-    end
-
-    def logger
-      LogSubscriber.logger
-    end
-
-    def silenced?(event)
-      logger.nil? || @event_levels[event]&.call(logger)
-    end
-
-    def call(event)
-      super if logger
-    rescue => e
-      log_exception(event.name, e)
-    end
-
-    def publish_event(event)
-      super if logger
-    rescue => e
-      log_exception(event.name, e)
-    end
-
-    attr_writer :event_levels # :nodoc:
-
-  private
-    %w(info debug warn error fatal unknown).each do |level|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{level}(progname = nil, &block)
-          logger.#{level}(progname, &block) if logger
-        end
-      METHOD
-    end
-
-    # Set color by using a symbol or one of the defined constants. Set modes
-    # by specifying bold, italic, or underline options. Inspired by Highline,
-    # this method will automatically clear formatting at the end of the returned String.
-    def color(text, color, mode_options = {}) # :doc:
-      return text unless colorize_logging
-      color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
-      mode = mode_from(mode_options)
-      clear = "\e[#{MODES[:clear]}m"
-      "#{mode}#{color}#{text}#{clear}"
-    end
-
-    def mode_from(options)
-      modes = MODES.values_at(*options.compact_blank.keys)
-
-      "\e[#{modes.join(";")}m" if modes.any?
-    end
-
-    def log_exception(name, e)
-      if logger
-        logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
-      end
-    end
-  end
-end