serialize_attributes 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c505eb52395e2c8fe3786c3ef97dd04e5a56f978072d839ba517c0069f9dce93
-  data.tar.gz: 5ea660579c45ebd3cca56da5c3ea7e07fe9af5fb38a05fd62d3133f118f3d8df
+  metadata.gz: 60ef1282c29e5ec4ae46242eed3dac95e756ddd5e6c57c95befc19a695bb9a6e
+  data.tar.gz: 9aa223ae50c2c60344844109bb4772a225796c7d70a0e7b355014bf765b402d9
 SHA512:
-  metadata.gz: 311846e88d0c92cf41bf5adbd32c1515fbd1d131df0d733cfd444963bedc8594620d05cb12cfe701b40fba851195931f6f53673dcbe25593bf257e2b28c183dc
-  data.tar.gz: c5e2e60ba000e0afe423cee6c37e20fae5b590a39bcadab76d65712db712359e1d4ae3c0532e44565d673cb1c8f55cd4d535b9fdc057f50d11d3e3744f0803e9
+  metadata.gz: 867430cdb67e77c32ef2860fced5b004e80d3ac15300da02010addeff5d8100c0d20c84b0f8a80458041ad93896ccd0b86c8250dc3aad198e874eac9842f2bef
+  data.tar.gz: 5cebc02f04aa76e0d1dca6ecc9b63f645e595710d902d08a207eaf9d13fe11c6c5b6e51f9e52c3990340ada60d24bc1bd6bfdd189dd3137ce0652e8f88850964

data/README.md

@@ -7,7 +7,7 @@ class MyModel
   serialize_attributes :settings do
     attribute :user_name, :string
     attribute :subscribed, :boolean, default: false
-    attribute :subscriptions, :string, array: true 
+    attribute :subscriptions, :string, array: true
   end
 end
 ```
@@ -63,6 +63,16 @@ record
 #=> #<MyModel id: 1, settings: { user_name: "Nick", subscribed: true }>
 ```
 
+Additionally you can use predicated methods the same way you do with an ActiveRecord's attribute.
+Indeed behind the curtain we use `ActiveRecord::AttributeMethods::Query`.
+
+```ruby
+record.subscribed?
+#=> false
+record.user_name?
+#=> true
+```
+
 ### Getting all of the stored attributes
 
 Default values are not automatically persisted to the database, so there is a helper
@@ -145,6 +155,54 @@ specify a `default` attribute yourself explicitly:
 attribute :emails, :string, array: true, default: ["unknown@example.com"]
 ```
 
+### Enumerated ("enum") types
+
+Since enum types are a common thing when managing external data, there is a special enum
+type defined by the library:
+
+```ruby
+class MyModel
+  serialize_attributes :settings do
+    attribute :state, :enum, of: ["open", "closed"]
+  end
+end
+```
+
+Unlike `ActiveRecord::Enum`, enums here work by attaching an inclusion validator to your
+model. So for example, with the above code, I'll get a validation failure by default:
+
+```ruby
+MyModel.new(state: nil).tap(&:valid?).errors
+#=> { state: "is not included in the list" }
+```
+
+If you wish to allow nil values in your enum, you should add it to the `of` collection:
+
+```ruby
+attribute :state, :enum, of: [nil, "open", "closed"]
+```
+
+The column is probably now the source of truth for correct values, so you can also
+introspect the store to fetch these from elsewhere (e.g. for building documentation):
+
+```ruby
+MyModel.serialized_attributes_store(:settings).enum_options(:state)
+#=> ["open", "closed"]
+```
+
+Finally, you can also use complex types within the enum itself, by passing an additional
+`type:` attribute. Values will then be cast or deserialized per that type, and the result
+of the casting is what is validated, e.g:
+
+```ruby
+attribute :state, :enum, of: [nil, true, false], type: :boolean
+```
+
+```ruby
+MyModel.new(state: "f").state
+#=> false
+```
+
 ### Usage with ActiveModel alone
 
 It's also possible to use this library without `ActiveRecord`:

data/lib/serialize_attributes/store.rb

@@ -19,16 +19,16 @@ module SerializeAttributes
     # Get a list of the attributes managed by this store. Pass an optional `type` argument
     # to filter attributes by their type.
     #
-    #   Model.serialize_attributes_store(:settings).attribute_names
+    #   Model.serialized_attributes_store(:settings).attribute_names
     #   => [:user_name, :subscribed, :subscriptions]
     #
-    #   Model.serialize_attributes_store(:settings).attribute_names(type: :string)
+    #   Model.serialized_attributes_store(:settings).attribute_names(type: :string)
     #   => [:user_name, :subscriptions]
     #
-    #  Model.serialize_attributes_store(:settings).attribute_names(type: :string, array: true)
+    #  Model.serialized_attributes_store(:settings).attribute_names(type: :string, array: true)
     #  => [:subscriptions]
     #
-    #  Model.serialize_attributes_store(:settings).attribute_names(type: :string, array: false)
+    #  Model.serialized_attributes_store(:settings).attribute_names(type: :string, array: false)
     #  => [:user_name]
     #
     #
@@ -42,12 +42,26 @@ module SerializeAttributes
       end.keys
     end
 
+    # Get a list of enumerated options for the column `name` in this store.
+    #
+    #   Model.serialized_attributes_store(:settings).enum_options(:enumy)
+    #   => [nil, "placed", "confirmed"]
+    def enum_options(name)
+      type = @attributes.fetch(name.to_sym)
+      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
     #
     #    Model.serialized_attributes_store(:settings).cast(:user_name, 42)
     #    => "42"
     def cast(name, value)
-      @attributes[name.to_sym].cast(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)
     end
 
     # Deserialize a stored attribute using the value from the database (or elsewhere)
@@ -55,7 +69,12 @@ module SerializeAttributes
     #   Model.serialized_attributes_store(:settings).deserialize(:subscribed, "0")
     #   => false
     def deserialize(name, value)
-      @attributes[name.to_sym].deserialize(value)
+      attribute = @attributes[name.to_sym]
+      if attribute.nil?
+        raise "The attribute #{name} is not defined in serialize_attribute method in the #{@model_class} class."
+      end
+
+      attribute.deserialize(value)
     end
 
     # Retrieve the default value for a given block. If the default is a Proc, it can be
@@ -80,23 +99,40 @@ module SerializeAttributes
       end
     end
 
-    def attribute(name, type, **options)
+    NO_DEFAULT = Object.new
+
+    def attribute(name, type, default: NO_DEFAULT, array: false, **type_options)
       name = name.to_sym
-      arr = options.delete(:array) { false }
-      type = ActiveModel::Type.lookup(type, **options.except(:default)) if type.is_a?(Symbol)
-      type = ArrayWrapper.new(type) if arr
+      type = ActiveModel::Type.lookup(type, **type_options) if type.is_a?(Symbol)
+
+      if array
+        raise ArgumentError, "Enum-arrays not currently supported" if type.is_a?(Types::Enum)
+
+        type = ArrayWrapper.new(type)
+      end
 
       @attributes[name] = type
 
-      if options.key?(:default)
-        @defaults[name] = options[:default]
-      elsif arr
+      if default != NO_DEFAULT
+        @defaults[name] = default
+      elsif array
         @defaults[name] = []
       end
 
+      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
-          store = public_send(:#{@column_name})              #   store = public_send(:settings)
+          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
@@ -105,20 +141,31 @@ module SerializeAttributes
               .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 #{arr} && cast_value == ArrayWrapper::EMPTY     #   if false && cast_value == ArrayWrapper::EMPTY
+          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)
                                                              #
-          self.public_send(:#{@column_name}=, store)         #   self.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
       RUBY
     end

data/lib/serialize_attributes/types/enum.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module SerializeAttributes
+  module Types
+    # A custom type which can only hold one of a set of predetermined values.
+    class Enum
+      attr_reader :options
+
+      # Construct a type instance.
+      #
+      # @param of   [Array]  One or more possible values that this type can take
+      # @param type [Symbol] An optional ActiveModel::Type instance, or symbol, for
+      #                      casting/uncasting (only required if enum has non-primitive types)
+      #
+      # @example Required to be one of two values
+      #   attribute :state, :enum, of: ["placed", "confirmed"]
+      #
+      # @example Optionally allowing nil
+      #   attribute :folding, :enum, of: [nil, "top-fold", "bottom-fold"]
+      #
+      # @example Casting input/output using another type
+      #   attribute :loves_pizza, :enum, of: [true], type: :boolean
+      #   # object.loves_pizza = "t"
+      #   #=> true
+      def initialize(of: [], type: nil)
+        @options = of.freeze
+        @type    = resolve_type(type)
+      end
+
+      def attach_validations_to(object, field_name)
+        object.validates_inclusion_of(field_name, in: @options)
+      end
+
+      delegate_missing_to :@type
+
+      private
+
+      UNTYPED_TYPE = ActiveModel::Type::Value.new
+
+      def resolve_type(given)
+        case given
+        in Symbol then ActiveModel::Type.lookup(given)
+        in nil    then UNTYPED_TYPE
+        in _      then given
+        end
+      end
+    end
+  end
+end
+
+ActiveModel::Type.register(:enum, SerializeAttributes::Types::Enum)

data/lib/serialize_attributes/version.rb

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

data/lib/serialize_attributes.rb

@@ -2,6 +2,7 @@
 
 require "serialize_attributes/version"
 require "serialize_attributes/store"
+require "serialize_attributes/types/enum"
 
 # Serialize ActiveModel attributes in JSON using type casting
 module SerializeAttributes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serialize_attributes
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Zaikio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -36,6 +36,7 @@ files:
 - Rakefile
 - lib/serialize_attributes.rb
 - lib/serialize_attributes/store.rb
+- lib/serialize_attributes/types/enum.rb
 - lib/serialize_attributes/version.rb
 homepage: https://github.com/zaikio/serialize_attributes
 licenses: