para 0.9.3.1 → 0.9.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e971f0c36fc8256afd9883b9865af8be4628934c8aad4d998aa0efc47173a5
-  data.tar.gz: d0cb9cc08791c12f92ad514714d05782d643fa167511215ac53ddb765c030b50
+  metadata.gz: 6deb45940599a543b4257463561e645256df1db47b9cef62f1d287b97e841abd
+  data.tar.gz: a37ab4aca7ab0c23baf41a65083c84bdbdb6d6fe12437621b08f9a4f49baf22d
 SHA512:
-  metadata.gz: cdb7af1bcc3fa32b75acc7e0212f02d612037f90ef06c6b7c988002e376582cd620099ffc3267c49e70488b33c6da36d80b5bb75d0557c870a98d59490e5d40a
-  data.tar.gz: bddb7765e1d09f4bce763884fffbd1d9815c346cb028dc227f26287060724f9ba5ad4ed9d0bdbc682fa79b8aa07952dec5c1ec45234a902631fbe50729d17531
+  metadata.gz: 229be291a706963be79ef902fb99fdedad27092a62f8c855d912b57c21d10f94ed8e9ffd254a9bb1f29ae465ab6ec1cbe3753af53096778ce6131bdca83ef3b3
+  data.tar.gz: 10e5675bb29448fd949112632bda77b2dc897d7ca3b2d2dd8dfbac4ef47a19d8ddf629aa6ef40cea98dbfed05bfc716afe8fe06b1c57b950e2af8b541f859672

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

@@ -21,9 +21,9 @@ class Para.NestedManyField
       $(el).find('.resource-position-field').val(i)
 
   initializeCocoon: ->
-    @$fieldsList.on 'cocoon:after-insert', @afterInsertField
-    @$fieldsList.on 'cocoon:before-remove', @beforeRemoveField
-    @$fieldsList.on 'cocoon:after-remove', @afterRemoveField
+    @$fieldsList.on 'cocoon:after-insert', @stoppingPropagation(@afterInsertField)
+    @$fieldsList.on 'cocoon:before-remove', @stoppingPropagation(@beforeRemoveField)
+    @$fieldsList.on 'cocoon:after-remove', @stoppingPropagation(@afterRemoveField)
 
   stoppingPropagation: (callback) =>
     (e, args...) =>

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/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,29 +1,91 @@
 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
 
-      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)
+        cloneable_options = resource.cloneable_options
+        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|
           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)
@@ -31,37 +93,72 @@ module Para
             else
               add_reflection_options(reflection_options, association_target)
             end
-          end      
+          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)
         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)
         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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: para
 version: !ruby/object:Gem::Version
-  version: 0.9.3.1
+  version: 0.9.3.2
 platform: ruby
 authors:
 - Valentin Ballestrino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-08 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