ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/parameter_filter.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/duplicable"
-
-module ActiveSupport
-  # +ParameterFilter+ allows you to specify keys for sensitive data from
-  # hash-like object and replace corresponding value. Filtering only certain
-  # sub-keys from a hash is possible by using the dot notation:
-  # 'credit_card.number'. If a proc is given, each key and value of a hash and
-  # all sub-hashes are passed to it, where the value or the key can be replaced
-  # using String#replace or similar methods.
-  #
-  #   ActiveSupport::ParameterFilter.new([:password])
-  #   => replaces the value to all keys matching /password/i with "[FILTERED]"
-  #
-  #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
-  #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
-  #
-  #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
-  #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
-  #   change { file: { code: "xxxx"} }
-  #
-  #   ActiveSupport::ParameterFilter.new([-> (k, v) do
-  #     v.reverse! if /secret/i.match?(k)
-  #   end])
-  #   => reverses the value to all keys matching /secret/i
-  class ParameterFilter
-    FILTERED = "[FILTERED]" # :nodoc:
-
-    # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
-    # Other types of filters are treated as +String+ using +to_s+.
-    # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
-    #
-    # ==== Options
-    #
-    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
-    def initialize(filters = [], mask: FILTERED)
-      @filters = filters
-      @mask = mask
-    end
-
-    # Mask value of +params+ if key matches one of filters.
-    def filter(params)
-      compiled_filter.call(params)
-    end
-
-    # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
-    def filter_param(key, value)
-      @filters.empty? ? value : compiled_filter.value_for_key(key, value)
-    end
-
-  private
-    def compiled_filter
-      @compiled_filter ||= CompiledFilter.compile(@filters, mask: @mask)
-    end
-
-    class CompiledFilter # :nodoc:
-      def self.compile(filters, mask:)
-        return lambda { |params| params.dup } if filters.empty?
-
-        strings, regexps, blocks, deep_regexps, deep_strings = [], [], [], nil, nil
-
-        filters.each do |item|
-          case item
-          when Proc
-            blocks << item
-          when Regexp
-            if item.to_s.include?("\\.")
-              (deep_regexps ||= []) << item
-            else
-              regexps << item
-            end
-          else
-            s = Regexp.escape(item.to_s)
-            if s.include?("\\.")
-              (deep_strings ||= []) << s
-            else
-              strings << s
-            end
-          end
-        end
-
-        regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
-        (deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings&.any?
-
-        new regexps, deep_regexps, blocks, mask: mask
-      end
-
-      attr_reader :regexps, :deep_regexps, :blocks
-
-      def initialize(regexps, deep_regexps, blocks, mask:)
-        @regexps = regexps
-        @deep_regexps = deep_regexps&.any? ? deep_regexps : nil
-        @blocks = blocks
-        @mask = mask
-      end
-
-      def call(params, parents = [], original_params = params)
-        filtered_params = params.class.new
-
-        params.each do |key, value|
-          filtered_params[key] = value_for_key(key, value, parents, original_params)
-        end
-
-        filtered_params
-      end
-
-      def value_for_key(key, value, parents = [], original_params = nil)
-        parents.push(key) if deep_regexps
-        if regexps.any? { |r| r.match?(key.to_s) }
-          value = @mask
-        elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| r.match?(joined) }
-          value = @mask
-        elsif value.is_a?(Hash)
-          value = call(value, parents, original_params)
-        elsif value.is_a?(Array)
-          # If we don't pop the current parent it will be duplicated as we
-          # process each array value.
-          parents.pop if deep_regexps
-          value = value.map { |v| value_for_key(key, v, parents, original_params) }
-          # Restore the parent stack after processing the array.
-          parents.push(key) if deep_regexps
-        elsif blocks.any?
-          key = key.dup if key.duplicable?
-          value = value.dup if value.duplicable?
-          blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
-        end
-        parents.pop if deep_regexps
-        value
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/per_thread_registry.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  # NOTE: This approach has been deprecated for end-user code in favor of {thread_mattr_accessor}[rdoc-ref:Module#thread_mattr_accessor] and friends.
-  # Please use that approach instead.
-  #
-  # This module is used to encapsulate access to thread local variables.
-  #
-  # Instead of polluting the thread locals namespace:
-  #
-  #   Thread.current[:connection_handler]
-  #
-  # you define a class that extends this module:
-  #
-  #   module ActiveRecord
-  #     class RuntimeRegistry
-  #       extend ActiveSupport::PerThreadRegistry
-  #
-  #       attr_accessor :connection_handler
-  #     end
-  #   end
-  #
-  # and invoke the declared instance accessors as class methods. So
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
-  #
-  # sets a connection handler local to the current thread, and
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns a connection handler local to the current thread.
-  #
-  # This feature is accomplished by instantiating the class and storing the
-  # instance as a thread local keyed by the class name. In the example above
-  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
-  # The class methods proxy to said thread local instance.
-  #
-  # If the class has an initializer, it must accept no arguments.
-  module PerThreadRegistry
-    def self.extended(object)
-      object.instance_variable_set :@per_thread_registry_key, object.name.freeze
-    end
-
-    def instance
-      Thread.current[@per_thread_registry_key] ||= new
-    end
-
-    private
-      def method_missing(name, *args, &block)
-        # Caches the method definition as a singleton method of the receiver.
-        #
-        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
-        singleton_class.delegate name, to: :instance
-
-        send(name, *args, &block)
-      end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/proxy_object.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # A class with no predefined methods that behaves similarly to Builder's
-  # BlankSlate. Used for proxy classes.
-  class ProxyObject < ::BasicObject
-    undef_method :==
-    undef_method :equal?
-
-    # Let ActiveSupport::ProxyObject at least raise exceptions.
-    def raise(*args)
-      ::Object.send(:raise, *args)
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/rails.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# This is a private interface.
-#
-# Rails components cherry pick from Active Support as needed, but there are a
-# few features that are used for sure in some way or another and it is not worth
-# putting individual requires absolutely everywhere. Think blank? for example.
-#
-# This file is loaded by every Rails component except Active Support itself,
-# but it does not belong to the Rails public interface. It is internal to
-# Rails and can change anytime.
-
-# Defines Object#blank? and Object#present?.
-require "active_support/core_ext/object/blank"
-
-# Support for ClassMethods and the included macro.
-require "active_support/concern"
-
-# Defines Class#class_attribute.
-require "active_support/core_ext/class/attribute"
-
-# Defines Module#delegate.
-require "active_support/core_ext/module/delegation"
-
-# Defines ActiveSupport::Deprecation.
-require "active_support/deprecation"

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/railtie.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/i18n_railtie"
-
-module ActiveSupport
-  class Railtie < Rails::Railtie # :nodoc:
-    config.active_support = ActiveSupport::OrderedOptions.new
-
-    config.eager_load_namespaces << ActiveSupport
-
-    initializer "active_support.set_authenticated_message_encryption" do |app|
-      config.after_initialize do
-        unless app.config.active_support.use_authenticated_message_encryption.nil?
-          ActiveSupport::MessageEncryptor.use_authenticated_message_encryption =
-            app.config.active_support.use_authenticated_message_encryption
-        end
-      end
-    end
-
-    initializer "active_support.reset_all_current_attributes_instances" do |app|
-      app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
-      app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
-      app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
-
-      ActiveSupport.on_load(:active_support_test_case) do
-        require "active_support/current_attributes/test_helper"
-        include ActiveSupport::CurrentAttributes::TestHelper
-      end
-    end
-
-    initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
-      end
-
-      if disallowed_deprecation = app.config.active_support.disallowed_deprecation
-        ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
-      end
-
-      if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
-        ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
-      end
-    end
-
-    # Sets the default value for Time.zone
-    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
-    initializer "active_support.initialize_time_zone" do |app|
-      begin
-        TZInfo::DataSource.get
-      rescue TZInfo::DataSourceNotFound => e
-        raise e.exception "tzinfo-data is not present. Please add gem 'tzinfo-data' to your Gemfile and run bundle install"
-      end
-      require "active_support/core_ext/time/zones"
-      Time.zone_default = Time.find_zone!(app.config.time_zone)
-    end
-
-    # Sets the default week start
-    # If assigned value is not a valid day symbol (e.g. :sunday, :monday, ...), an exception will be raised.
-    initializer "active_support.initialize_beginning_of_week" do |app|
-      require "active_support/core_ext/date/calculations"
-      beginning_of_week_default = Date.find_beginning_of_week!(app.config.beginning_of_week)
-
-      Date.beginning_of_week_default = beginning_of_week_default
-    end
-
-    initializer "active_support.require_master_key" do |app|
-      if app.config.respond_to?(:require_master_key) && app.config.require_master_key
-        begin
-          app.credentials.key
-        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
-          $stderr.puts error.message
-          exit 1
-        end
-      end
-    end
-
-    initializer "active_support.set_configs" do |app|
-      app.config.active_support.each do |k, v|
-        k = "#{k}="
-        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
-      end
-    end
-
-    initializer "active_support.set_hash_digest_class" do |app|
-      config.after_initialize do
-        if app.config.active_support.use_sha1_digests
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            config.active_support.use_sha1_digests is deprecated and will
-            be removed from Rails 6.2. Use
-            config.active_support.hash_digest_class = ::Digest::SHA1 instead.
-          MSG
-          ActiveSupport::Digest.hash_digest_class = ::Digest::SHA1
-        end
-
-        if klass = app.config.active_support.hash_digest_class
-          ActiveSupport::Digest.hash_digest_class = klass
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/reloader.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/execution_wrapper"
-require "active_support/executor"
-
-module ActiveSupport
-  #--
-  # This class defines several callbacks:
-  #
-  #   to_prepare -- Run once at application startup, and also from
-  #   +to_run+.
-  #
-  #   to_run -- Run before a work run that is reloading. If
-  #   +reload_classes_only_on_change+ is true (the default), the class
-  #   unload will have already occurred.
-  #
-  #   to_complete -- Run after a work run that has reloaded. If
-  #   +reload_classes_only_on_change+ is false, the class unload will
-  #   have occurred after the work run, but before this callback.
-  #
-  #   before_class_unload -- Run immediately before the classes are
-  #   unloaded.
-  #
-  #   after_class_unload -- Run immediately after the classes are
-  #   unloaded.
-  #
-  class Reloader < ExecutionWrapper
-    define_callbacks :prepare
-
-    define_callbacks :class_unload
-
-    # Registers a callback that will run once at application startup and every time the code is reloaded.
-    def self.to_prepare(*args, &block)
-      set_callback(:prepare, *args, &block)
-    end
-
-    # Registers a callback that will run immediately before the classes are unloaded.
-    def self.before_class_unload(*args, &block)
-      set_callback(:class_unload, *args, &block)
-    end
-
-    # Registers a callback that will run immediately after the classes are unloaded.
-    def self.after_class_unload(*args, &block)
-      set_callback(:class_unload, :after, *args, &block)
-    end
-
-    to_run(:after) { self.class.prepare! }
-
-    # Initiate a manual reload
-    def self.reload!
-      executor.wrap do
-        new.tap do |instance|
-          instance.run!
-        ensure
-          instance.complete!
-        end
-      end
-      prepare!
-    end
-
-    def self.run! # :nodoc:
-      if check!
-        super
-      else
-        Null
-      end
-    end
-
-    # Run the supplied block as a work unit, reloading code as needed
-    def self.wrap
-      executor.wrap do
-        super
-      end
-    end
-
-    class_attribute :executor, default: Executor
-    class_attribute :check, default: lambda { false }
-
-    def self.check! # :nodoc:
-      @should_reload ||= check.call
-    end
-
-    def self.reloaded! # :nodoc:
-      @should_reload = false
-    end
-
-    def self.prepare! # :nodoc:
-      new.run_callbacks(:prepare)
-    end
-
-    def initialize
-      super
-      @locked = false
-    end
-
-    # Acquire the ActiveSupport::Dependencies::Interlock unload lock,
-    # ensuring it will be released automatically
-    def require_unload_lock!
-      unless @locked
-        ActiveSupport::Dependencies.interlock.start_unloading
-        @locked = true
-      end
-    end
-
-    # Release the unload lock if it has been previously obtained
-    def release_unload_lock!
-      if @locked
-        @locked = false
-        ActiveSupport::Dependencies.interlock.done_unloading
-      end
-    end
-
-    def run! # :nodoc:
-      super
-      release_unload_lock!
-    end
-
-    def class_unload!(&block) # :nodoc:
-      require_unload_lock!
-      run_callbacks(:class_unload, &block)
-    end
-
-    def complete! # :nodoc:
-      super
-      self.class.reloaded!
-    ensure
-      release_unload_lock!
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/rescuable.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/string/inflections"
-
-module ActiveSupport
-  # Rescuable module adds support for easier exception handling.
-  module Rescuable
-    extend Concern
-
-    included do
-      class_attribute :rescue_handlers, default: []
-    end
-
-    module ClassMethods
-      # Registers exception classes with a handler to be called by <tt>rescue_with_handler</tt>.
-      #
-      # <tt>rescue_from</tt> receives a series of exception classes or class
-      # names, and an exception handler specified by a trailing <tt>:with</tt>
-      # option containing the name of a method or a Proc object. Alternatively, a block
-      # can be given as the handler.
-      #
-      # Handlers that take one argument will be called with the exception, so
-      # that the exception can be inspected when dealing with it.
-      #
-      # Handlers are inherited. They are searched from right to left, from
-      # bottom to top, and up the hierarchy. The handler of the first class for
-      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if
-      # any.
-      #
-      #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
-      #
-      #     rescue_from 'MyAppError::Base' do |exception|
-      #       render xml: exception, status: 500
-      #     end
-      #
-      #     private
-      #       def deny_access
-      #         ...
-      #       end
-      #
-      #       def show_errors(exception)
-      #         exception.record.new_record? ? ...
-      #       end
-      #   end
-      #
-      # Exceptions raised inside exception handlers are not propagated up.
-      def rescue_from(*klasses, with: nil, &block)
-        unless with
-          if block_given?
-            with = block
-          else
-            raise ArgumentError, "Need a handler. Pass the with: keyword argument or provide a block."
-          end
-        end
-
-        klasses.each do |klass|
-          key = if klass.is_a?(Module) && klass.respond_to?(:===)
-            klass.name
-          elsif klass.is_a?(String)
-            klass
-          else
-            raise ArgumentError, "#{klass.inspect} must be an Exception class or a String referencing an Exception class"
-          end
-
-          # Put the new handler at the end because the list is read in reverse.
-          self.rescue_handlers += [[key, with]]
-        end
-      end
-
-      # Matches an exception to a handler based on the exception class.
-      #
-      # If no handler matches the exception, check for a handler matching the
-      # (optional) exception.cause. If no handler matches the exception or its
-      # cause, this returns +nil+, so you can deal with unhandled exceptions.
-      # Be sure to re-raise unhandled exceptions if this is what you expect.
-      #
-      #     begin
-      #       …
-      #     rescue => exception
-      #       rescue_with_handler(exception) || raise
-      #     end
-      #
-      # Returns the exception if it was handled and +nil+ if it was not.
-      def rescue_with_handler(exception, object: self, visited_exceptions: [])
-        visited_exceptions << exception
-
-        if handler = handler_for_rescue(exception, object: object)
-          handler.call exception
-          exception
-        elsif exception
-          if visited_exceptions.include?(exception.cause)
-            nil
-          else
-            rescue_with_handler(exception.cause, object: object, visited_exceptions: visited_exceptions)
-          end
-        end
-      end
-
-      def handler_for_rescue(exception, object: self) #:nodoc:
-        case rescuer = find_rescue_handler(exception)
-        when Symbol
-          method = object.method(rescuer)
-          if method.arity == 0
-            -> e { method.call }
-          else
-            method
-          end
-        when Proc
-          if rescuer.arity == 0
-            -> e { object.instance_exec(&rescuer) }
-          else
-            -> e { object.instance_exec(e, &rescuer) }
-          end
-        end
-      end
-
-      private
-        def find_rescue_handler(exception)
-          if exception
-            # Handlers are in order of declaration but the most recently declared
-            # is the highest priority match, so we search for matching handlers
-            # in reverse.
-            _, handler = rescue_handlers.reverse_each.detect do |class_or_name, _|
-              if klass = constantize_rescue_handler_class(class_or_name)
-                klass === exception
-              end
-            end
-
-            handler
-          end
-        end
-
-        def constantize_rescue_handler_class(class_or_name)
-          case class_or_name
-          when String, Symbol
-            begin
-              # Try a lexical lookup first since we support
-              #
-              #     class Super
-              #       rescue_from 'Error', with: …
-              #     end
-              #
-              #     class Sub
-              #       class Error < StandardError; end
-              #     end
-              #
-              # so an Error raised in Sub will hit the 'Error' handler.
-              const_get class_or_name
-            rescue NameError
-              class_or_name.safe_constantize
-            end
-          else
-            class_or_name
-          end
-        end
-    end
-
-    # Delegates to the class method, but uses the instance as the subject for
-    # rescue_from handlers (method calls, instance_exec blocks).
-    def rescue_with_handler(exception)
-      self.class.rescue_with_handler exception, object: self
-    end
-
-    # Internal handler lookup. Delegates to class method. Some libraries call
-    # this directly, so keeping it around for compatibility.
-    def handler_for_rescue(exception) #:nodoc:
-      self.class.handler_for_rescue exception, object: self
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/secure_compare_rotator.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/security_utils"
-require "active_support/messages/rotator"
-
-module ActiveSupport
-  # The ActiveSupport::SecureCompareRotator is a wrapper around +ActiveSupport::SecurityUtils.secure_compare+
-  # and allows you to rotate a previously defined value to a new one.
-  #
-  # It can be used as follow:
-  #
-  #   rotator = ActiveSupport::SecureCompareRotator.new('new_production_value')
-  #   rotator.rotate('previous_production_value')
-  #   rotator.secure_compare!('previous_production_value')
-  #
-  # One real use case example would be to rotate a basic auth credentials:
-  #
-  #   class MyController < ApplicationController
-  #     def authenticate_request
-  #       rotator = ActiveSupport::SecureComparerotator.new('new_password')
-  #       rotator.rotate('old_password')
-  #
-  #       authenticate_or_request_with_http_basic do |username, password|
-  #         rotator.secure_compare!(password)
-  #       rescue ActiveSupport::SecureCompareRotator::InvalidMatch
-  #         false
-  #       end
-  #     end
-  #   end
-  class SecureCompareRotator
-    include SecurityUtils
-    prepend Messages::Rotator
-
-    InvalidMatch = Class.new(StandardError)
-
-    def initialize(value, **_options)
-      @value = value
-    end
-
-    def secure_compare!(other_value, on_rotation: @on_rotation)
-      secure_compare(@value, other_value) ||
-        run_rotations(on_rotation) { |wrapper| wrapper.secure_compare!(other_value) } ||
-        raise(InvalidMatch)
-    end
-
-    private
-      def build_rotation(previous_value, _options)
-        self.class.new(previous_value)
-      end
-  end
-end