serialize_attributes 0.6.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60ef1282c29e5ec4ae46242eed3dac95e756ddd5e6c57c95befc19a695bb9a6e
-  data.tar.gz: 9aa223ae50c2c60344844109bb4772a225796c7d70a0e7b355014bf765b402d9
+  metadata.gz: fcfd75fcff7e883cb0063752bb35de287b4683c59e0029bf654d77b0e67b7ec0
+  data.tar.gz: adc7cc26ba5b6dca8b543a2a33960419c66cd37149a5e759bdfc820f131fbe60
 SHA512:
-  metadata.gz: 867430cdb67e77c32ef2860fced5b004e80d3ac15300da02010addeff5d8100c0d20c84b0f8a80458041ad93896ccd0b86c8250dc3aad198e874eac9842f2bef
-  data.tar.gz: 5cebc02f04aa76e0d1dca6ecc9b63f645e595710d902d08a207eaf9d13fe11c6c5b6e51f9e52c3990340ada60d24bc1bd6bfdd189dd3137ce0652e8f88850964
+  metadata.gz: f160a8efe020f2d47d385f3c2ea76149adcf2d6eff06dd6d9b49e08e0684e7fa1cbcd4abb7e6c8f8ea3d25cebed1c888a2aa7bbb42d4a7fff5f0c5ec30d08d67
+  data.tar.gz: a58b02f33d14bd4afa8202a7d69553377ecf2fc2b9b4c011fbc5fdf2ff8460628dc8675d8ad883bfedb98e810779597a3afbe4f01347a9014baa5189d0223afb

data/README.md

@@ -148,12 +148,7 @@ class MyModel
 end
 ```
 
-Please note that the default value for an array attribute is always `[]`, unless you
-specify a `default` attribute yourself explicitly:
-
-```ruby
-attribute :emails, :string, array: true, default: ["unknown@example.com"]
-```
+Please note that the default value for an array attribute is always `[]`.
 
 ### Enumerated ("enum") types
 

data/lib/serialize_attributes/store.rb

@@ -4,18 +4,19 @@ module SerializeAttributes
   # SerializeAttributes::Store is the individual store, keyed by name. You can get a
   # reference to the store by calling `Model.serialized_attributes_store(column_name)`.
   class Store
-    def initialize(model_class, column_name, &block)
-      # :nodoc:
+    def initialize(model_class, column_name, &block) # :nodoc:
       @model_class = model_class
       @column_name = column_name
-      @attributes = {}
+      @attribute_types = {}
       @defaults = {}
 
       instance_exec(&block)
       wrap_store_column
-      [self, @attributes, @defaults].each(&:freeze)
+      [self, @attribute_types, @defaults].each(&:freeze)
     end
 
+    attr_reader :attribute_types
+
     # Get a list of the attributes managed by this store. Pass an optional `type` argument
     # to filter attributes by their type.
     #
@@ -33,13 +34,13 @@ module SerializeAttributes
     #
     #
     def attribute_names(type: nil, array: nil)
-      attributes = @attributes
-      attributes = @attributes.select { |_, v| v.is_a?(ArrayWrapper) == array } unless array.nil?
+      attributes = @attribute_types
+      attributes = @attribute_types.select { |_, v| v.is_a?(ArrayWrapper) == array } unless array.nil?
       if type
         attributes_for_type(attributes, type)
       else
         attributes
-      end.keys
+      end.keys.map(&:to_sym)
     end
 
     # Get a list of enumerated options for the column `name` in this store.
@@ -47,46 +48,44 @@ module SerializeAttributes
     #   Model.serialized_attributes_store(:settings).enum_options(:enumy)
     #   => [nil, "placed", "confirmed"]
     def enum_options(name)
-      type = @attributes.fetch(name.to_sym)
+      type = @attribute_types.fetch(name.to_s)
       raise ArgumentError, "`#{name}` attribute is not an enum type" unless type.respond_to?(:options)
 
       type.options
     end
 
-    # Cast a stored attribute against a given name
+    # Cast a stored attribute against a given name into an
+    # ActiveModel::Attribute::FromUser object (the cast value can be got using `#value`).
     #
-    #    Model.serialized_attributes_store(:settings).cast(:user_name, 42)
+    #    Model.serialized_attributes_store(:settings).cast(:user_name, 42).value
     #    => "42"
     def cast(name, value)
-      # @attributes.fetch(name.to_sym) returns the Type as defined in ActiveModel::Type or
-      # raise an error if the type is unknown.
-      # Type::Integer.new.cast("42") => 42
-      @attributes.fetch(name.to_sym).cast(value)
+      type = @attributes_types.fetch(name.to_s)
+
+      ActiveModel::Attribute.from_user(name, value, type)
     end
 
-    # Deserialize a stored attribute using the value from the database (or elsewhere)
+    # Deserialize a stored attribute using the value from the database (or elsewhere) into
+    # an ActiveModel::Attribute::FromDatabase object (the cast value can be got using
+    # `#value`).
     #
-    #   Model.serialized_attributes_store(:settings).deserialize(:subscribed, "0")
+    #   Model.serialized_attributes_store(:settings).deserialize(:subscribed, "0").value
     #   => false
     def deserialize(name, value)
-      attribute = @attributes[name.to_sym]
-      if attribute.nil?
+      type = @attribute_types[name.to_s]
+      if type.nil?
         raise "The attribute #{name} is not defined in serialize_attribute method in the #{@model_class} class."
       end
 
-      attribute.deserialize(value)
+      ActiveModel::Attribute.from_database(name, value, type)
     end
 
-    # Retrieve the default value for a given block. If the default is a Proc, it can be
-    # optionally executed in the context of the model.
+    # Retrieve the default value for a given block.
     #
     #   Model.serialized_attributes_store(:settings).default(:subscribed)
     #   #=> false
-    def default(name, context = nil)
-      given = @defaults[name]
-      return (context || self).instance_exec(&given) if given.is_a?(Proc)
-
-      given
+    def default(name)
+      @defaults[name.to_s]
     end
 
     private
@@ -102,7 +101,7 @@ module SerializeAttributes
     NO_DEFAULT = Object.new
 
     def attribute(name, type, default: NO_DEFAULT, array: false, **type_options)
-      name = name.to_sym
+      name = name.to_s
       type = ActiveModel::Type.lookup(type, **type_options) if type.is_a?(Symbol)
 
       if array
@@ -111,7 +110,7 @@ module SerializeAttributes
         type = ArrayWrapper.new(type)
       end
 
-      @attributes[name] = type
+      @attribute_types[name] = type
 
       if default != NO_DEFAULT
         @defaults[name] = default
@@ -122,68 +121,56 @@ module SerializeAttributes
       type.attach_validations_to(@model_class, name) if type.respond_to?(:attach_validations_to)
 
       @model_class.module_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{name}                                          # def user_name
-          if @_bad_typcasting                                #   if @_bad_typcasting
-            store =                                          #     store =
-              read_attribute_before_type_cast(               #       read_attribute_before_type_cast(
-                :#{@column_name}                             #         :settings
-              )                                              #       )
-            @_bad_typcasting = false                         #     @_bad_typcasting = false
-          else                                               #   else
-            store = public_send(:#{@column_name})            #     store = public_send(:settings)
-          end                                                #   end
-                                                             #
-          if store.key?("#{name}")                           #   if store.key?("user_name")
-            store["#{name}"]                                 #     store["user_name"]
-          else                                               #   else
-            self.class                                       #     self.class
-              .serialized_attributes_store(:#{@column_name}) #       .serialized_attributes_store(:settings)
-              .default(:#{name}, self)                       #       .default(:user_name, self)
-          end                                                #   end
-        end                                                  # end
-                                                             #
-        unless #{array}                                      # unless array
-          def #{name}?                                       #   def user_name?
-            query_attribute("#{name}")                       #     query_attribute(:user_name)
-          end                                                #   end
-        end                                                  # end
-                                                             #
-        def #{name}=(value)                                  # def user_name=(value)
-          cast_value = self.class                            #   cast_value = self.class
-            .serialized_attributes_store(:#{@column_name})   #     .serialized_attributes_store(:settings)
-            .cast(:#{name}, value)                           #     .cast(:user_name, value)
-          store = public_send(:#{@column_name})              #   store = public_send(:settings)
-                                                             #
-          if #{array} && cast_value == ArrayWrapper::EMPTY   #   if array && cast_value == ArrayWrapper::EMPTY
-            store.delete("#{name}")                          #     store.delete("user_name")
-          else                                               #   else
-            store.merge!("#{name}" => cast_value)            #     store.merge!("user_name" => cast_value)
-          end                                                #   end
-          public_send(:#{@column_name}=, store)              #   public_send(:settings=, store)
-                                                             #
-          values_before_typecast = store.values              #   values_before_typecast = store.values
-          values_after_typecast =                            #   values_after_typecast =
-            public_send(:#{@column_name}).values             #     public_send(:settings).values
-          @_bad_typcasting =                                 #     @_bad_typcasting =
-            values_before_typecast != values_after_typecast  #       values_before_typecast != values_after_typecast
-        end                                                  # end
+        def #{name}                               # def user_name
+          store = public_send(:#{@column_name})   #   store = public_send(:settings)
+          store.fetch_value("#{name}")            #   store.fetch_value("user_name")
+        end                                       # end
+
+        unless #{array}                           # unless false
+          def #{name}?                            #   def user_name?
+            query_attribute("#{name}")            #     query_attribute("user_name")
+          end                                     #   end
+        end                                       # end
+
+        def #{name}=(value)                       # def user_name=(value)
+          store = public_send(:#{@column_name})   #   store = public_send(:settings)
+          try(:#{@column_name}_will_change!)      #   try(:settings_will_change!)
+          store.write_from_user("#{name}", value) #   store.write_from_user("user_name", value)
+        end                                       # end
       RUBY
     end
 
     class ArrayWrapper < SimpleDelegator # :nodoc:
-      EMPTY = Object.new
-
       def cast(value)
-        # We don't want to store the null value, because array types _always_ have a default
-        # configured. So we return this special object here, and check it again before
-        # updating the underlying store.
-        return EMPTY unless value
+        return [] if value.nil?
 
         Array(value)
       end
 
       def deserialize(value)
-        value.map { __getobj__.deserialize(_1) }
+        Array.wrap(value).map { __getobj__.deserialize(_1) }
+      end
+
+      # For arrays of strings (the most common array type), the underlying Type::String in
+      # Rails won't do this check if the raw value isn't a String (and returns `nil`):
+      #
+      #   def changed_in_place?(a, b)
+      #     if a.is_a?(String)
+      #       ...
+      #
+      # This means we have to override this check ourselves here.
+      def changed_in_place?(raw_old_value, new_value)
+        raw_old_value != new_value
+      end
+    end
+
+    class AttributeSet < ::ActiveModel::AttributeSet # :nodoc:
+      def ==(other)
+        attributes == if other.is_a?(Hash)
+                        other
+                      else
+                        other.attributes
+                      end
       end
     end
 
@@ -193,29 +180,54 @@ module SerializeAttributes
         @store = store
       end
 
+      def cast(value)
+        case value
+        when Hash then deserialize(value.stringify_keys)
+        else value
+        end
+      end
+
+      def changed_in_place?(raw_original_value, new_value)
+        (deserialize(raw_original_value) != new_value) || new_value.each_value.any?(&:changed_in_place?)
+      end
+
+      def serialize(value)
+        super(value.values_for_database)
+      end
+
       def deserialize(...)
-        result = __getobj__.deserialize(...)
+        result = super
         return result unless @store && result.respond_to?(:each)
 
-        result.each_with_object({}) do |(attribute_name, serialized_value), out|
-          out[attribute_name] = @store.deserialize(attribute_name, serialized_value)
-        end
+        AttributeSet.new(
+          @store.attribute_types.each_with_object({}) do |(attribute, type), out|
+            out[attribute] = if result.key?(attribute)
+                               @store.deserialize(attribute, result[attribute])
+                             else
+                               ActiveModel::Attribute.from_user(attribute, @store.default(attribute), type)
+                             end
+          end
+        )
       end
     end
 
-    # This method wraps the original store column and catches the `deserialize` call -
+    # This method wraps the original store column and catches several read/write calls;
     # this gives us a chance to convert the data in the database back into our types.
     #
-    # We're using the block form of `.attribute` to avoid loading the database schema just
-    # to figure out our wrapping type.
+    # We using the block form of `.attribute` when the schema is lazily loaded (and has
+    # not been loaded yet).
     def wrap_store_column
-      return unless @model_class.respond_to?(:attribute_types)
-
-      store = self
+      if respond_to?(:schema_loaded?) && !schema_loaded?
+        store = self
+        @model_class.attribute(@column_name) do
+          original_type = @model_class.attribute_types.fetch(@column_name.to_s)
+          StoreColumnWrapper.new(original_type, store)
+        end
 
-      @model_class.attribute(@column_name) do
+      else
         original_type = @model_class.attribute_types.fetch(@column_name.to_s)
-        StoreColumnWrapper.new(original_type, store)
+        type = StoreColumnWrapper.new(original_type, self)
+        @model_class.attribute(@column_name, type)
       end
     end
   end

data/lib/serialize_attributes/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SerializeAttributes
-  VERSION = "0.6.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serialize_attributes
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Zaikio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-26 00:00:00.000000000 Z
+date: 2022-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel