开源软件构建与测试

_service:tar_scm:rubygem-activemodel.spec Changed

@@ -3,7 +3,7 @@
 %bcond_with bootstrap
 
 Name:		rubygem-%{gem_name}
-Version: 	6.1.4.1
+Version: 	7.0.4
 Release:	1
 Summary:	A toolkit for building modeling frameworks (part of Rails)
 License:	MIT
@@ -12,12 +12,12 @@
 # The gem doesn't ship with the test suite.
 # You may check it out like so
 # git clone https://github.com/rails/rails.git
-# cd rails/activemodel && git archive -v -o activemodel-6.1.4.1-tests.txz v6.1.4.1 test/
+# cd rails/activemodel && git archive -v -o activemodel-7.0.4-tests.txz v7.0.4 test/
 Source1:	%{gem_name}-%{version}-tests.txz
 # The tools are needed for the test suite, are however unpackaged in gem file.
 # You may check it out like so
 # git clone http://github.com/rails/rails.git --no-checkout
-# cd rails && git archive -v -o rails-6.1.4.1-tools.txz v6.1.4.1 tools/
+# cd rails && git archive -v -o rails-7.0.4-tools.txz v7.0.4 tools/
 Source2:	rails-%{version}-tools.txz
 
 BuildRequires:	ruby(release)
@@ -81,6 +81,9 @@
 %doc %{gem_instdir}/README.rdoc
 
 %changelog
+* Thu Jan 19 2023 wangkai <wangkai385@h-partners.com> - 7.0.4-1
+- Upgrade to version 7.0.4
+
 * Mon May 02 2022 wangkerong <wangkerong@h-partners.com>- 6.1.4.1-1
 - Upgrade to 6.1.4.1

_service Changed

_service:tar_scm:activemodel-6.1.4.1-tests.txz Deleted

_service:tar_scm:activemodel-7.0.4-tests.txz Added

_service:tar_scm:activemodel-6.1.4.1.gem/checksums.yaml.gz -> _service:tar_scm:activemodel-7.0.4.gem/checksums.yaml.gz Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/CHANGELOG.md -> _service:tar_scm:activemodel-7.0.4.gem/data/CHANGELOG.md Changed

@@ -1,117 +1,209 @@
-## Rails 6.1.4.1 (August 19, 2021) ##
+## Rails 7.0.4 (September 09, 2022) ##
+
+*   Handle name clashes in attribute methods code generation cache.
+
+    When two distinct attribute methods would generate similar names,
+    the first implementation would be incorrectly re-used.
+
+    ```ruby
+    class A
+      attribute_method_suffix "_changed?"
+      define_attribute_methods :x
+    end
+
+    class B
+      attribute_method_suffix "?"
+      define_attribute_methods :x_changed
+    end
+    ```
+
+    *Jean Boussier*
+
+## Rails 7.0.3.1 (July 12, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.4 (June 24, 2021) ##
+## Rails 7.0.3 (May 09, 2022) ##
 
-*   Fix `to_json` for `ActiveModel::Dirty` object.
+*   No changes.
 
-    Exclude +mutations_from_database+ attribute from json as it lead to recursion.
 
-    *Anil Maurya*
+## Rails 7.0.2.4 (April 26, 2022) ##
+
+*   No changes.
 
 
-## Rails 6.1.3.2 (May 05, 2021) ##
+## Rails 7.0.2.3 (March 08, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.3.1 (March 26, 2021) ##
+## Rails 7.0.2.2 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.3 (February 17, 2021) ##
+## Rails 7.0.2.1 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.2.1 (February 10, 2021) ##
+## Rails 7.0.2 (February 08, 2022) ##
+
+*   Use different cache namespace for proxy calls
+
+    Models can currently have different attribute bodies for the same method
+    names, leading to conflicts. Adding a new namespace `:active_model_proxy`
+    fixes the issue.
+
+    *Chris Salzberg*
+
+
+## Rails 7.0.1 (January 06, 2022) ##
 
 *   No changes.
 
 
-## Rails 6.1.2 (February 09, 2021) ##
+## Rails 7.0.0 (December 15, 2021) ##
 
 *   No changes.
 
 
-## Rails 6.1.1 (January 07, 2021) ##
+## Rails 7.0.0.rc3 (December 14, 2021) ##
 
 *   No changes.
 
 
-## Rails 6.1.0 (December 09, 2020) ##
+## Rails 7.0.0.rc2 (December 14, 2021) ##
 
-*   Pass in `base` instead of `base_class` to Error.human_attribute_name
+*   No changes.
 
-    This is useful in cases where the `human_attribute_name` method depends
-    on other attributes' values of the class under validation to derive what the
-    attribute name should be.
+## Rails 7.0.0.rc1 (December 06, 2021) ##
 
-    *Filipe Sabella*
+*   Remove support to Marshal load Rails 5.x `ActiveModel::AttributeSet` format.
 
-*   Deprecate marshalling load from legacy attributes format.
+    *Rafael Mendonça França*
 
-    *Ryuta Kamizono*
+*   Remove support to Marshal and YAML load Rails 5.x error format.
 
-*   `*_previously_changed?` accepts `:from` and `:to` keyword arguments like `*_changed?`.
+    *Rafael Mendonça França*
 
-        topic.update!(status: :archived)
-        topic.status_previously_changed?(from: "active", to: "archived")
-        # => true
+*   Remove deprecated support to use `=` in `ActiveModel::Errors#messages`.
 
-    *George Claghorn*
+    *Rafael Mendonça França*
 
-*   Raise FrozenError when trying to write attributes that aren't backed by the database on an object that is frozen:
+*   Remove deprecated support to `delete` errors from `ActiveModel::Errors#messages`.
 
-        class Animal
-          include ActiveModel::Attributes
-          attribute :age
-        end
+    *Rafael Mendonça França*
 
-        animal = Animal.new
-        animal.freeze
-        animal.age = 25 # => FrozenError, "can't modify a frozen Animal"
+*   Remove deprecated support to `clear` errors from `ActiveModel::Errors#messages`.
 
-    *Josh Brody*
+    *Rafael Mendonça França*
 
-*   Add `*_previously_was` attribute methods when dirty tracking. Example:
+*   Remove deprecated support concat errors to `ActiveModel::Errors#messages`.
 
-        pirate.update(catchphrase: "Ahoy!")
-        pirate.previous_changes"catchphrase" # => "Thar She Blows!", "Ahoy!"
-        pirate.catchphrase_previously_was # => "Thar She Blows!"
+    *Rafael Mendonça França*
 
-    *DHH*
+*   Remove deprecated `ActiveModel::Errors#to_xml`.
 
-*   Encapsulate each validation error as an Error object.
+    *Rafael Mendonça França*
 
-    The `ActiveModel`’s `errors` collection is now an array of these Error
-    objects, instead of messages/details hash.
+*   Remove deprecated `ActiveModel::Errors#keys`.
 
-    For each of these `Error` object, its `message` and `full_message` methods
-    are for generating error messages. Its `details` method would return error’s
-    extra parameters, found in the original `details` hash.
+    *Rafael Mendonça França*
 
-    The change tries its best at maintaining backward compatibility, however
-    some edge cases won’t be covered, like `errors#first` will return `ActiveModel::Error` and manipulating
-    `errors.messages` and `errors.details` hashes directly will have no effect. Moving forward,
-    please convert those direct manipulations to use provided API methods instead.
+*   Remove deprecated `ActiveModel::Errors#values`.
 
-    The list of deprecated methods and their planned future behavioral changes at the next major release are:
+    *Rafael Mendonça França*
 
-    * `errors#slice!` will be removed.
-    * `errors#each` with the `key, value` two-arguments block will stop working, while the `error` single-argument block would return `Error` object.
-    * `errors#values` will be removed.
-    * `errors#keys` will be removed.
-    * `errors#to_xml` will be removed.
-    * `errors#to_h` will be removed, and can be replaced with `errors#to_hash`.
-    * Manipulating `errors` itself as a hash will have no effect (e.g. `errors:foo = 'bar'`).
-    * Manipulating the hash returned by `errors#messages` (e.g. `errors.messages:foo = 'bar'`) will have no effect.
-    * Manipulating the hash returned by `errors#details` (e.g. `errors.details:foo.clear`) will have no effect.
+*   Remove deprecated `ActiveModel::Errors#slice!`.
 
-    *lulalala*
+    *Rafael Mendonça França*
+
+*   Remove deprecated `ActiveModel::Errors#to_h`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated enumeration of `ActiveModel::Errors` instances as a Hash.
+
+    *Rafael Mendonça França*
+
+*   Clear secure password cache if password is set to `nil`
+
+    Before:
+
+       user.password = 'something'
+       user.password = nil
+
+       user.password # => 'something'
+
+    Now:
+
+       user.password = 'something'
+       user.password = nil
+
+       user.password # => nil
+
+    *Markus Doits*
+
+## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
+*   No changes.
+
+
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
+
+*   Introduce `ActiveModel::API`.
+
+    Make `ActiveModel::API` the minimum API to talk with Action Pack and Action View.
+    This will allow adding more functionality to `ActiveModel::Model`.
+
+    *Petrik de Heus*, *Nathaniel Watts*
+
+*   Fix dirty check for Float::NaN and BigDecimal::NaN.
+
+    Float::NaN and BigDecimal::NaN in Ruby are special values(https://bugs.ruby-lang.org/issues/1720)
+    and can't be compared with `==`.
+
+    *Marcelo Lauxen*
+
+*   Fix `to_json` for `ActiveModel::Dirty` object.
+
+    Exclude `mutations_from_database` attribute from json as it lead to recursion.
+
+    *Anil Maurya*
+
+*   Add `ActiveModel::AttributeSet#values_for_database`.
+
+    Returns attributes with values for assignment to the database.
+
+    *Chris Salzberg*
+
+*   Fix delegation in ActiveModel::Type::Registry#lookup and ActiveModel::Type.lookup.
+
+    Passing a last positional argument `{}` would be incorrectly considered as keyword argument.
+
+    *Benoit Daloze*
+
+*   Cache and re-use generated attribute methods.
+
+    Generated methods with identical implementations will now share their instruction sequences
+    leading to reduced memory retention, and slightly faster load time.
+
+    *Jean Boussier*
+
+*   Add `in: range`  parameter to `numericality` validator.
+
+    *Michal Papis*
+
+*   Add `locale` argument to `ActiveModel::Name#initialize` to be used to generate the `singular`,
+   `plural`, `route_key` and `singular_route_key` values.
+
+    *Lukas Pokorny*
+
+*   Make ActiveModel::Errors#inspect slimmer for readability
+
+    *lulalala*
 
-Please check 6-0-stable(https://github.com/rails/rails/blob/6-0-stable/activemodel/CHANGELOG.md) for previous changes.
+Please check 6-1-stable(https://github.com/rails/rails/blob/6-1-stable/activemodel/CHANGELOG.md) for previous changes.

_service:tar_scm:activemodel-6.1.4.1.gem/data/MIT-LICENSE -> _service:tar_scm:activemodel-7.0.4.gem/data/MIT-LICENSE Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/README.rdoc -> _service:tar_scm:activemodel-7.0.4.gem/data/README.rdoc Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model.rb Changed

_service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/api.rb Added

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # == Active \Model \API
+  #
+  # Includes the required interface for an object to interact with
+  # Action Pack and Action View, using different Active Model modules.
+  # It includes model name introspections, conversions, translations, and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like Active Record does.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => "bob"
+  #   person.age  # => "18"
+  #
+  # Note that, by default, <tt>ActiveModel::API</tt> implements <tt>persisted?</tt>
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id.present?
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name, :omg
+  #
+  #     def initialize(attributes={})
+  #       super
+  #       @omg ||= true
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.omg # => true
+  #
+  # For more detailed information on other functionalities available, please
+  # refer to the specific modules included in <tt>ActiveModel::API</tt>
+  # (see below).
+  module API
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::API
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => "18"
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::API
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
+  end
+end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/attribute.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/attribute.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/attribute_methods.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/attribute_methods.rb Changed

@@ -67,6 +67,7 @@
 
     NAME_COMPILABLE_REGEXP = /\Aa-zA-Z_\w*!?=?\z/
     CALL_COMPILABLE_REGEXP = /\Aa-zA-Z_\w*!??\z/
+    FORWARD_PARAMETERS = "*args"
 
     included do
       class_attribute :attribute_aliases, instance_writer: false, default: {}
@@ -105,8 +106,8 @@
       #   person.name          # => "Bob"
       #   person.clear_name
       #   person.name          # => nil
-      def attribute_method_prefix(*prefixes)
-        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new prefix: prefix }
+      def attribute_method_prefix(*prefixes, parameters: nil)
+        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new(prefix: prefix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -140,8 +141,8 @@
       #   person.name = 'Bob'
       #   person.name          # => "Bob"
       #   person.name_short?   # => true
-      def attribute_method_suffix(*suffixes)
-        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new suffix: suffix }
+      def attribute_method_suffix(*suffixes, parameters: nil)
+        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new(suffix: suffix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -177,7 +178,7 @@
       #   person.reset_name_to_default!
       #   person.name                         # => 'Default Name'
       def attribute_method_affix(*affixes)
-        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new prefix: affix:prefix, suffix: affix:suffix }
+        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new(**affix) }
         undefine_attribute_methods
       end
 
@@ -207,11 +208,33 @@
       #   person.nickname_short? # => true
       def alias_attribute(new_name, old_name)
         self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
-        CodeGenerator.batch(self, __FILE__, __LINE__) do |owner|
+        ActiveSupport::CodeGenerator.batch(self, __FILE__, __LINE__) do |code_generator|
           attribute_method_matchers.each do |matcher|
-            matcher_new = matcher.method_name(new_name).to_s
-            matcher_old = matcher.method_name(old_name).to_s
-            define_proxy_call false, owner, matcher_new, matcher_old
+            method_name = matcher.method_name(new_name).to_s
+            target_name = matcher.method_name(old_name).to_s
+            parameters = matcher.parameters
+
+            mangled_name = target_name
+            unless NAME_COMPILABLE_REGEXP.match?(target_name)
+              mangled_name = "__temp__#{target_name.unpack1("h*")}"
+            end
+
+            code_generator.define_cached_method(method_name, as: mangled_name, namespace: :alias_attribute) do |batch|
+              body = if CALL_COMPILABLE_REGEXP.match?(target_name)
+                "self.#{target_name}(#{parameters || ''})"
+              else
+                call_args = ":'#{target_name}'"
+                call_args << parameters if parameters
+                "send(#{call_args.join(", ")})"
+              end
+
+              modifier = matcher.parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
+
+              batch <<
+                "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
+                body <<
+                "end"
+            end
           end
         end
       end
@@ -230,7 +253,7 @@
       # <tt>ActiveModel::AttributeMethods</tt>.
       #
       # To use, pass attribute names (as strings or symbols). Be sure to declare
-      # +define_attribute_methods+ after you define any prefix, suffix or affix
+      # +define_attribute_methods+ after you define any prefix, suffix, or affix
       # methods, or they will not hook in.
       #
       #   class Person
@@ -251,7 +274,7 @@
       #     end
       #   end
       def define_attribute_methods(*attr_names)
-        CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) }
         end
       end
@@ -286,7 +309,7 @@
       #   person.name        # => "Bob"
       #   person.name_short? # => true
       def define_attribute_method(attr_name, _owner: generated_attribute_methods)
-        CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
+        ActiveSupport::CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
           attribute_method_matchers.each do |matcher|
             method_name = matcher.method_name(attr_name)
 
@@ -296,7 +319,7 @@
               if respond_to?(generate_method, true)
                 send(generate_method, attr_name.to_s, owner: owner)
               else
-                define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s
+                define_proxy_call(owner, method_name, matcher.target, matcher.parameters, attr_name.to_s, namespace: :active_model_proxy)
               end
             end
           end
@@ -335,46 +358,6 @@
       end
 
       private
-        class CodeGenerator
-          class << self
-            def batch(owner, path, line)
-              if owner.is_a?(CodeGenerator)
-                yield owner
-              else
-                instance = new(owner, path, line)
-                result = yield instance
-                instance.execute
-                result
-              end
-            end
-          end
-
-          def initialize(owner, path, line)
-            @owner = owner
-            @path = path
-            @line = line
-            @sources = "# frozen_string_literal: true\n"
-            @renames = {}
-          end
-
-          def <<(source_line)
-            @sources << source_line
-          end
-
-          def rename_method(old_name, new_name)
-            @renamesold_name = new_name
-          end
-
-          def execute
-            @owner.module_eval(@sources.join(";"), @path, @line - 1)
-            @renames.each do |old_name, new_name|
-              @owner.alias_method new_name, old_name
-              @owner.undef_method old_name
-            end
-          end
-        end
-        private_constant :CodeGenerator
-
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
@@ -398,42 +381,48 @@
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            attribute_method_matchers.map { |matcher| matcher.match(method_name) }.compact
+            attribute_method_matchers.filter_map { |matcher| matcher.match(method_name) }
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
-        # using the given `extra` args. This falls back on `define_method`
-        # and `send` if the given names cannot be compiled.
-        def define_proxy_call(include_private, code_generator, name, target, *extra)
-          defn = if NAME_COMPILABLE_REGEXP.match?(name)
-            "def #{name}(*args)"
-          else
-            "define_method(:'#{name}') do |*args|"
+        # using the given `extra` args. This falls back on `send`
+        # if the called name cannot be compiled.
+        def define_proxy_call(code_generator, name, target, parameters, *call_args, namespace:)
+          mangled_name = name
+          unless NAME_COMPILABLE_REGEXP.match?(name)
+            mangled_name = "__temp__#{name.unpack1("h*")}"
           end
 
-          extra = (extra.map!(&:inspect) << "*args").join(", ")
+          code_generator.define_cached_method(name, as: mangled_name, namespace: :"#{namespace}_#{target}") do |batch|
+            call_args.map!(&:inspect)
+            call_args << parameters if parameters
 
-          body = if CALL_COMPILABLE_REGEXP.match?(target)
-            "#{"self." unless include_private}#{target}(#{extra})"
-          else
-            "send(:'#{target}', #{extra})"
-          end
+            body = if CALL_COMPILABLE_REGEXP.match?(target)
+              "self.#{target}(#{call_args.join(", ")})"
+            else
+              call_args.unshift(":'#{target}'")
+              "send(#{call_args.join(", ")})"
+            end
+
+            modifier = parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
 
-          code_generator <<
-            defn <<
-            body <<
-            "end" <<
-            "ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)"
+            batch <<
+              "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
+              body <<
+              "end"
+          end
         end
 
-        class AttributeMethodMatcher #:nodoc:
-          attr_reader :prefix, :suffix, :target
+        class AttributeMethodMatcher # :nodoc:
+          attr_reader :prefix, :suffix, :target, :parameters
 
           AttributeMethodMatch = Struct.new(:target, :attr_name)
 
-          def initialize(options = {})
-            @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
+          def initialize(prefix: "", suffix: "", parameters: nil)
+            @prefix = prefix
+            @suffix = suffix
+            @parameters = parameters.nil? ? FORWARD_PARAMETERS : parameters
             @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
             @target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
@@ -469,7 +458,7 @@
         match ? attribute_missing(match, *args, &block) : super
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:method_missing)
 
     # +attribute_missing+ is like +method_missing+, but for attributes. When
     # +method_missing+ is called we check to see if there is a matching
@@ -478,6 +467,7 @@
     def attribute_missing(match, *args, &block)
       __send__(match.target, match.attr_name, *args, &block)
     end
+    ruby2_keywords(:attribute_missing)
 
     # A +Person+ instance with a +name+ attribute can ask
     # <tt>person.respond_to?(:name)</tt>, <tt>person.respond_to?(:name=)</tt>,
@@ -520,10 +510,6 @@
 
         # We want to generate the methods via module_eval rather than
         # define_method, because define_method is slower on dispatch.
-        # Evaluating many similar methods may use more memory as the instruction
-        # sequences are duplicated and cached (in MRI).  define_method may
-        # be slower on dispatch, but if you're careful about the closure
-        # created, then define_method will consume much less memory.
         #
         # But sometimes the database might return columns with
         # characters that are not allowed in normal method names (like
@@ -547,7 +533,6 @@
             temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
             attr_name_expr = "::ActiveModel::AttributeMethods::AttrNames::#{const_name}"
             yield temp_method_name, attr_name_expr
-            owner.rename_method(temp_method_name, method_name)
           end
         end
       end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/attribute_set.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/attribute_set.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/attribute_set/builder.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/attribute_set/builder.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/attributes.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/attributes.rb Changed

@@ -4,25 +4,26 @@
 require "active_model/attribute/user_provided_default"
 
 module ActiveModel
-  module Attributes #:nodoc:
+  module Attributes # :nodoc:
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
     included do
-      attribute_method_suffix "="
+      attribute_method_suffix "=", parameters: "value"
       class_attribute :attribute_types, :_default_attributes, instance_accessor: false
       self.attribute_types = Hash.new(Type.default_value)
       self._default_attributes = AttributeSet.new({})
     end
 
     module ClassMethods
-      def attribute(name, type = Type::Value.new, **options)
+      def attribute(name, cast_type = nil, default: NO_DEFAULT_PROVIDED, **options)
         name = name.to_s
-        if type.is_a?(Symbol)
-          type = ActiveModel::Type.lookup(type, **options.except(:default))
-        end
-        self.attribute_types = attribute_types.merge(name => type)
-        define_default_attribute(name, options.fetch(:default, NO_DEFAULT_PROVIDED), type)
+
+        cast_type = Type.lookup(cast_type, **options) if Symbol === cast_type
+        cast_type ||= attribute_typesname
+
+        self.attribute_types = attribute_types.merge(name => cast_type)
+        define_default_attribute(name, default, cast_type)
         define_attribute_method(name)
       end
 
@@ -46,10 +47,12 @@
           ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
             owner, name, writer: true,
           ) do |temp_method_name, attr_name_expr|
-            owner <<
-              "def #{temp_method_name}(value)" <<
-              "  _write_attribute(#{attr_name_expr}, value)" <<
-              "end"
+            owner.define_cached_method("#{name}=", as: temp_method_name, namespace: :active_model) do |batch|
+              batch <<
+                "def #{temp_method_name}(value)" <<
+                "  _write_attribute(#{attr_name_expr}, value)" <<
+                "end"
+            end
           end
         end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/callbacks.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/callbacks.rb Changed

@@ -32,7 +32,7 @@
   #     end
   #   end
   #
-  # Then in your class, you can use the +before_create+, +after_create+ and
+  # Then in your class, you can use the +before_create+, +after_create+, and
   # +around_create+ methods, just as you would in an Active Record model.
   #
   #   before_create :action_before_create
@@ -63,7 +63,7 @@
   # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
   #
   module Callbacks
-    def self.extended(base) #:nodoc:
+    def self.extended(base) # :nodoc:
       base.class_eval do
         include ActiveSupport::Callbacks
       end
@@ -84,7 +84,7 @@
     #   define_model_callbacks :update,  only: :before
     #   define_model_callbacks :destroy, only: :around
     #
-    # Would create +after_create+, +before_update+ and +around_destroy+ methods
+    # Would create +after_create+, +before_update+, and +around_destroy+ methods
     # only.
     #
     # You can pass in a class to before_<type>, after_<type> and around_<type>,

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/conversion.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/conversion.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/dirty.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/dirty.rb Changed

@@ -123,10 +123,11 @@
     include ActiveModel::AttributeMethods
 
     included do
-      attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
-      attribute_method_suffix "_previously_changed?", "_previous_change", "_previously_was"
-      attribute_method_affix prefix: "restore_", suffix: "!"
-      attribute_method_affix prefix: "clear_", suffix: "_change"
+      attribute_method_suffix "_previously_changed?", "_changed?", parameters: "**options"
+      attribute_method_suffix "_change", "_will_change!", "_was", parameters: false
+      attribute_method_suffix "_previous_change", "_previously_was", parameters: false
+      attribute_method_affix prefix: "restore_", suffix: "!", parameters: false
+      attribute_method_affix prefix: "clear_", suffix: "_change", parameters: false
     end
 
     def initialize_dup(other) # :nodoc:
@@ -140,7 +141,7 @@
     end
 
     def as_json(options = {}) # :nodoc:
-      options:except = options:except, "mutations_from_database".flatten
+      options:except = *options:except, "mutations_from_database", "mutations_before_last_save"
       super(options)
     end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/error.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/error.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/errors.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/errors.rb Changed

@@ -48,9 +48,9 @@
   #
   # The last three methods are required in your object for +Errors+ to be
   # able to generate error messages correctly and also handle multiple
-  # languages. Of course, if you extend your object with <tt>ActiveModel::Translation</tt>
+  # languages. Of course, if you extend your object with ActiveModel::Translation
   # you will not need to implement the last two. Likewise, using
-  # <tt>ActiveModel::Validations</tt> will handle the validation related methods
+  # ActiveModel::Validations will handle the validation related methods
   # for you.
   #
   # The above allows you to do:
@@ -63,12 +63,19 @@
     include Enumerable
 
     extend Forwardable
-    def_delegators :@errors, :size, :clear, :blank?, :empty?, :uniq!, :any?
-    # TODO: forward all enumerable methods after `each` deprecation is removed.
-    def_delegators :@errors, :count
 
-    LEGACY_ATTRIBUTES = :messages, :details.freeze
-    private_constant :LEGACY_ATTRIBUTES
+    # :method: each
+    #
+    # :call-seq: each(&block)
+    #
+    # Iterates through each error object.
+    #
+    #   person.errors.add(:name, :too_short, count: 2)
+    #   person.errors.each do |error|
+    #     # Will yield <#ActiveModel::Error attribute=name, type=too_short,
+    #                                       options={:count=>3}>
+    #   end
+    def_delegators :@errors, :each, :clear, :empty?, :size, :uniq!
 
     # The actual array of +Error+ objects
     # This method is aliased to <tt>objects</tt>.
@@ -95,11 +102,14 @@
     # Copies the errors from <tt>other</tt>.
     # For copying errors but keep <tt>@base</tt> as is.
     #
-    # other - The ActiveModel::Errors instance.
+    # ==== Parameters
+    #
+    # * +other+ - The ActiveModel::Errors instance.
     #
-    # Examples
+    # ==== Examples
     #
     #   person.errors.copy!(other)
+    #
     def copy!(other) # :nodoc:
       @errors = other.errors.deep_dup
       @errors.each { |error|
@@ -107,14 +117,15 @@
       }
     end
 
-    # Imports one error
+    # Imports one error.
     # Imported errors are wrapped as a NestedError,
     # providing access to original error object.
     # If attribute or type needs to be overridden, use +override_options+.
     #
-    # override_options - Hash
-    # @option override_options Symbol :attribute Override the attribute the error belongs to
-    # @option override_options Symbol :type Override type of the error.
+    # ==== Options
+    #
+    # * +:attribute+ - Override the attribute the error belongs to.
+    # * +:type+ - Override type of the error.
     def import(error, override_options = {})
       :attribute, :type.each do |key|
         if override_options.key?(key)
@@ -125,39 +136,25 @@
     end
 
     # Merges the errors from <tt>other</tt>,
-    # each <tt>Error</tt> wrapped as <tt>NestedError</tt>.
+    # each Error wrapped as NestedError.
+    #
+    # ==== Parameters
     #
-    # other - The ActiveModel::Errors instance.
+    # * +other+ - The ActiveModel::Errors instance.
     #
-    # Examples
+    # ==== Examples
     #
     #   person.errors.merge!(other)
+    #
     def merge!(other)
+      return errors if equal?(other)
+
       other.errors.each { |error|
         import(error)
       }
     end
 
-    # Removes all errors except the given keys. Returns a hash containing the removed errors.
-    #
-    #   person.errors.keys                  # => :name, :age, :gender, :city
-    #   person.errors.slice!(:age, :gender) # => { :name=>"cannot be nil", :city=>"cannot be nil" }
-    #   person.errors.keys                  # => :age, :gender
-    def slice!(*keys)
-      deprecation_removal_warning(:slice!)
-
-      keys = keys.map(&:to_sym)
-
-      results = messages.dup.slice!(*keys)
-
-      @errors.keep_if do |error|
-        keys.include?(error.attribute)
-      end
-
-      results
-    end
-
-    # Search for errors matching +attribute+, +type+ or +options+.
+    # Search for errors matching +attribute+, +type+, or +options+.
     #
     # Only supplied params will be matched.
     #
@@ -205,76 +202,7 @@
     #   person.errors:name  # => "cannot be nil"
     #   person.errors'name' # => "cannot be nil"
     def (attribute)
-      DeprecationHandlingMessageArray.new(messages_for(attribute), self, attribute)
-    end
-
-    # Iterates through each error object.
-    #
-    #   person.errors.add(:name, :too_short, count: 2)
-    #   person.errors.each do |error|
-    #     # Will yield <#ActiveModel::Error attribute=name, type=too_short,
-    #                                       options={:count=>3}>
-    #   end
-    #
-    # To be backward compatible with past deprecated hash-like behavior,
-    # when block accepts two parameters instead of one, it
-    # iterates through each error key, value pair in the error messages hash.
-    # Yields the attribute and the error for that attribute. If the attribute
-    # has more than one error message, yields once for each error message.
-    #
-    #   person.errors.add(:name, :blank, message: "can't be blank")
-    #   person.errors.each do |attribute, message|
-    #     # Will yield :name and "can't be blank"
-    #   end
-    #
-    #   person.errors.add(:name, :not_specified, message: "must be specified")
-    #   person.errors.each do |attribute, message|
-    #     # Will yield :name and "can't be blank"
-    #     # then yield :name and "must be specified"
-    #   end
-    def each(&block)
-      if block.arity <= 1
-        @errors.each(&block)
-      else
-        ActiveSupport::Deprecation.warn(<<~MSG)
-          Enumerating ActiveModel::Errors as a hash has been deprecated.
-          In Rails 6.1, `errors` is an array of Error objects,
-          therefore it should be accessed by a block with a single block
-          parameter like this:
-
-          person.errors.each do |error|
-            attribute = error.attribute
-            message = error.message
-          end
-
-          You are passing a block expecting two parameters,
-          so the old hash behavior is simulated. As this is deprecated,
-          this will result in an ArgumentError in Rails 6.2.
-        MSG
-        @errors.
-          sort { |a, b| a.attribute <=> b.attribute }.
-          each { |error| yield error.attribute, error.message }
-      end
-    end
-
-    # Returns all message values.
-    #
-    #   person.errors.messages # => {:name=>"cannot be nil", "must be specified"}
-    #   person.errors.values   # => "cannot be nil", "must be specified"
-    def values
-      deprecation_removal_warning(:values, "errors.map { |error| error.message }")
-      @errors.map(&:message).freeze
-    end
-
-    # Returns all message keys.
-    #
-    #   person.errors.messages # => {:name=>"cannot be nil", "must be specified"}
-    #   person.errors.keys     # => :name
-    def keys
-      deprecation_removal_warning(:keys, "errors.attribute_names")
-      keys = @errors.map(&:attribute)
-      keys.uniq!
-      keys.freeze
+      messages_for(attribute)
     end
 
     # Returns all error attribute names
@@ -285,22 +213,6 @@
       @errors.map(&:attribute).uniq.freeze
     end
 
-    # Returns an xml formatted representation of the Errors hash.
-    #
-    #   person.errors.add(:name, :blank, message: "can't be blank")
-    #   person.errors.add(:name, :not_specified, message: "must be specified")
-    #   person.errors.to_xml
-    #   # =>
-    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    #   #  <errors>
-    #   #    <error>name can't be blank</error>
-    #   #    <error>name must be specified</error>
-    #   #  </errors>
-    def to_xml(options = {})
-      deprecation_removal_warning(:to_xml)
-      to_a.to_xml({ root: "errors", skip_types: true }.merge!(options))
-    end
-
     # Returns a Hash that can be used as the JSON representation for this
     # object. You can pass the <tt>:full_messages</tt> option. This determines
     # if the json object should contain full messages or not (false by default).
@@ -323,33 +235,26 @@
       end
     end
 
-    def to_h
-      ActiveSupport::Deprecation.warn(<<~EOM)
-        ActiveModel::Errors#to_h is deprecated and will be removed in Rails 6.2.
-        Please use `ActiveModel::Errors.to_hash` instead. The values in the hash
-        returned by `ActiveModel::Errors.to_hash` is an array of error messages.
-      EOM
+    undef :to_h
 
-      to_hash.transform_values { |values| values.last }
-    end
+    EMPTY_ARRAY = .freeze # :nodoc:
 
     # Returns a Hash of attributes with an array of their error messages.
-    #
-    # Updating this hash would still update errors state for backward
-    # compatibility, but this behavior is deprecated.
     def messages
-      DeprecationHandlingMessageHash.new(self)
+      hash = to_hash
+      hash.default = EMPTY_ARRAY
+      hash.freeze
+      hash
     end
 
     # Returns a Hash of attributes with an array of their error details.
-    #
-    # Updating this hash would still update errors state for backward
-    # compatibility, but this behavior is deprecated.
     def details
       hash = group_by_attribute.transform_values do |errors|
         errors.map(&:details)
       end
-      DeprecationHandlingDetailsHash.new(hash)
+      hash.default = EMPTY_ARRAY
+      hash.freeze
+      hash
     end
 
     # Returns a Hash of attributes with an array of their Error objects.
@@ -378,6 +283,14 @@
     # If +type+ is a symbol, it will be translated using the appropriate
     # scope (see +generate_message+).
     #
+    #   person.errors.add(:name, :blank)
+    #   person.errors.messages
+    #   # => {:name=>"can't be blank"}
+    #
+    #   person.errors.add(:name, :too_long, { count: 25 })
+    #   person.errors.messages
+    #   # => "is too long (maximum is 25 characters)"
+    #
     # If +type+ is a proc, it will be called, allowing for things like
     # <tt>Time.now</tt> to be used within an error.
     #
@@ -521,7 +434,7 @@
     # if it's not there, it's looked up in <tt>activemodel.errors.models.MODEL.MESSAGE</tt> and if
     # that is not there also, it returns the translation of the default message
     # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model
-    # name, translated attribute name and the value are available for
+    # name, translated attribute name, and the value are available for
     # interpolation.
     #
     # When using inheritance in your models, it will check all the inherited
@@ -542,25 +455,10 @@
       Error.generate_message(attribute, type, @base, options)
     end
 
-    def marshal_load(array) # :nodoc:
-      # Rails 5
-      @errors = 
-      @base = array0
-      add_from_legacy_details_hash(array2)
-    end
-
-    def init_with(coder) # :nodoc:
-      data = coder.map
-
-      data.each { |k, v|
-        next if LEGACY_ATTRIBUTES.include?(k.to_sym)
-        instance_variable_set(:"@#{k}", v)
-      }
-
-      @errors ||= 
+    def inspect # :nodoc:
+      inspection = @errors.inspect
 
-      # Legacy support Rails 5.x details hash
-      add_from_legacy_details_hash(data"details") if data.key?("details")
+      "#<#{self.class.name} #{inspection}>"
     end
 
     private
@@ -572,97 +470,6 @@
 
         attribute.to_sym, type, options
       end
-
-      def add_from_legacy_details_hash(details)
-        details.each { |attribute, errors|
-          errors.each { |error|
-            type = error.delete(:error)
-            add(attribute, type, **error)
-          }
-        }
-      end
-
-      def deprecation_removal_warning(method_name, alternative_message = nil)
-        message = +"ActiveModel::Errors##{method_name} is deprecated and will be removed in Rails 6.2."
-        if alternative_message
-          message << "\n\nTo achieve the same use:\n\n  "
-          message << alternative_message
-        end
-        ActiveSupport::Deprecation.warn(message)
-      end
-
-      def deprecation_rename_warning(old_method_name, new_method_name)
-        ActiveSupport::Deprecation.warn("ActiveModel::Errors##{old_method_name} is deprecated. Please call ##{new_method_name} instead.")
-      end
-  end
-
-  class DeprecationHandlingMessageHash < SimpleDelegator
-    def initialize(errors)
-      @errors = errors
-      super(prepare_content)
-    end
-
-    def =(attribute, value)
-      ActiveSupport::Deprecation.warn("Calling `=` to an ActiveModel::Errors is deprecated. Please call `ActiveModel::Errors#add` instead.")
-
-      @errors.delete(attribute)
-      Array(value).each do |message|
-        @errors.add(attribute, message)
-      end
-
-      __setobj__ prepare_content
-    end
-
-    def delete(attribute)
-      ActiveSupport::Deprecation.warn("Calling `delete` to an ActiveModel::Errors messages hash is deprecated. Please call `ActiveModel::Errors#delete` instead.")
-
-      @errors.delete(attribute)
-    end
-
-    private
-      def prepare_content
-        content = @errors.to_hash
-        content.each do |attribute, value|
-          contentattribute = DeprecationHandlingMessageArray.new(value, @errors, attribute)
-        end
-        content.default_proc = proc do |hash, attribute|
-          hash = hash.dup
-          hashattribute = DeprecationHandlingMessageArray.new(, @errors, attribute)
-          __setobj__ hash.freeze
-          hashattribute
-        end
-        content.freeze
-      end
-  end
-
-  class DeprecationHandlingMessageArray < SimpleDelegator
-    def initialize(content, errors, attribute)
-      @errors = errors
-      @attribute = attribute
-      super(content.freeze)
-    end
-
-    def <<(message)
-      ActiveSupport::Deprecation.warn("Calling `<<` to an ActiveModel::Errors message array in order to add an error is deprecated. Please call `ActiveModel::Errors#add` instead.")
-
-      @errors.add(@attribute, message)
-      __setobj__ @errors.messages_for(@attribute)
-      self
-    end
-
-    def clear
-      ActiveSupport::Deprecation.warn("Calling `clear` to an ActiveModel::Errors message array in order to delete all errors is deprecated. Please call `ActiveModel::Errors#delete` instead.")
-
-      @errors.delete(@attribute)
-    end
-  end
-
-  class DeprecationHandlingDetailsHash < SimpleDelegator
-    def initialize(details)
-      details.default = 
-      details.freeze
-      super(details)
-    end
   end
 
   # Raised when a validation cannot be corrected by end users and are considered

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/gem_version.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/gem_version.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/locale/en.yml -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/locale/en.yml Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/model.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/model.rb Changed

@@ -3,11 +3,10 @@
 module ActiveModel
   # == Active \Model \Basic \Model
   #
-  # Includes the required interface for an object to interact with
-  # Action Pack and Action View, using different Active Model modules.
-  # It includes model name introspections, conversions, translations and
-  # validations. Besides that, it allows you to initialize the object with a
-  # hash of attributes, pretty much like Active Record does.
+  # Allows implementing models similar to ActiveRecord::Base.
+  # Includes ActiveModel::API for the required interface for an
+  # object to interact with Action Pack and Action View, but can be
+  # extended with other functionalities.
   #
   # A minimal implementation could be:
   #
@@ -20,23 +19,7 @@
   #   person.name # => "bob"
   #   person.age  # => "18"
   #
-  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
-  # to return +false+, which is the most common case. You may want to override
-  # it in your class to simulate a different scenario:
-  #
-  #   class Person
-  #     include ActiveModel::Model
-  #     attr_accessor :id, :name
-  #
-  #     def persisted?
-  #       self.id == 1
-  #     end
-  #   end
-  #
-  #   person = Person.new(id: 1, name: 'bob')
-  #   person.persisted? # => true
-  #
-  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # If for some reason you need to run code on <tt>initialize</tt>, make
   # sure you call +super+ if you want the attributes hash initialization to
   # happen.
   #
@@ -58,42 +41,6 @@
   # (see below).
   module Model
     extend ActiveSupport::Concern
-    include ActiveModel::AttributeAssignment
-    include ActiveModel::Validations
-    include ActiveModel::Conversion
-
-    included do
-      extend ActiveModel::Naming
-      extend ActiveModel::Translation
-    end
-
-    # Initializes a new model with the given +params+.
-    #
-    #   class Person
-    #     include ActiveModel::Model
-    #     attr_accessor :name, :age
-    #   end
-    #
-    #   person = Person.new(name: 'bob', age: '18')
-    #   person.name # => "bob"
-    #   person.age  # => "18"
-    def initialize(attributes = {})
-      assign_attributes(attributes) if attributes
-
-      super()
-    end
-
-    # Indicates if the model is persisted. Default is +false+.
-    #
-    #  class Person
-    #    include ActiveModel::Model
-    #    attr_accessor :id, :name
-    #  end
-    #
-    #  person = Person.new(id: 1, name: 'bob')
-    #  person.persisted? # => false
-    def persisted?
-      false
-    end
+    include ActiveModel::API
   end
 end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/naming.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/naming.rb Changed

@@ -3,6 +3,7 @@
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/introspection"
 require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/module/delegation"
 
 module ActiveModel
   class Name
@@ -153,6 +154,7 @@
     # Returns a new ActiveModel::Name instance. By default, the +namespace+
     # and +name+ option will take the namespace and name of the given class
     # respectively.
+    # Use +locale+ argument for singularize and pluralize model name.
     #
     #   module Foo
     #     class Bar
@@ -161,7 +163,7 @@
     #
     #   ActiveModel::Name.new(Foo::Bar).to_s
     #   # => "Foo::Bar"
-    def initialize(klass, namespace = nil, name = nil)
+    def initialize(klass, namespace = nil, name = nil, locale = :en)
       @name = name || klass.name
 
       raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
@@ -169,16 +171,17 @@
       @unnamespaced = @name.delete_prefix("#{namespace.name}::") if namespace
       @klass        = klass
       @singular     = _singularize(@name)
-      @plural       = ActiveSupport::Inflector.pluralize(@singular)
+      @plural       = ActiveSupport::Inflector.pluralize(@singular, locale)
+      @uncountable  = @plural == @singular
       @element      = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@name))
       @human        = ActiveSupport::Inflector.humanize(@element)
       @collection   = ActiveSupport::Inflector.tableize(@name)
       @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
       @i18n_key     = @name.underscore.to_sym
 
-      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
-      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
-      @route_key << "_index" if @plural == @singular
+      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key, locale) : @plural.dup)
+      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key, locale)
+      @route_key << "_index" if @uncountable
     end
 
     # Transform the model name into a more human format, using I18n. By default,
@@ -206,6 +209,10 @@
       I18n.translate(defaults.shift, **options)
     end
 
+    def uncountable?
+      @uncountable
+    end
+
     private
       def _singularize(string)
         ActiveSupport::Inflector.underscore(string).tr("/", "_")
@@ -232,7 +239,7 @@
   # is required to pass the \Active \Model Lint test. So either extending the
   # provided method below, or rolling your own is required.
   module Naming
-    def self.extended(base) #:nodoc:
+    def self.extended(base) # :nodoc:
       base.silence_redefinition_of_method :model_name
       base.delegate :model_name, to: :class
     end
@@ -279,7 +286,7 @@
     #   ActiveModel::Naming.uncountable?(Sheep) # => true
     #   ActiveModel::Naming.uncountable?(Post)  # => false
     def self.uncountable?(record_or_class)
-      plural(record_or_class) == singular(record_or_class)
+      model_name_from_record_or_class(record_or_class).uncountable?
     end
 
     # Returns string to use while generating route names. It differs for
@@ -321,7 +328,7 @@
       model_name_from_record_or_class(record_or_class).param_key
     end
 
-    def self.model_name_from_record_or_class(record_or_class) #:nodoc:
+    def self.model_name_from_record_or_class(record_or_class) # :nodoc:
       if record_or_class.respond_to?(:to_model)
         record_or_class.to_model.model_name
       else

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/secure_password.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/secure_password.rb Changed

@@ -36,7 +36,9 @@
       #
       #   gem 'bcrypt', '~> 3.1.7'
       #
-      # Example using Active Record (which automatically includes ActiveModel::SecurePassword):
+      # ==== Examples
+      #
+      # ===== Using Active Record (which automatically includes ActiveModel::SecurePassword)
       #
       #   # Schema: User(name:string, password_digest:string, recovery_password_digest:string)
       #   class User < ActiveRecord::Base
@@ -58,6 +60,27 @@
       #   user.authenticate_recovery_password('42password')          # => user
       #   User.find_by(name: 'david')&.authenticate('notright')      # => false
       #   User.find_by(name: 'david')&.authenticate('mUc3m00RsqyRe') # => user
+      #
+      # ===== Conditionally requiring a password
+      #
+      #   class Account
+      #     include ActiveModel::SecurePassword
+      #
+      #     attr_accessor :is_guest, :password_digest
+      #
+      #     has_secure_password
+      #
+      #     def errors
+      #       super.tap { |errors| errors.delete(:password, :blank) if is_guest }
+      #     end
+      #   end
+      #
+      #   account = Account.new
+      #   account.valid? # => false, password required
+      #
+      #   account.is_guest = true
+      #   account.valid? # => true
+      #
       def has_secure_password(attribute = :password, validations: true)
         # Load bcrypt gem only when has_secure_password is used.
         # This is to avoid ActiveModel (and by extension the entire framework)
@@ -94,6 +117,7 @@
 
         define_method("#{attribute}=") do |unencrypted_password|
           if unencrypted_password.nil?
+            instance_variable_set("@#{attribute}", nil)
             self.public_send("#{attribute}_digest=", nil)
           elsif !unencrypted_password.empty?
             instance_variable_set("@#{attribute}", unencrypted_password)
@@ -118,7 +142,7 @@
         #   user.authenticate_password('mUc3m00RsqyRe') # => user
         define_method("authenticate_#{attribute}") do |unencrypted_password|
           attribute_digest = public_send("#{attribute}_digest")
-          BCrypt::Password.new(attribute_digest).is_password?(unencrypted_password) && self
+          attribute_digest.present? && BCrypt::Password.new(attribute_digest).is_password?(unencrypted_password) && self
         end
 
         alias_method :authenticate, :authenticate_password if attribute == :password

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/serialization.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/serialization.rb Changed

@@ -123,7 +123,7 @@
     #   user.serializable_hash(include: { notes: { only: 'title' }})
     #   # => {"name" => "Napoleon", "notes" => {"title"=>"Battle of Austerlitz"}}
     def serializable_hash(options = nil)
-      attribute_names = attributes.keys
+      attribute_names = attribute_names_for_serialization
 
       return serializable_attributes(attribute_names) if options.blank?
 
@@ -149,6 +149,10 @@
     end
 
     private
+      def attribute_names_for_serialization
+        attributes.keys
+      end
+
       # Hook method defining how an attribute value should be retrieved for
       # serialization. By default this is assumed to be an instance named after
       # the attribute. Override this method in subclasses should you need to
@@ -177,7 +181,7 @@
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
       #   +opts+        - options for the association records
-      def serializable_add_includes(options = {}) #:nodoc:
+      def serializable_add_includes(options = {}) # :nodoc:
         return unless includes = options:include
 
         unless includes.is_a?(Hash)

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/translation.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/translation.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type/date.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type/date.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type/helpers/numeric.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type/helpers/numeric.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type/helpers/time_value.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type/helpers/time_value.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type/integer.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type/integer.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type/registry.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type/registry.rb Changed

@@ -1,70 +1,38 @@
 # frozen_string_literal: true
 
 module ActiveModel
-  # :stopdoc:
   module Type
-    class Registry
+    class Registry # :nodoc:
       def initialize
-        @registrations = 
+        @registrations = {}
       end
 
-      def initialize_dup(other)
+      def initialize_copy(other)
         @registrations = @registrations.dup
         super
       end
 
-      def register(type_name, klass = nil, **options, &block)
+      def register(type_name, klass = nil, &block)
         unless block_given?
           block = proc { |_, *args| klass.new(*args) }
           block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
-        registrations << registration_klass.new(type_name, block, **options)
+        registrationstype_name = block
       end
 
-      def lookup(symbol, *args, **kwargs)
-        registration = find_registration(symbol, *args, **kwargs)
+      def lookup(symbol, *args)
+        registration = registrationssymbol
 
         if registration
-          registration.call(self, symbol, *args, **kwargs)
+          registration.call(symbol, *args)
         else
           raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
       end
+      ruby2_keywords(:lookup)
 
       private
         attr_reader :registrations
-
-        def registration_klass
-          Registration
-        end
-
-        def find_registration(symbol, *args, **kwargs)
-          registrations.find { |r| r.matches?(symbol, *args, **kwargs) }
-        end
-    end
-
-    class Registration
-      # Options must be taken because of https://bugs.ruby-lang.org/issues/10856
-      def initialize(name, block, **)
-        @name = name
-        @block = block
-      end
-
-      def call(_registry, *args, **kwargs)
-        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
-          block.call(*args, **kwargs)
-        else
-          block.call(*args)
-        end
-      end
-
-      def matches?(type_name, *args, **kwargs)
-        type_name == name
-      end
-
-      private
-        attr_reader :name, :block
     end
   end
-  # :startdoc:
 end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/type/time.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/type/time.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations.rb Changed

@@ -32,7 +32,7 @@
   #   person.errors.messages          # => {first_name:"starts with z."}
   #
   # Note that <tt>ActiveModel::Validations</tt> automatically adds an +errors+
-  # method to your instances initialized with a new <tt>ActiveModel::Errors</tt>
+  # method to your instances initialized with a new ActiveModel::Errors
   # object, so there is no need for you to do this manually.
   module Validations
     extend ActiveSupport::Concern
@@ -73,14 +73,14 @@
       #   <tt>on: :create, :custom_validation_context</tt>)
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
       # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       def validates_each(*attr_names, &block)
         validates_with BlockValidator, _merge_attributes(attr_names), &block
@@ -118,7 +118,7 @@
       #     end
       #   end
       #
-      # Or with a block where self points to the current record to be validated:
+      # Or with a block where +self+ points to the current record to be validated:
       #
       #   class Comment
       #     include ActiveModel::Validations
@@ -137,14 +137,14 @@
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: :create, :custom_validation_context</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       #
       # NOTE: Calling +validate+ multiple times on the same method will overwrite previous definitions.
@@ -152,7 +152,7 @@
       def validate(*args, &block)
         options = args.extract_options!
 
-        if args.all? { |arg| arg.is_a?(Symbol) }
+        if args.all?(Symbol)
           options.each_key do |k|
             unless VALID_OPTIONS_FOR_VALIDATE.include?(k)
               raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{VALID_OPTIONS_FOR_VALIDATE.map(&:inspect).join(', ')}. Perhaps you meant to call `validates` instead of `validate`?")
@@ -241,7 +241,7 @@
       #   class Person
       #     include ActiveModel::Validations
       #
-      #     attr_accessor :name , :age
+      #     attr_accessor :name, :age
       #
       #     validates_presence_of :name
       #     validates_inclusion_of :age, in: 0..99
@@ -272,7 +272,7 @@
       end
 
       # Copy validators on inheritance.
-      def inherited(base) #:nodoc:
+      def inherited(base) # :nodoc:
         dup = _validators.dup
         base._validators = dup.each { |k, v| dupk = v.dup }
         super
@@ -280,7 +280,7 @@
     end
 
     # Clean the +Errors+ object if instance is duped.
-    def initialize_dup(other) #:nodoc:
+    def initialize_dup(other) # :nodoc:
       @errors = nil
       super
     end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/absence.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/absence.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/acceptance.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/acceptance.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/callbacks.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/callbacks.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/clusivity.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/clusivity.rb Changed

_service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/comparability.rb Added

_service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/comparison.rb Added

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_model/validations/comparability"
+
+module ActiveModel
+  module Validations
+    class ComparisonValidator < EachValidator # :nodoc:
+      include Comparability
+
+      def check_validity!
+        unless (options.keys & COMPARE_CHECKS.keys).any?
+          raise ArgumentError, "Expected one of :greater_than, :greater_than_or_equal_to, "\
+          ":equal_to, :less_than, :less_than_or_equal_to, or :other_than option to be supplied."
+        end
+      end
+
+      def validate_each(record, attr_name, value)
+        options.slice(*COMPARE_CHECKS.keys).each do |option, raw_option_value|
+          option_value = option_value(record, raw_option_value)
+
+          if value.nil? || value.blank?
+            return record.errors.add(attr_name, :blank, **error_options(value, option_value))
+          end
+
+          unless value.public_send(COMPARE_CHECKSoption, option_value)
+            record.errors.add(attr_name, option, **error_options(value, option_value))
+          end
+        rescue ArgumentError => e
+          record.errors.add(attr_name, e.message)
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates the value of a specified attribute fulfills all
+      # defined comparisons with another value, proc, or attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :value, greater_than: 'the sum of its parts'
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "failed comparison").
+      # * <tt>:greater_than</tt> - Specifies the value must be greater than the
+      #   supplied value.
+      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+      #   greater than or equal to the supplied value.
+      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+      #   value.
+      # * <tt>:less_than</tt> - Specifies the value must be less than the
+      #   supplied value.
+      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+      #   than or equal to the supplied value.
+      # * <tt>:other_than</tt> - Specifies the value must not be equal to the
+      #   supplied value.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
+      #
+      # The validator requires at least one of the following checks to be supplied.
+      # Each will accept a proc, value, or a symbol which corresponds to a method:
+      #
+      # * <tt>:greater_than</tt>
+      # * <tt>:greater_than_or_equal_to</tt>
+      # * <tt>:equal_to</tt>
+      # * <tt>:less_than</tt>
+      # * <tt>:less_than_or_equal_to</tt>
+      # * <tt>:other_than</tt>
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
+      #     validates_comparison_of :preferred_name, other_than: :given_name, allow_nil: true
+      #   end
+      def validates_comparison_of(*attr_names)
+        validates_with ComparisonValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/confirmation.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/confirmation.rb Changed

@@ -19,13 +19,13 @@
 
       private
         def setup!(klass)
-          klass.attr_reader(*attributes.map do |attribute|
+          klass.attr_reader(*attributes.filter_map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-          end.compact)
+          end)
 
-          klass.attr_writer(*attributes.map do |attribute|
+          klass.attr_writer(*attributes.filter_map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-          end.compact)
+          end)
         end
 
         def confirmation_value_equal?(record, attribute, value, confirmed)
@@ -71,7 +71,7 @@
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_confirmation_of(*attr_names)
         validates_with ConfirmationValidator, _merge_attributes(attr_names)
       end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/exclusion.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/exclusion.rb Changed

@@ -29,8 +29,8 @@
       #
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of items that the value shouldn't
-      #   be part of. This can be supplied as a proc, lambda or symbol which returns an
-      #   enumerable. If the enumerable is a numerical, time or datetime range the test
+      #   be part of. This can be supplied as a proc, lambda, or symbol which returns an
+      #   enumerable. If the enumerable is a numerical, time, or datetime range the test
       #   is performed with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When
       #   using a proc or lambda the instance under validation is passed as an argument.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
@@ -40,7 +40,7 @@
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_exclusion_of(*attr_names)
         validates_with ExclusionValidator, _merge_attributes(attr_names)
       end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/format.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/format.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/inclusion.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/inclusion.rb Changed

@@ -28,8 +28,8 @@
       #
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of available items. This can be
-      #   supplied as a proc, lambda or symbol which returns an enumerable. If the
-      #   enumerable is a numerical, time or datetime range the test is performed
+      #   supplied as a proc, lambda, or symbol which returns an enumerable. If the
+      #   enumerable is a numerical, time, or datetime range the test is performed
       #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
       #   a proc or lambda the instance under validation is passed as an argument.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
@@ -38,7 +38,7 @@
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       def validates_inclusion_of(*attr_names)
         validates_with InclusionValidator, _merge_attributes(attr_names)
       end

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/length.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/length.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/numericality.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/numericality.rb Changed

@@ -1,27 +1,34 @@
 # frozen_string_literal: true
 
+require "active_model/validations/comparability"
 require "bigdecimal/util"
 
 module ActiveModel
   module Validations
     class NumericalityValidator < EachValidator # :nodoc:
-      CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
-                 equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
-                 odd: :odd?, even: :even?, other_than: :!= }.freeze
+      include Comparability
 
-      RESERVED_OPTIONS = CHECKS.keys + :only_integer
+      RANGE_CHECKS = { in: :in? }
+      NUMBER_CHECKS = { odd: :odd?, even: :even? }
+
+      RESERVED_OPTIONS = COMPARE_CHECKS.keys + NUMBER_CHECKS.keys + RANGE_CHECKS.keys + :only_integer
 
       INTEGER_REGEX = /\A+-?\d+\z/
 
       HEXADECIMAL_REGEX = /\A+-?0xX/
 
       def check_validity!
-        keys = CHECKS.keys - :odd, :even
-        options.slice(*keys).each do |option, value|
+        options.slice(*COMPARE_CHECKS.keys).each do |option, value|
           unless value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
             raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
           end
         end
+
+        options.slice(*RANGE_CHECKS.keys).each do |option, value|
+          unless value.is_a?(Range)
+            raise ArgumentError, ":#{option} must be a range"
+          end
+        end
       end
 
       def validate_each(record, attr_name, value, precision: Float::DIG, scale: nil)
@@ -37,23 +44,18 @@
 
         value = parse_as_number(value, precision, scale)
 
-        options.slice(*CHECKS.keys).each do |option, option_value|
-          case option
-          when :odd, :even
-            unless value.to_i.public_send(CHECKSoption)
+        options.slice(*RESERVED_OPTIONS).each do |option, option_value|
+          if NUMBER_CHECKS.include?(option)
+            unless value.to_i.public_send(NUMBER_CHECKSoption)
               record.errors.add(attr_name, option, **filtered_options(value))
             end
-          else
-            case option_value
-            when Proc
-              option_value = option_value.call(record)
-            when Symbol
-              option_value = record.send(option_value)
+          elsif RANGE_CHECKS.include?(option)
+            unless value.public_send(RANGE_CHECKSoption, option_value)
+              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
             end
-
-            option_value = parse_as_number(option_value, precision, scale)
-
-            unless value.public_send(CHECKSoption, option_value)
+          elsif COMPARE_CHECKS.include?(option)
+            option_value = option_as_number(record, option_value, precision, scale)
+            unless value.public_send(COMPARE_CHECKSoption, option_value)
               record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
             end
           end
@@ -61,6 +63,10 @@
       end
 
     private
+      def option_as_number(record, option_value, precision, scale)
+        parse_as_number(option_value(record, option_value), precision, scale)
+      end
+
       def parse_as_number(raw_value, precision, scale)
         if raw_value.is_a?(Float)
           parse_float(raw_value, precision, scale)
@@ -155,7 +161,7 @@
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "is not a number").
       # * <tt>:only_integer</tt> - Specifies whether the value has to be an
-      #   integer, e.g. an integral value (default is +false+).
+      #   integer (default is +false+).
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
       #   +false+). Notice that for Integer and Float columns empty strings are
       #   converted to +nil+.
@@ -173,10 +179,11 @@
       #   supplied value.
       # * <tt>:odd</tt> - Specifies the value must be an odd number.
       # * <tt>:even</tt> - Specifies the value must be an even number.
+      # * <tt>:in</tt> - Check that the value is within a range.
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      # See ActiveModel::Validations::ClassMethods#validates for more information.
       #
       # The following checks can also be supplied with a proc or a symbol which
       # corresponds to a method:

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/presence.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/presence.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/validates.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/validates.rb Changed

@@ -78,14 +78,14 @@
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: :create, :custom_validation_context</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or
+      #   method, proc, or string should return or evaluate to a +true+ or
       #   +false+ value.
       # * <tt>:allow_nil</tt> - Skip validation if the attribute is +nil+.
       # * <tt>:allow_blank</tt> - Skip validation if the attribute is blank.

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validations/with.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validations/with.rb Changed

@@ -51,16 +51,16 @@
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: :create, :custom_validation_context</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a +true+ or
+      #   The method, proc, or string should return or evaluate to a +true+ or
       #   +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur
       #   (e.g. <tt>unless: :skip_validation</tt>, or
       #   <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a +true+ or
+      #   The method, proc, or string should return or evaluate to a +true+ or
       #   +false+ value.
       # * <tt>:strict</tt> - Specifies whether validation should be strict.
       #   See <tt>ActiveModel::Validations#validates!</tt> for more information.

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/validator.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/validator.rb Changed

@@ -65,7 +65,7 @@
   # life cycle, and not on each validation run.
   #
   # The easiest way to add custom validators for validating individual attributes
-  # is with the convenient <tt>ActiveModel::EachValidator</tt>.
+  # is with the convenient ActiveModel::EachValidator.
   #
   #   class TitleValidator < ActiveModel::EachValidator
   #     def validate_each(record, attribute, value)
@@ -74,7 +74,7 @@
   #   end
   #
   # This can now be used in combination with the +validates+ method
-  # (see <tt>ActiveModel::Validations::ClassMethods.validates</tt> for more on this).
+  # (see ActiveModel::Validations::ClassMethods#validates for more on this).
   #
   #   class Person
   #     include ActiveModel::Validations
@@ -126,10 +126,10 @@
 
   # +EachValidator+ is a validator which iterates through the attributes given
   # in the options hash invoking the <tt>validate_each</tt> method passing in the
-  # record, attribute and value.
+  # record, attribute, and value.
   #
   # All \Active \Model validations are built on top of this validator.
-  class EachValidator < Validator #:nodoc:
+  class EachValidator < Validator
     attr_reader :attributes
 
     # Returns a new validator instance. All options will be available via the
@@ -174,7 +174,7 @@
 
   # +BlockValidator+ is a special +EachValidator+ which receives a block on initialization
   # and call this block for each attribute being validated. +validates_each+ uses this validator.
-  class BlockValidator < EachValidator #:nodoc:
+  class BlockValidator < EachValidator # :nodoc:
     def initialize(options, &block)
       @block = block
       super

_service:tar_scm:activemodel-6.1.4.1.gem/data/lib/active_model/version.rb -> _service:tar_scm:activemodel-7.0.4.gem/data/lib/active_model/version.rb Changed

_service:tar_scm:activemodel-6.1.4.1.gem/metadata.gz -> _service:tar_scm:activemodel-7.0.4.gem/metadata.gz Changed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemodel
 version: !ruby/object:Gem::Version
-  version: 6.1.4.1
+  version: 7.0.4
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: 
-date: 2021-08-19 00:00:00.000000000 Z
+date: 2022-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.4.1
+        version: 7.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.4.1
+        version: 7.0.4
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -36,6 +36,7 @@
 - MIT-LICENSE
 - README.rdoc
 - lib/active_model.rb
+- lib/active_model/api.rb
 - lib/active_model/attribute.rb
 - lib/active_model/attribute/user_provided_default.rb
 - lib/active_model/attribute_assignment.rb
@@ -87,6 +88,8 @@
 - lib/active_model/validations/acceptance.rb
 - lib/active_model/validations/callbacks.rb
 - lib/active_model/validations/clusivity.rb
+- lib/active_model/validations/comparability.rb
+- lib/active_model/validations/comparison.rb
 - lib/active_model/validations/confirmation.rb
 - lib/active_model/validations/exclusion.rb
 - lib/active_model/validations/format.rb
@@ -104,10 +107,11 @@
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v6.1.4.1/activemodel/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v6.1.4.1/
+  changelog_uri: https://github.com/rails/rails/blob/v7.0.4/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.0.4/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v6.1.4.1/activemodel
+  source_code_uri: https://github.com/rails/rails/tree/v7.0.4/activemodel
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: 
 require_paths:
@@ -116,14 +120,14 @@
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: 
-rubygems_version: 3.2.15
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: A toolkit for building modeling frameworks (part of Rails).

_service:tar_scm:rails-6.1.4.1-tools.txz Deleted

_service:tar_scm:rails-7.0.4-tools.txz Added

Changes of Revision 2