attr_json 1.5.0 → 2.0.0.rc1

data/lib/attr_json/model.rb

@@ -20,7 +20,7 @@ module AttrJson
   # Meant for use as an attribute of a AttrJson::Record. Can be nested,
   # AttrJson::Models can have attributes that are other AttrJson::Models.
   #
-  # @note Includes ActiveModel::Model whether you like it or not. TODO, should it?
+  # @note Includes ActiveModel::Model whether you like it or not.
   #
   # You can control what happens if you set an unknown key (one that you didn't
   # register with `attr_json`) with the config attribute `attr_json_config(unknown_key:)`.
@@ -47,6 +47,21 @@ module AttrJson
   #          #...
   #        end
   #
+  # ## Date-type timezone conversion
+  #
+  # By default, AttrJson::Model date/time attributes will be
+  # [ActiveRecord timezone-aware](https://api.rubyonrails.org/classes/ActiveRecord/Timestamp.html)
+  # based on settings of `config.active_record.time_zone_aware_attributes` and
+  # `ActiveRecord::Base.time_zone_aware_types`.
+  #
+  # If you'd like to override this, you can set:
+  #
+  # ```
+  # attr_json_config(time_zone_aware_attributes: true)
+  # attr_json_config(time_zone_aware_attributes: false)
+  # attr_json_config(time_zone_aware_attributes: [:datetime, :time]) # custom list of types
+  # ```
+  #
   # ## ActiveRecord `serialize`
   #
   # If you want to map a single AttrJson::Model to a json/jsonb column, you
@@ -65,6 +80,15 @@ module AttrJson
   #   serialize :some_json_column, ValueModel.to_serialize_coder
   # end
   #
+  # # Strip nils
+  #
+  # When embedded in an `attr_json` attribute, models are normally serialized with `nil` values
+  # stripped from hash where possible, for a more compact representation.
+  # This can be set differently in the type.
+  #
+  #     attr_json :lang_and_value, LangAndValue.to_type(strip_nils: false)
+  #
+  # See #serializable_hash docs for possible values.
   module Model
     extend ActiveSupport::Concern
 
@@ -106,7 +130,7 @@ module AttrJson
       # The inverse of model#serializable_hash -- re-hydrates a serialized hash to a model.
       #
       # Similar to `.new`, but translates things that need to be translated in deserialization,
-      # like store_keys, and properly calling deserialize on the underlying types.
+      # like store_keys, and properly calling deserialize (rather than cast) on the underlying types.
       #
       # @example Model.new_from_serializable(hash)
       def new_from_serializable(attributes = {})
@@ -127,10 +151,25 @@ module AttrJson
         self.new(attributes)
       end
 
-      def to_type
-        @type ||= AttrJson::Type::Model.new(self)
+      # @returns ActiveModel::Type suitable for including this model in
+      # an AttrJson::Record or ::Model attribute
+      #
+      # @param strip_nils [Boolean,Symbol] [true,false,:safely] as a type,
+      #   should we strip nils when serializing? By default this type strips
+      #   nils in :safely mode. See AttrJson::Model#serializable_hash
+      def to_type(strip_nils: :safely)
+        @type ||= AttrJson::Type::Model.new(self, strip_nils: strip_nils)
       end
 
+      # An ActiveModel::Type that can be used to serialize this model
+      # across an entire JSON(b) column.
+      #
+      # @example using standard ActiveRecord `serialize` feature.
+      #
+      #     class MyTable < ApplicationRecord
+      #       serialize :some_json_column, MyModel.to_serialization_coder
+      #     end
+      #
       def to_serialization_coder
         @serialization_coder ||= AttrJson::SerializationCoderFromType.new(to_type)
       end
@@ -154,6 +193,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.
@@ -166,6 +207,8 @@ module AttrJson
       def attr_json(name, type, **options)
         options.assert_valid_keys(*(AttributeDefinition::VALID_OPTIONS - [:container_attribute] + [:validate]))
 
+        type = _attr_json_maybe_wrap_timezone_aware(type)
+
         self.attr_json_registry = attr_json_registry.with(
           AttributeDefinition.new(name.to_sym, type, options.except(:validate))
         )
@@ -200,6 +243,42 @@ module AttrJson
           mod
         end
       end
+
+      # wrap in ActiveRecord type for timezone-awareness/conversion, if needed
+      # We at present only need this in AttrJson::Model cause in AttrJson::Record,
+      # our sync with ActiveRecord attributes takes care of it for us.
+      # See https://github.com/rails/rails/blob/v7.0.4/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb#L78
+      #
+      # For now we use ActiveRecord::Base state to decide.
+      #
+      # We have to turn a symbol type into a real object type if we want to wrap it -- we will
+      # return an actual ActiveModel::Value::Type either way, converting from symbol!
+      #
+      # That *wrapped* type will be the new type, registered with AttributeDefinition
+      # and then with Rails `attribute`, to provide timezone conversion.
+      def _attr_json_maybe_wrap_timezone_aware(type)
+        type = AttributeDefinition.lookup_type(type)
+
+        if self.attr_json_config.time_zone_aware_attributes.nil?
+          # nil config means use ActiveRecord::Base
+          aware       = ActiveRecord::Base.time_zone_aware_attributes
+          aware_types = ActiveRecord::Base.time_zone_aware_types
+        elsif self.attr_json_config.time_zone_aware_attributes.kind_of?(Array)
+          # Array config means we're doing it, and these are the types
+          aware       = true
+          aware_types = self.attr_json_config.time_zone_aware_attributes
+        else
+          # boolean config, types from ActiveRecord::Base
+          aware       = !!self.attr_json_config.time_zone_aware_attributes
+          aware_types = ActiveRecord::Base.time_zone_aware_types
+        end
+
+        if aware && aware_types.include?(type.type)
+          type = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(type)
+        end
+
+        type
+      end
     end
 
     def initialize(attributes = {})
@@ -254,32 +333,64 @@ module AttrJson
       self.class.attribute_names
     end
 
-    # Override from ActiveModel::Serialization to #serialize
-    # by type to make sure any values set directly on hash still
+    # Override from ActiveModel::Serialization to:
+    #
+    # * handle store_key settings
+    #
+    # * #serialize by type to make sure any values set directly on hash still
     # get properly type-serialized.
-    def serializable_hash(*options)
-      super.collect do |key, value|
+    #
+    # * custom logic for keeping nil values out of serialization to be more compact
+    #
+    # @param strip_nils [:symbol, Boolean] (default false) Should we keep keys with
+    #   `nil` values out of the serialization entirely? You might want to to keep
+    #   your in-database serialization compact. By default this method does not -- but
+    #   by default AttrJson::Type::Model sends `:safely` when serializing.
+    #     * false => do not strip nils
+    #     * :safely => strip nils only when there is no default value for the attribute,
+    #       so `nil` can still override the default value
+    #     * true => strip nils even if there is a default value -- in AttrJson
+    #       context, this means the default will be reapplied over nil on
+    #       every de-serialization!
+    def serializable_hash(options=nil)
+      strip_nils = options&.has_key?(:strip_nils) ? options.delete(:strip_nils) : false
+
+      unless [true, false, :safely].include?(strip_nils)
+        raise ArgumentError, ":strip_nils must be true, false, or :safely"
+      end
+
+      super(options).collect do |key, value|
         if attribute_def = self.class.attr_json_registry[key.to_sym]
           key = attribute_def.store_key
-          if value.kind_of?(Time) || value.kind_of?(DateTime)
-            value = value.utc.change(usec: 0)
-          end
 
           value = attribute_def.serialize(value)
         end
-        # Do we need unknown key handling here? Apparently not?
-        [key, value]
-      end.to_h
+
+        # strip_nils handling
+        if value.nil? && (
+           (strip_nils == :safely && !attribute_def&.has_default?) ||
+            strip_nils == true )
+        then
+          # do not include in serializable_hash
+          nil
+        else
+          [key, value]
+        end
+      end.compact.to_h
     end
 
     # ActiveRecord JSON serialization will insist on calling
     # this, instead of the specified type's #serialize, at least in some cases.
     # So it's important we define it -- the default #as_json added by ActiveSupport
     # will serialize all instance variables, which is not what we want.
-    def as_json(*options)
-      serializable_hash(*options)
+    #
+    # @param strip_nils [:symbol, Boolean] (default false) [true, false, :safely],
+    #   see #serializable_hash
+    def as_json(options=nil)
+      serializable_hash(options)
     end
 
+
     # We deep_dup on #to_h, you want attributes unduped, ask for #attributes.
     def to_h
       attributes.deep_dup

data/lib/attr_json/nested_attributes/writer.rb

@@ -15,12 +15,10 @@ module AttrJson
       delegate :nested_attributes_options, to: :model
 
       def assign_nested_attributes(attributes)
-        if attr_def.array_type?
-          if attr_def.type.base_type_primitive?
-            assign_nested_attributes_for_primitive_array(attributes)
-          else
-            assign_nested_attributes_for_model_array(attributes)
-          end
+        if attr_def.array_of_primitive_type?
+          assign_nested_attributes_for_primitive_array(attributes)
+        elsif attr_def.array_type?
+          assign_nested_attributes_for_model_array(attributes)
         else
           assign_nested_attributes_for_single_model(attributes)
         end

data/lib/attr_json/nested_attributes.rb

@@ -65,6 +65,10 @@ module AttrJson
             raise ArgumentError, "No attr_json found for name '#{attr_name}'. Has it been defined yet?"
           end
 
+          unless attr_def.array_type? || attr_def.single_model_type?
+            raise TypeError, "attr_json_accepts_nested_attributes_for is only for array or nested model types; `#{attr_name}` is type #{attr_def.type.type.inspect}"
+          end
+
           # We're sharing AR class attr in an AR, or using our own in a Model.
           nested_attributes_options = self.nested_attributes_options.dup
           nested_attributes_options[attr_name.to_sym] = options
@@ -80,7 +84,7 @@ module AttrJson
           end
 
           # No build method for our wacky array of primitive type.
-          if options[:define_build_method] && !(attr_def.array_type? && attr_def.type.base_type_primitive?)
+          if options[:define_build_method] && !attr_def.array_of_primitive_type?
             _attr_jsons_module.module_eval do
               build_method_name = "build_#{attr_name.to_s.singularize}"
               if method_defined?(build_method_name)

data/lib/attr_json/record.rb

@@ -24,35 +24,51 @@ 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
+
+      # 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
 
-    # adapted from ActiveRecord query_attribute method
-    # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/attribute_methods/query.rb#L12
+    # 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.attribute_names.each do |attr_name|
+        begin
+          attribute_def = self.class.attr_json_registry.fetch(attr_name.to_sym)
+          json_value    = public_send(attribute_def.container_attribute)
+          value         = json_value[attribute_def.store_key]
+
+          if value
+            # 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.
+            json_value[attribute_def.store_key] = read_attribute(attr_name)
+          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 +109,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 +119,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,22 +132,22 @@ 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
@@ -150,63 +169,65 @@ module AttrJson
         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/type/array.rb

@@ -30,6 +30,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 +45,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/model.rb

@@ -8,13 +8,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 +60,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/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "1.5.0"
+  VERSION = "2.0.0.rc1"
 end

data/lib/attr_json.rb

@@ -9,11 +9,6 @@ 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
 
 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