pretty-api 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e020194708396186f0a862e8fcdfe24b4bba1d9ce4449f7261bef0c2a76451d2
-  data.tar.gz: fdf19f29e2a101b15a6f2bf4e48fcc84a5ae5bef7469c2eeea6490272cbe66e5
+  metadata.gz: 7ae1f5a395773d7742e4e8d35c5bd8ab123c474b5e0bef974b3f493b3149e97f
+  data.tar.gz: c501cd773a268868814c2c8ebe08dd425eea7be219c2f3d72e52cb292305aa0e
 SHA512:
-  metadata.gz: 3a4a6b834fc2d8b2c27be2d27bae71b6c366584227071299dcdf0fbd58fcde1d9225a9051dc470acfbe1213bed65e8556eb7c4cc6dd03df83f2df2f233b3a9ca
-  data.tar.gz: 883fd45dfb069e6fe71cde4603265ebab372bfbf0f64007b3aa1e76b164c1a9fdec5f5b143799162a0f8d4477746ea0c33d999b02b569af28bbe99808e92c6ab
+  metadata.gz: f6826d7e3534689df805027042f6e65282a29fcb08456c8384f5598b9c7727613de31e55d7daa92509e874ce2dd3dc2bb11c7f0b734bcfa3d3ffb1e197ad3e99
+  data.tar.gz: bf162d88d8828702df78a4e731f0dd4c64bdc1bebdd94cd61cece7f2a0047a622111de4460b513343cb5d38f3459643d12e8bd9918ab0f24e85611082caf2bf9

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.3.0] - 2024-06-01
+
+- Support for ActionController::Parameters from Rails
+- Support for self-referencing associations
+- Support for circular accepts_nested_attributes_for
+- Fix inaccurate destroy for nested attributes
+- More specs
+
 ## [0.1.0] - 2024-05-30
 
 - Initial release

data/internal.md

@@ -5,13 +5,26 @@ to avoid forgetting important implementations motivations.
 
 This gem can get a little confusing sometimes because `accepts_nested_attributes_for` can be used with any kind
 of associations (has_many, belongs_to, has_one, has_many_though, ...) and it can also be used to self reference itself
-or another association that reference itself. We must handle properly these use case to avoid infinite loop.
+or another association that reference itself. We must handle properly these use case properly to avoid infinite loop.
 
 We are able to extract the dependency tree of an association with the internal method `nested_attributes_tree`. This
-method is implemented in two formats: one that returns an array structure, one that returns an hash structure. The library
-itself doesn't make any use of two formats, however we do want to support to type of structure for better user
-experience and compatibility. This is mostly useful for unit testings but this allow users to use the structure they
-want when they pass manually the association tree to the public helpers method.
+method can be bypassed by passing explicitly your own structure. As of today, the structure looks like this
+
+```ruby
+{
+  CompanyCar => {
+    organization: { allow_destroy: true, model: Organization, type: :belongs_to } 
+  },
+  Organization => { 
+    company_car: { allow_destroy: true, model: CompanyCar, type: :has_one },
+    services: { allow_destroy: true, model: Service, type: :has_many } 
+  },
+  Phone => {},
+  Service => { 
+    phones: { allow_destroy: true, model: Phone, type: :has_many } 
+  }
+}
+```
 
 ### Notes on the pretty nested attributes implementation
 
@@ -20,6 +33,3 @@ lead to odd behavior or potential accidental data loss. We must rely on the prim
 given parameter. If not done properly, it would append in the parameters `{ id: ..., _destroy: true}` wrongly thinking
 some associations dont exist. I believe ActiveRecord would raise a RecordNotFound exception to protect against this
 scenario, however we have unit tests to protect against this scenario to avoid code regression in the future.
-
-Internally it infers automatically the dependency tree of a record by calling `nested_attributes_tree` or by receiving
-an hash or an array by the user explicitly. This is subject to the spoken hash or array format spoken earlier.

data/lib/pretty_api/active_record/associations.rb

@@ -1,52 +1,25 @@
 module PrettyApi
   module ActiveRecord
     class Associations
-      def self.nested_attributes_tree(model, structure = :array)
-        if structure == :array
-          nested_attributes_tree_array(model)
-        elsif structure == :hash
-          nested_attributes_tree_hash(model)
-        end
-      end
-
-      def self.nested_attributes_tree_hash(model, depth = {})
-        nested_attributes_descriptions(model).index_by { |a| a[:id] }.each_with_object({}) do |(key, assoc), result|
-          depth[key] ||= 0
+      def self.nested_attributes_tree(model, result = {})
+        model.nested_attributes_options.each_key do |association_name|
+          result[model] ||= {}
 
-          next unless depth[key] < PrettyApi.max_nested_attributes_depth
+          association = attribute_association(model, association_name)
+          association_class = association.class_name.constantize
 
-          depth[key] += 1
-          result[assoc[:name]] = nested_attributes_tree_hash(assoc[:model], depth)
-          depth[key] -= 1
-        end
-      end
-
-      def self.nested_attributes_tree_array(model, depth = {})
-        nested_attributes_descriptions(model).index_by { |a| a[:id] }.map do |(key, association)|
-          depth[key] ||= 0
-
-          next nil if depth[key] >= PrettyApi.max_nested_attributes_depth
+          result[model][association_name] = {
+            model: association_class,
+            type: association.macro,
+            allow_destroy: attribute_destroy_allowed?(model, association_name)
+          }
 
-          depth[key] += 1
-          result = { association[:name] => nested_attributes_tree_array(association[:model], depth) }
-          depth[key] -= 1
+          next if result.key?(association_class)
 
-          result.compact_blank.blank? ? association[:name] : result
-        end.compact_blank
-      end
-
-      def self.nested_attributes_descriptions(model)
-        model.nested_attributes_options.keys.map do |association_name|
-          association_model = attribute_association_class(model, association_name)
-          {
-            id: "#{model}_#{association_name}",
-            name: association_name,
-            model: association_model,
-            associations: association_model.nested_attributes_options.keys.map do |n|
-              attribute_association_class(association_model, n)
-            end
-          }
+          result[association_class] = {}
+          nested_attributes_tree(association_class, result)
         end
+        result
       end
 
       def self.attribute_destroy_allowed?(model, attribute)
@@ -56,18 +29,6 @@ module PrettyApi
       def self.attribute_association(model, attribute)
         model.reflect_on_association(attribute).chain.last
       end
-
-      def self.attribute_association_class(model, attribute)
-        model.reflect_on_association(attribute).class_name.constantize
-      end
-
-      def self.association_type(association)
-        association.macro
-      end
-
-      def self.association_primary_key(association)
-        association.class_name.constantize.primary_key
-      end
     end
   end
 end

data/lib/pretty_api/errors/nested_errors.rb

@@ -1,56 +1,53 @@
 module PrettyApi
   module Errors
     class NestedErrors
-      def self.parsed_nested_errors(record, attrs)
+      def initialize(nested_tree:)
+        @nested_tree = nested_tree
+      end
+
+      def parse(record)
         errors = record_only_errors(record)
 
-        return errors if attrs.blank?
+        return errors if nested_tree.blank?
 
-        parse_deep_nested_errors(record, attrs, errors)
+        parse_deep_nested_errors(record, nested_tree[record.class], errors)
 
         PrettyApi::Utils::Hash.deep_compact_blank(errors)
       end
 
-      def self.parse_deep_nested_errors(record, attrs, result, parent_record = nil)
-        case attrs
-        when Hash
-          attrs.each do |key, value|
-            parse_association_errors(record, key, value, result, parent_record)
-          end
-        when Array
-          attrs.each { |value| parse_deep_nested_errors record, value, result, parent_record }
-        else
-          parse_association_errors(record, attrs, nil, result, parent_record)
-        end
-      end
+      private
+
+      attr_reader :nested_tree
 
-      def self.parse_association_errors(record, attr, nested_attrs, result, parent_record)
-        association = record.send(attr)
+      def parse_deep_nested_errors(record, attrs, result, parent_record = nil)
+        attrs.each do |assoc_key, assoc_info|
+          association = record.send(assoc_key)
 
-        return if association.blank?
-        return if association == parent_record
+          next if association.blank?
+          next if association == parent_record
 
-        if association.respond_to? :to_a
-          parse_has_many_errors(record, association, attr, nested_attrs, result)
-        else
-          parse_has_one_errors(record, association, attr, nested_attrs, result)
+          if association.respond_to? :to_a
+            parse_has_many_errors(record, association, assoc_key, assoc_info, result)
+          else
+            parse_has_one_errors(record, association, assoc_key, assoc_info, result)
+          end
         end
       end
 
-      def self.parse_has_many_errors(record, associations, attr, nested_attrs, result)
-        result[attr] = {}
+      def parse_has_many_errors(record, associations, assoc_key, assoc_info, result)
+        result[assoc_key] = {}
         associations.each_with_index do |association, i|
-          result[attr][i] = record_only_errors(association)
-          parse_deep_nested_errors association, nested_attrs, result[attr][i], record if nested_attrs.present?
+          result[assoc_key][i] = record_only_errors(association)
+          parse_deep_nested_errors association, nested_tree[assoc_info[:model]], result[assoc_key][i], record
         end
       end
 
-      def self.parse_has_one_errors(record, association, attr, nested_attrs, result)
-        result[attr] = record_only_errors(association)
-        parse_deep_nested_errors association, nested_attrs, result[attr], record if nested_attrs.present?
+      def parse_has_one_errors(record, association, assoc_key, assoc_info, result)
+        result[assoc_key] = record_only_errors(association)
+        parse_deep_nested_errors association, nested_tree[assoc_info[:model]], result[assoc_key], record
       end
 
-      def self.record_only_errors(record)
+      def record_only_errors(record)
         record.errors.as_json.reject { |k, _v| k.to_s.include?(".") }
       end
     end

data/lib/pretty_api/helpers.rb

@@ -8,13 +8,13 @@ module PrettyApi
 
         attrs ||= PrettyApi::ActiveRecord::Associations.nested_attributes_tree(record.class)
 
-        PrettyApi::Parameters::NestedAttributes.parse_nested_attributes(record, params, attrs)
+        PrettyApi::Parameters::NestedAttributes.new(nested_tree: attrs).parse(record, params)
       end
 
       def pretty_nested_errors(record, attrs = nil)
         attrs ||= PrettyApi::ActiveRecord::Associations.nested_attributes_tree(record.class)
 
-        PrettyApi::Errors::NestedErrors.parsed_nested_errors(record, attrs)
+        PrettyApi::Errors::NestedErrors.new(nested_tree: attrs).parse(record)
       end
     end
   end

data/lib/pretty_api/parameters/nested_attributes.rb

@@ -1,66 +1,66 @@
 module PrettyApi
   module Parameters
     class NestedAttributes
-      def self.parse_nested_attributes(record, params, attrs)
+      def initialize(nested_tree:)
+        @nested_tree = nested_tree
+      end
+
+      def parse(record, params)
+        parse_nested_attributes(record, params, nested_tree[record.class])
+      end
+
+      private
+
+      attr_reader :nested_tree
+
+      def parse_nested_attributes(record, params, attrs)
         return {} if params.blank?
 
-        case attrs
-        when Hash, Array
-          parse_deep_nested_attributes(record, params, attrs)
-        when String, Symbol
-          if params.key?(attrs)
-            include_associations_to_destroy(record, params, attrs)
-            params["#{attrs}_attributes"] = params.delete(attrs)
-          end
+        attrs.each do |assoc_key, assoc_info|
+          next unless params.key?(assoc_key)
+
+          parse_deep_nested_attributes(record, params, assoc_key, assoc_info)
+
+          include_associations_to_destroy(record, params, assoc_key, assoc_info)
+          params["#{assoc_key}_attributes"] = params.delete(assoc_key)
         end
 
         params
       end
 
-      def self.parse_deep_nested_attributes(record, params, attrs)
-        case attrs
-        when Hash
-          attrs.each do |assoc_key, nested_assoc|
-            if params[assoc_key].is_a? Array
-              parse_has_many_association(record, params, assoc_key, nested_assoc)
-            else
-              parse_has_one_association(record, params, assoc_key, nested_assoc)
-            end
-            parse_nested_attributes(record, params, assoc_key)
-          end
-        when Array
-          attrs.each { |assoc_or_nested_assoc| parse_nested_attributes(record, params, assoc_or_nested_assoc) }
+      def parse_deep_nested_attributes(record, params, assoc_key, assoc_info)
+        if assoc_info[:type] == :has_many
+          parse_has_many_association(record, params, assoc_key, assoc_info)
+        else
+          parse_has_one_association(record, params, assoc_key, assoc_info)
         end
       end
 
-      def self.parse_has_many_association(record, params, assoc_key, nested_assoc)
-        params[assoc_key].each do |p|
+      def parse_has_many_association(record, params, assoc_key, assoc_info)
+        (params[assoc_key] || []).each do |p|
           assoc_primary_key = record.try(:class).try(:primary_key)
           assoc = record.try(assoc_key).try(:detect) { |r| r.try(assoc_primary_key) == p[assoc_primary_key] }
-          parse_nested_attributes(assoc, p, nested_assoc)
+          parse_nested_attributes(assoc, p, nested_tree[assoc_info[:model]])
         end
       end
 
-      def self.parse_has_one_association(record, params, assoc_key, nested_assoc)
-        parse_nested_attributes(record.try(assoc_key), params[assoc_key], nested_assoc)
+      def parse_has_one_association(record, params, assoc_key, assoc_info)
+        parse_nested_attributes(record.try(assoc_key), params[assoc_key], nested_tree[assoc_info[:model]])
       end
 
-      def self.include_associations_to_destroy(record, params, attr)
+      def include_associations_to_destroy(record, params, assoc_key, assoc_info)
         return unless PrettyApi.destroy_missing_associations && record.present?
 
-        association = PrettyApi::ActiveRecord::Associations.attribute_association(record.class, attr)
-
-        return unless PrettyApi::ActiveRecord::Associations.attribute_destroy_allowed?(record.class, attr)
-
-        primary_key = PrettyApi::ActiveRecord::Associations.association_primary_key(association)
+        return unless assoc_info[:allow_destroy]
 
-        assoc_type = PrettyApi::ActiveRecord::Associations.association_type(association)
+        primary_key = assoc_info[:model].primary_key
+        assoc_type = assoc_info[:type]
 
-        include_has_many_to_destroy(record, params, attr, primary_key) if assoc_type == :has_many
-        include_has_one_to_destroy(record, params, attr, primary_key) if assoc_type.in?(%i[has_one belongs_to])
+        include_has_many_to_destroy(record, params, assoc_key, primary_key) if assoc_type == :has_many
+        include_has_one_to_destroy(record, params, assoc_key, primary_key) if assoc_type.in?(%i[has_one belongs_to])
       end
 
-      def self.include_has_many_to_destroy(record, params, attr, primary_key)
+      def include_has_many_to_destroy(record, params, attr, primary_key)
         ids_to_destroy = PrettyApi::ActiveRecord::Orm
                            .where_not(record.send(attr), primary_key, params[attr].pluck(primary_key))
                            .pluck(primary_key)
@@ -68,7 +68,7 @@ module PrettyApi
         params[attr].push(*ids_to_destroy.map { |id| { primary_key => id, _destroy: true } })
       end
 
-      def self.include_has_one_to_destroy(record, params, attr, primary_key)
+      def include_has_one_to_destroy(record, params, attr, primary_key)
         association_id = record.send(attr).try(primary_key)
 
         return if association_id.blank?

data/lib/pretty_api/version.rb

@@ -1,3 +1,3 @@
 module PrettyApi
-  VERSION = "0.2.0".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/pretty_api.rb

@@ -11,7 +11,4 @@ require_relative "pretty_api/parameters/nested_attributes"
 module PrettyApi
   singleton_class.attr_accessor :destroy_missing_associations
   self.destroy_missing_associations = true
-
-  singleton_class.attr_accessor :max_nested_attributes_depth
-  self.max_nested_attributes_depth = 1
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pretty-api
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - James St-Pierre