attr_json 1.4.0 → 2.6.0

data/lib/attr_json/record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/attribute_definition'
 require 'attr_json/attribute_definition/registry'
 require 'attr_json/type/container_attribute'
@@ -24,35 +26,61 @@ module AttrJson
 
       class_attribute :attr_json_registry, instance_accessor: false
       self.attr_json_registry = AttrJson::AttributeDefinition::Registry.new
-    end
 
-    protected
+      # Ensure that rails attributes tracker knows about values we just fetched
+      after_initialize do
+        attr_json_sync_to_rails_attributes
+      end
 
-    # adapted from ActiveRecord query_attribute method
-    # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/attribute_methods/query.rb#L12
+      # After a safe, rails attribute dirty tracking ends up re-creating
+      # new objects for attribute values, so we need to sync again
+      # so mutation effects both.
+      after_save do
+        attr_json_sync_to_rails_attributes
+      end
+    end
+
+    # Sync all values FROM the json_attributes json column TO rails attributes
     #
-    # Sadly we could not re-use Rails code here, becuase the built-in method assumes attribute
-    # can be obtained with `self[attr_name]`, which you can not with attr_json (is that bad?), as
-    # well as `self.class.columns_hash[attr_name]` which you definitely can not (which is probably not bad),
-    # and has no way to use the value-translation semantics independently of that. May be a problem if
-    # ActiveRecord changes it's query method semantics in the future, will have to be sync'd here.
+    # If values have for some reason gotten out of sync this will make them the
+    # identical objects again, with the container hash value being the source.
     #
-    # Used to implement query methods on attr_json attributes, like `attr_json :foo, :string`, method `#foo?`
-    def self.attr_json_query_method(record, attribute)
-      value = record.send(attribute)
-
-      case value
-      when true
-        true
-      when false, nil, ActiveModel::Type::Boolean::FALSE_VALUES
-        false
-      else
-        if value.respond_to?(:to_i) && ( Numeric === value || value.to_s !~ /[^0-9]/ )
-          !value.to_i.zero?
-        elsif value.respond_to?(:zero?)
-          !value.zero?
-        else
-          !value.blank?
+    # In some cases, the values may already be equivalent but different objects --
+    # This is meant to ensure they are the _same object_ in both places, so
+    # mutation of mutable object will effect both places, for instance for dirty
+    # tracking.
+    def attr_json_sync_to_rails_attributes
+      self.class.attr_json_registry.definitions.group_by(&:container_attribute).each_pair do |container_attribute, definitions|
+        begin
+          # column may have eg been left out of an explicit 'select'
+          next unless has_attribute?(container_attribute)
+
+          container_value    = public_send(container_attribute)
+
+          # isn't expected to be possible to be nil rather than empty hash, but
+          # if it is from some edge case, well, we don't have values to sync, fine
+          next if container_value.nil?
+
+          definitions.each do |attribute_def|
+            attr_name     = attribute_def.name
+            value         = container_value[attribute_def.store_key]
+
+            unless value.nil?
+              # TODO, can we just make this use the setter?
+              write_attribute(attr_name, value)
+
+              clear_attribute_change(attr_name) if persisted?
+
+              # writing and clearning will result in a new object stored in
+              # rails attributes, we want
+              # to make sure the exact same object is in the json attribute,
+              # so in-place mutation changes to it are reflected in both places.
+              container_value[attribute_def.store_key] = read_attribute(attr_name)
+            end
+          end
+        rescue AttrJson::Type::Model::BadCast, AttrJson::Type::PolymorphicModel::TypeError => e
+          # There was bad data in the DB, we're just going to skip the Rails attribute sync.
+          # Should we log?
         end
       end
     end
@@ -93,7 +121,8 @@ module AttrJson
       end
 
 
-
+      # Registers an attr_json attribute, and a Rails attribute covering it.
+      #
       # Type can be a symbol that will be looked up in `ActiveModel::Type.lookup`,
       # or an ActiveModel:::Type::Value).
       #
@@ -102,6 +131,8 @@ module AttrJson
       # @param type [ActiveModel::Type::Value] An instance of an ActiveModel::Type::Value (or subclass)
       #
       # @option options [Boolean] :array (false) Make this attribute an array of given type.
+      #    Array types default to an empty array. If you want to turn that off, you can add
+      #    `default: AttrJson::AttributeDefinition::NO_DEFAULT_PROVIDED`
       #
       # @option options [Object] :default (nil) Default value, if a Proc object it will be #call'd
       #   for default.
@@ -113,100 +144,94 @@ module AttrJson
       #   json(b) ActiveRecord attribute/column to serialize as a key in. Defaults to
       #  `attr_json_config.default_container_attribute`, which defaults to `:json_attributes`
       #
-      # @option options [Boolean] :validate (true) Create an ActiveRecord::Validations::AssociatedValidator so
-      #   validation errors on the attributes post up to self.
+      # @option options [Boolean] :validate (true) validation errors on nested models in the attributes
+      #   should post up to self similar to Rails ActiveRecord::Validations::AssociatedValidator on
+      #   associated objects.
+      #
+      # @option options [Boolean,Hash] :accepts_nested_attributes. If true, equivalent
+      #   of  writing `attr_json_accepts_nested_attributes :attribute_name`. If value is a hash,
+      #   then same, but with hash as options to `attr_json_accepts_nested_attributes`.
+      #   Default taken from `attr_json_config.default_accepts_nested_attributes`, for
+      #   array or model types where it is applicable.
       #
-      # @option options [Boolean] :rails_attribute (false) Create an actual ActiveRecord
-      #    `attribute` for name param. A Rails attribute isn't needed for our functionality,
-      #    but registering thusly will let the type be picked up by simple_form and
-      #    other tools that may look for it via Rails attribute APIs. Default can be changed
-      #    with `attr_json_config(default_rails_attribute: true)`
       def attr_json(name, type, **options)
         options = {
-          rails_attribute: self.attr_json_config.default_rails_attribute,
           validate: true,
           container_attribute: self.attr_json_config.default_container_attribute,
-          accepts_nested_attributes: self.attr_json_config.default_accepts_nested_attributes
         }.merge!(options)
-        options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :rails_attribute, :accepts_nested_attributes])
+        options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :accepts_nested_attributes])
         container_attribute = options[:container_attribute]
 
-        # TODO arg check container_attribute make sure it exists. Hard cause
-        # schema isn't loaded yet when class def is loaded. Maybe not.
 
-        # Want to lazily add an attribute cover to the json container attribute,
-        # only if it hasn't already been done. WARNING we are using internal
-        # Rails API here, but only way to do this lazily, which I thought was
-        # worth it. On the other hand, I think .attribute is idempotent, maybe we don't need it...
-        #
-        # We set default to empty hash, because that 'tricks' AR into knowing any
-        # application of defaults is a change that needs to be saved.
-        unless attributes_to_define_after_schema_loads[container_attribute.to_s] &&
-               attributes_to_define_after_schema_loads[container_attribute.to_s].first.is_a?(AttrJson::Type::ContainerAttribute) &&
-               attributes_to_define_after_schema_loads[container_attribute.to_s].first.model == self
-           # If this is already defined, but was for superclass, we need to define it again for
-           # this class.
+        # Make sure to "lazily" register attribute for *container* class if this is the first time
+        # this container attribute hsa been encountered for this specific class. The registry
+        # helps us keep track. Kinda messy, in future we may want a more explicit API
+        # that does not require us to implicitly track first-time per-container.
+        unless self.attr_json_registry.container_attribute_registered?(model: self, attribute_name: container_attribute.to_sym)
            attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute), default: -> { {} }
+           self.attr_json_registry.register_container_attribute(model: self, attribute_name: container_attribute.to_sym)
         end
 
         self.attr_json_registry = attr_json_registry.with(
-          AttributeDefinition.new(name.to_sym, type, options.except(:rails_attribute, :validate, :accepts_nested_attributes))
+          AttributeDefinition.new(name.to_sym, type, options.except(:validate, :accepts_nested_attributes))
         )
 
-        # By default, automatically validate nested models
+        # By default, automatically validate nested models, allowing nils.
         if type.kind_of?(AttrJson::Type::Model) && options[:validate]
-          self.validates_with ActiveRecord::Validations::AssociatedValidator, attributes: [name.to_sym]
-        end
-
-        # We don't actually use this for anything, we provide our own covers. But registering
-        # it with usual system will let simple_form and maybe others find it.
-        if options[:rails_attribute]
-          attr_json_definition = attr_json_registry[name]
-
-          attribute_args = attr_json_definition.has_default? ? { default: attr_json_definition.default_argument } : {}
-          self.attribute name.to_sym, attr_json_definition.type, **attribute_args
-
-          # Ensure that rails attributes tracker knows about value we just fetched
-          # for this particular attribute. Yes, we are registering an after_find for each
-          # attr_json registered with rails_attribute:true, using the `name` from above under closure. .
-          after_find do
-            value = public_send(name)
-            if value && has_attribute?(name.to_sym)
-              write_attribute(name.to_sym, value)
-              self.send(:clear_attribute_changes, [name.to_sym])
+          # implementation adopted from:
+          #   https://github.com/rails/rails/blob/v7.0.4.1/activerecord/lib/active_record/validations/associated.rb#L6-L10
+          #
+          # but had to customize to allow nils in an array through
+          validates_each name.to_sym do |record, attr, value|
+            if Array(value).reject { |element| element.nil? || element.valid? }.any?
+              record.errors.add(attr, :invalid, value: value)
             end
           end
         end
 
-        _attr_jsons_module.module_eval do
-          # For getter and setter, we used to use read_store_attribute/write_store_attribute
-          # copied from Rails store_accessor implementation.
-          # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-          #
-          # But in fact just getting/setting in the hash provided to us by ActiveRecord json type
-          # container works BETTER for dirty tracking. We had a test that only passed doing it
-          # this simple way.
+        # Register as a Rails attribute
+        attr_json_definition = attr_json_registry[name]
+        attribute_args = attr_json_definition.has_default? ? { default: attr_json_definition.default_argument } : {}
+        self.attribute name.to_sym, attr_json_definition.type, **attribute_args
 
+        # For getter and setter, we consider the container has the "canonical" data location.
+        # But setter also writes to rails attribute, and tries to keep them in sync with the
+        # *same object*, so mutations happen to both places.
+        #
+        # This began roughly modelled on approach of Rail sstore_accessor implementation:
+        # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
+        #
+        # ...But wound up with lots of evolution to try to get dirty tracking working as well
+        # as we could -- without a completely custom separate dirty tracking implementation
+        # like store_accessor tries!
+        _attr_jsons_module.module_eval do
           define_method("#{name}=") do |value|
-            super(value) if defined?(super)
+            super(value) # should write to rails attribute
+
+            # write to container hash, with value read from attribute to try to keep objects
+            # sync'd to exact same object in rails attribute and container hash.
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
-            public_send(attribute_def.container_attribute)[attribute_def.store_key] = attribute_def.cast(value)
+            public_send(attribute_def.container_attribute)[attribute_def.store_key] = read_attribute(name)
           end
 
           define_method("#{name}") do
+            # read from container hash -- we consider that the canonical location.
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
             public_send(attribute_def.container_attribute)[attribute_def.store_key]
           end
+        end
 
-          define_method("#{name}?") do
-            # implementation of `query_store_attribute` is based on Rails `query_attribute` implementation
-            AttrJson::Record.attr_json_query_method(self, name)
-          end
+        accepts_nested_attributes = if options.has_key?(:accepts_nested_attributes)
+          options[:accepts_nested_attributes]
+        elsif attr_json_definition.single_model_type? || attr_json_definition.array_type?
+          # use configured default only if we have a type appropriate for it!
+          self.attr_json_config.default_accepts_nested_attributes
+        else
+          false
         end
 
-        # Default attr_json_accepts_nested_attributes_for values
-        if options[:accepts_nested_attributes]
-          options = options[:accepts_nested_attributes] == true ? {} : options[:accepts_nested_attributes]
+        if accepts_nested_attributes
+          options = accepts_nested_attributes == true ? {} : accepts_nested_attributes
           self.attr_json_accepts_nested_attributes_for name, **options
         end
       end

data/lib/attr_json/serialization_coder_from_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
 
   # A little wrapper to provide an object that provides #dump and #load method for use

data/lib/attr_json/type/array.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # You can wrap any ActiveModel::Type in one of these, and it's magically
@@ -30,6 +32,10 @@ module AttrJson
         convert_to_array(value).collect { |v| base_type.deserialize(v) }
       end
 
+      def changed_in_place?(raw_old_value, new_value)
+        serialize(new_value) != raw_old_value
+      end
+
       # This is used only by our own keypath-chaining query stuff.
       def value_for_contains_query(key_path_arr, value)
         [
@@ -41,10 +47,13 @@ module AttrJson
         ]
       end
 
-      # Hacky, hard-coded classes, but used in our weird primitive implementation in NestedAttributes,
-      # better than putting the conditionals there
+      # Soft-deprecated. You probably want to use
+      #
+      #    AttrJson::AttributeDefinition#array_of_primitive_type?
+      #
+      # instead where possible.
       def base_type_primitive?
-        !(base_type.is_a?(AttrJson::Type::Model) || base_type.is_a?(AttrJson::Type::PolymorphicModel))
+        ! AttrJson::AttributeDefinition.single_model_type?(base_type)
       end
 
       protected

data/lib/attr_json/type/container_attribute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # A type that gets applied to the AR container/store jsonb attribute,

data/lib/attr_json/type/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # An ActiveModel::Type representing a particular AttrJson::Model
@@ -8,13 +10,22 @@ module AttrJson
     # but normally that's only done in AttrJson::Model.to_type, there isn't
     # an anticipated need to create from any other place.
     #
+    #
     class Model < ::ActiveModel::Type::Value
       class BadCast < ArgumentError ; end
 
-      attr_accessor :model
-      def initialize(model)
+      attr_accessor :model, :strip_nils
+
+      # @param model [AttrJson::Model] the model _class_ object
+      # @param strip_nils [Symbol,Boolean] [true, false, or :safely]
+      #  (default :safely), As a type, should we strip nils when serialiing?
+      #  This value passed to AttrJson::Model#serialized_hash(strip_nils).
+      #  by default it's :safely, we strip nils when it can be done safely
+      #  to preserve default overrides.
+      def initialize(model, strip_nils: :safely)
         #TODO type check, it really better be a AttrJson::Model. maybe?
         @model = model
+        @strip_nils = strip_nils
       end
 
       def type
@@ -51,9 +62,9 @@ module AttrJson
         if v.nil?
           nil
         elsif v.kind_of?(model)
-          v.serializable_hash
+          v.serializable_hash(strip_nils: strip_nils)
         else
-          (cast_v = cast(v)) && cast_v.serializable_hash
+          (cast_v = cast(v)) && cast_v.serializable_hash(strip_nils: strip_nils)
         end
       end
 

data/lib/attr_json/type/polymorphic_model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # AttrJson::Type::PolymorphicModel can be used to create attr_json attributes
@@ -100,17 +102,11 @@ module AttrJson
       end
 
       def cast(v)
-        if v.nil?
-          v
-        elsif model_names.include?(v.class.name)
-          v
-        elsif v.respond_to?(:to_hash)
-          cast_from_hash(v.to_hash)
-        elsif v.respond_to?(:to_h)
-          cast_from_hash(v.to_h)
-        else
-          raise_bad_model_name(v.class, v)
-        end
+        cast_or_deserialize(v, :cast)
+      end
+
+      def deserialize(v)
+        cast_or_deserialize(v, :deserialize)
       end
 
       def serialize(v)
@@ -127,10 +123,6 @@ module AttrJson
         type.serialize(v).merge(type_key => model_name)
       end
 
-      def deserialize(v)
-        cast(v)
-      end
-
       def type_for_model_name(model_name)
         model_type_lookup[model_name]
       end
@@ -153,15 +145,29 @@ module AttrJson
 
       protected
 
-      def raise_missing_type_key(value)
-        raise TypeError, "AttrJson::Type::Polymorphic can't cast without '#{type_key}' key: #{value}"
-      end
-
-      def raise_bad_model_name(name, value)
-        raise TypeError, "This AttrJson::Type::PolymorphicType can only include {#{model_names.join(', ')}}, not '#{name}': #{value.inspect}"
+      # We need to make sure to call the correct operation on
+      # the model type, so that we get the same result as if
+      # we had called the type directly
+      #
+      # @param v [Object, nil] the value to cast or deserialize
+      # @param operation [Symbol] :cast or :deserialize
+      def cast_or_deserialize(v, operation)
+        if v.nil?
+          v
+        elsif model_names.include?(v.class.name)
+          v
+        elsif v.respond_to?(:to_hash)
+          model_from_hash(v.to_hash, operation)
+        elsif v.respond_to?(:to_h)
+          model_from_hash(v.to_h, operation)
+        else
+          raise_bad_model_name(v.class, v)
+        end
       end
 
-      def cast_from_hash(hash)
+      # @param hash [Hash] the value to cast or deserialize
+      # @param operation [Symbol] :cast or :deserialize
+      def model_from_hash(hash, operation)
         new_hash = hash.stringify_keys
         model_name = new_hash.delete(type_key.to_s)
 
@@ -171,7 +177,21 @@ module AttrJson
 
         raise_bad_model_name(model_name, hash) if type.nil?
 
-        type.cast(new_hash)
+        if operation == :deserialize
+          type.deserialize(new_hash)
+        elsif operation == :cast
+          type.cast(new_hash)
+        else
+          raise ArgumentError, "Unknown operation #{operation}"
+        end
+      end
+
+      def raise_missing_type_key(value)
+        raise TypeError, "AttrJson::Type::Polymorphic can't cast without '#{type_key}' key: #{value}"
+      end
+
+      def raise_bad_model_name(name, value)
+        raise TypeError, "This AttrJson::Type::PolymorphicType can only include {#{model_names.join(', ')}}, not '#{name}': #{value.inspect}"
       end
     end
   end

data/lib/attr_json/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "1.4.0"
+  VERSION = "2.6.0"
 end

data/lib/attr_json.rb

@@ -9,11 +9,26 @@ require 'attr_json/nested_attributes'
 require 'attr_json/record/query_scopes'
 require 'attr_json/type/polymorphic_model'
 
-# Dirty not supported on Rails 5.0
-if Gem.loaded_specs["activerecord"].version.release >= Gem::Version.new('5.1')
-  require 'attr_json/record/dirty'
-end
-
 module AttrJson
-
+  # We need to convert Symbols to strings a lot at present -- ActiveRecord does too, so
+  # not too suprrising.
+  #
+  # In Rails 3.0 and above, we can use Symbol#name to get a frozen string back
+  # and avoid extra allocations. https://bugs.ruby-lang.org/issues/16150
+  #
+  # Ruby 2.7 doens't yet have it though. As long as we are supporting ruby 2.7,
+  # we'll just check at runtime to keep this lean
+  if RUBY_VERSION.split('.').first.to_i >= 3
+    def self.efficient_to_s(obj)
+      if obj.kind_of?(Symbol)
+        obj.name
+      else
+        obj.to_s
+      end
+    end
+  else
+    def self.efficient_to_s(obj)
+      obj.to_s
+    end
+  end
 end

data/playground_models.rb

@@ -61,7 +61,7 @@ class MyModel < ActiveRecord::Base
   self.table_name = "products"
 
   include AttrJson::Record
-  include AttrJson::Record::Dirty
+  #include AttrJson::Record::Dirty
 
   attr_json :str, :string
   attr_json :str_array, :string, array: true
@@ -76,7 +76,7 @@ end
 class Product < StaticProduct
   include AttrJson::Record
   include AttrJson::Record::QueryScopes
-  include AttrJson::Record::Dirty
+  #include AttrJson::Record::Dirty
 
   attr_json :title, :string
   attr_json :rank, :integer

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: attr_json
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Jonathan Rochkind
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,20 +15,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 6.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 6.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -72,20 +71,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.7'
-- !ruby/object:Gem::Dependency
-  name: database_cleaner
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: yard-activesupport-concern
   requirement: !ruby/object:Gem::Requirement
@@ -144,8 +129,8 @@ dependencies:
         version: '1.0'
 description: |-
   ActiveRecord attributes stored serialized in a json column, super smooth.
-  For Rails 5.0, 5.1, or 5.2. Typed and cast like Active Record. Supporting nested models,
-  dirty tracking, some querying (with postgres jsonb contains), and working smoothy with form builders.
+  Typed and cast like Active Record. Supporting nested models, dirty tracking, some querying
+  (with postgres jsonb contains), and working smoothy with form builders.
 
   Use your database as a typed object store via ActiveRecord, in the same models right next to
   ordinary ActiveRecord column-backed attributes and associations. Your json-serialized attr_json
@@ -173,15 +158,15 @@ files:
 - bin/rspec
 - bin/setup
 - config.ru
-- doc_src/dirty_tracking.md
 - doc_src/forms.md
 - gemfiles/.bundle/config
-- gemfiles/rails_5_0.gemfile
-- gemfiles/rails_5_1.gemfile
-- gemfiles/rails_5_2.gemfile
 - gemfiles/rails_6_0.gemfile
 - gemfiles/rails_6_1.gemfile
 - gemfiles/rails_7_0.gemfile
+- gemfiles/rails_7_1.gemfile
+- gemfiles/rails_7_2.gemfile
+- gemfiles/rails_8_0.gemfile
+- gemfiles/rails_8_1.gemfile
 - gemfiles/rails_edge.gemfile
 - lib/attr_json.rb
 - lib/attr_json/attribute_definition.rb
@@ -189,12 +174,12 @@ files:
 - lib/attr_json/config.rb
 - lib/attr_json/model.rb
 - lib/attr_json/model/cocoon_compat.rb
+- lib/attr_json/model/nested_model_validator.rb
 - lib/attr_json/nested_attributes.rb
 - lib/attr_json/nested_attributes/builder.rb
 - lib/attr_json/nested_attributes/multiparameter_attribute_writer.rb
 - lib/attr_json/nested_attributes/writer.rb
 - lib/attr_json/record.rb
-- lib/attr_json/record/dirty.rb
 - lib/attr_json/record/query_builder.rb
 - lib/attr_json/record/query_scopes.rb
 - lib/attr_json/serialization_coder_from_type.rb
@@ -210,7 +195,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/jrochkind/attr_json
   source_code_uri: https://github.com/jrochkind/attr_json
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -218,15 +202,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.7.1
 specification_version: 4
 summary: ActiveRecord attributes stored serialized in a json column, super smooth.
 test_files: []