store_model 0.6.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 675a1eed74c9c24e82a9cdc3ad86135de65fb9cef761b87a5dbb4d2ddf904fc9
-  data.tar.gz: 7d1ac5c24cbf430c70109165381b55ea53a35ce331a7cbf65aa5ed9a59cdcbf5
+  metadata.gz: '08b39695323b89c1d405590f4947ca989e00c74a4eab76c00acb593f21d46a83'
+  data.tar.gz: dedd6070fdce1873ec69f582877aa3219ffb925c1aa7d4a249c80d8524017aa4
 SHA512:
-  metadata.gz: '098c71eee5aea9204a9a305dec5233040a55f80da73335bdf86b754f5de82ab90931d05cbcec7cb0fb187f175ed4c59bb985898dda853469a535f7ca023379c3'
-  data.tar.gz: e60c5f89a0f1c43e48433ecac9b91976567a696887fe0d3a4cd959ac14fa927d34f9876b2ace988c05bd67157976dc2b5cbd4033a88030b21952fa4f3e62792c
+  metadata.gz: 783d91fbea217d2a72e7495ce068b7dba1ea90a6828fde79ce2af9278acac0fdde85cd9a57b928bb2197f55f08229bdb23b69584f27ca1c3e9787c8abe061a93
+  data.tar.gz: 459659e56410f04f32e5196e2a93799b6022c3aa10d240dc44abf69d0b7da016c705c0baba5fd89822ee8d0aa35469e9dbae41b2ec9bc1909d0f231149c64586

data/README.md

@@ -1,4 +1,4 @@
-# StoreModel [![Gem Version](https://badge.fury.io/rb/store_model.svg)](https://rubygems.org/gems/store_model) [![Build Status](https://travis-ci.org/DmitryTsepelev/store_model.svg?branch=master)](https://travis-ci.org/DmitryTsepelev/store_model) [![Coverage Status](https://coveralls.io/repos/github/DmitryTsepelev/store_model/badge.svg?branch=master)](https://coveralls.io/github/DmitryTsepelev/store_model?branch=master)
+# StoreModel [![Gem Version](https://badge.fury.io/rb/store_model.svg)](https://rubygems.org/gems/store_model) [![Coverage Status](https://coveralls.io/repos/github/DmitryTsepelev/store_model/badge.svg?branch=master)](https://coveralls.io/github/DmitryTsepelev/store_model?branch=master)
 
 **StoreModel** gem allows you to wrap JSON-backed DB columns with ActiveModel-like classes.
 
@@ -88,6 +88,7 @@ product.save
   * [Nested models](./docs/nested_models.md)
   * [Unknown attributes](./docs/unknown_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)
 

data/lib/active_model/validations/store_model_validator.rb

@@ -21,17 +21,29 @@ module ActiveModel
         end
 
         case record.type_for_attribute(attribute).type
-        when :json
-          strategy.call(attribute, record.errors, value.errors) if value.invalid?
-        when :array
-          record.errors.add(attribute, :invalid) if value.any?(&:invalid?)
+        when :json, :polymorphic
+          call_json_strategy(attribute, record.errors, value)
+        when :array, :polymorphic_array
+          call_array_strategy(attribute, record.errors, value)
         end
       end
 
       private
 
+      def call_json_strategy(attribute, record_errors, value)
+        strategy.call(attribute, record_errors, value.errors) if value.invalid?
+      end
+
+      def call_array_strategy(attribute, record_errors, value)
+        array_strategy.call(attribute, record_errors, value) if value.select(&:invalid?).present?
+      end
+
       def strategy
-        StoreModel::CombineErrorsStrategies.configure(options)
+        @strategy ||= StoreModel::CombineErrorsStrategies.configure(options)
+      end
+
+      def array_strategy
+        @array_strategy ||= StoreModel::CombineErrorsStrategies.configure_array(options)
       end
     end
   end

data/lib/store_model.rb

@@ -10,5 +10,10 @@ module StoreModel # :nodoc:
     def config
       @config ||= Configuration.new
     end
+
+    # @return instance [Types::OneOf]
+    def one_of(&block)
+      Types::OneOf.new(&block)
+    end
   end
 end

data/lib/store_model/combine_errors_strategies.rb

@@ -2,6 +2,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"
 
 module StoreModel
   # Module with built-in strategies for combining errors.
@@ -16,10 +17,31 @@ module StoreModel
     def configure(options)
       configured_strategy = options[:merge_errors] || StoreModel.config.merge_errors
 
+      get_configured_strategy(
+        configured_strategy,
+        StoreModel::CombineErrorsStrategies::MergeErrorStrategy
+      )
+    end
+
+    # Finds a array strategy based on +options+ and global config.
+    #
+    # @param options [Hash]
+    #
+    # @return [Object] strategy
+    def configure_array(options)
+      configured_strategy = options[:merge_array_errors] || StoreModel.config.merge_array_errors
+
+      get_configured_strategy(
+        configured_strategy,
+        StoreModel::CombineErrorsStrategies::MergeArrayErrorStrategy
+      )
+    end
+
+    def get_configured_strategy(configured_strategy, true_strategy_class)
       if configured_strategy.respond_to?(:call)
         configured_strategy
       elsif configured_strategy == true
-        StoreModel::CombineErrorsStrategies::MergeErrorStrategy.new
+        true_strategy_class.new
       elsif configured_strategy.nil?
         StoreModel::CombineErrorsStrategies::MarkInvalidErrorStrategy.new
       else

data/lib/store_model/combine_errors_strategies/merge_array_error_strategy.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StoreModel
+  module CombineErrorsStrategies
+    # +MergeArrayErrorStrategy+ copies errors from the StoreModel::Model to the parent
+    # record attribute errors.
+    class MergeArrayErrorStrategy
+      # 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 [Array] an array or store_models that have been validated
+      def call(attribute, base_errors, store_models)
+        store_models.each_with_index do |store_model, index|
+          store_model.errors.full_messages.each do |full_message|
+            base_errors.add(attribute, :invalid, message: "[#{index}] #{full_message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/store_model/combine_errors_strategies/merge_error_strategy.rb

@@ -7,16 +7,17 @@ module StoreModel
     class MergeErrorStrategy
       # Merges errors on +attribute+ from the child model with parent errors.
       #
-      # @param _attribute [String] name of the validated attribute
+      # @param attribute [String] name of the validated attribute
       # @param base_errors [ActiveModel::Errors] errors object of the parent record
       # @param store_model_errors [ActiveModel::Errors] errors object of the StoreModel::Model
       # attribute
-      def call(_attribute, base_errors, store_model_errors)
+      def call(attribute, base_errors, store_model_errors)
         if Rails::VERSION::MAJOR < 6 || Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR.zero?
-          base_errors.copy!(store_model_errors)
+          base_errors.delete(attribute)
+          store_model_errors.each { |field, error| base_errors.add(field, error) }
         else
           store_model_errors.errors.each do |error|
-            base_errors.add(:configuration, :invalid, message: error.full_message)
+            base_errors.add(attribute, :invalid, message: error.full_message)
           end
         end
       end

data/lib/store_model/configuration.rb

@@ -6,5 +6,9 @@ module StoreModel
     # Controls usage of MergeErrorStrategy
     # @return [Boolean]
     attr_accessor :merge_errors
+
+    # Controls usage of MergeArrayErrorStrategy
+    # @return [Boolean]
+    attr_accessor :merge_array_errors
   end
 end

data/lib/store_model/nested_attributes.rb

@@ -14,9 +14,9 @@ module StoreModel
       def accepts_nested_attributes_for(*associations)
         associations.each do |association|
           case attribute_types[association.to_s]
-          when Types::JsonType
+          when Types::One
             alias_method "#{association}_attributes=", "#{association}="
-          when Types::ArrayType
+          when Types::Many
             define_method "#{association}_attributes=" do |attributes|
               assign_nested_attributes_for_collection_association(association, attributes)
             end

data/lib/store_model/type_builders.rb

@@ -3,16 +3,16 @@
 module StoreModel
   # Contains methods for converting StoreModel::Model to ActiveModel::Type::Value.
   module TypeBuilders
-    # Converts StoreModel::Model to Types::JsonType
-    # @return [Types::JsonType]
+    # Converts StoreModel::Model to Types::One
+    # @return [Types::One]
     def to_type
-      Types::JsonType.new(self)
+      Types::One.new(self)
     end
 
-    # Converts StoreModel::Model to Types::ArrayType
-    # @return [Types::ArrayType]
+    # Converts StoreModel::Model to Types::Many
+    # @return [Types::Many]
     def to_array_type
-      Types::ArrayType.new(self)
+      Types::Many.new(self)
     end
   end
 end

data/lib/store_model/types.rb

@@ -1,12 +1,23 @@
 # frozen_string_literal: true
 
-require "store_model/types/json_type"
-require "store_model/types/array_type"
+require "store_model/types/polymorphic_helper"
+
+require "store_model/types/one_base"
+require "store_model/types/one"
+require "store_model/types/one_polymorphic"
+
+require "store_model/types/many_base"
+require "store_model/types/many"
+require "store_model/types/many_polymorphic"
+
 require "store_model/types/enum_type"
 
+require "store_model/types/one_of"
+
 module StoreModel
   # Contains all custom types.
   module Types
     class CastError < StandardError; end
+    class ExpandWrapperError < StandardError; end
   end
 end

data/lib/store_model/types/many.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling an array of
+    # StoreModel::Model
+    class Many < ManyBase
+      # Initializes type for model class
+      #
+      # @param model_klass [StoreModel::Model] model class to handle
+      #
+      # @return [StoreModel::Types::Many]
+      def initialize(model_klass)
+        @model_klass = model_klass
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :array
+      end
+
+      protected
+
+      def ensure_model_class(array)
+        array.map do |object|
+          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 Array instances are allowed"
+      end
+    end
+  end
+end

data/lib/store_model/types/{array_type.rb → many_base.rb}

@@ -6,21 +6,12 @@ module StoreModel
   module Types
     # Implements ActiveModel::Type::Value type for handling an array of
     # StoreModel::Model
-    class ArrayType < ActiveModel::Type::Value
-      # Initializes type for model class
-      #
-      # @param model_klass [StoreModel::Model] model class to handle
-      #
-      # @return [StoreModel::Types::ArrayType]
-      def initialize(model_klass)
-        @model_klass = model_klass
-      end
-
+    class ManyBase < ActiveModel::Type::Value
       # Returns type
       #
       # @return [Symbol]
       def type
-        :array
+        raise NotImplementedError
       end
 
       # Casts +value+ from DB or user to StoreModel::Model instance
@@ -34,8 +25,7 @@ module StoreModel
         when Array then ensure_model_class(value)
         when nil then value
         else
-          raise StoreModel::Types::CastError,
-                "failed casting #{value.inspect}, only String or Array instances are allowed"
+          raise_cast_error(value)
         end
       end
 
@@ -64,28 +54,28 @@ module StoreModel
         cast_value(raw_old_value) != new_value
       end
 
-      private
+      protected
 
-      # rubocop:disable Style/RescueModifier
-      def decode_and_initialize(array_value)
-        decoded = ActiveSupport::JSON.decode(array_value) rescue []
-        decoded.map { |attributes| cast_model_type_value(attributes) }
+      def ensure_model_class(_array)
+        raise NotImplementedError
       end
-      # rubocop:enable Style/RescueModifier
 
-      def ensure_model_class(array)
-        array.map do |object|
-          object.is_a?(@model_klass) ? object : cast_model_type_value(object)
-        end
+      def cast_model_type_value(_value)
+        raise NotImplementedError
       end
 
-      def cast_model_type_value(value)
-        model_klass_type.cast_value(value)
+      def raise_cast_error(_value)
+        raise NotImplementedError
       end
 
-      def model_klass_type
-        @model_klass_type ||= @model_klass.to_type
+      private
+
+      # rubocop:disable Style/RescueModifier
+      def decode_and_initialize(array_value)
+        decoded = ActiveSupport::JSON.decode(array_value) rescue []
+        decoded.map { |attributes| cast_model_type_value(attributes) }
       end
+      # rubocop:enable Style/RescueModifier
     end
   end
 end

data/lib/store_model/types/many_polymorphic.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling an array of
+    # StoreModel::Model
+    class ManyPolymorphic < ManyBase
+      include PolymorphicHelper
+
+      # Initializes type for model class
+      #
+      # @param model_wrapper [Proc] class to handle
+      #
+      # @return [StoreModel::Types::PolymorphicArrayType ]
+      def initialize(model_wrapper)
+        @model_wrapper = model_wrapper
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :polymorphic_array
+      end
+
+      private
+
+      def ensure_model_class(array)
+        array.map do |object|
+          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/{json_type.rb → one.rb}

@@ -5,12 +5,12 @@ require "active_model"
 module StoreModel
   module Types
     # Implements ActiveModel::Type::Value type for handling an instance of StoreModel::Model
-    class JsonType < ActiveModel::Type::Value
+    class One < OneBase
       # Initializes type for model class
       #
       # @param model_klass [StoreModel::Model] model class to handle
       #
-      # @return [StoreModel::Types::JsonType]
+      # @return [StoreModel::Types::One]
       def initialize(model_klass)
         @model_klass = model_klass
       end
@@ -30,7 +30,7 @@ module StoreModel
       def cast_value(value)
         case value
         when String then decode_and_initialize(value)
-        when Hash then @model_klass.new(value)
+        when Hash then model_instance(value)
         when @model_klass, nil then value
         else raise_cast_error(value)
         end
@@ -53,40 +53,16 @@ module StoreModel
         end
       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
-
       private
 
-      # rubocop:disable Style/RescueModifier
-      def decode_and_initialize(value)
-        decoded = ActiveSupport::JSON.decode(value) rescue nil
-        @model_klass.new(decoded) unless decoded.nil?
-      rescue ActiveModel::UnknownAttributeError => e
-        handle_unknown_attribute(decoded, e)
-      end
-      # rubocop:enable Style/RescueModifier
-
       def raise_cast_error(value)
         raise StoreModel::Types::CastError,
               "failed casting #{value.inspect}, only String, " \
               "Hash or #{@model_klass.name} instances are allowed"
       end
 
-      def handle_unknown_attribute(value, exception)
-        attribute = exception.attribute.to_sym
-        value_symbolized = value.symbolize_keys
-
-        cast_value(value_symbolized.except(attribute)).tap do |configuration|
-          configuration.unknown_attributes[attribute.to_s] = value_symbolized[attribute]
-        end
+      def model_instance(value)
+        @model_klass.new(value)
       end
     end
   end

data/lib/store_model/types/one_base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling an instance of StoreModel::Model
+    class OneBase < ActiveModel::Type::Value
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        raise NotImplementedError
+      end
+
+      # Casts +value+ from DB or user to StoreModel::Model instance
+      #
+      # @param value [Object] a value to cast
+      #
+      # @return StoreModel::Model
+      def cast_value(_value)
+        raise NotImplementedError
+      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 raise_cast_error(_value)
+        raise NotImplementedError
+      end
+
+      def model_instance(_value)
+        raise NotImplementedError
+      end
+
+      private
+
+      # rubocop:disable Style/RescueModifier
+      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_of.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling an array of
+    # StoreModel::Model
+    class OneOf
+      def initialize(&block)
+        @block = block
+      end
+
+      def to_type
+        Types::OnePolymorphic.new(@block)
+      end
+
+      def to_array_type
+        Types::ManyPolymorphic.new(@block)
+      end
+    end
+  end
+end

data/lib/store_model/types/one_polymorphic.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module StoreModel
+  module Types
+    # Implements ActiveModel::Type::Value type for handling an instance of StoreModel::Model
+    class OnePolymorphic < OneBase
+      include PolymorphicHelper
+
+      # Initializes type for model class
+      #
+      # @param model_wrapper [Proc] class to handle
+      #
+      # @return [StoreModel::Types::OnePolymorphic ]
+      def initialize(model_wrapper)
+        @model_wrapper = model_wrapper
+      end
+
+      # Returns type
+      #
+      # @return [Symbol]
+      def type
+        :polymorphic
+      end
+
+      # Casts +value+ from DB or user to StoreModel::Model instance
+      #
+      # @param value [Object] a value to cast
+      #
+      # @return StoreModel::Model
+      def cast_value(value)
+        case value
+        when String then decode_and_initialize(value)
+        when Hash then extract_model_klass(value).new(value)
+        when nil then value
+        else
+          raise_cast_error(value) unless value.class.ancestors.include?(StoreModel::Model)
+
+          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
+      # to understand.
+      #
+      # @param value [Object] value to serialize
+      #
+      # @return [String] serialized value
+      def serialize(value)
+        case value
+        when Hash
+          ActiveSupport::JSON.encode(value)
+        else
+          return ActiveSupport::JSON.encode(value) if implements_model?(value.class)
+
+          super
+        end
+      end
+
+      protected
+
+      # Check if block returns an appropriate class and raise cast error if not
+      #
+      # @param value [Object] raw data
+      #
+      # @return [Class] which implements StoreModel::Model
+      def extract_model_klass(value)
+        model_klass = @model_wrapper.call(value)
+
+        raise_extract_wrapper_error(model_klass) unless implements_model?(model_klass)
+
+        model_klass
+      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
+
+      def model_instance(value)
+        extract_model_klass(value).new(value)
+      end
+    end
+  end
+end

data/lib/store_model/types/polymorphic_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Shared methods for polymorphic classes
+module PolymorphicHelper
+  def raise_extract_wrapper_error(invalid_klass)
+    raise StoreModel::Types::ExpandWrapperError,
+          "#{invalid_klass.inspect} is an invalid model klass"
+  end
+
+  def implements_model?(klass)
+    klass&.ancestors&.include?(StoreModel::Model)
+  end
+end

data/lib/store_model/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_model
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.2
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-14 00:00:00.000000000 Z
+date: 2021-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -56,16 +56,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.64.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.64.0
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,7 @@ files:
 - lib/store_model.rb
 - lib/store_model/combine_errors_strategies.rb
 - 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/configuration.rb
 - lib/store_model/enum.rb
@@ -105,15 +106,21 @@ files:
 - lib/store_model/railtie.rb
 - lib/store_model/type_builders.rb
 - lib/store_model/types.rb
-- lib/store_model/types/array_type.rb
 - lib/store_model/types/enum_type.rb
-- lib/store_model/types/json_type.rb
+- lib/store_model/types/many.rb
+- lib/store_model/types/many_base.rb
+- lib/store_model/types/many_polymorphic.rb
+- lib/store_model/types/one.rb
+- lib/store_model/types/one_base.rb
+- lib/store_model/types/one_of.rb
+- lib/store_model/types/one_polymorphic.rb
+- lib/store_model/types/polymorphic_helper.rb
 - lib/store_model/version.rb
 homepage: https://github.com/DmitryTsepelev/store_model
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,8 +135,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Gem for working with JSON-backed attributes as ActiveRecord models
 test_files: []