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/object/json.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-# Hack to load json gem first so we can overwrite its to_json.
-require "json"
-require "bigdecimal"
-require "ipaddr"
-require "uri/generic"
-require "pathname"
-require "active_support/core_ext/big_decimal/conversions" # for #to_s
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/object/instance_variables"
-require "time"
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/date_time/conversions"
-require "active_support/core_ext/date/conversions"
-
-#--
-# The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
-# their default behavior. That said, we need to define the basic to_json method in all of them,
-# otherwise they will always use to_json gem implementation, which is backwards incompatible in
-# several cases (for instance, the JSON implementation for Hash does not work) with inheritance
-# and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
-#
-# On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
-# JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
-# passes a ::JSON::State object as the only argument to to_json, we can detect that and forward the
-# calls to the original to_json method.
-#
-# It should be noted that when using ::JSON.{generate,dump} directly, ActiveSupport's encoder is
-# bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
-# ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
-# should give exactly the same results with or without active support.
-
-module ActiveSupport
-  module ToJsonWithActiveSupportEncoder # :nodoc:
-    def to_json(options = nil)
-      if options.is_a?(::JSON::State)
-        # Called from JSON.{generate,dump}, forward it to JSON gem's to_json
-        super(options)
-      else
-        # to_json is being invoked directly, use ActiveSupport's encoder
-        ActiveSupport::JSON.encode(self, options)
-      end
-    end
-  end
-end
-
-[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
-  klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
-end
-
-class Object
-  def as_json(options = nil) #:nodoc:
-    if respond_to?(:to_hash)
-      to_hash.as_json(options)
-    else
-      instance_values.as_json(options)
-    end
-  end
-end
-
-class Struct #:nodoc:
-  def as_json(options = nil)
-    Hash[members.zip(values)].as_json(options)
-  end
-end
-
-class TrueClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class FalseClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class NilClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class String
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class Symbol
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Numeric
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class Float
-  # Encoding Infinity or NaN to JSON should return "null". The default returns
-  # "Infinity" or "NaN" which are not valid JSON.
-  def as_json(options = nil) #:nodoc:
-    finite? ? self : nil
-  end
-end
-
-class BigDecimal
-  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
-  # however, parse non-integer JSON numbers directly as floats. Clients using
-  # those libraries would get in general a wrong number and no way to recover
-  # other than manually inspecting the string with the JSON code itself.
-  #
-  # That's why a JSON string is returned. The JSON literal is not numeric, but
-  # if the other end knows by contract that the data is supposed to be a
-  # BigDecimal, it still has the chance to post-process the string and get the
-  # real value.
-  def as_json(options = nil) #:nodoc:
-    finite? ? to_s : nil
-  end
-end
-
-class Regexp
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-module Enumerable
-  def as_json(options = nil) #:nodoc:
-    to_a.as_json(options)
-  end
-end
-
-class IO
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Range
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Array
-  def as_json(options = nil) #:nodoc:
-    map { |v| options ? v.as_json(options.dup) : v.as_json }
-  end
-end
-
-class Hash
-  def as_json(options = nil) #:nodoc:
-    # create a subset of the hash by applying :only or :except
-    subset = if options
-      if attrs = options[:only]
-        slice(*Array(attrs))
-      elsif attrs = options[:except]
-        except(*Array(attrs))
-      else
-        self
-      end
-    else
-      self
-    end
-
-    result = {}
-    subset.each do |k, v|
-      result[k.to_s] = options ? v.as_json(options.dup) : v.as_json
-    end
-    result
-  end
-end
-
-class Time
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
-    else
-      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
-    end
-  end
-end
-
-class Date
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-      strftime("%Y-%m-%d")
-    else
-      strftime("%Y/%m/%d")
-    end
-  end
-end
-
-class DateTime
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
-    else
-      strftime("%Y/%m/%d %H:%M:%S %z")
-    end
-  end
-end
-
-class URI::Generic #:nodoc:
-  def as_json(options = nil)
-    to_s
-  end
-end
-
-class Pathname #:nodoc:
-  def as_json(options = nil)
-    to_s
-  end
-end
-
-class IPAddr # :nodoc:
-  def as_json(options = nil)
-    to_s
-  end
-end
-
-class Process::Status #:nodoc:
-  def as_json(options = nil)
-    { exitstatus: exitstatus, pid: pid }
-  end
-end
-
-class Exception
-  def as_json(options = nil)
-    to_s
-  end
-end

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

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/to_query"

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-class Object
-  # Alias of <tt>to_s</tt>.
-  def to_param
-    to_s
-  end
-
-  # Converts an object into a string suitable for use as a URL query string,
-  # using the given <tt>key</tt> as the param name.
-  def to_query(key)
-    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
-  end
-end
-
-class NilClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class TrueClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class FalseClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class Array
-  # Calls <tt>to_param</tt> on all its elements and joins the result with
-  # slashes. This is used by <tt>url_for</tt> in Action Pack.
-  def to_param
-    collect(&:to_param).join "/"
-  end
-
-  # Converts an array into a string suitable for use as a URL query string,
-  # using the given +key+ as the param name.
-  #
-  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
-  def to_query(key)
-    prefix = "#{key}[]"
-
-    if empty?
-      nil.to_query(prefix)
-    else
-      collect { |value| value.to_query(prefix) }.join "&"
-    end
-  end
-end
-
-class Hash
-  # Returns a string representation of the receiver suitable for use as a URL
-  # query string:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query
-  #   # => "name=David&nationality=Danish"
-  #
-  # An optional namespace can be passed to enclose key names:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query('user')
-  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
-  #
-  # The string pairs "key=value" that conform the query string
-  # are sorted lexicographically in ascending order.
-  #
-  # This method is also aliased as +to_param+.
-  def to_query(namespace = nil)
-    query = collect do |key, value|
-      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
-        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-      end
-    end.compact
-
-    query.sort! unless namespace.to_s.include?("[]")
-    query.join("&")
-  end
-
-  alias_method :to_param, :to_query
-end

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

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require "delegate"
-
-module ActiveSupport
-  module Tryable #:nodoc:
-    def try(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
-        else
-          yield self
-        end
-      elsif respond_to?(method_name)
-        public_send(method_name, *args, &b)
-      end
-    end
-    ruby2_keywords(:try) if respond_to?(:ruby2_keywords, true)
-
-    def try!(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
-        else
-          yield self
-        end
-      else
-        public_send(method_name, *args, &b)
-      end
-    end
-    ruby2_keywords(:try!) if respond_to?(:ruby2_keywords, true)
-  end
-end
-
-class Object
-  include ActiveSupport::Tryable
-
-  ##
-  # :method: try
-  #
-  # :call-seq:
-  #   try(*a, &b)
-  #
-  # Invokes the public method whose name goes as first argument just like
-  # +public_send+ does, except that if the receiver does not respond to it the
-  # call returns +nil+ rather than raising an exception.
-  #
-  # This method is defined to be able to write
-  #
-  #   @person.try(:name)
-  #
-  # instead of
-  #
-  #   @person.name if @person
-  #
-  # +try+ calls can be chained:
-  #
-  #   @person.try(:spouse).try(:name)
-  #
-  # instead of
-  #
-  #   @person.spouse.name if @person && @person.spouse
-  #
-  # +try+ will also return +nil+ if the receiver does not respond to the method:
-  #
-  #   @person.try(:non_existing_method) # => nil
-  #
-  # instead of
-  #
-  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) # => nil
-  #
-  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
-  # to the method:
-  #
-  #   nil.try(:to_i) # => nil, rather than 0
-  #
-  # Arguments and blocks are forwarded to the method if invoked:
-  #
-  #   @posts.try(:each_slice, 2) do |a, b|
-  #     ...
-  #   end
-  #
-  # The number of arguments in the signature must match. If the object responds
-  # to the method the call is attempted and +ArgumentError+ is still raised
-  # in case of argument mismatch.
-  #
-  # If +try+ is called without arguments it yields the receiver to a given
-  # block unless it is +nil+:
-  #
-  #   @person.try do |p|
-  #     ...
-  #   end
-  #
-  # You can also call try with a block without accepting an argument, and the block
-  # will be instance_eval'ed instead:
-  #
-  #   @person.try { upcase.truncate(50) }
-  #
-  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
-  # with instances of classes that do not have +Object+ among their ancestors,
-  # like direct subclasses of +BasicObject+.
-
-  ##
-  # :method: try!
-  #
-  # :call-seq:
-  #   try!(*a, &b)
-  #
-  # Same as #try, but raises a +NoMethodError+ exception if the receiver is
-  # not +nil+ and does not implement the tried method.
-  #
-  #   "a".try!(:upcase) # => "A"
-  #   nil.try!(:upcase) # => nil
-  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
-end
-
-class Delegator
-  include ActiveSupport::Tryable
-
-  ##
-  # :method: try
-  #
-  # :call-seq:
-  #   try(a*, &b)
-  #
-  # See Object#try
-
-  ##
-  # :method: try!
-  #
-  # :call-seq:
-  #   try!(a*, &b)
-  #
-  # See Object#try!
-end
-
-class NilClass
-  # Calling +try+ on +nil+ always returns +nil+.
-  # It becomes especially helpful when navigating through associations that may return +nil+.
-  #
-  #   nil.try(:name) # => nil
-  #
-  # Without +try+
-  #   @person && @person.children.any? && @person.children.first.name
-  #
-  # With +try+
-  #   @person.try(:children).try(:first).try(:name)
-  def try(_method_name = nil, *)
-    nil
-  end
-
-  # Calling +try!+ on +nil+ always returns +nil+.
-  #
-  #   nil.try!(:name) # => nil
-  def try!(_method_name = nil, *)
-    nil
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/option_merger"
-
-class Object
-  # An elegant way to factor duplication out of options passed to a series of
-  # method calls. Each method called in the block, with the block variable as
-  # the receiver, will have its options merged with the default +options+ hash
-  # provided. Each method called on the block variable must take an options
-  # hash as its final argument.
-  #
-  # Without <tt>with_options</tt>, this code contains duplication:
-  #
-  #   class Account < ActiveRecord::Base
-  #     has_many :customers, dependent: :destroy
-  #     has_many :products,  dependent: :destroy
-  #     has_many :invoices,  dependent: :destroy
-  #     has_many :expenses,  dependent: :destroy
-  #   end
-  #
-  # Using <tt>with_options</tt>, we can remove the duplication:
-  #
-  #   class Account < ActiveRecord::Base
-  #     with_options dependent: :destroy do |assoc|
-  #       assoc.has_many :customers
-  #       assoc.has_many :products
-  #       assoc.has_many :invoices
-  #       assoc.has_many :expenses
-  #     end
-  #   end
-  #
-  # It can also be used with an explicit receiver:
-  #
-  #   I18n.with_options locale: user.locale, scope: 'newsletter' do |i18n|
-  #     subject i18n.t :subject
-  #     body    i18n.t :body, user_name: user.name
-  #   end
-  #
-  # When you don't pass an explicit receiver, it executes the whole block
-  # in merging options context:
-  #
-  #   class Account < ActiveRecord::Base
-  #     with_options dependent: :destroy do
-  #       has_many :customers
-  #       has_many :products
-  #       has_many :invoices
-  #       has_many :expenses
-  #     end
-  #   end
-  #
-  # <tt>with_options</tt> can also be nested since the call is forwarded to its receiver.
-  #
-  # NOTE: Each nesting level will merge inherited defaults in addition to their own.
-  #
-  #   class Post < ActiveRecord::Base
-  #     with_options if: :persisted?, length: { minimum: 50 } do
-  #       validates :content, if: -> { content.present? }
-  #     end
-  #   end
-  #
-  # The code is equivalent to:
-  #
-  #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
-  #
-  # Hence the inherited default for +if+ key is ignored.
-  #
-  # NOTE: You cannot call class methods implicitly inside of with_options.
-  # You can access these methods using the class name instead:
-  #
-  #   class Phone < ActiveRecord::Base
-  #     enum phone_number_type: { home: 0, office: 1, mobile: 2 }
-  #
-  #     with_options presence: true do
-  #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }
-  #     end
-  #   end
-  #
-  def with_options(options, &block)
-    option_merger = ActiveSupport::OptionMerger.new(self, options)
-    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/duplicable"
-require "active_support/core_ext/object/deep_dup"
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/object/inclusion"
-
-require "active_support/core_ext/object/conversions"
-require "active_support/core_ext/object/instance_variables"
-
-require "active_support/core_ext/object/json"
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/object/with_options"

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module CompareWithRange
-    # Extends the default Range#=== to support range comparisons.
-    #  (1..5) === (1..5)  # => true
-    #  (1..5) === (2..3)  # => true
-    #  (1..5) === (1...6) # => true
-    #  (1..5) === (2..6)  # => false
-    #
-    # The native Range#=== behavior is untouched.
-    #  ('a'..'f') === ('c') # => true
-    #  (5..9) === (11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def ===(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 includes 1..9 but it does not include 1..10.
-        # 1..10 includes 1...11 but it does not include 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
-
-    # Extends the default Range#include? to support range comparisons.
-    #  (1..5).include?(1..5)  # => true
-    #  (1..5).include?(2..3)  # => true
-    #  (1..5).include?(1...6) # => true
-    #  (1..5).include?(2..6)  # => false
-    #
-    # The native Range#include? behavior is untouched.
-    #  ('a'..'f').include?('c') # => true
-    #  (5..9).include?(11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def include?(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 includes 1..9 but it does not include 1..10.
-        # 1..10 includes 1...11 but it does not include 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
-
-    # Extends the default Range#cover? to support range comparisons.
-    #  (1..5).cover?(1..5)  # => true
-    #  (1..5).cover?(2..3)  # => true
-    #  (1..5).cover?(1...6) # => true
-    #  (1..5).cover?(2..6)  # => false
-    #
-    # The native Range#cover? behavior is untouched.
-    #  ('a'..'f').cover?('c') # => true
-    #  (5..9).cover?(11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def cover?(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 covers 1..9 but it does not cover 1..10.
-        # 1..10 covers 1...11 but it does not cover 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
-  end
-end
-
-Range.prepend(ActiveSupport::CompareWithRange)