store_model 4.2.1 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80b3d46c14f2f0952709d1c0bd2d4ea2a3455cbedbeeb428a48e42886ef59270
-  data.tar.gz: 7f1b852caa46ca69e49e5f4a9ca58194b4bf2a9d63caa1dc295444b6913407b8
+  metadata.gz: c65c5b8e184e6b4f7c402a7a2a82df8228d2b55c7ad6352c3752ac988bc86943
+  data.tar.gz: f2f404a6330ded65170e6256adb71c109592c6187a85d221d6887c965eeb9a1c
 SHA512:
-  metadata.gz: e895325edadf56ff398ae92f3968205efbc7e75f8ed5d1b06b2465224e223efef80ac366d968644030b9148550e88801cfad8908dd61348b31507ad4c793ae11
-  data.tar.gz: 1766b1327befd59eefc5186220202edbea2478080f5546b5042e2d01feb1d4f536c3aba66b8b7c247c06811673d4f5430823d31b132965ba7b0fca34cb0e873e
+  metadata.gz: cf0146c740b94e5591d16794431120afc4c28dfb3477757571d4d77fb8833836fccdb94d5776f9199f92164ab36029def584d3a802ee186b531916d82c098e6b
+  data.tar.gz: ae1753153b834b2b02bfa2ec4afc767540833eea27f59e653c3dbf8435bba3c1810999fba5128d71ce97e38e31314bc5622c8a01eb3054e743acd337bfae1b09

data/README.md

@@ -131,11 +131,13 @@ end
   * [Enums](./docs/enums.md)
   * [Nested models](./docs/nested_models.md)
   * [Unknown attributes](./docs/unknown_attributes.md)
+  * [Empty attributes](./docs/empty_attributes.md)
 3. [Array of stored models](./docs/array_of_stored_models.md)
-4. [One of](./docs/one_of.md)
-4. [Alternatives](./docs/alternatives.md)
-5. [Defining custom types](./docs/defining_custom_types.md)
-6. [Disabling Parent Tracking](./docs/enable_parent_assignment.md)
+4. [Hash of stored models](./docs/hash_of_stored_models.md)
+5. [One of](./docs/one_of.md)
+6. [Alternatives](./docs/alternatives.md)
+7. [Defining custom types](./docs/defining_custom_types.md)
+8. [Disabling Parent Tracking](./docs/enable_parent_assignment.md)
 
 ## Credits
 

data/lib/active_model/validations/store_model_validator.rb

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

data/lib/store_model/combine_errors_strategies/merge_hash_error_strategy.rb

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

data/lib/store_model/combine_errors_strategies.rb

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

data/lib/store_model/configuration.rb

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

data/lib/store_model/model.rb

@@ -32,10 +32,18 @@ module StoreModel
       def from_values(values)
         to_array_type.cast_value(values)
       end
+
+      # Defines a discriminator attribute with a value
+      # @param discriminator [Symbol, String] attribute name (default: :type)
+      # @param type [Symbol, String] attribute type (default: :string)
+      # @param value [String] the discriminator value
+      def discriminator_attribute(discriminator = "type", value:, type: :string)
+        attribute discriminator, type, default: value
+      end
     end
 
     attr_accessor :parent
-    attr_writer :serialize_unknown_attributes, :serialize_enums_using_as_json
+    attr_writer :serialize_unknown_attributes, :serialize_enums_using_as_json, :serialize_empty_attributes
 
     delegate :each_value, to: :attributes
 
@@ -45,7 +53,7 @@ module StoreModel
     # @param options [Hash]
     #
     # @return [Hash]
-    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       serialize_unknown_attributes = if options.key?(:serialize_unknown_attributes)
                                        options[:serialize_unknown_attributes]
                                      else
@@ -58,10 +66,20 @@ module StoreModel
                                         StoreModel.config.serialize_enums_using_as_json
                                       end
 
+      serialize_empty_attributes = if options.key?(:serialize_empty_attributes)
+                                     options[:serialize_empty_attributes]
+                                   else
+                                     StoreModel.config.serialize_empty_attributes
+                                   end
+
+      # If the model is nested, we need to ensure that the serialization
+
       result = @attributes.keys.each_with_object({}) do |key, values|
         attr = @attributes.fetch(key)
-        assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json)
-        values[key] = serialized_attribute(attr)
+        assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json,
+                                     serialize_empty_attributes)
+        serialized = serialized_attribute(attr)
+        values[key] = serialized if serialize_empty_attributes || !serialized.nil?
       end.with_indifferent_access
 
       result.merge!(unknown_attributes) if serialize_unknown_attributes
@@ -226,6 +244,23 @@ module StoreModel
       end
     end
 
+    # Returns the value of the `@serialize_empty_attributes` instance
+    # variable. The default value is the value of the globally configured
+    # `serialize_empty_attributes` option.
+    #
+    # This method is used to determine whether empty values should be serialized
+    # when the `as_json` method is called in nested StoreModel::Model
+    # objects.
+    #
+    # @return [Boolean]
+    def serialize_empty_attributes?
+      if @serialize_empty_attributes.nil?
+        StoreModel.config.serialize_empty_attributes || true
+      else
+        @serialize_empty_attributes
+      end
+    end
+
     private
 
     def attribute?(attribute)
@@ -263,16 +298,18 @@ module StoreModel
 
       array.as_json(
         serialize_unknown_attributes: array.first.serialize_unknown_attributes?,
-        serialize_enums_using_as_json: array.first.serialize_enums_using_as_json?
+        serialize_enums_using_as_json: array.first.serialize_enums_using_as_json?,
+        serialize_empty_attributes: array.first.serialize_empty_attributes?
       )
     end
 
-    def assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json)
+    def assign_serialization_options(attr, serialize_unknown_attributes, serialize_enums_using_as_json, serialize_empty_attributes) # rubocop:disable Layout/LineLength
       return unless Array(attr.value).all? { |value| value.is_a?(StoreModel::Model) }
 
       Array(attr.value).each do |value|
         value.serialize_unknown_attributes = serialize_unknown_attributes
         value.serialize_enums_using_as_json = serialize_enums_using_as_json
+        value.serialize_empty_attributes = serialize_empty_attributes
       end
     end
   end

data/lib/store_model/type_builders.rb

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

data/lib/store_model/types/hash.rb

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

data/lib/store_model/types/hash_base.rb

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

data/lib/store_model/types/hash_polymorphic.rb

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

data/lib/store_model/types/one.rb

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

data/lib/store_model/types/one_of.rb

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

data/lib/store_model/types/one_polymorphic.rb

@@ -38,7 +38,7 @@ module StoreModel
         elsif value.class.ancestors.include?(StoreModel::Model)
           value
         elsif value.respond_to?(:to_h) # Hash itself included
-          extract_model_klass(value).new(value.to_h)
+          extract_model_klass(value).to_type.cast_value(value.to_h)
         else
           raise_cast_error(value)
         end
@@ -53,7 +53,7 @@ module StoreModel
       #
       # @return [String] serialized value
       def serialize(value)
-        return super unless value.is_a?(Hash) || implements_model?(value.class)
+        return super unless value.is_a?(::Hash) || implements_model?(value.class)
 
         if value.is_a?(StoreModel::Model)
           ActiveSupport::JSON.encode(

data/lib/store_model/types.rb

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

data/lib/store_model/version.rb

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

data/lib/store_model.rb

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

metadata

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