para 0.9.0 → 0.9.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d193279195926cf9c9d771bc66d9d0087bfe61ff9e7662f1c66833278088dc1
-  data.tar.gz: deaba7951bc96c94bf6175bf55061b2d14f988d9f992d538e27774ad21587a78
+  metadata.gz: 8f742ef6484e0ccd595c1a79e219f4cb2a03c72a7fbf9f584990c638412f19e0
+  data.tar.gz: 8c231925d6c2ecc4d0eb7208c5c4b530410d1a30d8a1276d849f31d3e52f5f76
 SHA512:
-  metadata.gz: '0584c068c6a24a3a8a9c9a608f4c2288644df56ca6b34007c98da511ab22ec55178ff1462d43e411a43ecf4b00cc0dcbc05b7529ba6c2643302b8b8930c96810'
-  data.tar.gz: 54d4160767fce3095334d2d81c370cf3fc103d07ef0db5afe1b180c2325fde2cd727d3db5c541bfe49395f607d69667b4fa83b33df22c1a06b22a619ecfa2981
+  metadata.gz: e42df31fcb4d4d490f5b5127939494fbc9e07855ee1123fd720f089c2e36737b4e1f706b347d36699270ed00eeeb4a228ca81050bdc8ae35b84bbde8a7dfd7b6
+  data.tar.gz: 707696ad2b1f6a2c43f6944f6543ca5dd8dd5a17c3c91942d0d3c38b43e5d2c652d1b76a35409c2de0019c11658f81a6922931d3e4126a6490a77ed189bd8e8a

data/app/assets/javascripts/para/inputs/nested_many.coffee

@@ -5,7 +5,7 @@ class Para.NestedManyField
     @initializeOrderable()
     @initializeCocoon()
 
-    @$field.on 'shown.bs.collapse', $.proxy(@collapseShown, this)
+    @$field.on 'shown.bs.collapse', @stoppingPropagation(@collapseShown)
 
   initializeOrderable: ->
     @orderable = @$field.hasClass('orderable')
@@ -21,11 +21,17 @@ class Para.NestedManyField
       $(el).find('.resource-position-field').val(i)
 
   initializeCocoon: ->
-    @$fieldsList.on 'cocoon:after-insert', $.proxy(@afterInsertField, this)
-    @$fieldsList.on 'cocoon:before-remove', $.proxy(@beforeRemoveField, this)
-    @$fieldsList.on 'cocoon:after-remove', $.proxy(@afterRemoveField, this)
+    @$fieldsList.on 'cocoon:after-insert', @stoppingPropagation(@afterInsertField)
+    @$fieldsList.on 'cocoon:before-remove', @stoppingPropagation(@beforeRemoveField)
+    @$fieldsList.on 'cocoon:after-remove', @stoppingPropagation(@afterRemoveField)
 
-  afterInsertField: (e, $element) ->
+  stoppingPropagation: (callback) =>
+    (e, args...) =>
+      e.stopPropagation()
+      callback(e, args...)
+
+
+  afterInsertField: (e, $element) =>
     if ($collapsible = $element.find('[data-open-on-insert="true"]')).length
       @openInsertedField($collapsible)
 
@@ -36,21 +42,21 @@ class Para.NestedManyField
 
     $element.simpleForm()
 
-  beforeRemoveField: (e, $element) ->
+  beforeRemoveField: (e, $element) =>
     $nextEl = $element.next()
     # Remove attributes mappings field for new records since it will try to
     # create an empty nested resource otherwise
     $nextEl.remove() if $nextEl.is('[data-attributes-mappings]') and not $element.is('[data-persisted]')
 
   # When a sub field is removed, update every sub field position
-  afterRemoveField: ->
+  afterRemoveField: =>
     @handleOrderingUpdated();
 
   openInsertedField: ($field) ->
     $target = $($field.attr('href'))
     $target.collapse('show')
 
-  collapseShown: (e) ->
+  collapseShown: (e) =>
     $target = $(e.target)
 
     if $target.is("[data-rendered]") or $target.data("rendered")

data/app/controllers/para/admin/exports_controller.rb

@@ -8,7 +8,7 @@ module Para
       def create
         job = @exporter.perform_later(
           model_name: @component.try(:model).try(:name),
-          search: params[:q],
+          search: params[:q]&.permit!,
           params: params.permit(@exporter.params_whitelist).to_h
         )
 

data/app/controllers/para/admin/nested_forms_controller.rb

@@ -5,6 +5,7 @@ module Para
         @model = params[:model_name].constantize
         @object = params[:id] ? @model.find(params[:id]) : @model.new
         @object_name = params[:object_name]
+        @builder_options = params[:builder_options]&.permit! || {}
 
         render layout: false
       end

data/app/views/para/admin/nested_forms/show.html.haml

@@ -1,6 +1,15 @@
 - nested_form = nil
 
-- para_form_for(@object, url: "") do |form|
+-# Initialize an unredered form builder that will only be used to create the nested fields
+-# by using the yielded block form builder argument.
+-#
+-# The form's object name is set through the provided :object_name param to ensure that
+-# the form inputs are named correctly in the loading form.
+-#
+-# Builder options allow to customize the options passed to the form builder to customize
+-# the rendered partials.
+-#
+- para_form_for(@object, @builder_options.merge(url: "")) do |form|
   - form.object_name = @object_name
   - nested_form = capture do
     = render(partial: find_partial_for(@model, :remote_nested_form), locals: { form: form, model: @model, object: @object, object_name: @object_name })

data/app/views/para/admin/resources/_navigation.html.haml

@@ -1,10 +1,13 @@
 .top-nav-tabs-affix-placeholder
   %ul.top-nav-tabs-affix.nav.nav-tabs{ role: "tablist", "data-top-level-affix": true }
-    %li{ class: ("active" if active_component == parent_component) }
-      = link_to parent_component.path do
-        = parent_component.name
+    - if can?(:manage, parent_component) && show_component?(parent_component)
+      %li{ class: ("active" if active_component == parent_component) }
+        = link_to parent_component.path do
+          = parent_component.name
 
     - parent_component.child_components.each do |child_component|
+      - next unless can?(:manage, child_component) && show_component?(child_component)
+
       %li{ class: ("active" if active_component == child_component) }
         = link_to child_component.path do
           = child_component.name

data/app/views/para/admin/resources/_remote_nested_form.html.haml

@@ -1 +1 @@
-= render partial: find_partial_for(model, :fields), locals: { form: form }
+= render partial: find_partial_for(model, form.nested_fields_partial_name), locals: { form: form }

data/app/views/para/inputs/_nested_many.html.haml

@@ -2,6 +2,7 @@
   .fields-list{ id: dom_identifier }
     = form.simple_fields_for attribute_name, resources, nested_attribute_name: attribute_name, orderable: orderable, track_attribute_mappings: render_partial do |nested_form|
       = render partial: find_partial_for(model, 'nested_many/container', partial_dir: 'inputs'), locals: { form: nested_form, model: nested_form.object.class, subclass: subclass, nested_locals: nested_locals, inset: inset, uncollapsed: uncollapsed, render_partial: render_partial, remote_partial_params: remote_partial_params }
+
   -# Add button
   - if add_button
     - if subclass

data/app/views/para/inputs/_nested_one.html.haml

@@ -6,7 +6,7 @@
           = render partial: find_partial_for(model, 'nested_one/container', partial_dir: 'inputs'), locals: { nested_form: nested_form, form: form, model: nested_form.object.class, subclass: subclass, nested_locals: nested_locals }
 
     - else
-      = render partial: find_partial_for(model, :fields), locals: { form: nested_form, parent: form.object }.merge(nested_locals)
+      = render partial: find_partial_for(model, form.nested_fields_partial_name), locals: { form: nested_form, parent: form.object }.merge(nested_locals)
 
   - if defined?(subclass) && subclass
-    = render partial: 'para/inputs/nested_one/add_with_subclasses', locals: { form: form, model: model, dom_identifier: dom_identifier, nested_locals: nested_locals, attribute_name: attribute_name, subclasses: subclasses, add_button_label: add_button_label, add_button_class: add_button_class, subclass: subclass }
+    = render partial: 'para/inputs/nested_one/add_with_subclasses', locals: { form: form, model: model, dom_identifier: dom_identifier, nested_locals: nested_locals, attribute_name: attribute_name, subclasses: subclasses, add_button_label: add_button_label, add_button_class: add_button_class, subclass: subclass }

data/app/views/para/inputs/nested_many/_container.html.haml

@@ -14,7 +14,7 @@
   .panel-collapse.form-inputs.collapse{ id: form.nested_resource_dom_id, class: ('in' if uncollapsed && form.object.persisted?), data: { rendered: render_partial, render_path: @component.path(remote_partial_params), id: form.object.id, :"object-name" => form.object_name, :"model-name" => model.name } }
     .panel-body{ data: { :"nested-form-container" => true } }
       - if render_partial
-        = render partial: find_partial_for(model, :fields), locals: { form: form }.merge(nested_locals)
+        = render partial: find_partial_for(model, form.nested_fields_partial_name), locals: { form: form }.merge(nested_locals)
       - else
         = fa_icon "spinner spin"
 

data/app/views/para/inputs/nested_one/_container.html.haml

@@ -6,4 +6,4 @@
         %i.fa.fa-angle-up
 
   .panel-body.panel-collapse.form-inputs.collapse{ id: nested_form.nested_resource_dom_id }
-    = render partial: find_partial_for(model, :fields), locals: { form: nested_form, parent: nested_form.object }.merge(nested_locals)
+    = render partial: find_partial_for(model, form.nested_fields_partial_name), locals: { form: nested_form, parent: nested_form.object }.merge(nested_locals)

data/lib/para/cloneable/attachments_cloner.rb

@@ -1,36 +1,90 @@
 module Para
   module Cloneable
     class AttachmentsCloner
-      attr_reader :original, :clone
+      attr_reader :original, :clone, :dictionary
 
-      def initialize(original, clone)
+      # Handle both one and many attachment relations
+      ATTACHMENTS_RELATION_REGEX = /_attachments?\z/
+
+      def initialize(original, clone, dictionary)
         @original = original
         @clone = clone
+        @dictionary = dictionary
       end
-      
+
       def clone!
         return unless defined?(ActiveStorage)
-        
-        attachment_reflections = original.class.reflections.select { |k, v| 
-          k.to_s.match(/_attachment\z/) && 
-          v.options[:class_name] == "ActiveStorage::Attachment" 
-        }
+
+        attachment_reflections = original.class.reflections.select do |name, reflection|
+          name.to_s.match(ATTACHMENTS_RELATION_REGEX) &&
+          reflection.options[:class_name] == "ActiveStorage::Attachment"
+        end
 
         attachment_reflections.each do |name, reflection|
-          original_attachment = original.send(name)
-          next unless original_attachment
-          
-          association_name = name.gsub(/_attachment\z/, "")
-
-          Para::ActiveStorageDownloader.new(original_attachment).download_blob_to_tempfile do |tempfile|
-            clone.send(association_name).attach({
-              io: tempfile,
-              filename: original_attachment.blob.filename,
-              content_type: original_attachment.blob.content_type
-            })
+          association_target = original.send(name)
+          next unless association_target
+
+          if reflection.collection?
+            association_target.each do |attachment|
+              clone_attachment(name, attachment)
+            end
+          else
+            clone_attachment(name, association_target)
           end
         end
       end
+
+      def clone_attachment(name, original_attachment)
+        association_name = name.gsub(ATTACHMENTS_RELATION_REGEX, "")
+        original_blob = original_attachment.blob
+
+        # Handle missing file in storage service by bypassing the attachment cloning
+        return unless ActiveStorage::Blob.service.exist?(original_blob&.key)
+
+        Para::ActiveStorageDownloader.new(original_attachment).download_blob_to_tempfile do |tempfile|
+          attachment_target = clone.send(association_name)
+
+          attachment_target.attach({
+            io: tempfile,
+            filename: original_blob.filename,
+            content_type: original_blob.content_type
+          })
+
+          cloned_attachment = find_cloned_attachment(attachment_target, original_blob)
+
+          # Store the cloned attachment and blob into the deep_cloneable dictionary used
+          # by the `deep_clone` method to ensure that, if needed during the cloning
+          # operation, they won't be cloned once more and are accessible for processing
+          store_cloned(original_attachment, cloned_attachment)
+          store_cloned(original_blob, cloned_attachment.blob)
+        end
+      end
+
+      # Seemlessly handle one and many attachment relations return values and fetch
+      # the attachment that we just cloned by comparing blobs checksum, as depending
+      # which ActiveStorage version we're on (Rails 5.2 or 6), the `#attach` method
+      # doesn't always return the same, so for now we still handle the Rails 5.2 case.
+      def find_cloned_attachment(attachment_target, original_blob)
+        attachments = if attachment_target.attachments.any?
+          attachment_target.attachments
+        else
+          [attachment_target.attachment]
+        end
+
+        attachment = attachments.find do |att|
+          att.blob.checksum == original_blob.checksum
+        end
+      end
+
+      # This stores the source and clone resources into the deep_clone dictionary, which
+      # simulates what the deep_cloneable gem does when it clones a resource
+      #
+      def store_cloned(source, clone)
+        store_key = source.class.name.tableize.to_sym
+
+        dictionary[store_key] ||= {}
+        dictionary[store_key][source] = clone
+      end
     end
   end
-end
+end

data/lib/para/cloneable/include_tree_builder.rb

@@ -1,67 +1,196 @@
+# frozen_string_literal: true
+
 module Para
   module Cloneable
+    # This object acts as a service to compile a nested cloneable options hash to be
+    # provided to the `deep_clone` method from the `deep_cloneable` gem. It iterates over
+    # every reflections that must be included for a given model when it's cloned, and
+    # creates a nested hash of :include and :except directives based on the tree that
+    # is created by nested `acts_as_cloneable` calls on the different models of the
+    # application
+    #
+    # Example :
+    #
+    #   Given the following model structure :
+    #
+    #     class Article < ApplicationRecord
+    #       acts_as_cloneable :category, :comments, except: [:publication_date]
+    #
+    #       belongs_to :category
+    #       has_many :comments
+    #     end
+    #
+    #     class Category < ApplicationRecord
+    #       acts_as_cloneable :category, except: [:articles_count]
+    #
+    #       has_many :articles
+    #     end
+    #
+    #     class Comment < ApplicationRecord
+    #       acts_as_cloneable :author
+    #
+    #       belongs_to :article
+    #       belongs_to :author
+    #     end
+    #
+    #     class Author < ApplicationRecord
+    #       acts_as_cloneable except: [:email]
+    #
+    #       has_many :articles
+    #     end
+    #
+    #   The behavior would be :
+    #
+    #     Para::Cloneable::IncludeTreeBuilder.new(article).build
+    #     # => {
+    #            include: [:category, { comments: :author }],
+    #            except: [:publication_date, {
+    #              category: [:articles_count],
+    #              comments: { author: [:email] }
+    #            }]
+    #          }
+    #
     class IncludeTreeBuilder
-      attr_reader :resource,  :cloneable_options
+      attr_reader :resource, :cloneable_options
 
-      def initialize(resource, cloneable_options)
+      def initialize(resource)
         @resource = resource
-        @cloneable_options = cloneable_options.deep_dup
+        @cloneable_options = resource.cloneable_options.deep_dup
       end
-      
+
       def build
-        include_tree = build_cloneable_tree(resource, cloneable_options[:include])
-        cloneable_options[:include] = clean_include_tree(include_tree)
-        cloneable_options
+        options_tree = build_cloneable_options_tree(resource)
+        exceptions = extract_exceptions_from(options_tree)
+        inclusions = clean_options_tree(options_tree)
+        cloneable_options.merge(include: inclusions, except: exceptions)
       end
-      
+
       private
 
-      def build_cloneable_tree(resource, include)
-        include.each_with_object({}) do |reflection_name, hash|
+      # The cloneable options tree iterates over the resources' relations that are
+      # declared as included in the cloneable_options of the provided resource, and
+      # recursively checks included relations for its associated resources.
+      #
+      # It returns a nested hash with the included relations and their :except array
+      # if it exist, which include the attributes that shouldn't be duplicated when
+      # the resource is cloned.
+      #
+      def build_cloneable_options_tree(resource, path = [])
+        cloneable_options = resource.cloneable_options
+
+        # Iterate over the resource's cloneable options' :include array and recursively
+        # add nested included resources to its own included resources.
+        options = cloneable_options[:include].each_with_object({}) do |reflection_name, hash|
+          # This avoids cyclic dependencies issues by stopping nested association
+          # inclusions before the cycle starts.
+          #
+          # For example, if a post includes its author, and the author includes its posts,
+          # this would make the system fail with a stack level too deep error. Here this
+          # guard allows the inclusion to stop at :
+          #
+          #   { posts: { author: { posts: { author: {}}}}}
+          #
+          # Which ensures that, using the dictionary strategy of deep_cloneable, all
+          # posts' authors' posts will have their author mapped to an already cloned
+          # author when it comes to cloning the "author" 4th level of the include tree.
+          #
+          # This is not the most optimized solution, but works well enough as if the
+          # author's posts match previously cloned posts, they won't be cloned as they'll
+          # exist in the cloned resources dictionary.
+          next if path.length >= 4 &&
+                  path[-4] == path[-2] &&
+                  path[-2] == reflection_name &&
+                  path[-3] == path[-1]
+
           hash[reflection_name] = {}
 
-          if (reflection = resource.class.reflections[reflection_name.to_s])
-            reflection_options = hash[reflection_name]
-            association_target = resource.send(reflection_name)
-            
-            if reflection.collection?
-              association_target.each do |nested_resource|
-                add_reflection_options(reflection_options, nested_resource)
-              end
-            else
-              add_reflection_options(reflection_options, association_target)
+          unless (reflection = resource.class.reflections[reflection_name.to_s])
+            next
+          end
+
+          reflection_options = hash[reflection_name]
+          association_target = resource.send(reflection_name)
+
+          if reflection.collection?
+            association_target.each do |nested_resource|
+              add_reflection_options(
+                reflection_options,
+                nested_resource,
+                [*path, reflection_name]
+              )
             end
-          end      
+          else
+            add_reflection_options(
+              reflection_options,
+              association_target,
+              [*path, reflection_name]
+            )
+          end
         end
+
+        # Add the :except array from the resource to the current options hash and merge
+        # it if one already exist from another resource of the same class.
+        options[:except] ||= []
+        options[:except] |= Array.wrap(cloneable_options[:except])
+
+        options
       end
 
-      def add_reflection_options(reflection_options, nested_resource)
+      def add_reflection_options(reflection_options, nested_resource, path)
         options = nested_resource.class.try(:cloneable_options)
         return reflection_options unless options
-        
-        include_options = options[:include]
-        target_options = build_cloneable_tree(nested_resource, include_options)
+
+        target_options = build_cloneable_options_tree(nested_resource, path)
         reflection_options.deep_merge!(target_options)
       end
 
-      def clean_include_tree(tree)
+      # Iterates over the generated options tree to extract all the nested :except options
+      # into their own separate hash, removing :except keys from the original options
+      # tree hash.
+      #
+      def extract_exceptions_from(tree)
+        exceptions = tree.delete(:except) || []
+        nested_exceptions = {}
+
+        tree.each do |key, value|
+          next unless value.is_a?(Hash) && !value.empty?
+
+          sub_exceptions = extract_exceptions_from(value)
+          nested_exceptions[key] = sub_exceptions unless sub_exceptions.empty?
+        end
+
+        exceptions += [nested_exceptions] unless nested_exceptions.empty?
+        exceptions
+      end
+
+      # Iterates over the remaining options tree hash and converts empty hash values' keys
+      # to be stored in an array, and returns an array of symbols and hashes that is
+      # compatible with what is expected as argument for the :include option of the
+      # `deep_clone` method.
+      #
+      # Example :
+      #
+      #   clean_options_tree({ category: {}, comments: { author: {} } })
+      #   # => [:category, { comments: [:author] }]
+      #
+      def clean_options_tree(tree)
         shallow_relations = []
         deep_relations = {}
-        
+
         tree.each do |key, value|
+          # If the value is an empty hash, consider it as a shallow relation and add
+          # it to the shallow relations array
           if !value || value.empty?
             shallow_relations << key
+          # If the value is a hash with nested keys, process its nested values and add
+          # the result to the deep relations hash
           else
-            deep_relations[key] = clean_include_tree(value)
+            deep_relations[key] = clean_options_tree(value)
           end
         end
 
-        if deep_relations.empty?
-          shallow_relations
-        else
-          shallow_relations + [deep_relations]
-        end
+        deep_relations.empty? ? shallow_relations : shallow_relations + [deep_relations]
       end
     end
   end
-end
+end

data/lib/para/cloneable.rb

@@ -17,12 +17,14 @@ module Para
     # macro.
     #
     def deep_clone!(options = {})
-      processed_options = Para::Cloneable::IncludeTreeBuilder.new(self, cloneable_options).build
+      dictionary = options[:dictionary] ||= {}
+
+      processed_options = Para::Cloneable::IncludeTreeBuilder.new(self).build
       options = options.reverse_merge(processed_options)
       callback = build_clone_callback(options.delete(:prepare))
-      
+
       deep_clone(options) do |original, clone|
-        Para::Cloneable::AttachmentsCloner.new(original, clone).clone!
+        Para::Cloneable::AttachmentsCloner.new(original, clone, dictionary).clone!
         callback&.call(original, clone)
       end
     end
@@ -63,9 +65,23 @@ module Para
         # if other sibling models don't define those relations
         options[:skip_missing_associations] = true
 
-        self.cloneable_options = options.reverse_merge({
+        # If `acts_as_cloneable` is called multiple times, for example by a parent class
+        # and the by its subclass, ensure that we don't lose the previously defined
+        # cloneable options, to avoid having to repeat the same include options in each
+        # subclass, if it has to define subclass specific cloneable options.
+        previous_cloneable_options = cloneable_options || {}
+
+        # Prepare the new cloneable options hash with the provided arguments
+        new_cloneable_options = options.reverse_merge({
           include: args
         })
+
+        # Merges previous and new cloneable options into the cloneable_options class
+        # attribute, also merging the `:include` array
+        self.cloneable_options =
+          previous_cloneable_options.merge(new_cloneable_options) do |key, a, b|
+            a.is_a?(Array) && b.is_a?(Array) ? (a + b).uniq : b
+          end
       end
 
       def cloneable?

data/lib/para/components_configuration.rb

@@ -34,16 +34,24 @@ module Para
     def section_for(identifier)
       if (section = sections_cache[identifier])
         section
-      elsif (section_id = sections_ids_hash[identifier])
-        sections_cache[identifier] = Para::ComponentSection.find(section_id)
+      else
+        sections_cache[identifier] = if (section_id = sections_ids_hash[identifier])
+          Para::ComponentSection.find(section_id)
+        else
+          Para::ComponentSection.find_by(identifier: identifier)
+        end
       end
     end
 
     def component_for(identifier)
       if (component = components_cache[identifier])
         component
-      elsif (component_id = components_ids_hash[identifier])
-        components_cache[identifier] = Para::Component::Base.find(component_id)
+      else
+        components_cache[identifier] = if (component_id = components_ids_hash[identifier])
+          Para::Component::Base.find(component_id)
+        else
+          Para::Component::Base.find_by(identifier: identifier)
+        end
       end
     end
 

data/lib/para/engine.rb

@@ -24,6 +24,7 @@ module Para
 
     initializer 'Para Cloneable' do
       ActiveSupport.on_load(:active_record) do
+        prepend Para::Ext::DeepCloneExtension
         include Para::Cloneable
       end
     end

data/lib/para/ext/deep_cloneable.rb

@@ -0,0 +1,26 @@
+require "deep_cloneable/deep_clone"
+
+module Para
+  module Ext
+    module DeepCloneExtension
+      # Override the default deep_cloneable method to avoid nested :except rules that target
+      # polymorphic relations to try to assign default values to unexisting attributes on
+      # models that don't define the excluded attribute
+      #
+      # For example, we can have :
+      #
+      #   { except: { comments: { author: [:confirmation_token] } } }
+      #
+      # Because some comments have a an author that's a user, and the user `acts_as_cloneable`
+      # macro defines `{ except: [:confirmation_token] }`, but if one of the comments has
+      # an anonymous user in its author relation, this method would faild with a
+      # ActiveModel::MissingAttributeError.
+      #
+      def dup_default_attribute_value_to(kopy, attribute, origin)
+        return unless kopy.attributes.keys.include?(attribute.to_s)
+
+        kopy[attribute] = origin.class.column_defaults.dup[attribute.to_s]
+      end
+    end
+  end
+end

data/lib/para/ext.rb

@@ -10,6 +10,7 @@ module Para
 end
 
 require 'para/ext/paperclip'
+require 'para/ext/deep_cloneable'
 require 'para/ext/active_job_status'
 require 'para/ext/active_record_nested_attributes'
 require 'para/ext/request_iframe_xhr'

data/lib/para/form_builder/nested_form.rb

@@ -76,6 +76,14 @@ module Para
         nested? && options[:parent_builder].object
       end
 
+      # Returns the partial name to be looked up for rendering used inside the nested
+      # fields partials, for the nested fields container and the remote nested fields
+      # partial.
+      #
+      def nested_fields_partial_name
+        :fields
+      end
+
       private
 
       def default_resource_name

data/lib/para/inputs/nested_many_input.rb

@@ -3,7 +3,7 @@ module Para
     class NestedManyInput < NestedBaseInput
       attr_reader :resource
 
-      def input(wrapper_options = nil)
+      def input(_wrapper_options = nil)
         input_html_options[:class] << "nested-many"
 
         orderable = options.fetch(:orderable, model.orderable?)
@@ -40,6 +40,8 @@ module Para
         end
       end
 
+      private
+
       def parent_model
         @parent_model ||= @builder.object.class
       end

data/lib/para/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Para
-  VERSION = '0.9.0'
+  VERSION = '0.9.3.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: para
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.3.3
 platform: ruby
 authors:
 - Valentin Ballestrino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-14 00:00:00.000000000 Z
+date: 2021-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -766,6 +766,7 @@ files:
 - lib/para/ext.rb
 - lib/para/ext/active_job_status.rb
 - lib/para/ext/active_record_nested_attributes.rb
+- lib/para/ext/deep_cloneable.rb
 - lib/para/ext/paperclip.rb
 - lib/para/ext/request_iframe_xhr.rb
 - lib/para/form_builder.rb