ric 0.14.2 → 0.14.6

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-if RUBY_VERSION < "2.6.0"
-  require "active_support/core_ext/module/redefine_method"
-  URI::Parser.class_eval do
-    silence_redefinition_of_method :unescape
-    def unescape(str, escaped = /%[a-fA-F\d]{2}/)
-      # TODO: Are we actually sure that ASCII == UTF-8?
-      # YK: My initial experiments say yes, but let's be sure please
-      enc = str.encoding
-      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-      str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
-    end
-  end
-end
-
-module URI
-  class << self
-    def parser
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        URI.parser is deprecated and will be removed in Rails 6.2.
-        Use `URI::DEFAULT_PARSER` instead.
-      MSG
-      URI::DEFAULT_PARSER
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
-  require path
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport::CurrentAttributes::TestHelper # :nodoc:
-  def before_setup
-    ActiveSupport::CurrentAttributes.reset_all
-    super
-  end
-
-  def after_teardown
-    super
-    ActiveSupport::CurrentAttributes.reset_all
-  end
-end

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

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/callbacks"
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
-  # before and after each request. This allows you to keep all the per-request attributes easily
-  # available to the whole system.
-  #
-  # The following full app-like example demonstrates how to use a Current class to
-  # facilitate easy access to the global, per-request attributes without passing them deeply
-  # around everywhere:
-  #
-  #   # app/models/current.rb
-  #   class Current < ActiveSupport::CurrentAttributes
-  #     attribute :account, :user
-  #     attribute :request_id, :user_agent, :ip_address
-  #
-  #     resets { Time.zone = nil }
-  #
-  #     def user=(user)
-  #       super
-  #       self.account = user.account
-  #       Time.zone    = user.time_zone
-  #     end
-  #   end
-  #
-  #   # app/controllers/concerns/authentication.rb
-  #   module Authentication
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       before_action :authenticate
-  #     end
-  #
-  #     private
-  #       def authenticate
-  #         if authenticated_user = User.find_by(id: cookies.encrypted[:user_id])
-  #           Current.user = authenticated_user
-  #         else
-  #           redirect_to new_session_url
-  #         end
-  #       end
-  #   end
-  #
-  #   # app/controllers/concerns/set_current_request_details.rb
-  #   module SetCurrentRequestDetails
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       before_action do
-  #         Current.request_id = request.uuid
-  #         Current.user_agent = request.user_agent
-  #         Current.ip_address = request.ip
-  #       end
-  #     end
-  #   end
-  #
-  #   class ApplicationController < ActionController::Base
-  #     include Authentication
-  #     include SetCurrentRequestDetails
-  #   end
-  #
-  #   class MessagesController < ApplicationController
-  #     def create
-  #       Current.account.messages.create(message_params)
-  #     end
-  #   end
-  #
-  #   class Message < ApplicationRecord
-  #     belongs_to :creator, default: -> { Current.user }
-  #     after_create { |message| Event.create(record: message) }
-  #   end
-  #
-  #   class Event < ApplicationRecord
-  #     before_create do
-  #       self.request_id = Current.request_id
-  #       self.user_agent = Current.user_agent
-  #       self.ip_address = Current.ip_address
-  #     end
-  #   end
-  #
-  # A word of caution: It's easy to overdo a global singleton like Current and tangle your model as a result.
-  # Current should only be used for a few, top-level globals, like account, user, and request details.
-  # The attributes stuck in Current should be used by more or less all actions on all requests. If you start
-  # sticking controller-specific attributes in there, you're going to create a mess.
-  class CurrentAttributes
-    include ActiveSupport::Callbacks
-    define_callbacks :reset
-
-    class << self
-      # Returns singleton instance for this class in this thread. If none exists, one is created.
-      def instance
-        current_instances[current_instances_key] ||= new
-      end
-
-      # Declares one or more attributes that will be given both class and instance accessor methods.
-      def attribute(*names)
-        generated_attribute_methods.module_eval do
-          names.each do |name|
-            define_method(name) do
-              attributes[name.to_sym]
-            end
-
-            define_method("#{name}=") do |attribute|
-              attributes[name.to_sym] = attribute
-            end
-          end
-        end
-
-        names.each do |name|
-          define_singleton_method(name) do
-            instance.public_send(name)
-          end
-
-          define_singleton_method("#{name}=") do |attribute|
-            instance.public_send("#{name}=", attribute)
-          end
-        end
-      end
-
-      # Calls this block before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
-      def before_reset(&block)
-        set_callback :reset, :before, &block
-      end
-
-      # Calls this block after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
-      def resets(&block)
-        set_callback :reset, :after, &block
-      end
-      alias_method :after_reset, :resets
-
-      delegate :set, :reset, to: :instance
-
-      def reset_all # :nodoc:
-        current_instances.each_value(&:reset)
-      end
-
-      def clear_all # :nodoc:
-        reset_all
-        current_instances.clear
-      end
-
-      private
-        def generated_attribute_methods
-          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
-        end
-
-        def current_instances
-          Thread.current[:current_attributes_instances] ||= {}
-        end
-
-        def current_instances_key
-          @current_instances_key ||= name.to_sym
-        end
-
-        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
-
-    attr_accessor :attributes
-
-    def initialize
-      @attributes = {}
-    end
-
-    # Expose one or more attributes within a block. Old values are returned after the block concludes.
-    # Example demonstrating the common use of needing to set Current attributes outside the request-cycle:
-    #
-    #   class Chat::PublicationJob < ApplicationJob
-    #     def perform(attributes, room_number, creator)
-    #       Current.set(person: creator) do
-    #         Chat::Publisher.publish(attributes: attributes, room_number: room_number)
-    #       end
-    #     end
-    #   end
-    def set(set_attributes)
-      old_attributes = compute_attributes(set_attributes.keys)
-      assign_attributes(set_attributes)
-      yield
-    ensure
-      assign_attributes(old_attributes)
-    end
-
-    # Reset all attributes. Should be called before and after actions, when used as a per-request singleton.
-    def reset
-      run_callbacks :reset do
-        self.attributes = {}
-      end
-    end
-
-    private
-      def assign_attributes(new_attributes)
-        new_attributes.each { |key, value| public_send("#{key}=", value) }
-      end
-
-      def compute_attributes(keys)
-        keys.index_with { |key| public_send(key) }
-      end
-  end
-end

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflector/methods"
-
-module ActiveSupport
-  # Autoload and eager load conveniences for your library.
-  #
-  # This module allows you to define autoloads based on
-  # Rails conventions (i.e. no need to define the path
-  # it is automatically guessed based on the filename)
-  # and also define a set of constants that needs to be
-  # eager loaded:
-  #
-  #   module MyLib
-  #     extend ActiveSupport::Autoload
-  #
-  #     autoload :Model
-  #
-  #     eager_autoload do
-  #       autoload :Cache
-  #     end
-  #   end
-  #
-  # Then your library can be eager loaded by simply calling:
-  #
-  #   MyLib.eager_load!
-  module Autoload
-    def self.extended(base) # :nodoc:
-      base.class_eval do
-        @_autoloads = {}
-        @_under_path = nil
-        @_at_path = nil
-        @_eager_autoload = false
-      end
-    end
-
-    def autoload(const_name, path = @_at_path)
-      unless path
-        full = [name, @_under_path, const_name.to_s].compact.join("::")
-        path = Inflector.underscore(full)
-      end
-
-      if @_eager_autoload
-        @_autoloads[const_name] = path
-      end
-
-      super const_name, path
-    end
-
-    def autoload_under(path)
-      @_under_path, old_path = path, @_under_path
-      yield
-    ensure
-      @_under_path = old_path
-    end
-
-    def autoload_at(path)
-      @_at_path, old_path = path, @_at_path
-      yield
-    ensure
-      @_at_path = old_path
-    end
-
-    def eager_autoload
-      old_eager, @_eager_autoload = @_eager_autoload, true
-      yield
-    ensure
-      @_eager_autoload = old_eager
-    end
-
-    def eager_load!
-      @_autoloads.each_value { |file| require file }
-    end
-
-    def autoloads
-      @_autoloads
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concurrency/share_lock"
-
-module ActiveSupport #:nodoc:
-  module Dependencies #:nodoc:
-    class Interlock
-      def initialize # :nodoc:
-        @lock = ActiveSupport::Concurrency::ShareLock.new
-      end
-
-      def loading
-        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load]) do
-          yield
-        end
-      end
-
-      def unloading
-        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload]) do
-          yield
-        end
-      end
-
-      def start_unloading
-        @lock.start_exclusive(purpose: :unload, compatible: [:load, :unload])
-      end
-
-      def done_unloading
-        @lock.stop_exclusive(compatible: [:load, :unload])
-      end
-
-      def start_running
-        @lock.start_sharing
-      end
-
-      def done_running
-        @lock.stop_sharing
-      end
-
-      def running
-        @lock.sharing do
-          yield
-        end
-      end
-
-      def permit_concurrent_loads
-        @lock.yield_shares(compatible: [:load]) do
-          yield
-        end
-      end
-
-      def raw_state(&block) # :nodoc:
-        @lock.raw_state(&block)
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require "active_support/core_ext/string/inflections"
-
-module ActiveSupport
-  module Dependencies
-    module ZeitwerkIntegration # :nodoc: all
-      module Decorations
-        def clear
-          Dependencies.unload_interlock do
-            Rails.autoloaders.main.reload
-          rescue Zeitwerk::ReloadingDisabledError
-            raise "reloading is disabled because config.cache_classes is true"
-          end
-        end
-
-        def constantize(cpath)
-          ActiveSupport::Inflector.constantize(cpath)
-        end
-
-        def safe_constantize(cpath)
-          ActiveSupport::Inflector.safe_constantize(cpath)
-        end
-
-        def autoloaded_constants
-          Rails.autoloaders.main.unloadable_cpaths
-        end
-
-        def autoloaded?(object)
-          cpath = object.is_a?(Module) ? real_mod_name(object) : object.to_s
-          Rails.autoloaders.main.unloadable_cpath?(cpath)
-        end
-
-        def verbose=(verbose)
-          l = verbose ? logger || Rails.logger : nil
-          Rails.autoloaders.each { |autoloader| autoloader.logger = l }
-        end
-
-        def unhook!
-          :no_op
-        end
-      end
-
-      module RequireDependency
-        def require_dependency(filename)
-          filename = filename.to_path if filename.respond_to?(:to_path)
-          if abspath = ActiveSupport::Dependencies.search_for_file(filename)
-            require abspath
-          else
-            require filename
-          end
-        end
-      end
-
-      module Inflector
-        # Concurrent::Map is not needed. This is a private class, and overrides
-        # must be defined while the application boots.
-        @overrides = {}
-
-        def self.camelize(basename, _abspath)
-          @overrides[basename] || basename.camelize
-        end
-
-        def self.inflect(overrides)
-          @overrides.merge!(overrides)
-        end
-      end
-
-      class << self
-        def take_over(enable_reloading:)
-          setup_autoloaders(enable_reloading)
-          freeze_paths
-          decorate_dependencies
-        end
-
-        private
-          def setup_autoloaders(enable_reloading)
-            Dependencies.autoload_paths.each do |autoload_path|
-              # Zeitwerk only accepts existing directories in `push_dir` to
-              # prevent misconfigurations.
-              next unless File.directory?(autoload_path)
-
-              autoloader = \
-                autoload_once?(autoload_path) ? Rails.autoloaders.once : Rails.autoloaders.main
-
-              autoloader.push_dir(autoload_path)
-              autoloader.do_not_eager_load(autoload_path) unless eager_load?(autoload_path)
-            end
-
-            Rails.autoloaders.main.enable_reloading if enable_reloading
-            Rails.autoloaders.each(&:setup)
-          end
-
-          def autoload_once?(autoload_path)
-            Dependencies.autoload_once_paths.include?(autoload_path)
-          end
-
-          def eager_load?(autoload_path)
-            Dependencies._eager_load_paths.member?(autoload_path)
-          end
-
-          def freeze_paths
-            Dependencies.autoload_paths.freeze
-            Dependencies.autoload_once_paths.freeze
-            Dependencies._eager_load_paths.freeze
-          end
-
-          def decorate_dependencies
-            Dependencies.unhook!
-            Dependencies.singleton_class.prepend(Decorations)
-            Object.prepend(RequireDependency)
-          end
-      end
-    end
-  end
-end