store_model 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81df7c27571266926547a2a5aad309128741860b15fe94876476744efa4932d9
-  data.tar.gz: 33a62eb4baa468872e3b409e34755a8d057841f4b764e0ecac6f50cef4481286
+  metadata.gz: 637fbd26ab60269ee1f0e8c9d091c1c145af797edfb5924f2741b4175f63e550
+  data.tar.gz: fa6ccf49426de71facd6324f4d13da525b48f4136c6d21a6dc48bc1530cfcacc
 SHA512:
-  metadata.gz: '019a485b12c9216f493198d6e02d03284e9f912c3eea96ee4c0fb1d2a4be3284c1febfc92e7045c28b6a5266bc8a7cd5eca663536fe4d928d27cf5dfdb31b688'
-  data.tar.gz: b7aaea3584e1f59caea549b9f98e7ee310677746d1d7e58c8b741c01d899592697a6b831fe6a28615fcb6253d38fea9ce57bcb046bb97e6587601dc94ceea224
+  metadata.gz: ece230a89c62e1a5089ab15c184a1cc9fd7b18b3eb5652a3e21df6ae74a40e172fd8fbb8cd92df0e5b64586e4fe5f77f5f681a7092110ad7a11d458c6f3075cb
+  data.tar.gz: 21f9ba16ad9f8b361d02d7a0794c89af1ca3365ea31495dd5f8f1d9e059d9c91112c7d31beb3ae5e6b5371448f65784854cf18ec617cb275472dc2a2539b13ca

data/README.md

@@ -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,9 +21,9 @@ module ActiveModel
         end
 
         case record.type_for_attribute(attribute).type
-        when :json
+        when :json, :polymorphic
           call_json_strategy(attribute, record.errors, value)
-        when :array
+        when :array, :polymorphic_array
           call_array_strategy(attribute, record.errors, value)
         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/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,66 @@
+# 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
+
+        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.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_model
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-19 00:00:00.000000000 Z
+date: 2020-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -106,9 +106,15 @@ 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: