store_model 2.0.1 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5678f8d809e7ed7745c5bd21b10bb455ecef32fac89cbc0fe9d5928c99dcf7c8
-  data.tar.gz: 13fd4acba36ff7b96d8111043de74e94442f63a02d718571fdda3682521e0dab
+  metadata.gz: a3b12509ebafeb20d7a2bcb2ae1094dcd756f1b86f31dd8066b0abd61d8f998a
+  data.tar.gz: d3a06944b46ebf4094de55736e892f15ae27514e0604047260e74a033bbc7cda
 SHA512:
-  metadata.gz: e57e9ebc4b7e6547c75c8b0375742194eafa6104d2abfd2b55e9e657c64e2af935e99505bb712e8e1ef3d38123f4852d89603f10bfacfa620ec2cb38751995b6
-  data.tar.gz: a2c9e761568bc100697c7240762ed27aac4d8ccde2429f4e037357121351f120a1b9a17909f6670f0215691f909032131979ebbe0001d67bba1d2cadeebaadeb
+  metadata.gz: 7d8ec95caf59aea39e3cedc20a471db9289f4c1eda9d083a1b2fd321f732e7d056b67ac58a7f4f437cb04e932c1f14f18e56dfb9b04c884e5d64025cc7d7989b
+  data.tar.gz: e526dbc89d1c4186b1fe94581acb2b1d80e207bcf08d69809dffc393d43e3d8d2cd08c905d3d3d4f842c9bf7db9ad1581611368fabe8206eb0445c16a2c615eb

data/README.md

@@ -76,7 +76,49 @@ product.save
 _Usage note: Rails and assigning Arrays/Hashes to records_
 
 - Assigned attributes must be a String, Hash, Array of Hashes, or StoreModel. For example, if the attributes are coming from a controller, be sure to convert any ActionController::Parameters as needed.
-- Any changes made to a StoreModel instance requires the attribute be re-assigned; Rails doesn't track mutations of objects. For example: `self.my_stored_models = my_stored_models.map(&:as_json)`
+- Any changes made to a StoreModel instance requires the attribute be flagged as dirty, either by reassignment (`self.my_stored_models = my_stored_models.map(&:as_json)`) or by `will_change!` (`self.my_stored_models_will_change!`)
+- Mixing `StoreModel::NestedAttributes` into your model will allow you to use `accepts_nested_attributes_for` in the same way as ActiveRecord.
+
+```ruby
+class Supplier < ActiveRecord::Base
+  include StoreModel::NestedAttributes
+
+  has_many :bicycles, dependent: :destroy
+
+  attribute :products, Product.to_array_type
+
+  accepts_nested_attributes_for :bicycles, :products, allow_destroy: true
+end
+```
+
+This will allow the form builders to work their magic:
+
+```erb
+<%= form_with model: @supplier do |form| %>
+  <%= form.fields_for :products do |product_fields| %>
+    <%= product_fields.text_field :name %>
+  <% end %>
+<% end %>
+```
+
+Resulting in:
+```html
+<input type="text" name="supplier[products_attributes][0][name]" id="supplier_products_attributes_0_name">
+```
+
+In the controller:
+```ruby
+def create
+  @supplier = Supplier.new(supplier_params)
+  @supplier.save
+end
+
+private
+
+def supplier_params
+  params.require(:supplier).permit(products_attributes: [:name])
+end
+```
 
 ## Documentation
 

data/lib/store_model/configuration.rb

@@ -15,6 +15,10 @@ module StoreModel
     # @return [Boolean]
     attr_accessor :serialize_unknown_attributes
 
+    # Controls if the result of `as_json` will serialize enum fiels using `as_json`
+    # @return [Boolean]
+    attr_accessor :serialize_enums_using_as_json
+
     def initialize
       @serialize_unknown_attributes = true
     end

data/lib/store_model/model.rb

@@ -7,7 +7,7 @@ require "store_model/nested_attributes"
 
 module StoreModel
   # When included into class configures it to handle JSON column
-  module Model
+  module Model # rubocop:disable Metrics/ModuleLength
     def self.included(base) # :nodoc:
       base.include ActiveModel::Model
       base.include ActiveModel::Attributes
@@ -31,16 +31,27 @@ module StoreModel
     # @param options [Hash]
     #
     # @return [Hash]
-    def as_json(options = {})
+    def as_json(options = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       serialize_unknown_attributes = if options.key?(:serialize_unknown_attributes)
                                        options[:serialize_unknown_attributes]
                                      else
                                        StoreModel.config.serialize_unknown_attributes
                                      end
 
-      result = attributes.with_indifferent_access
+      serialize_enums_using_as_json = if options.key?(:serialize_enums_using_as_json)
+                                        options[:serialize_enums_using_as_json]
+                                      else
+                                        StoreModel.config.serialize_enums_using_as_json
+                                      end
+
+      result = @attributes.keys.each_with_object({}) do |key, values|
+        values[key] = serialized_attribute(key)
+      end.with_indifferent_access
+
       result.merge!(unknown_attributes) if serialize_unknown_attributes
-      result.as_json(options)
+      result.as_json(options).tap do |json|
+        serialize_enums!(json) if serialize_enums_using_as_json
+      end
     end
 
     # Returns an Object, similar to Hash#fetch, raises
@@ -167,17 +178,6 @@ module StoreModel
       @unknown_attributes ||= {}
     end
 
-    # Serialized values for storing in db
-    #
-    # @return [Hash]
-    def values_for_database
-      result = @attributes.keys.each_with_object({}) do |key, values|
-        values[key] = @attributes.fetch(key).value_for_database
-      end
-      result.merge!(unknown_attributes)
-      result
-    end
-
     private
 
     def attribute?(attribute)
@@ -186,5 +186,29 @@ module StoreModel
       else value.present?
       end
     end
+
+    def serialize_enums!(json)
+      enum_mappings =
+        self.class
+            .attribute_types
+            .select { |_, type| type.is_a?(StoreModel::Types::EnumType) }
+
+      enum_mappings.each do |name, _|
+        next unless json.key?(name)
+
+        json[name] = public_send(name).as_json unless json[name].nil?
+      end
+    end
+
+    def serialized_attribute(attr_name)
+      attr = @attributes.fetch(attr_name)
+      if attr.value.is_a? StoreModel::Model
+        Types::RawJSONEncoder.new(attr.value_for_database)
+      elsif attr.value.is_a? Array
+        attr.value.as_json
+      else
+        attr.value_for_database
+      end
+    end
   end
 end

data/lib/store_model/nested_attributes.rb

@@ -13,27 +13,54 @@ module StoreModel
       # @param associations [Array] list of associations and options to define attributes, for example:
       #   accepts_nested_attributes_for [:suppliers, allow_destroy: true]
       #
+      # Alternatively, use the standard Rails syntax:
+      #
+      # @param associations [Array] list of associations and attributes to define getters and setters.
+      #
+      # @param options [Hash] options not supported by StoreModel will still be passed to ActiveRecord.
+      #
       # Supported options:
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
       #   (e.g. 1, '1', true, or 'true'). This option is off by default.
-      def accepts_nested_attributes_for(*associations)
-        associations.each do |association, options|
-          case attribute_types[association.to_s]
-          when Types::One
-            define_association_setter_for_single(association, options)
-            alias_method "#{association}_attributes=", "#{association}="
-          when Types::Many
-            define_association_setter_for_many(association, options)
-          end
+      #
+      # [:reject_if]
+      #   Allows you to specify a Proc or a Symbol pointing to a method that
+      #   checks whether a record should be built for a certain attribute hash.
+      #   The hash is passed to the supplied Proc or the method and it should
+      #   return either true or false. Passing <tt>:all_blank</tt> instead of a Proc
+      #   will create a proc that will reject a record where all the attributes
+      #   are blank excluding any value for <tt>_destroy</tt>.
+      #
+      #   See https://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html#method-i-accepts_nested_attributes_for
+      def accepts_nested_attributes_for(*attributes)
+        global_options = attributes.extract_options!
 
-          define_attr_accessor_for_destroy(association, options)
+        attributes.each do |attribute, options|
+          case attribute_types[attribute.to_s]
+          when Types::OneBase, Types::ManyBase
+            define_store_model_attr_accessors(attribute, options || global_options)
+          else
+            super(attribute, options || global_options)
+          end
         end
       end
 
       private
 
+      def define_store_model_attr_accessors(attribute, options)
+        case attribute_types[attribute.to_s]
+        when Types::OneBase
+          define_association_setter_for_single(attribute, options)
+          alias_method "#{attribute}_attributes=", "#{attribute}="
+        when Types::ManyBase
+          define_association_setter_for_many(attribute, options)
+        end
+
+        define_attr_accessor_for_destroy(attribute, options)
+      end
+
       def define_attr_accessor_for_destroy(association, options)
         return unless options&.dig(:allow_destroy)
 
@@ -61,8 +88,6 @@ module StoreModel
       end
     end
 
-    private
-
     def assign_nested_attributes_for_collection_association(association, attributes, options)
       attributes = attributes.values if attributes.is_a?(Hash)
 
@@ -72,7 +97,20 @@ module StoreModel
         end
       end
 
+      attributes.reject! { |attribute| call_reject_if(attribute, options[:reject_if]) } if options&.dig(:reject_if)
+
       send("#{association}=", attributes)
     end
+
+    def call_reject_if(attributes, callback)
+      callback = ActiveRecord::NestedAttributes::ClassMethods::REJECT_ALL_BLANK_PROC if callback == :all_blank
+
+      case callback
+      when Symbol
+        method(callback).arity.zero? ? send(callback) : send(callback, attributes)
+      when Proc
+        callback.call(attributes)
+      end
+    end
   end
 end

data/lib/store_model/types/one.rb

@@ -46,9 +46,7 @@ module StoreModel
       # @return [String] serialized value
       def serialize(value)
         case value
-        when @model_klass
-          ActiveSupport::JSON.encode(value.values_for_database)
-        when Hash
+        when @model_klass, Hash
           ActiveSupport::JSON.encode(value)
         else
           super

data/lib/store_model/types/raw_json.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module StoreModel
+  module Types
+    # Implements #encode_json and #as_json methods.
+    # By wrapping serialized objects in this type, it prevents duplicate
+    # JSON serialization passes on nested object. It is named as Encoder
+    # as it will not work to inflate typed attributes and is intended
+    # to be used internally.
+    class RawJSONEncoder < String
+      def encode_json(_encoder)
+        self
+      end
+
+      def as_json(_options = nil)
+        JSON.parse(self)
+      end
+    end
+  end
+end

data/lib/store_model/types.rb

@@ -14,6 +14,8 @@ require "store_model/types/enum_type"
 
 require "store_model/types/one_of"
 
+require "store_model/types/raw_json"
+
 module StoreModel
   # Contains all custom types.
   module Types

data/lib/store_model/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StoreModel # :nodoc:
-  VERSION = "2.0.1"
+  VERSION = "2.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_model
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.1
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-09 00:00:00.000000000 Z
+date: 2023-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -115,6 +115,7 @@ files:
 - lib/store_model/types/one_of.rb
 - lib/store_model/types/one_polymorphic.rb
 - lib/store_model/types/polymorphic_helper.rb
+- lib/store_model/types/raw_json.rb
 - lib/store_model/version.rb
 homepage: https://github.com/DmitryTsepelev/store_model
 licenses: