store_model 4.6.1 → 4.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c20c6465ee84ba2d0ffce4610ea14b6f6fed01e5da08cda8b165392e1d2e2952
-  data.tar.gz: 072ca921fd0b02814fc917b5d2c6b2df14f8c3bd99c536fda472b5df64ea7774
+  metadata.gz: cdc2533305687b1b68c6f89ac876f26db75da028d8678739f54f716fdf6d36b4
+  data.tar.gz: 7cc3699f31b7109983e03520caba608f3aacf5739d4b31440a58c0eb1e778b5b
 SHA512:
-  metadata.gz: a2e4339119a3076c4d200a535267033045d0fe75b461c2dfbe9b8d95bae1b4ecff0634ea5cbc5786076029fa2aba8027ac8a70e4f9d465c750f5f4d3a404b237
-  data.tar.gz: 1c8e8941a81e46a1f4d082a59252fc7867bcb95684a814a17701121e69ae82005fb0ca21da2dd3fea49467d3048c0c51ea0661c9d92b706573ce4a7e265c3eb5
+  metadata.gz: a62aea392fd0662f66b400423f18d6b64f63841e27d5692089073e11a3602271280973cd08ce66dc7af1c2d979cc06000434fb31fdb0ea784c2619960567d2fd
+  data.tar.gz: 1cb3f90063e27f74600c61abe8a120443a72044df9fd55da0239d33958e01444dc75ae945cd71c73fb7bb47b980c327219e8ec90a8560e61b67f752e7f81076d

data/lib/store_model/ext/active_record/base.rb

@@ -8,25 +8,14 @@ module StoreModel
     include ParentAssignment
 
     def _read_attribute(*)
-      value = super
-      assign_parent_to_store_model_relation(value) if store_model_attribute?(value)
-      value
+      super.tap do |value|
+        assign_parent_to_store_model_relation(value)
+      end
     end
 
     def _write_attribute(*)
-      value = super
-      assign_parent_to_store_model_relation(value) if store_model_attribute?(value)
-      value
-    end
-
-    private
-
-    def store_model_attribute?(value)
-      case value
-      when StoreModel::Model then true
-      when Array then value.first.is_a?(StoreModel::Model)
-      when Hash then value.each_value.any? { |v| v.is_a?(StoreModel::Model) }
-      else false
+      super.tap do |value|
+        assign_parent_to_store_model_relation(value)
       end
     end
   end

data/lib/store_model/ext/parent_assignment.rb

@@ -6,17 +6,14 @@ module StoreModel
     private
 
     def assign_parent_to_store_model_relation(attribute)
-      assign_parent_to_singular_store_model(attribute)
-      return if !attribute.is_a?(Array) && !attribute.is_a?(Hash)
-
-      (attribute.try(:values) || attribute).each(&method(:assign_parent_to_singular_store_model))
-    end
-
-    def assign_parent_to_singular_store_model(item)
-      return unless item.is_a?(StoreModel::Model)
-      return if item.frozen?
-
-      item.parent = self
+      case attribute
+      when StoreModel::Model
+        attribute.parent = self unless attribute.frozen?
+      when Array
+        attribute.each(&method(:assign_parent_to_store_model_relation))
+      when Hash
+        attribute.each_value(&method(:assign_parent_to_store_model_relation))
+      end
     end
   end
 end

data/lib/store_model/model.rb

@@ -4,6 +4,7 @@ require "store_model/types"
 require "store_model/enum"
 require "store_model/type_builders"
 require "store_model/nested_attributes"
+require "store_model/unknown_attribute_assignment"
 
 module StoreModel
   # When included into class configures it to handle JSON column
@@ -26,6 +27,9 @@ module StoreModel
 
       base.attribute_method_suffix "?"
 
+      # Included last so it takes precedence over ActiveModel::AttributeAssignment.
+      base.include StoreModel::UnknownAttributeAssignment
+
       base.extend(ClassMethods)
     end
     # rubocop:enable Metrics/MethodLength
@@ -60,32 +64,30 @@ module StoreModel
     # @param options [Hash]
     #
     # @return [Hash]
-    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      serialize_unknown_attributes = if options.key?(:serialize_unknown_attributes)
+    def as_json(options = nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      serialize_unknown_attributes = if options&.key?(:serialize_unknown_attributes)
                                        options[:serialize_unknown_attributes]
                                      else
                                        StoreModel.config.serialize_unknown_attributes
                                      end
 
-      serialize_enums_using_as_json = if options.key?(:serialize_enums_using_as_json)
+      serialize_enums_using_as_json = if options&.key?(:serialize_enums_using_as_json)
                                         options[:serialize_enums_using_as_json]
                                       else
                                         StoreModel.config.serialize_enums_using_as_json
                                       end
 
-      serialize_empty_attributes = if options.key?(:serialize_empty_attributes)
+      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,
                                      serialize_empty_attributes)
-        serialized = serialized_attribute(attr)
+        serialized = serialized_attribute(attr, options)
         values[key] = serialized if serialize_empty_attributes || !serialized.nil?
       end.with_indifferent_access
 
@@ -293,27 +295,29 @@ module StoreModel
       end
     end
 
-    def serialized_attribute(attr)
+    def serialized_attribute(attr, options)
       case attr.value
       when StoreModel::Model
-        Types::RawJSONEncoder.new(attr.value_for_database)
+        attr.value.as_json(options)
       when Array
-        serialize_array_attribute(attr.value)
+        serialize_array_attribute(attr.value, options)
       when Hash # attribute :smth, json
-        attr.value
+        serialize_hash_attribute(attr.value, options)
       else
         attr.value_for_database
       end
     end
 
-    def serialize_array_attribute(array)
+    def serialize_array_attribute(array, options)
       return array.as_json unless array.any? && array.all? { |value| value.is_a?(StoreModel::Model) }
 
-      array.as_json(
-        serialize_unknown_attributes: array.first.serialize_unknown_attributes?,
-        serialize_enums_using_as_json: array.first.serialize_enums_using_as_json?,
-        serialize_empty_attributes: array.first.serialize_empty_attributes?
-      )
+      array.as_json(options)
+    end
+
+    def serialize_hash_attribute(hash, options)
+      return hash unless hash.any? && hash.values.all? { |value| value.nil? || value.is_a?(StoreModel::Model) }
+
+      hash.transform_values { |value| value&.as_json(options) }
     end
 
     def assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json, serialize_empty_attributes) # rubocop:disable Layout/LineLength

data/lib/store_model/types/one.rb

@@ -28,7 +28,7 @@ module StoreModel
       # @param value [Object] a value to cast
       #
       # @return StoreModel::Model
-      def cast_value(value) # rubocop:disable Metrics/MethodLength
+      def cast_value(value)
         return nil if value.nil?
 
         if value.is_a?(String)
@@ -40,8 +40,6 @@ module StoreModel
         else
           raise_cast_error(value)
         end
-      rescue ActiveModel::UnknownAttributeError => e
-        handle_unknown_attribute(value, e)
       end
 
       # Casts a value from the ruby type to a type that the database knows how
@@ -93,9 +91,7 @@ module StoreModel
       end
 
       def model_instance(value)
-        @model_klass.new(value)
-      rescue ActiveModel::UnknownAttributeError => e
-        handle_unknown_attribute(value, e)
+        StoreModel::UnknownAttributeAssignment.collect { @model_klass.new(value) }
       end
 
       def deserialize_by_types(hash)

data/lib/store_model/types/one_base.rb

@@ -37,20 +37,8 @@ module StoreModel
       def decode_and_initialize(value)
         decoded = ActiveSupport::JSON.decode(value) rescue nil
         model_instance(decoded) unless decoded.nil?
-      rescue ActiveModel::UnknownAttributeError => e
-        handle_unknown_attribute(decoded, e)
       end
       # rubocop:enable Style/RescueModifier
-
-      def handle_unknown_attribute(value, exception)
-        attribute = exception.attribute.to_sym
-        value_symbolized = value.symbolize_keys
-        value_symbolized = value_symbolized[:attributes] if value_symbolized.key?(:attributes)
-
-        cast_value(value_symbolized.except(attribute)).tap do |configuration|
-          configuration.unknown_attributes[attribute.to_s] = value_symbolized[attribute]
-        end
-      end
     end
   end
 end

data/lib/store_model/types/one_polymorphic.rb

@@ -31,7 +31,7 @@ module StoreModel
       # @param value [Object] a value to cast
       #
       # @return StoreModel::Model
-      def cast_value(value) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def cast_value(value) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
         return nil if value.nil?
         return nil if @union && value.respond_to?(:empty?) && value.empty?
 
@@ -44,8 +44,6 @@ module StoreModel
         else
           raise_cast_error(value)
         end
-      rescue ActiveModel::UnknownAttributeError => e
-        handle_unknown_attribute(value, e)
       end
 
       # Casts a value from the ruby type to a type that the database knows how
@@ -95,15 +93,9 @@ module StoreModel
         return nil if decoded.nil?
         return nil if @union && decoded.respond_to?(:empty?) && decoded.empty?
 
-        model_instance(decoded)
-      rescue ActiveModel::UnknownAttributeError => e
-        handle_unknown_attribute(decoded, e)
+        extract_model_klass(decoded).to_type.cast_value(decoded)
       end
       # rubocop:enable Style/RescueModifier
-
-      def model_instance(value)
-        extract_model_klass(value).new(value)
-      end
     end
   end
 end

data/lib/store_model/unknown_attribute_assignment.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module StoreModel
+  # Keeps input keys without a writer in #unknown_attributes while a StoreModel
+  # type builds the model, instead of raising ActiveModel::UnknownAttributeError.
+  module UnknownAttributeAssignment
+    PENDING_KEY = :store_model_collect_unknown_attributes
+    BUILDING_KEY = :store_model_building_with_unknown_attributes
+
+    # Only the next StoreModel instance built inside the block collects unknown
+    # keys, so models built by its writers or a custom initializer stay strict.
+    def self.collect
+      previous = Thread.current[PENDING_KEY]
+      Thread.current[PENDING_KEY] = true
+      yield
+    ensure
+      Thread.current[PENDING_KEY] = previous
+    end
+
+    # `new` takes the pending flag before any custom `initialize` runs and can
+    # build other models.
+    def self.building
+      previous = Thread.current[BUILDING_KEY]
+      Thread.current[BUILDING_KEY] = Thread.current[PENDING_KEY]
+      Thread.current[PENDING_KEY] = nil
+      yield
+    ensure
+      Thread.current[BUILDING_KEY] = previous
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods # :nodoc:
+      def new(...)
+        UnknownAttributeAssignment.building { super }
+      end
+    end
+
+    # Falls back to the pending flag for factories that call Class#new directly.
+    def initialize(attributes = {})
+      @collecting_unknown_attributes = Thread.current[BUILDING_KEY] || Thread.current[PENDING_KEY]
+      Thread.current[BUILDING_KEY] = Thread.current[PENDING_KEY] = nil
+      super
+    ensure
+      @collecting_unknown_attributes = nil
+    end
+
+    private
+
+    # Checking for the writer up front avoids raising NoMethodError per unknown key,
+    # which goes through ActiveModel's method_missing and casts every attribute.
+    # Declared attributes can still be served by method_missing, for example after
+    # attribute_method_suffix undefines the generated writers.
+    def _assign_attribute(key, value)
+      return super unless @collecting_unknown_attributes
+
+      setter = :"#{key}="
+      if respond_to_without_attributes?(setter) || has_attribute?(key)
+        public_send(setter, value)
+      else
+        unknown_attributes[key.to_s] = value
+      end
+    end
+  end
+end

data/lib/store_model/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: store_model
 version: !ruby/object:Gem::Version
-  version: 4.6.1
+  version: 4.6.2
 platform: ruby
 authors:
 - DmitryTsepelev
@@ -107,6 +107,7 @@ files:
 - lib/store_model/types/one_polymorphic.rb
 - lib/store_model/types/polymorphic_helper.rb
 - lib/store_model/types/raw_json.rb
+- lib/store_model/unknown_attribute_assignment.rb
 - lib/store_model/version.rb
 homepage: https://github.com/DmitryTsepelev/store_model
 licenses: