store_model 4.2.2 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c266a446e1b239d465203bd52f8a611559ea11b511f3c3f0e737f8ac356d0ae
-  data.tar.gz: 6d9f845eea8855b7c4f5cf154a4f6d02dcc7d94801f2346ed5c3e83b5f04dc74
+  metadata.gz: fe31f43187a97021f54c79cbc8372b7e2b1c5a3c4bcb7b07b13def128bf69f34
+  data.tar.gz: '0456813d7c47e3a9888c23bd83dc90c233f8919734766e348c064350c3d502ce'
 SHA512:
-  metadata.gz: ad2ed153d5f0bc68ffde00f4254d60e05732fe7e3d0c826fa5a5720a8e77e4af3d0293e10941c1b3001789c1d26dc9cbb1f8624f8492cf914f8a65cddbcec250
-  data.tar.gz: 350da1596c977c36fbe7df0f311e1969a182501ba520f6e64aa6cbe61b84da8b9d86e6ac89bbd1738263fbc13c1868add33455867fda90b6eeed407f966afa0c
+  metadata.gz: 54a697b1a4782fa6bf3a6f84972789f6b42aab7ef9702e243d7fa4b9d7a6c035ea1421a560eb848083dd414b9bd594d577ca82a50642718d80607d742db64561
+  data.tar.gz: d591bf765bb19d91cc7972762349075edbb5ec9d633f3b0e4b9c290069af132e35b9d011e4537de43c18f3de76ca863e8b0576d93502ac95b24e4abb250bedd3

data/README.md

@@ -125,17 +125,19 @@ end
 ## Documentation
 
 1. [Installation](./docs/installation.md)
-2. StoreModel::Model API:
+2. `StoreModel::Model` API:
   * [Instantiation](./docs/instantiation.md)
   * [Validations](./docs/validations.md)
   * [Enums](./docs/enums.md)
   * [Nested models](./docs/nested_models.md)
   * [Unknown attributes](./docs/unknown_attributes.md)
+  * [Empty attributes](./docs/empty_attributes.md)
 3. [Array of stored models](./docs/array_of_stored_models.md)
-4. [One of](./docs/one_of.md)
-4. [Alternatives](./docs/alternatives.md)
-5. [Defining custom types](./docs/defining_custom_types.md)
-6. [Disabling Parent Tracking](./docs/enable_parent_assignment.md)
+4. [Hash of stored models](./docs/hash_of_stored_models.md)
+5. [One of](./docs/one_of.md)
+6. [Alternatives](./docs/alternatives.md)
+7. [Defining custom types](./docs/defining_custom_types.md)
+8. [Disabling Parent Tracking](./docs/enable_parent_assignment.md)
 
 ## Credits
 

data/lib/active_model/validations/store_model_validator.rb

@@ -14,6 +14,7 @@ module ActiveModel
       # @param record [ApplicationRecord] object to validate
       # @param attribute [String] name of the validated attribute
       # @param value [Object] value of the validated attribute
+      # rubocop:disable Metrics/MethodLength
       def validate_each(record, attribute, value)
         if value.nil?
           record.errors.add(attribute, :blank)
@@ -25,8 +26,11 @@ module ActiveModel
           call_json_strategy(record, attribute, value)
         when :array, :polymorphic_array
           call_array_strategy(record, attribute, value)
+        when :hash, :polymorphic_hash
+          call_hash_strategy(record, attribute, value)
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -39,6 +43,11 @@ module ActiveModel
         array_strategy.call(attribute, record.errors, value) if any_invalid
       end
 
+      def call_hash_strategy(record, attribute, value)
+        invalid_values = value.select { |_k, v| v.invalid?(record.validation_context) }
+        hash_strategy.call(attribute, record.errors, invalid_values) if invalid_values.present?
+      end
+
       def strategy
         @strategy ||= StoreModel::CombineErrorsStrategies.configure(options)
       end
@@ -46,6 +55,10 @@ module ActiveModel
       def array_strategy
         @array_strategy ||= StoreModel::CombineErrorsStrategies.configure_array(options)
       end
+
+      def hash_strategy
+        @hash_strategy ||= StoreModel::CombineErrorsStrategies.configure_hash(options)
+      end
     end
   end
 end

data/lib/store_model/combine_errors_strategies/mark_invalid_error_strategy.rb

@@ -10,8 +10,8 @@ module StoreModel
       # @param base_errors [ActiveModel::Errors] errors object of the parent record
       # @param _store_model_errors [ActiveModel::Errors] errors object of the
       # StoreModel::Model attribute
-      def call(attribute, base_errors, _store_model_errors)
-        base_errors.add(attribute, :invalid)
+      def call(attribute, base_errors, store_model_errors)
+        base_errors.add(attribute, :invalid, errors: store_model_errors)
       end
     end
   end

data/lib/store_model/combine_errors_strategies/merge_hash_error_strategy.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StoreModel
+  module CombineErrorsStrategies
+    # +MergeHashErrorStrategy+ copies errors from the StoreModel::Model to the parent
+    # record attribute errors with hash key prefixes.
+    class MergeHashErrorStrategy
+      # Merges errors on +attribute+ from the child model with parent errors.
+      #
+      # @param attribute [String] name of the validated attribute
+      # @param base_errors [ActiveModel::Errors] errors object of the parent record
+      # @param store_models [Hash] a hash of store_models that have been validated
+      def call(attribute, base_errors, store_models)
+        store_models.each do |key, store_model|
+          store_model.errors.full_messages.each do |full_message|
+            base_errors.add(attribute, :invalid, message: "[#{key}] #{full_message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/store_model/combine_errors_strategies.rb

@@ -3,6 +3,7 @@
 require "store_model/combine_errors_strategies/mark_invalid_error_strategy"
 require "store_model/combine_errors_strategies/merge_error_strategy"
 require "store_model/combine_errors_strategies/merge_array_error_strategy"
+require "store_model/combine_errors_strategies/merge_hash_error_strategy"
 
 module StoreModel
   # Module with built-in strategies for combining errors.
@@ -37,6 +38,20 @@ module StoreModel
       )
     end
 
+    # Finds a hash strategy based on +options+ and global config.
+    #
+    # @param options [Hash]
+    #
+    # @return [Object] strategy
+    def configure_hash(options)
+      configured_strategy = options[:merge_hash_errors] || StoreModel.config.merge_hash_errors
+
+      get_configured_strategy(
+        configured_strategy,
+        StoreModel::CombineErrorsStrategies::MergeHashErrorStrategy
+      )
+    end
+
     def get_configured_strategy(configured_strategy, true_strategy_class)
       if configured_strategy.respond_to?(:call)
         configured_strategy

data/lib/store_model/configuration.rb

@@ -11,10 +11,18 @@ module StoreModel
     # @return [Boolean]
     attr_accessor :merge_array_errors
 
+    # Controls usage of MergeHashErrorStrategy
+    # @return [Boolean]
+    attr_accessor :merge_hash_errors
+
     # Controls if the result of `as_json` will contain the unknown attributes of the model
     # @return [Boolean]
     attr_accessor :serialize_unknown_attributes
 
+    # Controls if the result of `as_json` will contain the nulls attributes of the model
+    # @return [Boolean]
+    attr_accessor :serialize_empty_attributes
+
     # Controls if the result of `as_json` will serialize enum fields using `as_json`
     # @return [Boolean]
     attr_accessor :serialize_enums_using_as_json
@@ -28,6 +36,7 @@ module StoreModel
       @serialize_unknown_attributes = true
       @enable_parent_assignment = true
       @serialize_enums_using_as_json = true
+      @serialize_empty_attributes = true
     end
   end
 end

data/lib/store_model/ext/parent_assignment.rb

@@ -7,9 +7,9 @@ module StoreModel
 
     def assign_parent_to_store_model_relation(attribute)
       assign_parent_to_singular_store_model(attribute)
-      return unless attribute.is_a?(Array)
+      return if !attribute.is_a?(Array) && !attribute.is_a?(Hash)
 
-      attribute.each(&method(:assign_parent_to_singular_store_model))
+      (attribute.try(:values) || attribute).each(&method(:assign_parent_to_singular_store_model))
     end
 
     def assign_parent_to_singular_store_model(item)

data/lib/store_model/model.rb

@@ -8,6 +8,7 @@ require "store_model/nested_attributes"
 module StoreModel
   # When included into class configures it to handle JSON column
   module Model # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable Metrics/MethodLength
     def self.included(base) # :nodoc:
       base.include ActiveModel::Model
       base.include ActiveModel::Attributes
@@ -15,6 +16,10 @@ module StoreModel
       base.include ActiveModel::AttributeMethods
       base.include StoreModel::NestedAttributes
 
+      if ActiveModel::VERSION::MAJOR >= 8 && ActiveModel::VERSION::MINOR >= 1
+        base.include ActiveModel::Attributes::Normalization
+      end
+
       base.extend StoreModel::Enum
       base.extend StoreModel::TypeBuilders
 
@@ -22,6 +27,7 @@ module StoreModel
 
       base.extend(ClassMethods)
     end
+    # rubocop:enable Metrics/MethodLength
 
     # Class methods for StoreModel::Model
     module ClassMethods
@@ -32,10 +38,18 @@ module StoreModel
       def from_values(values)
         to_array_type.cast_value(values)
       end
+
+      # Defines a discriminator attribute with a value
+      # @param discriminator [Symbol, String] attribute name (default: :type)
+      # @param type [Symbol, String] attribute type (default: :string)
+      # @param value [String] the discriminator value
+      def discriminator_attribute(discriminator = "type", value:, type: :string)
+        attribute discriminator, type, default: value
+      end
     end
 
     attr_accessor :parent
-    attr_writer :serialize_unknown_attributes, :serialize_enums_using_as_json
+    attr_writer :serialize_unknown_attributes, :serialize_enums_using_as_json, :serialize_empty_attributes
 
     delegate :each_value, to: :attributes
 
@@ -45,7 +59,7 @@ module StoreModel
     # @param options [Hash]
     #
     # @return [Hash]
-    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       serialize_unknown_attributes = if options.key?(:serialize_unknown_attributes)
                                        options[:serialize_unknown_attributes]
                                      else
@@ -58,10 +72,20 @@ module StoreModel
                                         StoreModel.config.serialize_enums_using_as_json
                                       end
 
+      serialize_empty_attributes = if options.key?(:serialize_empty_attributes)
+                                     options[:serialize_empty_attributes]
+                                   else
+                                     StoreModel.config.serialize_empty_attributes
+                                   end
+
+      # If the model is nested, we need to ensure that the serialization
+
       result = @attributes.keys.each_with_object({}) do |key, values|
         attr = @attributes.fetch(key)
-        assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json)
-        values[key] = serialized_attribute(attr)
+        assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json,
+                                     serialize_empty_attributes)
+        serialized = serialized_attribute(attr)
+        values[key] = serialized if serialize_empty_attributes || !serialized.nil?
       end.with_indifferent_access
 
       result.merge!(unknown_attributes) if serialize_unknown_attributes
@@ -226,6 +250,23 @@ module StoreModel
       end
     end
 
+    # Returns the value of the `@serialize_empty_attributes` instance
+    # variable. The default value is the value of the globally configured
+    # `serialize_empty_attributes` option.
+    #
+    # This method is used to determine whether empty values should be serialized
+    # when the `as_json` method is called in nested StoreModel::Model
+    # objects.
+    #
+    # @return [Boolean]
+    def serialize_empty_attributes?
+      if @serialize_empty_attributes.nil?
+        StoreModel.config.serialize_empty_attributes || true
+      else
+        @serialize_empty_attributes
+      end
+    end
+
     private
 
     def attribute?(attribute)
@@ -263,16 +304,18 @@ module StoreModel
 
       array.as_json(
         serialize_unknown_attributes: array.first.serialize_unknown_attributes?,
-        serialize_enums_using_as_json: array.first.serialize_enums_using_as_json?
+        serialize_enums_using_as_json: array.first.serialize_enums_using_as_json?,
+        serialize_empty_attributes: array.first.serialize_empty_attributes?
       )
     end
 
-    def assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json)
+    def assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json, serialize_empty_attributes) # rubocop:disable Layout/LineLength
       return unless Array(attr.value).all? { |value| value.is_a?(StoreModel::Model) }
 
       Array(attr.value).each do |value|
         value.serialize_unknown_attributes = serialize_unknown_attributes
         value.serialize_enums_using_as_json = serialize_enums_using_as_json
+        value.serialize_empty_attributes = serialize_empty_attributes
       end
     end
   end

data/lib/store_model/type_builders.rb

@@ -14,5 +14,11 @@ module StoreModel
     def to_array_type
       Types::Many.new(self)
     end
+
+    # Converts StoreModel::Model to Types::Hash
+    # @return [Types::Hash]
+    def to_hash_type
+      Types::Hash.new(self)
+    end
   end
 end

data/lib/store_model/types/hash.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling a hash of
+    # StoreModel::Model
+    class Hash < HashBase
+      # Initializes type for model class
+      #
+      # @param model_klass [StoreModel::Model] model class to handle
+      #
+      # @return [StoreModel::Types::Hash]
+      def initialize(model_klass)
+        @model_klass = model_klass
+        super()
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :hash
+      end
+
+      protected
+
+      def ensure_model_class(hash)
+        return {} unless hash.is_a?(::Hash)
+
+        hash.transform_values do |object|
+          next object if object.nil?
+
+          object.is_a?(@model_klass) ? object : cast_model_type_value(object)
+        end
+      end
+
+      def cast_model_type_value(value)
+        model_klass_type.cast_value(value)
+      end
+
+      def model_klass_type
+        @model_klass_type ||= @model_klass.to_type
+      end
+
+      def raise_cast_error(value)
+        raise StoreModel::Types::CastError,
+              "failed casting #{value.inspect}, only String or Hash instances are allowed"
+      end
+    end
+  end
+end

data/lib/store_model/types/hash_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements type for handling a hash of StoreModel::Model
+    class HashBase < Base
+      # Casts +value+ from DB or user to Hash of StoreModel::Model instances
+      #
+      # @param value [Object] a value to cast
+      #
+      # @return Hash
+      def cast_value(value)
+        case value
+        when String then decode_and_initialize(value)
+        when ::Hash then ensure_model_class(value)
+        when nil then value
+        else
+          raise_cast_error(value)
+        end
+      end
+
+      # Casts a value from the ruby type to a type that the database knows how
+      # to understand.
+      #
+      # @param value [Object] value to serialize
+      #
+      # @return [String] serialized value
+      def serialize(value)
+        return super unless value.is_a?(::Hash)
+        if value.empty? || value.values.any? { |v| !v.is_a?(StoreModel::Model) }
+          return ActiveSupport::JSON.encode(value)
+        end
+
+        ActiveSupport::JSON.encode(
+          value,
+          serialize_unknown_attributes: value.values.first.serialize_unknown_attributes?,
+          serialize_enums_using_as_json: value.values.first.serialize_enums_using_as_json?
+        )
+      end
+
+      # Determines whether the mutable value has been modified since it was read
+      #
+      # @param raw_old_value [Object] old value
+      # @param new_value [Object] new value
+      #
+      # @return [Boolean]
+      def changed_in_place?(raw_old_value, new_value)
+        cast_value(raw_old_value) != new_value
+      end
+
+      protected
+
+      def ensure_model_class(_hash)
+        raise NotImplementedError
+      end
+
+      def cast_model_type_value(_value)
+        raise NotImplementedError
+      end
+
+      private
+
+      # rubocop:disable Style/RescueModifier
+      def decode_and_initialize(hash_value)
+        decoded = ActiveSupport::JSON.decode(hash_value) rescue {}
+        return {} unless decoded.is_a?(::Hash)
+
+        decoded.transform_values do |attributes|
+          next nil if attributes.nil?
+
+          cast_model_type_value(attributes)
+        end
+      end
+      # rubocop:enable Style/RescueModifier
+    end
+  end
+end

data/lib/store_model/types/hash_polymorphic.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling a hash of
+    # polymorphic StoreModel::Model
+    class HashPolymorphic < HashBase
+      include PolymorphicHelper
+
+      # Initializes type for model class
+      #
+      # @param model_wrapper [Proc] proc that returns class based on value
+      #
+      # @return [StoreModel::Types::HashPolymorphic]
+      def initialize(model_wrapper)
+        @model_wrapper = model_wrapper
+        super()
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :polymorphic_hash
+      end
+
+      protected
+
+      def ensure_model_class(hash)
+        return {} unless hash.is_a?(::Hash)
+
+        hash.transform_values do |object|
+          next object if object.nil?
+          next object if implements_model?(object.class)
+
+          cast_model_type_value(object)
+        end
+      end
+
+      def cast_model_type_value(value)
+        model_klass = @model_wrapper.call(value)
+
+        raise_extract_wrapper_error(model_klass) unless implements_model?(model_klass)
+
+        model_klass.to_type.cast_value(value)
+      end
+
+      def raise_cast_error(value)
+        raise StoreModel::Types::CastError,
+              "failed casting #{value.inspect}, only String, " \
+              "Hash or instances which implement StoreModel::Model are allowed"
+      end
+    end
+  end
+end

data/lib/store_model/types/one.rb

@@ -56,7 +56,7 @@ module StoreModel
           ActiveSupport::JSON.encode(value,
                                      serialize_unknown_attributes: value.serialize_unknown_attributes?,
                                      serialize_enums_using_as_json: value.serialize_enums_using_as_json?)
-        when Hash
+        when ::Hash
           ActiveSupport::JSON.encode(value)
         else
           super
@@ -75,7 +75,7 @@ module StoreModel
         when String
           payload = ActiveSupport::JSON.decode(value) rescue {}
           model_instance(deserialize_by_types(payload))
-        when Hash
+        when ::Hash
           model_instance(deserialize_by_types(value))
         when nil
           nil

data/lib/store_model/types/one_of.rb

@@ -18,6 +18,10 @@ module StoreModel
       def to_array_type
         Types::ManyPolymorphic.new(@block)
       end
+
+      def to_hash_type
+        Types::HashPolymorphic.new(@block)
+      end
     end
   end
 end

data/lib/store_model/types/one_polymorphic.rb

@@ -53,7 +53,7 @@ module StoreModel
       #
       # @return [String] serialized value
       def serialize(value)
-        return super unless value.is_a?(Hash) || implements_model?(value.class)
+        return super unless value.is_a?(::Hash) || implements_model?(value.class)
 
         if value.is_a?(StoreModel::Model)
           ActiveSupport::JSON.encode(

data/lib/store_model/types.rb

@@ -11,6 +11,10 @@ require "store_model/types/many_base"
 require "store_model/types/many"
 require "store_model/types/many_polymorphic"
 
+require "store_model/types/hash_base"
+require "store_model/types/hash"
+require "store_model/types/hash_polymorphic"
+
 require "store_model/types/enum_type"
 
 require "store_model/types/one_of"

data/lib/store_model/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StoreModel # :nodoc:
-  VERSION = "4.2.2"
+  VERSION = "4.4.0"
 end

data/lib/store_model.rb

@@ -15,5 +15,61 @@ module StoreModel # :nodoc:
     def one_of(&block)
       Types::OneOf.new(&block)
     end
+
+    # Creates a union type for polymorphic attributes
+    # @param klasses [Array<Class>] array of classes that can be used
+    # @param discriminator [String, Symbol] the attribute key to check for type (default: 'type')
+    # @return instance [Types::OneOf]
+    def union(klasses, discriminator: "type")
+      discriminators_and_classes = klasses.map do |cls|
+        [cls._default_attributes[discriminator]&.value, cls]
+      end
+
+      validate_missing_discriminators!(discriminator, discriminators_and_classes)
+      validate_duplicate_discriminators!(discriminators_and_classes)
+
+      union_one_of(discriminator, Hash[discriminators_and_classes])
+    end
+
+    private
+
+    def validate_missing_discriminators!(discriminator, discriminators_and_classes)
+      missing_discriminator_classes = discriminators_and_classes.select do |(discriminator_value, _cls)|
+        discriminator_value.blank?
+      end.map(&:last)
+
+      return if missing_discriminator_classes.empty?
+
+      raise "discriminator_attribute not set for #{discriminator} on #{missing_discriminator_classes.join(', ')}"
+    end
+
+    def validate_duplicate_discriminators!(discriminators_and_classes)
+      discriminator_counts = discriminators_and_classes.group_by(&:first)
+      duplicates = discriminator_counts.select { |_discriminator_value, pairs| pairs.length > 1 }
+
+      return if duplicates.empty?
+
+      duplicate_messages = duplicates.map do |discriminator_value, pairs|
+        classes = pairs.map(&:last).map(&:name).join(", ")
+        "#{discriminator_value.inspect} => [#{classes}]"
+      end
+
+      raise "Duplicate discriminator values found: #{duplicate_messages.join('; ')}"
+    end
+
+    def union_one_of(discriminator, class_map)
+      Types::OneOf.new do |attributes|
+        next nil unless attributes
+
+        discriminator_value = attributes.with_indifferent_access[discriminator]
+
+        raise ArgumentError, "Missing discriminator attribute #{discriminator} for union" if discriminator_value.blank?
+
+        cls = class_map[discriminator_value]
+        raise ArgumentError, "Unknown discriminator value for union: #{discriminator_value}" if cls.blank?
+
+        cls
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: store_model
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.4.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -82,6 +81,7 @@ files:
 - lib/store_model/combine_errors_strategies/mark_invalid_error_strategy.rb
 - lib/store_model/combine_errors_strategies/merge_array_error_strategy.rb
 - lib/store_model/combine_errors_strategies/merge_error_strategy.rb
+- lib/store_model/combine_errors_strategies/merge_hash_error_strategy.rb
 - lib/store_model/configuration.rb
 - lib/store_model/enum.rb
 - lib/store_model/ext/active_model/attributes.rb
@@ -94,6 +94,9 @@ files:
 - lib/store_model/types.rb
 - lib/store_model/types/base.rb
 - lib/store_model/types/enum_type.rb
+- lib/store_model/types/hash.rb
+- lib/store_model/types/hash_base.rb
+- lib/store_model/types/hash_polymorphic.rb
 - lib/store_model/types/many.rb
 - lib/store_model/types/many_base.rb
 - lib/store_model/types/many_polymorphic.rb
@@ -108,7 +111,6 @@ homepage: https://github.com/DmitryTsepelev/store_model
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -123,8 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Gem for working with JSON-backed attributes as ActiveRecord models
 test_files: []