attr_json 1.4.0 → 2.6.0

data/lib/attr_json/attribute_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
  require 'attr_json/type/array'
 
  module AttrJson
@@ -34,23 +36,14 @@
 
       @default = if options.has_key?(:default)
         options[:default]
+      elsif options[:array] == true
+        -> { [] }
       else
         NO_DEFAULT_PROVIDED
       end
 
-      if type.is_a? Symbol
-        # ActiveModel::Type.lookup may make more sense, but ActiveModel::Type::Date
-        # seems to have a bug with multi-param assignment. Mostly they return
-        # the same types, but ActiveRecord::Type::Date works with multi-param assignment.
-        #
-        # We pass `adapter: nil` to avoid triggering a db connection.
-        # See: https://github.com/jrochkind/attr_json/issues/41
-        # This is at the "cost" of not using any adapter-specific types... which
-        # maybe preferable anyway?
-        type = ActiveRecord::Type.lookup(type, adapter: nil)
-      elsif ! type.is_a? ActiveModel::Type::Value
-        raise ArgumentError, "Second argument (#{type}) must be a symbol or instance of an ActiveModel::Type::Value subclass"
-      end
+      type = self.class.lookup_type(type)
+
       @type = (options[:array] == true ? AttrJson::Type::Array.new(type) : type)
     end
 
@@ -71,7 +64,7 @@
     end
 
     def store_key
-      (@store_key || name).to_s
+      AttrJson.efficient_to_s(@store_key || name)
     end
 
     def has_default?
@@ -102,5 +95,49 @@
     def array_type?
       type.is_a? AttrJson::Type::Array
     end
+
+    # Used for figuring out appropriate behavior for nested attribute implementation among
+    # other places. true if type is a nested model, either straight or polymorphic
+    def single_model_type?
+      self.class.single_model_type?(type)
+    end
+
+    def self.single_model_type?(arg_type)
+      arg_type.is_a?(AttrJson::Type::Model) || arg_type.is_a?(AttrJson::Type::PolymorphicModel)
+    end
+
+    # Used for figuring out appropriate behavior in nested attribute implementation among
+    # other places. true if type is an array of things that are not nested models.
+    def array_of_primitive_type?
+      array_type? && !self.class.single_model_type?(type.base_type)
+    end
+
+    # Can look up a symbol to a type, or leave a type alone, or raise if it's neither.
+    # Extracted into a method, so it can be called from AttrJson::Model#attr_json, for
+    # some timezone aware shenanigans.
+    def self.lookup_type(type)
+      if type.is_a? Symbol
+        # ActiveModel::Type.lookup may make more sense, but ActiveModel::Type::Date
+        # seems to have a bug with multi-param assignment. Mostly they return
+        # the same types, but ActiveRecord::Type::Date works with multi-param assignment.
+        #
+        # We pass `adapter: nil` to avoid triggering a db connection.
+        # See: https://github.com/jrochkind/attr_json/issues/41
+        # This is at the "cost" of not using any adapter-specific types... which
+        # maybe preferable anyway?
+        #
+        # AND we add precision for datetime/time types... since we're using Rails json
+        # serializing, we're kind of stuck with this precision in current implementation.
+        lookup_kwargs = { adapter: nil }
+        if type == :datetime || type == :time
+          lookup_kwargs[:precision] = ActiveSupport::JSON::Encoding.time_precision
+        end
+        type = ActiveRecord::Type.lookup(type, **lookup_kwargs)
+      elsif !(type.is_a?(ActiveModel::Type::Value) || type.is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter))
+        raise ArgumentError, "Second argument (#{type}) must be a symbol or instance of an ActiveModel::Type::Value subclass"
+      end
+      type
+    end
+
   end
 end

data/lib/attr_json/config.rb

@@ -5,18 +5,17 @@ module AttrJson
   class Config
     RECORD_ALLOWED_KEYS = %i{
       default_container_attribute
-      default_rails_attribute
       default_accepts_nested_attributes
     }
 
     MODEL_ALLOWED_KEYS = %i{
       unknown_key
       bad_cast
+      time_zone_aware_attributes
     }
 
     DEFAULTS = {
       default_container_attribute: "json_attributes",
-      default_rails_attribute: false,
       unknown_key: :raise
     }
 

data/lib/attr_json/model/nested_model_validator.rb

@@ -0,0 +1,27 @@
+module AttrJson
+  module Model
+    # Used to validate an attribute in an AttrJson::Model whose values are other models, when
+    # you want validation errors on the nested models to post up.
+    #
+    # This is based on ActiveRecord's own ActiveRecord::Validations::AssociatedValidator, and actually forked
+    # from it at https://github.com/rails/rails/blob/e37adfed4eff3b43350ec87222a922e9c72d9c1b/activerecord/lib/active_record/validations/associated.rb
+    #
+    # We used to simply use an ActiveRecord::Validations::AssociatedValidator, but as of https://github.com/jrochkind/attr_json/pull/220 (e1e798142d)
+    # it got ActiveRecord-specific functionality that no longer worked with our use case.
+    #
+    # No problem, the implementation is simple, we can provide it here, based on the last version that did work.
+    class NestedModelValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if Array(value).reject { |r| valid_object?(r) }.any?
+          record.errors.add(attribute, :invalid, **options.merge(value: value))
+        end
+      end
+
+      private
+        def valid_object?(record)
+          #(record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?
+          record.valid?
+        end
+    end
+  end
+end

data/lib/attr_json/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'active_model/type'
 
@@ -6,6 +8,7 @@ require 'attr_json/attribute_definition/registry'
 
 require 'attr_json/type/model'
 require 'attr_json/model/cocoon_compat'
+require 'attr_json/model/nested_model_validator'
 
 require 'attr_json/serialization_coder_from_type'
 
@@ -20,7 +23,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 +50,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 +83,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,14 +133,14 @@ 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 = {})
         attributes = attributes.collect do |key, value|
           # store keys in arguments get translated to attribute names on initialize.
-          if attribute_def = self.attr_json_registry.store_key_lookup("", key.to_s)
-            key = attribute_def.name.to_s
+          if attribute_def = self.attr_json_registry.store_key_lookup("".freeze, AttrJson.efficient_to_s(key))
+            key = AttrJson.efficient_to_s(attribute_def.name)
           end
 
           attr_type = self.attr_json_registry.has_attribute?(key) && self.attr_json_registry.type_for_attribute(key)
@@ -127,14 +154,43 @@ 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
+      #
+      #       # In Rails 7.1+:
+      #       # serialize :some_json_column, coder: MyModel.to_serialization_coder
+      #     end
+      #
       def to_serialization_coder
         @serialization_coder ||= AttrJson::SerializationCoderFromType.new(to_type)
       end
 
+      # like the ActiveModel::Attributes method
+      def attribute_names
+        attr_json_registry.attribute_names
+      end
+
+      # like the ActiveModel::Attributes method, hash with name keys, and ActiveModel::Type values
+      def attribute_types
+        attribute_names.collect { |name| [AttrJson.efficient_to_s(name), attr_json_registry.type_for_attribute(name)]}.to_h
+      end
+
+
       # Type can be an instance of an ActiveModel::Type::Value subclass, or a symbol that will
       # be looked up in `ActiveModel::Type.lookup`
       #
@@ -143,6 +199,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.
@@ -150,54 +208,34 @@ module AttrJson
       # @option options [String,Symbol] :store_key (nil) Serialize to JSON using
       #   given store_key, rather than name as would be usual.
       #
-      # @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) Mak validation errors on the attributes post up
+      #   to self, using something similar to an ActiveRecord::Validations::AssociatedValidator
       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))
         )
 
         # By default, automatically validate nested models
-        if type.kind_of?(AttrJson::Type::Model) && options[:validate] != false
-          # Yes. we're passing an ActiveRecord::Validations validator, but
-          # it works fine for ActiveModel. If this changes in the future, tests will catch.
-          self.validates_with ActiveRecord::Validations::AssociatedValidator, attributes: [name.to_sym]
+        if (type.kind_of?(AttrJson::Type::Model) || type.kind_of?(AttrJson::Type::PolymorphicModel)) && options[:validate] != false
+          # Post validations up with something based on ActiveRecord::Validations::AssociatedValidator
+          self.validates_with ::AttrJson::Model::NestedModelValidator, attributes: [name.to_sym]
         end
 
         _attr_jsons_module.module_eval do
           define_method("#{name}=") do |value|
-            _attr_json_write(name.to_s, value)
+            _attr_json_write(AttrJson.efficient_to_s(name), value)
           end
 
           define_method("#{name}") do
-            attributes[name.to_s]
+            attributes[AttrJson.efficient_to_s(name)]
           end
         end
       end
 
-      # This should kind of be considered 'protected', but the semantics
-      # of how we want to call it don't give us a visibility modifier that works.
-      # Prob means refactoring called for. TODO?
-      def fill_in_defaults(hash)
-        # Only if we need to mutate it to add defaults, we'll dup it first. deep_dup not neccesary
-        # since we're only modifying top-level here.
-        duped = false
-        attr_json_registry.definitions.each do |definition|
-          if definition.has_default? && ! (hash.has_key?(definition.store_key.to_s) || hash.has_key?(definition.store_key.to_sym))
-            unless duped
-              hash = hash.dup
-              duped = true
-            end
-
-            hash[definition.store_key] = definition.provide_default!
-          end
-        end
-
-        hash
-      end
-
       private
 
       # Define an anonymous module and include it, so can still be easily
@@ -210,14 +248,54 @@ 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 = {})
-      if !attributes.respond_to?(:transform_keys)
-        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
-      end
+      super
+
+      fill_in_defaults!
+    end
 
-      super(self.class.fill_in_defaults(attributes))
+    # inspired by https://github.com/rails/rails/blob/8015c2c2cf5c8718449677570f372ceb01318a32/activemodel/lib/active_model/attributes.rb
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      super
     end
 
     def attributes
@@ -255,32 +333,69 @@ module AttrJson
       self.class.attr_json_registry.has_attribute?(str)
     end
 
-    # Override from ActiveModel::Serialization to #serialize
-    # by type to make sure any values set directly on hash still
+    # like the ActiveModel::Attributes method
+    def attribute_names
+      self.class.attribute_names
+    end
+
+    # 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
@@ -301,14 +416,31 @@ module AttrJson
       false
     end
 
+    # like ActiveModel::Attributes at
+    # https://github.com/rails/rails/blob/8015c2c2cf5c8718449677570f372ceb01318a32/activemodel/lib/active_model/attributes.rb#L120
+    #
+    # is not a full deep freeze
+    def freeze
+      attributes.freeze unless frozen?
+      super
+    end
+
     private
 
+    def fill_in_defaults!
+      self.class.attr_json_registry.definitions.each do |definition|
+        if definition.has_default? && !attributes.has_key?(AttrJson.efficient_to_s(definition.name))
+          self.send("#{definition.name.to_s}=", definition.provide_default!)
+        end
+      end
+    end
+
     def _attr_json_write(key, value)
       if attribute_def = self.class.attr_json_registry[key.to_sym]
-        attributes[key.to_s] = attribute_def.cast(value)
+        attributes[AttrJson.efficient_to_s(key)] = attribute_def.cast(value)
       else
         # TODO, strict mode, ignore, raise, allow.
-        attributes[key.to_s] = value
+        attributes[AttrJson.efficient_to_s(key)] = value
       end
     end
 

data/lib/attr_json/nested_attributes/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module NestedAttributes
     # Implementation of `build_` methods, called by the `build_` methods

data/lib/attr_json/nested_attributes/multiparameter_attribute_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module NestedAttributes
     # Rails has a weird "multiparameter attribute" thing, that is used for simple_form's

data/lib/attr_json/nested_attributes/writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/nested_attributes/multiparameter_attribute_writer'
 
 module AttrJson
@@ -15,12 +17,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/nested_attributes/builder'
 require 'attr_json/nested_attributes/writer'
 
@@ -65,6 +67,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 +86,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/query_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Record
     # Implementation class called by #jsonb_contains scope method. Ordinarily

data/lib/attr_json/record/query_scopes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/record/query_builder'
 
 module AttrJson