releaf-content 1.0.8 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d45911222a0289b8828b3ebc98199a018e8735c
-  data.tar.gz: 0ec32f976aa909a836e5d1a31d7bf20d4591e4ae
+  metadata.gz: 7a3bb38f60b14152aac0b00614ff0d3ba1558b3c
+  data.tar.gz: cad1145449af7968692665a2804302f5b66384d5
 SHA512:
-  metadata.gz: ee44f44bf754da129aadb0982666ee8a99b74f575bfd621a9027388f8a84d0490e034b2176e4fba8abaad08beea888fa1a94f25dab83fec36b0be6424c9a75d4
-  data.tar.gz: 809a8f614e26754534feb4d31d67df03426b9f1229b22cf9b0d5477ab10507a977c9e7775749cba43e76f7c13f730a02cd02fa795a06620b418dfe7a95fbc713
+  metadata.gz: 7053c97279c704c480cf8eb46f66dbf94611dd34d50934cf78a1cc92aba8b2b69918c422115ecdcbdc8d6a6ba161254b4567ebf7b477010b9bbdedeb3019c795
+  data.tar.gz: d448e9e2920b641d3dc12ad41354e5f5469c088b5c0f3eda854d3710bf4e03e2b0b60aa909cce6ac1bfdc6a764fbc85aa03552bd314f977f1ed234499bef3246

data/app/services/releaf/content/node/copy.rb

@@ -11,6 +11,7 @@ module Releaf
           node.class.transaction do
             new_node = make_copy
           end
+
           new_node
         rescue ActiveRecord::RecordInvalid
           add_error_and_raise 'descendant invalid'
@@ -24,6 +25,16 @@ module Releaf
         add_error_and_raise("source or descendant node can't be parent of new node")
       end
 
+      def make_copy
+        new_node = duplicate_under
+
+        node.children.each do |child|
+          self.class.new(node: child, parent_id: new_node.id).make_copy
+        end
+
+        new_node
+      end
+
       def duplicate_under
         new_node = nil
         node.class.transaction do
@@ -34,57 +45,64 @@ module Releaf
             Releaf::Content::Node::SaveUnderParent.call(node: new_node, parent_id: parent_id)
           end
         end
+
         new_node
       end
 
       def duplicate_content
-        return if node.content_id.blank?
+        if node.content.present?
+          new_content = duplicate_object(node.content)
+          new_content.save!
+          new_content
+        else
+          nil
+        end
+      end
 
-        new_content = node.content.class.new(cloned_content_attributes)
-        duplicate_content_dragonfly_attributes(new_content)
+      def duplicate_object object
+        object.deep_clone include: duplicatable_associations(object.class) do |original, copy|
+          supplement_object_duplication(original, copy)
+        end
+      end
 
-        new_content.save!
-        new_content
+      def supplement_object_duplication(original, copy)
+        duplicate_dragonfly_attachments(original, copy)
       end
 
-      def cloned_content_attributes
-        skippable_attribute_names = ["id"] + content_dragonfly_attributes
-        node.content.attributes.except(*skippable_attribute_names)
+      def duplicatable_associations(owner_class)
+        Releaf::ResourceBase.new(owner_class).associations.collect do |association|
+          { association.name => duplicatable_associations(association.klass) }
+        end
       end
 
-      def duplicate_content_dragonfly_attributes(new_content)
-        content_dragonfly_attributes.each do |attribute_name|
-          accessor_name = attribute_name.gsub("_uid", "")
-          dragonfly_attachment = node.content.send(accessor_name)
+      def duplicate_dragonfly_attachments(original, copy)
+        attachment_keys = original.dragonfly_attachments.keys
+        return unless attachment_keys.present?
+
+        # during the dup() call the copy object has its dragonfly_attachments property duplicated from the original.
+        # here it gets set to nil to force its reinitialization on next access
+        copy.instance_variable_set(:@dragonfly_attachments, nil)
+
+        # all uids must be cleared in a separate loop before accessing any of the attachments
+        # (accessing any of the accessors regenerates the dragonfly_attachments collection and loads all uids)
+        attachment_keys.each { |accessor| copy.send("#{accessor}_uid=", nil) }
 
-          if dragonfly_attachment.present?
+        # once all uids have been reset, each attachment may be reassigned from the original.
+        # reassignment forces dragonfly to internally treat the new attachment as a copy
+        attachment_keys.each do |accessor|
+          attachment = original.send(accessor)
+
+          if attachment.present?
             begin
-              dragonfly_attachment.path  # verify that the file exists
+              attachment.path  # verify that the file exists
             rescue Dragonfly::Job::Fetch::NotFound
-              dragonfly_attachment = nil
+              attachment = nil
             end
           end
 
-          new_content.send("#{attribute_name}=", nil)
-          new_content.send("#{accessor_name}=", dragonfly_attachment)
+          copy.send("#{accessor}=", attachment)
         end
       end
-
-      def content_dragonfly_attributes
-        node.content.class.attribute_names.select do |attribute_name|
-          Releaf::Builders::Utilities::ResolveAttributeFieldMethodName.new(object: node.content, attribute_name: attribute_name).file?
-        end
-      end
-
-      def make_copy
-        new_node = duplicate_under
-
-        node.children.each do |child|
-          self.class.new(node: child, parent_id: new_node.id).make_copy
-        end
-
-        new_node
-      end
     end
   end
 end

data/lib/releaf-content.rb

@@ -1,5 +1,6 @@
 require 'awesome_nested_set'
 require 'stringex'
+require 'deep_cloneable'
 
 module Releaf::Content
   require 'releaf/content/engine'

data/spec/features/nodes_services_spec.rb

@@ -64,7 +64,7 @@ describe "Nodes services (copy, move)" do
 
   end
 
-  describe "Copying", create_nodes: true do
+  describe "Basic node copying", create_nodes: true do
     before create_nodes: true do
       @home_page_node = create(:home_page_node, locale: "lv")
       @home_page_node_2 = create(:home_page_node, locale: "en")
@@ -204,4 +204,187 @@ describe "Nodes services (copy, move)" do
       end
     end
   end
+
+
+  feature "Deep copying of content nodes", js: true do
+
+    let(:node_class) { Node }
+    let(:locale) { "en" }
+
+    background do
+      Rails.cache.clear
+      # preload ActsAsNode classes
+      Rails.application.eager_load!
+
+      create(:home_page_node, name: "Root page", locale: "en", slug: "en")
+      auth_as_user
+    end
+
+    def expect_different_values original, copy
+      expect(original).to be_present
+      expect(copy).to be_present
+      expect(original).to_not eq copy
+    end
+
+    scenario "Deep copying of content nodes with nested associations and files" do
+      visit "/admin/nodes/"
+      open_toolbox("Add child", node_class.first, ".view-index .collection li")
+
+      dummy_file_path = File.expand_path('../fixtures/dummy.png', __dir__)
+
+      within('.dialog.content-type.initialized') do
+        click_link "Banner page"
+      end
+
+      expect(page).to have_css('input[type="text"][name="resource[content_type]"][value="Banner page"]')
+
+      fill_in 'Name', with: "Banner page"
+      fill_in 'Slug', with: "banner-page"
+
+      attach_file('Top banner', dummy_file_path)
+      attach_file('Bottom banner', dummy_file_path)
+
+      within('section.nested[data-name="banner_groups"]') do
+        add_nested_item "banner_groups", 0 do
+          fill_in "Title", with: "Banner group 1 title"
+
+          within('section.nested[data-name="banners"]') do
+            add_nested_item "banners", 0 do
+              attach_file('Image', dummy_file_path)
+              fill_in "Url", with: "Banner-1-url"
+            end
+            add_nested_item "banners", 1 do
+              attach_file('Image', dummy_file_path)
+              fill_in "Url", with: "Banner-2-url"
+            end
+          end
+        end
+
+        add_nested_item "banner_groups", 1 do
+          fill_in "Title", with: "Banner group 2 title"
+        end
+      end
+
+      wait_for_all_richtexts
+      save_and_check_response "Create succeeded"
+
+      open_toolbox("Copy")
+
+      within('.dialog.copy.initialized') do
+        find('label', text: "Root page").click
+        click_button "Copy"
+      end
+
+      expect(page).to have_css('body > .notifications .notification[data-id="resource_status"][data-type="success"]', text: "Copy succeeded")
+
+      # verify record count in db
+      expect(node_class.where(content_type: 'BannerPage').count).to eq 2
+      expect(BannerGroup.count).to eq 4
+      expect(Banner.count).to eq 4
+
+
+      # verify that direct and nested files are duplicated correctly
+      [
+        { original: BannerPage.first, copy: BannerPage.last, accessor: :top_banner    },
+        { original: BannerPage.first, copy: BannerPage.last, accessor: :bottom_banner },
+        {
+          original: BannerPage.first.banner_groups.first.banners.first,
+          copy:     BannerPage.last.banner_groups.first.banners.first,
+          accessor: :image
+        }
+      ].each do |entry|
+        original = entry[:original]
+        copy     = entry[:copy]
+        accessor = entry[:accessor]
+        expect(original.id).to_not eq copy.id
+
+        # verify that uids exist and are different
+        expect_different_values(original.send("#{accessor}_uid"), copy.send("#{accessor}_uid"))
+
+        # verify files exist and are different
+        original_file = original.send(accessor)
+        copied_file = copy.send(accessor)
+
+        expect_different_values(original_file.path, copied_file.path)
+        expect(original_file.path).to start_with Dragonfly.app.datastore.root_path
+        expect(copied_file.path).to   start_with Dragonfly.app.datastore.root_path
+        expect(File.exist?(original_file.path)).to be true
+        expect(File.exist?(copied_file.path)).to be true
+      end
+
+
+      # change values in the copied node to make sure associations are not linked
+      original_id = node_class.where(content_type: "BannerPage").order(:item_position).first.id
+      copy_id     = node_class.where(content_type: "BannerPage").order(:item_position).last.id
+      expect(copy_id).to_not eq original_id
+
+      visit "/admin/nodes/#{copy_id}/edit/"
+
+      within('section.nested[data-name="banner_groups"]') do
+        within('.item[data-name="banner_groups"][data-index="0"]') do
+          expect(page).to have_field('Title', with: 'Banner group 1 title')
+          fill_in "Title", with: "Copied banner group 1 title"
+
+          within('.item[data-name="banners"][data-index="0"]') do
+            expect(page).to have_field('Url', with: 'Banner-1-url')
+            fill_in "Url", with: "Copied-banner-1-url"
+          end
+          within('.item[data-name="banners"][data-index="1"]') do
+            expect(page).to have_field('Url', with: 'Banner-2-url')
+            fill_in "Url", with: "Copied-banner-2-url"
+          end
+        end
+        within('.item[data-name="banner_groups"][data-index="1"]') do
+          expect(page).to have_field('Title', with: 'Banner group 2 title')
+          fill_in "Title", with: "Copied banner group 2 title"
+        end
+      end
+
+      copied_file_urls = {
+        top_banner:     find('.field[data-name="top_banner"]').find_link[:href],
+        bottom_banner:  find('.field[data-name="bottom_banner"]').find_link[:href],
+        nested_banner:  find('.item[data-name="banner_groups"][data-index="0"] .item[data-name="banners"][data-index="0"] .field[data-name="image"]').find_link[:href]
+      }
+
+      wait_for_all_richtexts
+      save_and_check_response "Update succeeded"
+
+      # verify that the original banner page still has the old values
+      visit "/admin/nodes/#{original_id}/edit/"
+
+      within('section.nested[data-name="banner_groups"]') do
+        within('.item[data-name="banner_groups"][data-index="0"]') do
+          expect(page).to have_field('Title', with: 'Banner group 1 title')
+
+          within('.item[data-name="banners"][data-index="0"]') do
+            expect(page).to have_field('Url', with: 'Banner-1-url')
+          end
+          within('.item[data-name="banners"][data-index="1"]') do
+            expect(page).to have_field('Url', with: 'Banner-2-url')
+          end
+        end
+        within('.item[data-name="banner_groups"][data-index="1"]') do
+          expect(page).to have_field('Title', with: 'Banner group 2 title')
+        end
+      end
+
+      original_file_urls = {
+        top_banner:     find('.field[data-name="top_banner"]').find_link[:href],
+        bottom_banner:  find('.field[data-name="bottom_banner"]').find_link[:href],
+        nested_banner:  find('.item[data-name="banner_groups"][data-index="0"] .item[data-name="banners"][data-index="0"] .field[data-name="image"]').find_link[:href]
+      }
+
+      # make sure that original and copied file urls are different and working
+      original_file_urls.each do |key, original_url|
+        expect_different_values(original_url, copied_file_urls[key])
+
+        [original_url, copied_file_urls[key]].each do |file_url|
+          visit file_url
+          expect(page.status_code).to eq 200
+        end
+      end
+
+    end
+
+  end
 end

data/spec/services/releaf/content/node/copy_spec.rb

@@ -1,90 +1,59 @@
 require "rails_helper"
 
 describe Releaf::Content::Node::Copy do
-  class DummyNodeServiceIncluder
-    include Releaf::Content::Node::Service
-  end
 
-  let(:node){ Node.new }
-  subject{ described_class.new(node: node, parent_id: 12) }
+  let(:root_node) { create(:home_page_node) }
 
-  describe "#duplicate_content" do
-    let(:node) { create(:node) }
+  let(:node) { create(node_factory, parent: root_node) }
+  let(:node_factory) { :text_page_node }
 
-    context "when content_id is blank" do
-      it "returns nil" do
-        expect( subject.duplicate_content ).to be nil
-      end
-    end
+  let(:content_factory) { :text_page }
+  let(:content_attributes) { { } }
 
-    context "when content_id is not blank" do
-      let(:node) { create(:home_page_node) }
+  let(:complex_node_factory) { :banner_page_node }
+  let(:complex_content_factory) { :banner_page }
+  let(:complex_content_duplicatable_associations) {
+  [
+    {
+      banner_groups: [
+        { banners: [] }
+      ]
+    }
+  ] }
 
-      it "returns saved duplicated content" do
-        content = HomePage.new
-        expect( content ).to receive(:save!)
-        expect( node.content.class ).to receive(:new).and_return(content)
-        expect( subject.duplicate_content ).to eq content
-      end
+  let(:file) { File.new(File.expand_path('../../../../fixtures/dummy.png', __dir__)) }
 
-      it "reassigns dragonfly accessors" do
-        content = HomePage.new
-        expect( content ).to receive(:save!)
-        allow( node.content.class ).to receive(:new).and_return(content)
-        expect( subject ).to receive(:duplicate_content_dragonfly_attributes).with(content)
-        expect( subject.duplicate_content ).to eq content
-      end
+  let(:original) { create(content_factory, content_attributes) }
 
-      it "doesn't return same as original content" do
-        result = subject.duplicate_content
-        expect( result ).to be_an_instance_of HomePage
-        expect( result.id ).to_not eq node.content_id
-      end
-    end
-  end
 
-  describe "#cloned_content_attributes" do
-    it "returns attributes without id and dragonfly attributes" do
-      node.content = HomePage.new(id: 42, banner_uid: "re", intro_text_html: "some text")
+  describe "#make_copy" do
+    # this is a double check to verify file duplication by doing the full copying process.
+    # #duplicate_dragonfly_attachments is tested separately in more detail below
+    subject { described_class.new(node: node, parent_id: root_node.id ) }
 
-      expect(subject.cloned_content_attributes).to have_key("intro_text_html")
-      expect(subject.cloned_content_attributes).not_to include(:id, :banner_uid)
-    end
-  end
+    context "when node content has dragonfly file fields" do
+      let(:node_factory) { complex_node_factory }
 
-  describe "#duplicate_content_dragonfly_attributes" do
-    context "when dragonfly file is present" do
-      it "reassigns dragonfly accessors to given content instance from node content" do
-        old_content = HomePage.create(banner: File.new("releaf-core/spec/fixtures/cs.png"))
-        new_content = HomePage.new()
-        node.content = old_content
-
-        expect(new_content).to receive(:banner=).with(old_content.banner)
-        expect(new_content).to receive(:banner_uid=).with(nil)
-        subject.duplicate_content_dragonfly_attributes(new_content)
-      end
-    end
+      it "duplicates dragonfly attachments, storing them as separate files that are no longer linked" do
+        node.content.top_banner = file
+        node.save!
+        copy = subject.make_copy
 
-    context "when dragonfly file is not present" do
-      it "doesn't reassigns dragonfly accessors to given content instance from node content" do
-        old_content = HomePage.new(banner_uid: "yy")
-        new_content = HomePage.new()
-        node.content = old_content
+        # make sure the uids are non-empty and different
+        expect(node.content.top_banner_uid).to be_present
+        expect(copy.content.top_banner_uid).to be_present
+        expect(copy.content.top_banner_uid).to_not eq node.content.top_banner_uid
 
-        expect(new_content).to receive(:banner=).with(nil)
-        expect(new_content).to receive(:banner_uid=).with(nil)
-        subject.duplicate_content_dragonfly_attributes(new_content)
+        # make sure the files are stored and exist
+        expect(copy.content.top_banner.path).to start_with Dragonfly.app.datastore.root_path
+        expect(node.content.top_banner.path).to start_with Dragonfly.app.datastore.root_path
+        expect(copy.content.top_banner.path).to_not eq node.content.top_banner.path
       end
     end
-  end
 
-  describe "#content_dragonfly_attributes" do
-    it "returns array of node content object dragonfly attributes" do
-      node.content = HomePage.new
-      expect(subject.content_dragonfly_attributes).to eq(["banner_uid"])
-    end
   end
 
+
   describe "#duplicate_under" do
     let!(:source_node) { create(:node, locale: "lv") }
     let!(:target_node) { create(:node, locale: "en") }
@@ -112,4 +81,251 @@ describe Releaf::Content::Node::Copy do
       subject.duplicate_under
     end
   end
+
+
+  describe "#duplicate_content" do
+
+    let(:content) { node.content }
+
+    before do
+      allow(subject).to receive(:node).and_return(node)
+    end
+
+    context "when node has a content object" do
+
+      it "calls #duplicate_object with current content" do
+        expect(subject).to receive(:duplicate_object).with(content).and_return(content)
+        subject.duplicate_content
+      end
+
+      it "saves the duplicated result" do
+        new_content = subject.duplicate_content
+        expect(new_content.new_record?).to be false
+      end
+
+      it "returns the newly saved content" do
+        new_content = subject.duplicate_content
+        expect(new_content.id).to_not eq content.id
+      end
+    end
+
+    context "when node does not have a content object" do
+      before do
+        node.content = nil
+      end
+
+      it "does nothing" do
+        expect(subject).to_not receive(:duplicate_object)
+        expect(node).to_not receive(:save!)
+        subject.duplicate_content
+      end
+      it "returns nil" do
+        expect(subject.duplicate_content).to be_nil
+      end
+    end
+
+  end
+
+
+  describe "#duplicate_object" do
+
+    context "when object has no duplicatable associations" do
+      let(:content_factory) { :text_page }
+      let(:content_attributes) { { text_html: "html" } }
+
+      it "builds an unsaved copy of the object" do
+        copy = subject.duplicate_object(original)
+        expect(copy.class).to be original.class
+        expect(copy.new_record?).to be true
+
+        expect(copy.text_html).to eq original.text_html
+      end
+
+      it "uses #deep_clone for copying" do
+        expect(subject).to receive(:duplicatable_associations).with(original.class).and_call_original
+        expect(original).to receive(:deep_clone).with( include: [] ).and_call_original
+        subject.duplicate_object(original)
+      end
+
+      it "calls #supplement_object_duplication with the original object and its new copy" do
+        copy = original.dup
+
+        # stub #dup (which is called by deep_clone internally) so that it returns a known instance
+        allow(original).to receive(:dup).and_return(copy)
+
+        expect(subject).to receive(:supplement_object_duplication).with(original, copy)
+        subject.duplicate_object(original)
+      end
+
+    end
+
+    context "when object has duplicatable associations" do
+      let(:content_factory) { complex_content_factory }
+
+      let(:content_attributes) do
+        {
+          intro_text_html: "Intro html",
+          banner_groups_attributes: [
+            {
+              title: "Group title",
+              banners_attributes: [
+                url: "Banner url"
+              ]
+            },
+          ]
+        }
+      end
+
+      it "passes duplicatable associations to #deep_clone" do
+        expect(original).to receive(:deep_clone).with( include: complex_content_duplicatable_associations ).and_call_original
+        subject.duplicate_object(original)
+      end
+
+      it "builds an unsaved copy with nested copies of associated objects" do
+        copy = subject.duplicate_object(original)
+        expect(copy.class).to be original.class
+        expect(copy.new_record?).to be true
+        expect(copy.intro_text_html).to eq original.intro_text_html
+
+        original_item = original.banner_groups.first
+        copied_item   = copy.banner_groups.first
+        expect(copied_item.class).to be original_item.class
+        expect(copied_item.new_record?).to be true
+        expect(copied_item.title).to eq original_item.title
+
+        original_nested_item  = original.banner_groups.first.banners.first
+        copied_nested_item    = copy.banner_groups.first.banners.first
+        expect(copied_nested_item.class).to be original_nested_item.class
+        expect(copied_nested_item.new_record?).to be true
+        expect(copied_nested_item.url).to eq original_nested_item.url
+      end
+
+      it "calls #supplement_object_duplication on all cloned objects" do
+        original_item         = original.banner_groups.first
+        original_nested_item  = original_item.banners.first
+
+        expect(subject).to receive(:supplement_object_duplication).with(original, kind_of(original.class))
+        expect(subject).to receive(:supplement_object_duplication).with(original_item, kind_of(original_item.class))
+        expect(subject).to receive(:supplement_object_duplication).with(original_nested_item, kind_of(original_nested_item.class))
+        subject.duplicate_object(original)
+      end
+
+    end
+
+  end
+
+  describe "#supplement_object_duplication" do
+    it "calls #duplicate_dragonfly_attachments with given original and copy" do
+      expect(subject).to receive(:duplicate_dragonfly_attachments).with(:foo, :bar)
+      subject.supplement_object_duplication(:foo, :bar)
+    end
+  end
+
+  describe "#duplicatable_associations" do
+    let(:content_class) { build(content_factory).class }
+
+    it "uses Releaf::ResourceBase to detect duplicatable associations" do
+      expect(Releaf::ResourceBase).to receive(:new).with(content_class).and_call_original
+      subject.duplicatable_associations(content_class)
+    end
+
+    context "when given class has duplicatable associations" do
+      it "returns duplicatable association names as nested arrays of hashes" do
+        expect(subject.duplicatable_associations(content_class)).to eq []
+      end
+    end
+
+    context "when given class has no duplicatable associations" do
+      let(:content_factory) { complex_content_factory }
+      it "returns an empty array" do
+        expect(subject.duplicatable_associations(content_class)).to eq complex_content_duplicatable_associations
+      end
+    end
+  end
+
+
+  describe "#duplicate_dragonfly_attachments" do
+    let(:content_factory) { complex_content_factory }
+    let(:copy) { original.dup }
+
+    context "when the original object's dragonfly attributes" do
+
+      context "are blank" do
+        it "sets the file attributes to nil on the given copy" do
+          expect(copy).to receive(:top_banner_uid=).with(nil).ordered
+          expect(copy).to receive(:top_banner=).with(nil).ordered
+          subject.duplicate_dragonfly_attachments(original, copy)
+        end
+      end
+
+      context "contain files" do
+
+        it "separates the attachments so that dragonfly treats them as separate files" do
+          # it is important that the owner class used in this test has at least two dragonfly attributes
+          # and the test is not using the first one.
+          # (an earlier implementation worked only with the first file
+          # and would have passed the test if the test used the first file)
+          expect(original.dragonfly_attachments.keys.find_index(:bottom_banner)).to be > 0
+
+          original.bottom_banner = file
+          original.save!
+
+          subject.duplicate_dragonfly_attachments(original, copy)
+          copy.save!
+
+          # refetch the objects. calling #reload on them is not enough
+          original_id = original.id
+          copy_id     = copy.id
+          klass       = original.class
+
+          original = klass.find(original_id)
+          copy     = klass.find(copy_id)
+
+          # make sure the uids are non-empty and different
+          expect(original.bottom_banner_uid).to be_present
+          expect(copy.bottom_banner_uid).to be_present
+          expect(copy.bottom_banner_uid).to_not eq original.bottom_banner_uid
+
+          # make sure the files are stored and exist
+          expect(copy.bottom_banner.path).to start_with Dragonfly.app.datastore.root_path
+          expect(original.bottom_banner.path).to start_with Dragonfly.app.datastore.root_path
+          expect(copy.bottom_banner.path).to_not eq original.bottom_banner.path
+
+          # make sure the metadata is readable as well
+          expect(copy.bottom_banner.format).to eq original.bottom_banner.format
+        end
+
+      end
+
+      context "contain files that are missing" do
+
+        it "sets the file attributes to nil on the given copy" do
+          original.top_banner = file
+          original.save!
+
+          original_id = original.id
+
+          # simulate deletion from filesystem by setting the uid to an invalid path
+          original.top_banner_uid = "xxx" + original.top_banner_uid
+          original.save!
+
+          klass = original.class
+          original = klass.find(original_id)
+
+          subject.duplicate_dragonfly_attachments(original, copy)
+          copy.save!
+          copy_id = copy.id
+          copy = klass.find(copy_id)
+
+          expect(copy.top_banner_uid).to be_nil
+          expect(copy.top_banner).to be_nil
+        end
+
+      end
+
+    end
+  end
+
+
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: releaf-content
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.9
 platform: ruby
 authors:
 - CubeSystems
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: releaf-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.8
+        version: 1.0.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.8
+        version: 1.0.9
 - !ruby/object:Gem::Dependency
   name: stringex
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: deep_cloneable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.2
 description: Content subsystem for releaf
 email: info@cubesystems.lv
 executables: []
@@ -100,6 +114,7 @@ files:
 - spec/controllers/releaf/content/nodes_controller_spec.rb
 - spec/features/nodes_services_spec.rb
 - spec/features/nodes_spec.rb
+- spec/fixtures/dummy.png
 - spec/lib/releaf/content/acts_as_node_spec.rb
 - spec/lib/releaf/content/configuration_spec.rb
 - spec/lib/releaf/content/engine_spec.rb
@@ -134,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Node and content routes support for releaf
@@ -146,6 +161,7 @@ test_files:
 - spec/controllers/releaf/content/nodes_controller_spec.rb
 - spec/features/nodes_services_spec.rb
 - spec/features/nodes_spec.rb
+- spec/fixtures/dummy.png
 - spec/lib/releaf/content/acts_as_node_spec.rb
 - spec/lib/releaf/content/configuration_spec.rb
 - spec/lib/releaf/content/engine_spec.rb