ric 0.14.2 → 0.14.6

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

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # A typical module looks like this:
-  #
-  #   module M
-  #     def self.included(base)
-  #       base.extend ClassMethods
-  #       base.class_eval do
-  #         scope :disabled, -> { where(disabled: true) }
-  #       end
-  #     end
-  #
-  #     module ClassMethods
-  #       ...
-  #     end
-  #   end
-  #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
-  # written as:
-  #
-  #   require "active_support/concern"
-  #
-  #   module M
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       scope :disabled, -> { where(disabled: true) }
-  #     end
-  #
-  #     class_methods do
-  #       ...
-  #     end
-  #   end
-  #
-  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
-  # and a +Bar+ module which depends on the former, we would typically write the
-  # following:
-  #
-  #   module Foo
-  #     def self.included(base)
-  #       base.class_eval do
-  #         def self.method_injected_by_foo
-  #           ...
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  #   module Bar
-  #     def self.included(base)
-  #       base.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Foo # We need to include this dependency for Bar
-  #     include Bar # Bar is the module that Host really needs
-  #   end
-  #
-  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
-  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
-  #
-  #   module Bar
-  #     include Foo
-  #     def self.included(base)
-  #       base.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Bar
-  #   end
-  #
-  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
-  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
-  # module dependencies are properly resolved:
-  #
-  #   require "active_support/concern"
-  #
-  #   module Foo
-  #     extend ActiveSupport::Concern
-  #     included do
-  #       def self.method_injected_by_foo
-  #         ...
-  #       end
-  #     end
-  #   end
-  #
-  #   module Bar
-  #     extend ActiveSupport::Concern
-  #     include Foo
-  #
-  #     included do
-  #       self.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Bar # It works, now Bar takes care of its dependencies
-  #   end
-  #
-  # === Prepending concerns
-  #
-  # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
-  # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
-  # prepended as well.
-  #
-  # <tt>prepend</tt> is also used for any dependencies.
-  module Concern
-    class MultipleIncludedBlocks < StandardError #:nodoc:
-      def initialize
-        super "Cannot define multiple 'included' blocks for a Concern"
-      end
-    end
-
-    class MultiplePrependBlocks < StandardError #:nodoc:
-      def initialize
-        super "Cannot define multiple 'prepended' blocks for a Concern"
-      end
-    end
-
-    def self.extended(base) #:nodoc:
-      base.instance_variable_set(:@_dependencies, [])
-    end
-
-    def append_features(base) #:nodoc:
-      if base.instance_variable_defined?(:@_dependencies)
-        base.instance_variable_get(:@_dependencies) << self
-        false
-      else
-        return false if base < self
-        @_dependencies.each { |dep| base.include(dep) }
-        super
-        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
-        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
-      end
-    end
-
-    def prepend_features(base) #:nodoc:
-      if base.instance_variable_defined?(:@_dependencies)
-        base.instance_variable_get(:@_dependencies).unshift self
-        false
-      else
-        return false if base < self
-        @_dependencies.each { |dep| base.prepend(dep) }
-        super
-        base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
-        base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
-      end
-    end
-
-    # Evaluate given block in context of base class,
-    # so that you can write class macros here.
-    # When you define more than one +included+ block, it raises an exception.
-    def included(base = nil, &block)
-      if base.nil?
-        if instance_variable_defined?(:@_included_block)
-          if @_included_block.source_location != block.source_location
-            raise MultipleIncludedBlocks
-          end
-        else
-          @_included_block = block
-        end
-      else
-        super
-      end
-    end
-
-    # Evaluate given block in context of base class,
-    # so that you can write class macros here.
-    # When you define more than one +prepended+ block, it raises an exception.
-    def prepended(base = nil, &block)
-      if base.nil?
-        if instance_variable_defined?(:@_prepended_block)
-          if @_prepended_block.source_location != block.source_location
-            raise MultiplePrependBlocks
-          end
-        else
-          @_prepended_block = block
-        end
-      else
-        super
-      end
-    end
-
-    # Define class methods from given block.
-    # You can define private class methods as well.
-    #
-    #   module Example
-    #     extend ActiveSupport::Concern
-    #
-    #     class_methods do
-    #       def foo; puts 'foo'; end
-    #
-    #       private
-    #         def bar; puts 'bar'; end
-    #     end
-    #   end
-    #
-    #   class Buzz
-    #     include Example
-    #   end
-    #
-    #   Buzz.foo # => "foo"
-    #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
-    def class_methods(&class_methods_module_definition)
-      mod = const_defined?(:ClassMethods, false) ?
-        const_get(:ClassMethods) :
-        const_set(:ClassMethods, Module.new)
-
-      mod.module_eval(&class_methods_module_definition)
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-module ActiveSupport
-  module Concurrency
-    # A monitor that will permit dependency loading while blocked waiting for
-    # the lock.
-    class LoadInterlockAwareMonitor < Monitor
-      EXCEPTION_NEVER = { Exception => :never }.freeze
-      EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze
-      private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
-
-      # Enters an exclusive section, but allows dependency loading while blocked
-      def mon_enter
-        mon_try_enter ||
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads { super }
-      end
-
-      def synchronize
-        Thread.handle_interrupt(EXCEPTION_NEVER) do
-          mon_enter
-
-          begin
-            Thread.handle_interrupt(EXCEPTION_IMMEDIATE) do
-              yield
-            end
-          ensure
-            mon_exit
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require "thread"
-require "monitor"
-
-module ActiveSupport
-  module Concurrency
-    # A share/exclusive lock, otherwise known as a read/write lock.
-    #
-    # https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock
-    class ShareLock
-      include MonitorMixin
-
-      # We track Thread objects, instead of just using counters, because
-      # we need exclusive locks to be reentrant, and we need to be able
-      # to upgrade share locks to exclusive.
-
-      def raw_state # :nodoc:
-        synchronize do
-          threads = @sleeping.keys | @sharing.keys | @waiting.keys
-          threads |= [@exclusive_thread] if @exclusive_thread
-
-          data = {}
-
-          threads.each do |thread|
-            purpose, compatible = @waiting[thread]
-
-            data[thread] = {
-              thread: thread,
-              sharing: @sharing[thread],
-              exclusive: @exclusive_thread == thread,
-              purpose: purpose,
-              compatible: compatible,
-              waiting: !!@waiting[thread],
-              sleeper: @sleeping[thread],
-            }
-          end
-
-          # NB: Yields while holding our *internal* synchronize lock,
-          # which is supposed to be used only for a few instructions at
-          # a time. This allows the caller to inspect additional state
-          # without things changing out from underneath, but would have
-          # disastrous effects upon normal operation. Fortunately, this
-          # method is only intended to be called when things have
-          # already gone wrong.
-          yield data
-        end
-      end
-
-      def initialize
-        super()
-
-        @cv = new_cond
-
-        @sharing = Hash.new(0)
-        @waiting = {}
-        @sleeping = {}
-        @exclusive_thread = nil
-        @exclusive_depth = 0
-      end
-
-      # Returns false if +no_wait+ is set and the lock is not
-      # immediately available. Otherwise, returns true after the lock
-      # has been acquired.
-      #
-      # +purpose+ and +compatible+ work together; while this thread is
-      # waiting for the exclusive lock, it will yield its share (if any)
-      # to any other attempt whose +purpose+ appears in this attempt's
-      # +compatible+ list. This allows a "loose" upgrade, which, being
-      # less strict, prevents some classes of deadlocks.
-      #
-      # For many resources, loose upgrades are sufficient: if a thread
-      # is awaiting a lock, it is not running any other code. With
-      # +purpose+ matching, it is possible to yield only to other
-      # threads whose activity will not interfere.
-      def start_exclusive(purpose: nil, compatible: [], no_wait: false)
-        synchronize do
-          unless @exclusive_thread == Thread.current
-            if busy_for_exclusive?(purpose)
-              return false if no_wait
-
-              yield_shares(purpose: purpose, compatible: compatible, block_share: true) do
-                wait_for(:start_exclusive) { busy_for_exclusive?(purpose) }
-              end
-            end
-            @exclusive_thread = Thread.current
-          end
-          @exclusive_depth += 1
-
-          true
-        end
-      end
-
-      # Relinquish the exclusive lock. Must only be called by the thread
-      # that called start_exclusive (and currently holds the lock).
-      def stop_exclusive(compatible: [])
-        synchronize do
-          raise "invalid unlock" if @exclusive_thread != Thread.current
-
-          @exclusive_depth -= 1
-          if @exclusive_depth == 0
-            @exclusive_thread = nil
-
-            if eligible_waiters?(compatible)
-              yield_shares(compatible: compatible, block_share: true) do
-                wait_for(:stop_exclusive) { @exclusive_thread || eligible_waiters?(compatible) }
-              end
-            end
-            @cv.broadcast
-          end
-        end
-      end
-
-      def start_sharing
-        synchronize do
-          if @sharing[Thread.current] > 0 || @exclusive_thread == Thread.current
-            # We already hold a lock; nothing to wait for
-          elsif @waiting[Thread.current]
-            # We're nested inside a +yield_shares+ call: we'll resume as
-            # soon as there isn't an exclusive lock in our way
-            wait_for(:start_sharing) { @exclusive_thread }
-          else
-            # This is an initial / outermost share call: any outstanding
-            # requests for an exclusive lock get to go first
-            wait_for(:start_sharing) { busy_for_sharing?(false) }
-          end
-          @sharing[Thread.current] += 1
-        end
-      end
-
-      def stop_sharing
-        synchronize do
-          if @sharing[Thread.current] > 1
-            @sharing[Thread.current] -= 1
-          else
-            @sharing.delete Thread.current
-            @cv.broadcast
-          end
-        end
-      end
-
-      # Execute the supplied block while holding the Exclusive lock. If
-      # +no_wait+ is set and the lock is not immediately available,
-      # returns +nil+ without yielding. Otherwise, returns the result of
-      # the block.
-      #
-      # See +start_exclusive+ for other options.
-      def exclusive(purpose: nil, compatible: [], after_compatible: [], no_wait: false)
-        if start_exclusive(purpose: purpose, compatible: compatible, no_wait: no_wait)
-          begin
-            yield
-          ensure
-            stop_exclusive(compatible: after_compatible)
-          end
-        end
-      end
-
-      # Execute the supplied block while holding the Share lock.
-      def sharing
-        start_sharing
-        begin
-          yield
-        ensure
-          stop_sharing
-        end
-      end
-
-      # Temporarily give up all held Share locks while executing the
-      # supplied block, allowing any +compatible+ exclusive lock request
-      # to proceed.
-      def yield_shares(purpose: nil, compatible: [], block_share: false)
-        loose_shares = previous_wait = nil
-        synchronize do
-          if loose_shares = @sharing.delete(Thread.current)
-            if previous_wait = @waiting[Thread.current]
-              purpose = nil unless purpose == previous_wait[0]
-              compatible &= previous_wait[1]
-            end
-            compatible |= [false] unless block_share
-            @waiting[Thread.current] = [purpose, compatible]
-          end
-
-          @cv.broadcast
-        end
-
-        begin
-          yield
-        ensure
-          synchronize do
-            wait_for(:yield_shares) { @exclusive_thread && @exclusive_thread != Thread.current }
-
-            if previous_wait
-              @waiting[Thread.current] = previous_wait
-            else
-              @waiting.delete Thread.current
-            end
-            @sharing[Thread.current] = loose_shares if loose_shares
-          end
-        end
-      end
-
-      private
-        # Must be called within synchronize
-        def busy_for_exclusive?(purpose)
-          busy_for_sharing?(purpose) ||
-            @sharing.size > (@sharing[Thread.current] > 0 ? 1 : 0)
-        end
-
-        def busy_for_sharing?(purpose)
-          (@exclusive_thread && @exclusive_thread != Thread.current) ||
-            @waiting.any? { |t, (_, c)| t != Thread.current && !c.include?(purpose) }
-        end
-
-        def eligible_waiters?(compatible)
-          @waiting.any? { |t, (p, _)| compatible.include?(p) && @waiting.all? { |t2, (_, c2)| t == t2 || c2.include?(p) } }
-        end
-
-        def wait_for(method)
-          @sleeping[Thread.current] = method
-          @cv.wait_while { yield }
-        ensure
-          @sleeping.delete Thread.current
-        end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/ordered_options"
-
-module ActiveSupport
-  # Configurable provides a <tt>config</tt> method to store and retrieve
-  # configuration options as an <tt>OrderedOptions</tt>.
-  module Configurable
-    extend ActiveSupport::Concern
-
-    class Configuration < ActiveSupport::InheritableOptions
-      def compile_methods!
-        self.class.compile_methods!(keys)
-      end
-
-      # Compiles reader methods so we don't have to go through method_missing.
-      def self.compile_methods!(keys)
-        keys.reject { |m| method_defined?(m) }.each do |key|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{key}; _get(#{key.inspect}); end
-          RUBY
-        end
-      end
-    end
-
-    module ClassMethods
-      def config
-        @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
-          superclass.config.inheritable_copy
-        else
-          # create a new "anonymous" class that will host the compiled reader methods
-          Class.new(Configuration).new
-        end
-      end
-
-      def configure
-        yield config
-      end
-
-      # Allows you to add shortcut so that you don't have to refer to attribute
-      # through config. Also look at the example for config to contrast.
-      #
-      # Defines both class and instance config accessors.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access
-      #   end
-      #
-      #   User.allowed_access # => nil
-      #   User.allowed_access = false
-      #   User.allowed_access # => false
-      #
-      #   user = User.new
-      #   user.allowed_access # => false
-      #   user.allowed_access = true
-      #   user.allowed_access # => true
-      #
-      #   User.allowed_access # => false
-      #
-      # The attribute name must be a valid method name in Ruby.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :"1_Badname"
-      #   end
-      #   # => NameError: invalid config attribute name
-      #
-      # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
-      # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access, instance_reader: false, instance_writer: false
-      #   end
-      #
-      #   User.allowed_access = false
-      #   User.allowed_access # => false
-      #
-      #   User.new.allowed_access = true # => NoMethodError
-      #   User.new.allowed_access        # => NoMethodError
-      #
-      # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access, instance_accessor: false
-      #   end
-      #
-      #   User.allowed_access = false
-      #   User.allowed_access # => false
-      #
-      #   User.new.allowed_access = true # => NoMethodError
-      #   User.new.allowed_access        # => NoMethodError
-      #
-      # Also you can pass a block to set up the attribute with a default value.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :hair_colors do
-      #       [:brown, :black, :blonde, :red]
-      #     end
-      #   end
-      #
-      #   User.hair_colors # => [:brown, :black, :blonde, :red]
-      def config_accessor(*names, instance_reader: true, instance_writer: true, instance_accessor: true) # :doc:
-        names.each do |name|
-          raise NameError.new("invalid config attribute name") unless /\A[_A-Za-z]\w*\z/.match?(name)
-
-          reader, reader_line = "def #{name}; config.#{name}; end", __LINE__
-          writer, writer_line = "def #{name}=(value); config.#{name} = value; end", __LINE__
-
-          singleton_class.class_eval reader, __FILE__, reader_line
-          singleton_class.class_eval writer, __FILE__, writer_line
-
-          if instance_accessor
-            class_eval reader, __FILE__, reader_line if instance_reader
-            class_eval writer, __FILE__, writer_line if instance_writer
-          end
-          send("#{name}=", yield) if block_given?
-        end
-      end
-      private :config_accessor
-    end
-
-    # Reads and writes attributes from a configuration <tt>OrderedOptions</tt>.
-    #
-    #   require "active_support/configurable"
-    #
-    #   class User
-    #     include ActiveSupport::Configurable
-    #   end
-    #
-    #   user = User.new
-    #
-    #   user.config.allowed_access = true
-    #   user.config.level = 1
-    #
-    #   user.config.allowed_access # => true
-    #   user.config.level          # => 1
-    def config
-      @_config ||= self.class.config.inheritable_copy
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # Reads a YAML configuration file, evaluating any ERB, then
-  # parsing the resulting YAML.
-  #
-  # Warns in case of YAML confusing characters, like invisible
-  # non-breaking spaces.
-  class ConfigurationFile # :nodoc:
-    class FormatError < StandardError; end
-
-    def initialize(content_path)
-      @content_path = content_path.to_s
-      @content = read content_path
-    end
-
-    def self.parse(content_path, **options)
-      new(content_path).parse(**options)
-    end
-
-    def parse(context: nil, **options)
-      source = render(context)
-      if YAML.respond_to?(:unsafe_load)
-        YAML.unsafe_load(source, **options) || {}
-      else
-        YAML.load(source, **options) || {}
-      end
-    rescue Psych::SyntaxError => error
-      raise "YAML syntax error occurred while parsing #{@content_path}. " \
-            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
-            "Error: #{error.message}"
-    end
-
-    private
-      def read(content_path)
-        require "yaml"
-        require "erb"
-
-        File.read(content_path).tap do |content|
-          if content.include?("\u00A0")
-            warn "File contains invisible non-breaking spaces, you may want to remove those"
-          end
-        end
-      end
-
-      def render(context)
-        erb = ERB.new(@content).tap { |e| e.filename = @content_path }
-        context ? erb.result(context) : erb.result
-      end
-  end
-end