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/hash/conversions.rb

@@ -1,263 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/xml_mini"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/string/inflections"
-
-class Hash
-  # Returns a string containing an XML representation of its receiver:
-  #
-  #   { foo: 1, bar: 2 }.to_xml
-  #   # =>
-  #   # <?xml version="1.0" encoding="UTF-8"?>
-  #   # <hash>
-  #   #   <foo type="integer">1</foo>
-  #   #   <bar type="integer">2</bar>
-  #   # </hash>
-  #
-  # To do so, the method loops over the pairs and builds nodes that depend on
-  # the _values_. Given a pair +key+, +value+:
-  #
-  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
-  #
-  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
-  #   and +key+ singularized as <tt>:children</tt>.
-  #
-  # * If +value+ is a callable object it must expect one or two arguments. Depending
-  #   on the arity, the callable is invoked with the +options+ hash as first argument
-  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The
-  #   callable can add nodes by using <tt>options[:builder]</tt>.
-  #
-  #     {foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
-  #     # => "<b>foo</b>"
-  #
-  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
-  #
-  #     class Foo
-  #       def to_xml(options)
-  #         options[:builder].bar 'fooing!'
-  #       end
-  #     end
-  #
-  #     { foo: Foo.new }.to_xml(skip_instruct: true)
-  #     # =>
-  #     # <hash>
-  #     #   <bar>fooing!</bar>
-  #     # </hash>
-  #
-  # * Otherwise, a node with +key+ as tag is created with a string representation of
-  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
-  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
-  #   added as well according to the following mapping:
-  #
-  #     XML_TYPE_NAMES = {
-  #       "Symbol"     => "symbol",
-  #       "Integer"    => "integer",
-  #       "BigDecimal" => "decimal",
-  #       "Float"      => "float",
-  #       "TrueClass"  => "boolean",
-  #       "FalseClass" => "boolean",
-  #       "Date"       => "date",
-  #       "DateTime"   => "dateTime",
-  #       "Time"       => "dateTime"
-  #     }
-  #
-  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
-  #
-  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
-  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
-  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
-  def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder::XmlMarkup)
-
-    options = options.dup
-    options[:indent]  ||= 2
-    options[:root]    ||= "hash"
-    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
-
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
-
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
-
-    builder.tag!(root) do
-      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
-      yield builder if block_given?
-    end
-  end
-
-  class << self
-    # Returns a Hash containing a collection of pairs when the key is the node name and the value is
-    # its content
-    #
-    #   xml = <<-XML
-    #     <?xml version="1.0" encoding="UTF-8"?>
-    #       <hash>
-    #         <foo type="integer">1</foo>
-    #         <bar type="integer">2</bar>
-    #       </hash>
-    #   XML
-    #
-    #   hash = Hash.from_xml(xml)
-    #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
-    #
-    # +DisallowedType+ is raised if the XML contains attributes with <tt>type="yaml"</tt> or
-    # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to
-    # parse this XML.
-    #
-    # Custom +disallowed_types+ can also be passed in the form of an
-    # array.
-    #
-    #   xml = <<-XML
-    #     <?xml version="1.0" encoding="UTF-8"?>
-    #       <hash>
-    #         <foo type="integer">1</foo>
-    #         <bar type="string">"David"</bar>
-    #       </hash>
-    #   XML
-    #
-    #   hash = Hash.from_xml(xml, ['integer'])
-    #   # => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer"
-    #
-    # Note that passing custom disallowed types will override the default types,
-    # which are Symbol and YAML.
-    def from_xml(xml, disallowed_types = nil)
-      ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
-    end
-
-    # Builds a Hash from XML just like <tt>Hash.from_xml</tt>, but also allows Symbol and YAML.
-    def from_trusted_xml(xml)
-      from_xml xml, []
-    end
-  end
-end
-
-module ActiveSupport
-  class XMLConverter # :nodoc:
-    # Raised if the XML contains attributes with type="yaml" or
-    # type="symbol". Read Hash#from_xml for more details.
-    class DisallowedType < StandardError
-      def initialize(type)
-        super "Disallowed type attribute: #{type.inspect}"
-      end
-    end
-
-    DISALLOWED_TYPES = %w(symbol yaml)
-
-    def initialize(xml, disallowed_types = nil)
-      @xml = normalize_keys(XmlMini.parse(xml))
-      @disallowed_types = disallowed_types || DISALLOWED_TYPES
-    end
-
-    def to_h
-      deep_to_h(@xml)
-    end
-
-    private
-      def normalize_keys(params)
-        case params
-        when Hash
-          Hash[params.map { |k, v| [k.to_s.tr("-", "_"), normalize_keys(v)] } ]
-        when Array
-          params.map { |v| normalize_keys(v) }
-        else
-          params
-        end
-      end
-
-      def deep_to_h(value)
-        case value
-        when Hash
-          process_hash(value)
-        when Array
-          process_array(value)
-        when String
-          value
-        else
-          raise "can't typecast #{value.class.name} - #{value.inspect}"
-        end
-      end
-
-      def process_hash(value)
-        if value.include?("type") && !value["type"].is_a?(Hash) && @disallowed_types.include?(value["type"])
-          raise DisallowedType, value["type"]
-        end
-
-        if become_array?(value)
-          _, entries = Array.wrap(value.detect { |k, v| not v.is_a?(String) })
-          if entries.nil? || value["__content__"].try(:empty?)
-            []
-          else
-            case entries
-            when Array
-              entries.collect { |v| deep_to_h(v) }
-            when Hash
-              [deep_to_h(entries)]
-            else
-              raise "can't typecast #{entries.inspect}"
-            end
-          end
-        elsif become_content?(value)
-          process_content(value)
-
-        elsif become_empty_string?(value)
-          ""
-        elsif become_hash?(value)
-          xml_value = value.transform_values { |v| deep_to_h(v) }
-
-          # Turn { files: { file: #<StringIO> } } into { files: #<StringIO> } so it is compatible with
-          # how multipart uploaded files from HTML appear
-          xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
-        end
-      end
-
-      def become_content?(value)
-        value["type"] == "file" || (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
-      end
-
-      def become_array?(value)
-        value["type"] == "array"
-      end
-
-      def become_empty_string?(value)
-        # { "string" => true }
-        # No tests fail when the second term is removed.
-        value["type"] == "string" && value["nil"] != "true"
-      end
-
-      def become_hash?(value)
-        !nothing?(value) && !garbage?(value)
-      end
-
-      def nothing?(value)
-        # blank or nil parsed values are represented by nil
-        value.blank? || value["nil"] == "true"
-      end
-
-      def garbage?(value)
-        # If the type is the only element which makes it then
-        # this still makes the value nil, except if type is
-        # an XML node(where type['value'] is a Hash)
-        value["type"] && !value["type"].is_a?(::Hash) && value.size == 1
-      end
-
-      def process_content(value)
-        content = value["__content__"]
-        if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
-          parser.arity == 1 ? parser.call(content) : parser.call(content, value)
-        else
-          content
-        end
-      end
-
-      def process_array(value)
-        value.map! { |i| deep_to_h(i) }
-        value.length > 1 ? value : value.first
-      end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a new hash with +self+ and +other_hash+ merged recursively.
-  #
-  #   h1 = { a: true, b: { c: [1, 2, 3] } }
-  #   h2 = { a: false, b: { x: [3, 4, 5] } }
-  #
-  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
-  #
-  # Like with Hash#merge in the standard library, a block can be provided
-  # to merge values:
-  #
-  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
-  #   h2 = { b: 250, c: { c1: 200 } }
-  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
-  #   # => { a: 100, b: 450, c: { c1: 300 } }
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
-
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash, &block)
-    merge!(other_hash) do |key, this_val, other_val|
-      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-        this_val.deep_merge(other_val, &block)
-      elsif block_given?
-        block.call(key, this_val, other_val)
-      else
-        other_val
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a new hash with all values converted by the block operation.
-  # This includes the values from the root hash and from all
-  # nested hashes and arrays.
-  #
-  #  hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #  hash.deep_transform_values{ |value| value.to_s.upcase }
-  #  # => {person: {name: "ROB", age: "28"}}
-  def deep_transform_values(&block)
-    _deep_transform_values_in_object(self, &block)
-  end
-
-  # Destructively converts all values by using the block operation.
-  # This includes the values from the root hash and from all
-  # nested hashes and arrays.
-  def deep_transform_values!(&block)
-    _deep_transform_values_in_object!(self, &block)
-  end
-
-  private
-    # Support methods for deep transforming nested hashes and arrays.
-    def _deep_transform_values_in_object(object, &block)
-      case object
-      when Hash
-        object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
-      when Array
-        object.map { |e| _deep_transform_values_in_object(e, &block) }
-      else
-        yield(object)
-      end
-    end
-
-    def _deep_transform_values_in_object!(object, &block)
-      case object
-      when Hash
-        object.transform_values! { |value| _deep_transform_values_in_object!(value, &block) }
-      when Array
-        object.map! { |e| _deep_transform_values_in_object!(e, &block) }
-      else
-        yield(object)
-      end
-    end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a hash that includes everything except given keys.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except(:c)     # => { a: true, b: false }
-  #   hash.except(:a, :b) # => { c: nil }
-  #   hash                # => { a: true, b: false, c: nil }
-  #
-  # This is useful for limiting a set of parameters to everything but a few known toggles:
-  #   @person.update(params[:person].except(:admin))
-  def except(*keys)
-    slice(*self.keys - keys)
-  end unless method_defined?(:except)
-
-  # Removes the given keys from hash and returns it.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except!(:c) # => { a: true, b: false }
-  #   hash             # => { a: true, b: false }
-  def except!(*keys)
-    keys.each { |key| delete(key) }
-    self
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/hash_with_indifferent_access"
-
-class Hash
-  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
-  #
-  #   { a: 1 }.with_indifferent_access['a'] # => 1
-  def with_indifferent_access
-    ActiveSupport::HashWithIndifferentAccess.new(self)
-  end
-
-  # Called when object is nested under an object that receives
-  # #with_indifferent_access. This method will be called on the current object
-  # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
-  # desirable.
-  #
-  #   b = { b: 1 }
-  #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
-  #   # => {"b"=>1}
-  alias nested_under_indifferent_access with_indifferent_access
-end

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

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a new hash with all keys converted to strings.
-  #
-  #   hash = { name: 'Rob', age: '28' }
-  #
-  #   hash.stringify_keys
-  #   # => {"name"=>"Rob", "age"=>"28"}
-  def stringify_keys
-    transform_keys(&:to_s)
-  end
-
-  # Destructively converts all keys to strings. Same as
-  # +stringify_keys+, but modifies +self+.
-  def stringify_keys!
-    transform_keys!(&:to_s)
-  end
-
-  # Returns a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+.
-  #
-  #   hash = { 'name' => 'Rob', 'age' => '28' }
-  #
-  #   hash.symbolize_keys
-  #   # => {:name=>"Rob", :age=>"28"}
-  def symbolize_keys
-    transform_keys { |key| key.to_sym rescue key }
-  end
-  alias_method :to_options,  :symbolize_keys
-
-  # Destructively converts all keys to symbols, as long as they respond
-  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
-  def symbolize_keys!
-    transform_keys! { |key| key.to_sym rescue key }
-  end
-  alias_method :to_options!, :symbolize_keys!
-
-  # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
-  # +ArgumentError+ on a mismatch.
-  #
-  # Note that keys are treated differently than HashWithIndifferentAccess,
-  # meaning that string and symbol keys will not match.
-  #
-  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
-  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
-  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
-  def assert_valid_keys(*valid_keys)
-    valid_keys.flatten!
-    each_key do |k|
-      unless valid_keys.include?(k)
-        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
-      end
-    end
-  end
-
-  # Returns a new hash with all keys converted by the block operation.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  #
-  #  hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
-  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
-  def deep_transform_keys(&block)
-    _deep_transform_keys_in_object(self, &block)
-  end
-
-  # Destructively converts all keys by using the block operation.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  def deep_transform_keys!(&block)
-    _deep_transform_keys_in_object!(self, &block)
-  end
-
-  # Returns a new hash with all keys converted to strings.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  #
-  #   hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #   hash.deep_stringify_keys
-  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
-  def deep_stringify_keys
-    deep_transform_keys(&:to_s)
-  end
-
-  # Destructively converts all keys to strings.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  def deep_stringify_keys!
-    deep_transform_keys!(&:to_s)
-  end
-
-  # Returns a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+. This includes the keys from the root hash
-  # and from all nested hashes and arrays.
-  #
-  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
-  #
-  #   hash.deep_symbolize_keys
-  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
-  def deep_symbolize_keys
-    deep_transform_keys { |key| key.to_sym rescue key }
-  end
-
-  # Destructively converts all keys to symbols, as long as they respond
-  # to +to_sym+. This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  def deep_symbolize_keys!
-    deep_transform_keys! { |key| key.to_sym rescue key }
-  end
-
-  private
-    # Support methods for deep transforming nested hashes and arrays.
-    def _deep_transform_keys_in_object(object, &block)
-      case object
-      when Hash
-        object.each_with_object({}) do |(key, value), result|
-          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
-        end
-      when Array
-        object.map { |e| _deep_transform_keys_in_object(e, &block) }
-      else
-        object
-      end
-    end
-
-    def _deep_transform_keys_in_object!(object, &block)
-      case object
-      when Hash
-        object.keys.each do |key|
-          value = object.delete(key)
-          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
-        end
-        object
-      when Array
-        object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
-      else
-        object
-      end
-    end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Merges the caller into +other_hash+. For example,
-  #
-  #   options = options.reverse_merge(size: 25, velocity: 10)
-  #
-  # is equivalent to
-  #
-  #   options = { size: 25, velocity: 10 }.merge(options)
-  #
-  # This is particularly useful for initializing an options hash
-  # with default values.
-  def reverse_merge(other_hash)
-    other_hash.merge(self)
-  end
-  alias_method :with_defaults, :reverse_merge
-
-  # Destructive +reverse_merge+.
-  def reverse_merge!(other_hash)
-    replace(reverse_merge(other_hash))
-  end
-  alias_method :reverse_update, :reverse_merge!
-  alias_method :with_defaults!, :reverse_merge!
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Replaces the hash with only the given keys.
-  # Returns a hash containing the removed key/value pairs.
-  #
-  #   hash = { a: 1, b: 2, c: 3, d: 4 }
-  #   hash.slice!(:a, :b)  # => {:c=>3, :d=>4}
-  #   hash                 # => {:a=>1, :b=>2}
-  def slice!(*keys)
-    omit = slice(*self.keys - keys)
-    hash = slice(*keys)
-    hash.default      = default
-    hash.default_proc = default_proc if default_proc
-    replace(hash)
-    omit
-  end
-
-  # Removes and returns the key/value pairs matching the given keys.
-  #
-  #   hash = { a: 1, b: 2, c: 3, d: 4 }
-  #   hash.extract!(:a, :b) # => {:a=>1, :b=>2}
-  #   hash                  # => {:c=>3, :d=>4}
-  def extract!(*keys)
-    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
-  end
-end

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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/conversions"
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/hash/deep_transform_values"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/hash/slice"

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflector"
-
-class Integer
-  # Ordinalize turns a number into an ordinal string used to denote the
-  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
-  #
-  #  1.ordinalize     # => "1st"
-  #  2.ordinalize     # => "2nd"
-  #  1002.ordinalize  # => "1002nd"
-  #  1003.ordinalize  # => "1003rd"
-  #  -11.ordinalize   # => "-11th"
-  #  -1001.ordinalize # => "-1001st"
-  def ordinalize
-    ActiveSupport::Inflector.ordinalize(self)
-  end
-
-  # Ordinal returns the suffix used to denote the position
-  # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
-  #
-  #  1.ordinal     # => "st"
-  #  2.ordinal     # => "nd"
-  #  1002.ordinal  # => "nd"
-  #  1003.ordinal  # => "rd"
-  #  -11.ordinal   # => "th"
-  #  -1001.ordinal # => "st"
-  def ordinal
-    ActiveSupport::Inflector.ordinal(self)
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-class Integer
-  # Check whether the integer is evenly divisible by the argument.
-  #
-  #   0.multiple_of?(0)  # => true
-  #   6.multiple_of?(5)  # => false
-  #   10.multiple_of?(2) # => true
-  def multiple_of?(number)
-    number == 0 ? self == 0 : self % number == 0
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/duration"
-require "active_support/core_ext/numeric/time"
-
-class Integer
-  # Returns a Duration instance matching the number of months provided.
-  #
-  #   2.months # => 2 months
-  def months
-    ActiveSupport::Duration.months(self)
-  end
-  alias :month :months
-
-  # Returns a Duration instance matching the number of years provided.
-  #
-  #   2.years # => 2 years
-  def years
-    ActiveSupport::Duration.years(self)
-  end
-  alias :year :years
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/integer/multiple"
-require "active_support/core_ext/integer/inflections"
-require "active_support/core_ext/integer/time"