serialize_attributes 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c06deef436a52e15560111b4055b706d769d684106edaa4d224a7121367cfde
-  data.tar.gz: e8bf6db9353e825f8df2cae7f79634c39826c69793a91a8dd3dba60a71c6039d
+  metadata.gz: f4fa19f41c2a597b312db2432d1df9a2efad508c91feebd885caab60f68304ac
+  data.tar.gz: a84b9c79d3bc59c8a416d8c2c3f2f08f46bdf3a25d8de465c8fb61593ce181aa
 SHA512:
-  metadata.gz: ff687f3298a043cfac0a8aa00931a2175640ff538c7753be1397d15a11995b234c778e2f6454ae5c4f64dd55fe6c3774beefbff349b4c4025f3020406fddaa51
-  data.tar.gz: 0471ec6fb74122457517c3dceb602000114257b3cf98d5f11cac75506da0a7e0ab74554545c26caf34f16edc70f6b0f21ae8e5f81a7ffc6324e5009b7e871cb0
+  metadata.gz: c5f6f45154a0b8f28b8712f81714c4d4eccccb9a58b7a54a0d2fe24499c101656d6416d80cf34eac0632de6444b8fe0b57503cbec6a5a2f8ffdea21badd7428c
+  data.tar.gz: 336dfe149b07fb43a171d417a79d33f1fc67eec5d6399cb73a803f38f0fc2afa72cafd1da859c489ad1c92551291337599dfb55827678f46c6717845288fc273

data/README.md

@@ -7,6 +7,7 @@ class MyModel
   serialize_attributes :settings do
     attribute :user_name, :string
     attribute :subscribed, :boolean, default: false
+    attribute :subscriptions, :string, array: true
   end
 end
 ```
@@ -144,6 +145,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

@@ -4,7 +4,8 @@ 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 = {}
@@ -18,29 +19,38 @@ 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
-    #   => [:user_name, :subscribed]
+    #   Model.serialized_attributes_store(:settings).attribute_names
+    #   => [:user_name, :subscribed, :subscriptions]
     #
-    #   Model.serialize_attributes_store(:settings).attribute_names(:string)
-    #   => [:user_name]
-    def attribute_names(type = nil)
+    #   Model.serialized_attributes_store(:settings).attribute_names(type: :string)
+    #   => [:user_name, :subscriptions]
+    #
+    #  Model.serialized_attributes_store(:settings).attribute_names(type: :string, array: true)
+    #  => [:subscriptions]
+    #
+    #  Model.serialized_attributes_store(:settings).attribute_names(type: :string, array: false)
+    #  => [:user_name]
+    #
+    #
+    def attribute_names(type: nil, array: nil)
+      attributes = @attributes
+      attributes = @attributes.select { |_, v| v.is_a?(ArrayWrapper) == array } unless array.nil?
       if type
-        type = ActiveModel::Type.lookup(type)&.class if type.is_a?(Symbol)
-        @attributes.select do |_, v|
-          v.is_a?(type)
-        end
+        attributes_for_type(attributes, type)
       else
-        @attributes
+        attributes
       end.keys
     end
 
-    # Get a list of attributes of a certain type
+    # Get a list of enumerated options for the column `name` in this store.
     #
-    #   Model.serialize_attributes_store(:settings).attributes_of_type(:string)
-    #   => [:user_name]
-    def attributes_of_type(type)
-      type = ActiveModel::Type.lookup(type) if type.is_a?(Symbol)
-      @attributes.select { |_, v| v.is_a?(type) }.keys
+    #   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
@@ -48,7 +58,10 @@ module SerializeAttributes
     #    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)
@@ -56,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 define 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
@@ -73,23 +91,48 @@ module SerializeAttributes
 
     private
 
-    def attribute(name, type, **options)
+    def attributes_for_type(attributes, type)
+      type = ActiveModel::Type.lookup(type)&.class if type.is_a?(Symbol)
+      attributes.select do |_, v|
+        v = v.__getobj__ if v.is_a?(ArrayWrapper)
+        v.is_a?(type)
+      end
+    end
+
+    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
@@ -98,20 +141,25 @@ module SerializeAttributes
               .default(:#{name}, self)                       #       .default(:user_name, self)
           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.3.1"
+  VERSION = "0.5.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
@@ -37,7 +38,7 @@ module SerializeAttributes
     #   Person.serialized_attribute_names(:settings, :string)
     #   => [:user_name]
     def serialized_attribute_names(column_name, type = nil)
-      serialized_attributes_store(column_name).attribute_names(type)
+      serialized_attributes_store(column_name).attribute_names(type: type)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serialize_attributes
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Zaikio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2022-07-25 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: