store_model 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5678f8d809e7ed7745c5bd21b10bb455ecef32fac89cbc0fe9d5928c99dcf7c8
-  data.tar.gz: 13fd4acba36ff7b96d8111043de74e94442f63a02d718571fdda3682521e0dab
+  metadata.gz: 61353c039b8274db76c67d73081ce718a5446e392df4bd5987f4dde023d5b244
+  data.tar.gz: 40f5011957af3787650b1f3565468fc0b59a4c1a2e090735e8cbf9926e8b622e
 SHA512:
-  metadata.gz: e57e9ebc4b7e6547c75c8b0375742194eafa6104d2abfd2b55e9e657c64e2af935e99505bb712e8e1ef3d38123f4852d89603f10bfacfa620ec2cb38751995b6
-  data.tar.gz: a2c9e761568bc100697c7240762ed27aac4d8ccde2429f4e037357121351f120a1b9a17909f6670f0215691f909032131979ebbe0001d67bba1d2cadeebaadeb
+  metadata.gz: 5e3065c9503681ac881fe2e2b2194bfc9f9c959c66e4a6430b47160ff4487cc1bdc6f4408dfc72e216f94eae729ce8462e09ae12364e3e37ef5341769588a796
+  data.tar.gz: 427cb2dab39fd79ef74fb3b1a1e48f89003fbb2e00ca25488cea257cc9f87c9aad5eedb4c469252a605e5932420ad6e257898e85ab7622c904c7cec99c75af73

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

@@ -31,16 +31,24 @@ 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
 
+      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.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
@@ -186,5 +194,18 @@ 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
   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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StoreModel # :nodoc:
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 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.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-09 00:00:00.000000000 Z
+date: 2023-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord