store_model 0.6.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4da91e0f6f9e27a71947f5a31b7bb0d936680bd263ad46f69916d995380af27
-  data.tar.gz: 463730c176403dd845382cd078d90e58faae6d2ee1a7c9670c7f7c48d68032d3
+  metadata.gz: e85a27e1f3a20217b3f6134d8f2679d556ce445c74b47ff223a3abec247219b9
+  data.tar.gz: e4c5baceadbbd1049ff8c0616e31d41302178ed74929ee512e1625a8d983c870
 SHA512:
-  metadata.gz: 1cb34bbaf868eea40c26d33b2c15a8fbd8c79f3e5429714172f0f38ea9e11a396241831744be82c280b8ace4de60237a5226d8a9cf77bedf2b200b8bb3e58485
-  data.tar.gz: 8dbf31fb3f4ece28979fa49d799b1f633e7e9f5007ceb38d0cf883ea214c50dc621c8f5b8c5367cb979910c74af039de675acbf7d69e7720d2f6d61b25a240e4
+  metadata.gz: 8e900e6ffeaffb83c1bc87b66b810d5e652871908c46542f1d3edbd7791761721d8a69bef57b9e187ce700c480dbd7c59d0dc9cda6a01092d64fcba27c4eb277
+  data.tar.gz: 8744a4125da41b45bb0bb510296924758b5b07345e173cf4193a5ca0b3759f62aa2dfc54b4d9233d757d7c92e8ce0a0fed2c139f95c51ab91935bfc8e440001e

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.
 
@@ -44,7 +44,7 @@ This approach works fine when you don't have a lot of keys with logic around the
 
 For instance, try to find a way to validate `:model` value to be required. Despite of the fact, that you'll have to write this validation by hand, it violates single-repsponsibility principle: why parent model (`Product`) should know about the logic related to a child (`Configuration`)?
 
-> 📖 Read more about the motivation in the [Wrapping JSON-based ActiveRecord attributes with classes](https://dev.to/evilmartians/wrapping-json-based-activerecord-attributes-with-classes-4apf) post
+> 📖 Read more about the motivation in the [Wrapping JSON-based ActiveRecord attributes with classes](https://evilmartians.com/chronicles/wrapping-json-based-active-record-attributes-with-classes) post
 
 ## Getting started
 
@@ -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.select(&:invalid?).present?
+        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/model.rb

@@ -70,13 +70,37 @@ module StoreModel
 
     # Checks if the attribute with a given name is defined
     #
+    # @example
+    #    class Person
+    #      include StoreModel::Model
+    #      attribute :name, :string
+    #      alias_attribute :new_name, :name
+    #    end
+    #
+    #    Person.has_attribute?('name')     # => true
+    #    Person.has_attribute?('new_name') # => true
+    #    Person.has_attribute?(:age)       # => true
+    #    Person.has_attribute?(:nothing)   # => false
+    #
     # @param attr_name [String] name of the attribute
     #
     # @return [Boolean]
     # rubocop:disable Naming/PredicateName
     def has_attribute?(attr_name)
-      attribute_types.key?(attr_name.to_s)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      attribute_types.key?(attr_name)
+    end
+
+    # Legacy implementation of #has_attribute?
+    #
+    # @param attr_name [String] name of the attribute
+    #
+    # @return [Boolean]
+    def _has_attribute?(attr_name)
+      attribute_types.key?(attr_name)
     end
+
     # rubocop:enable Naming/PredicateName
 
     # Contains a hash of attributes which are not defined but exist in the

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.2"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_model
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.9.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-17 00:00:00.000000000 Z
+date: 2021-04-21 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: []