store_model 0.7.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81df7c27571266926547a2a5aad309128741860b15fe94876476744efa4932d9
-  data.tar.gz: 33a62eb4baa468872e3b409e34755a8d057841f4b764e0ecac6f50cef4481286
+  metadata.gz: 1c612c06744ac1427fd3c3d718e414592ce983734f6aa547e7ffe052b6ac0ef3
+  data.tar.gz: 349b6f3625d2d94a585c119a3e2080519f9509ee738633062a95364ffd47eb98
 SHA512:
-  metadata.gz: '019a485b12c9216f493198d6e02d03284e9f912c3eea96ee4c0fb1d2a4be3284c1febfc92e7045c28b6a5266bc8a7cd5eca663536fe4d928d27cf5dfdb31b688'
-  data.tar.gz: b7aaea3584e1f59caea549b9f98e7ee310677746d1d7e58c8b741c01d899592697a6b831fe6a28615fcb6253d38fea9ce57bcb046bb97e6587601dc94ceea224
+  metadata.gz: d1df9be55ae81ae2648a1d1c9dc287731ae2954cbfbe9ea618d27aa50b954e5c867900b147aa7ede58382ecf21fcba8e62e6f1b2571700e1e64e76c834c16f69
+  data.tar.gz: 9224ce8f181e58f02e0fec9864acf1ba4c22e8a575d40ad6e3a66e354178c4c2b4478cb19e8290304da98fe06b0d862fd8da558f71f91ae4dc577d1f2a827000

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,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/combine_errors_strategies/merge_error_strategy.rb

@@ -13,7 +13,8 @@ module StoreModel
       # attribute
       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(attribute, :invalid, message: error.full_message)

data/lib/store_model/model.rb

@@ -11,10 +11,13 @@ module StoreModel
     def self.included(base) # :nodoc:
       base.include ActiveModel::Model
       base.include ActiveModel::Attributes
+      base.include ActiveModel::AttributeMethods
       base.include StoreModel::NestedAttributes
 
       base.extend StoreModel::Enum
       base.extend StoreModel::TypeBuilders
+
+      base.attribute_method_suffix "?"
     end
 
     attr_accessor :parent
@@ -70,13 +73,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
@@ -86,5 +113,14 @@ module StoreModel
     def unknown_attributes
       @unknown_attributes ||= {}
     end
+
+    private
+
+    def attribute?(attribute)
+      case value = attributes[attribute]
+      when 0 then false
+      else value.present?
+      end
+    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,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.7.0"
+  VERSION = "0.10.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.10.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-19 00:00:00.000000000 Z
+date: 2021-07-06 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
@@ -106,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
@@ -129,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: []