@@ -77,9 +78,10 @@ function clientDimensions(contentRect, scaleFactor) {
Math.ceil(contentRect.client.height * scaleFactor)
}
}
-function viewportUnitCustomProperties({width, height}) {
+export function viewportUnitCustomProperties({width, height}) {
return {
'--vw': width && `${width / 100}px`,
- '--vh': height && `${height / 100}px`
+ '--vh': height && `${height / 100}px`,
+ '--svh': height && `${height / 100}px`
}
}
diff --git a/entry_types/scrolled/package/src/testHelpers/normalizeSeed.js b/entry_types/scrolled/package/src/testHelpers/normalizeSeed.js
index 7d2781ad02..66c3f28090 100644
--- a/entry_types/scrolled/package/src/testHelpers/normalizeSeed.js
+++ b/entry_types/scrolled/package/src/testHelpers/normalizeSeed.js
@@ -253,9 +253,8 @@ function normalizeStorylines(storylines = [], chapters) {
{
id: 1000,
permaId: 100,
- configuration: {
- main: true
- }
+ role: 'main',
+ configuration: {}
}
]
}
diff --git a/entry_types/scrolled/package/src/widgets/excursionSheet/stories.js b/entry_types/scrolled/package/src/widgets/excursionSheet/stories.js
index 686e0efbce..4a229c61dc 100644
--- a/entry_types/scrolled/package/src/widgets/excursionSheet/stories.js
+++ b/entry_types/scrolled/package/src/widgets/excursionSheet/stories.js
@@ -23,7 +23,7 @@ function getSeed({
{
id: 1000,
permaId: 100,
- configuration: {main: true}
+ role: 'main'
},
{
id: 2000,
diff --git a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/chapters_controller_spec.rb b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/chapters_controller_spec.rb
index 5e1f7f9a60..1f4e8819d1 100644
--- a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/chapters_controller_spec.rb
+++ b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/chapters_controller_spec.rb
@@ -244,6 +244,22 @@ module PageflowScrolled
expect(response.status).to eq(204)
end
+ it 'moves the chapter to the trash' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+
+ authorize_for_editor_controller(entry)
+ delete(:destroy,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry,
+ id: chapter
+ }, format: 'json')
+
+ expect(chapter.reload.storyline)
+ .to eq(Storyline.find_or_create_trash_for(entry.draft))
+ end
+
it 'does not allow deleting a chapter from a different entry' do
entry = create(:entry, type_name: 'scrolled')
create(:scrolled_chapter, revision: entry.draft)
diff --git a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/content_elements_controller_spec.rb b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/content_elements_controller_spec.rb
index 379057b72f..97bcffc273 100644
--- a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/content_elements_controller_spec.rb
+++ b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/content_elements_controller_spec.rb
@@ -166,6 +166,77 @@ module PageflowScrolled
expect(section.content_elements.map(&:id)).to eq([content_elements.last.id])
end
+ it 'moves content elements marked by _trash flag to the trash' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ kept, trashed, merged = create_list(:content_element, 3, section:)
+
+ authorize_for_editor_controller(entry)
+ post(:batch,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry.id,
+ section_id: section.id,
+ content_elements: [
+ {id: kept.id},
+ {id: trashed.id, _delete: true, _trash: true},
+ {id: merged.id, _delete: true}
+ ]
+ }, format: 'json', as: :json)
+
+ expect(section.reload.content_elements).to eq([kept])
+ expect(trashed.reload.section.chapter.configuration['trash'])
+ .to include('kind' => 'contentElements',
+ 'originPermaId' => section.perma_id,
+ 'originPosition' => 1)
+ expect(ContentElement.exists?(merged.id)).to eq(false)
+ end
+
+ it 'does not trash content elements of other sections' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ other_section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section: other_section)
+
+ authorize_for_editor_controller(entry)
+ post(:batch,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry.id,
+ section_id: section.id,
+ content_elements: [
+ {id: content_element.id, _delete: true, _trash: true}
+ ]
+ }, format: 'json', as: :json)
+
+ expect(response.status).to eq(404)
+ expect(content_element.reload.section).to eq(other_section)
+ end
+
+ it 'records number of remaining preceding elements as origin position' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ merged = create(:content_element, section:, position: 0)
+ kept = create(:content_element, section:, position: 1)
+ trashed = create(:content_element, section:, position: 5)
+
+ authorize_for_editor_controller(entry)
+ post(:batch,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry.id,
+ section_id: section.id,
+ content_elements: [
+ {id: kept.id},
+ {id: merged.id, _delete: true},
+ {id: trashed.id, _delete: true, _trash: true}
+ ]
+ }, format: 'json', as: :json)
+
+ expect(trashed.reload.section.chapter.configuration['trash'])
+ .to include('originPosition' => 1)
+ end
+
it 'responds with array of objects containging content element ids and perma ids' do
entry = create(:entry, type_name: 'scrolled')
section = create(:section, revision: entry.draft)
@@ -390,6 +461,33 @@ module PageflowScrolled
expect(thread.reload.section_perma_id).to eq(target_section.perma_id)
end
+ it 'updates section_perma_id of threads on moved in elements when trashing in same batch' do
+ entry = create(:entry, type_name: 'scrolled')
+ source_section = create(:section, revision: entry.draft)
+ target_section = create(:section, revision: entry.draft)
+ trashed = create(:content_element, section: target_section)
+ element = create(:content_element, :text_block, section: source_section)
+ thread = create(:comment_thread,
+ revision: entry.draft,
+ subject_type: 'ContentElement',
+ subject_id: element.perma_id,
+ section_perma_id: source_section.perma_id)
+
+ authorize_for_editor_controller(entry)
+ post(:batch,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry.id,
+ section_id: target_section.id,
+ content_elements: [
+ {id: element.id},
+ {id: trashed.id, _delete: true, _trash: true}
+ ]
+ }, format: 'json', as: :json)
+
+ expect(thread.reload.section_perma_id).to eq(target_section.perma_id)
+ end
+
it 'leaves section_perma_id untouched for threads that stay in their section' do
entry = create(:entry, type_name: 'scrolled')
section = create(:section, revision: entry.draft)
@@ -536,6 +634,29 @@ module PageflowScrolled
expect(response.status).to eq(204)
end
+ it 'allows updating trashed content elements' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, :text_block, section:)
+ Trash.new(entry.draft).add_content_elements([content_element],
+ origin_section: section,
+ origin_position: 0)
+
+ authorize_for_editor_controller(entry)
+ patch(:update,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry,
+ id: content_element,
+ content_element: {
+ configuration: {children: 'late edit'}
+ }
+ }, format: 'json')
+
+ expect(content_element.reload.configuration).to eq('children' => 'late edit')
+ expect(response.status).to eq(204)
+ end
+
it 'does not allow updating a content element from a different entry' do
entry = create(:entry, type_name: 'scrolled')
other_entry = create(:entry, type_name: 'scrolled')
diff --git a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/fragment_extractions_controller_spec.rb b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/fragment_extractions_controller_spec.rb
index a8155fc29b..0d8c73ee31 100644
--- a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/fragment_extractions_controller_spec.rb
+++ b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/fragment_extractions_controller_spec.rb
@@ -146,7 +146,7 @@ module PageflowScrolled
post_extraction(entry:, chapter:)
fragment = Chapter.all_for_revision(find_library(account).draft).first
- expect(fragment.storyline.configuration).to include('main' => true)
+ expect(fragment.storyline.role).to eq('main')
end
it 'keeps sections of chapter in entry' do
diff --git a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/sections_controller_spec.rb b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/sections_controller_spec.rb
index 83d29553b4..bddeebbe85 100644
--- a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/sections_controller_spec.rb
+++ b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/sections_controller_spec.rb
@@ -330,6 +330,22 @@ module PageflowScrolled
expect(response.status).to eq(204)
end
+ it 'moves the section to the trash' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+
+ authorize_for_editor_controller(entry)
+ delete(:destroy,
+ params: {
+ entry_type: 'scrolled',
+ entry_id: entry,
+ id: section
+ }, format: 'json')
+
+ expect(section.reload.chapter.storyline)
+ .to eq(Storyline.find_or_create_trash_for(entry.draft))
+ end
+
it 'does not allow deleting a section from a different entry' do
entry = create(:entry, type_name: 'scrolled')
create(:section, revision: entry.draft)
diff --git a/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/trash_items_controller_spec.rb b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/trash_items_controller_spec.rb
new file mode 100644
index 0000000000..8cdb10148e
--- /dev/null
+++ b/entry_types/scrolled/spec/controllers/pageflow_scrolled/editor/trash_items_controller_spec.rb
@@ -0,0 +1,300 @@
+require 'spec_helper'
+require 'pageflow/editor_controller_test_helper'
+
+module PageflowScrolled
+ RSpec.describe Editor::TrashItemsController, type: :controller do
+ render_views
+ include Pageflow::EditorControllerTestHelper
+ include ActiveSupport::Testing::TimeHelpers
+
+ routes { PageflowScrolled::Engine.routes }
+
+ describe '#index' do
+ it 'requires authentication' do
+ entry = create(:entry, type_name: 'scrolled')
+
+ get(:index, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(response.status).to eq(401)
+ end
+
+ it 'lists trashed sections with origin and trash time' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ section = create(:section, chapter:, position: 3)
+ content_element = create(:content_element, section:)
+ travel_to(Time.utc(2026, 10, 1, 12)) do
+ Trash.new(entry.draft).add_section(section)
+ end
+
+ authorize_for_editor_controller(entry)
+ get(:index, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(response.body).to include_json(
+ [
+ {
+ id: section.reload.chapter_id,
+ kind: 'section',
+ originPermaId: chapter.perma_id,
+ originPosition: 3,
+ trashedAt: '2026-10-01T12:00:00Z',
+ sections: [
+ {
+ id: section.id,
+ permaId: section.perma_id,
+ contentElements: [{id: content_element.id}]
+ }
+ ]
+ }
+ ]
+ )
+ end
+
+ it 'lists trashed chapters with title' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft,
+ configuration: {'title' => 'Intro'})
+ section = create(:section, chapter:)
+ Trash.new(entry.draft).add_chapter(chapter)
+
+ authorize_for_editor_controller(entry)
+ get(:index, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(response.body).to include_json(
+ [
+ {
+ id: chapter.id,
+ kind: 'chapter',
+ title: 'Intro',
+ sections: [{id: section.id}]
+ }
+ ]
+ )
+ end
+
+ it 'lists newest items first' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ first_section = create(:section, chapter:)
+ second_section = create(:section, chapter:)
+ trash = Trash.new(entry.draft)
+ trash.add_section(first_section)
+ trash.add_section(second_section)
+
+ authorize_for_editor_controller(entry)
+ get(:index, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(JSON.parse(response.body).map { |e| e['sections'].first['id'] })
+ .to eq([second_section.id, first_section.id])
+ end
+
+ it 'renders empty list if nothing has been trashed' do
+ entry = create(:entry, type_name: 'scrolled')
+
+ authorize_for_editor_controller(entry)
+ get(:index, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(JSON.parse(response.body)).to eq([])
+ end
+ end
+
+ describe '#restore' do
+ it 'requires authentication' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ Trash.new(entry.draft).add_section(section)
+
+ post(:restore,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(401)
+ end
+
+ it 'restores section and renders it with content elements' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ section = create(:section, chapter:)
+ content_element = create(:content_element, section:)
+ Trash.new(entry.draft).add_section(section)
+
+ authorize_for_editor_controller(entry)
+ post(:restore,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(200)
+ expect(response.body).to include_json(
+ id: section.id,
+ permaId: section.perma_id,
+ chapterId: chapter.id,
+ contentElements: [{id: content_element.id, permaId: content_element.perma_id}]
+ )
+ end
+
+ it 'restores chapter and renders it with sections and content elements' do
+ entry = create(:entry, type_name: 'scrolled')
+ storyline = Storyline.all_for_revision(entry.draft).first
+ chapter = create(:scrolled_chapter, storyline:, configuration: {'title' => 'Intro'})
+ section = create(:section, chapter:)
+ content_element = create(:content_element, section:)
+ Trash.new(entry.draft).add_chapter(chapter)
+
+ authorize_for_editor_controller(entry)
+ post(:restore,
+ params: {entry_type: 'scrolled', entry_id: entry, id: chapter.id},
+ format: 'json')
+
+ expect(response.status).to eq(200)
+ expect(response.body).to include_json(
+ id: chapter.id,
+ permaId: chapter.perma_id,
+ storylineId: storyline.id,
+ configuration: {title: 'Intro'},
+ sections: [
+ {id: section.id, contentElements: [{id: content_element.id}]}
+ ]
+ )
+ expect(JSON.parse(response.body)['configuration']).not_to have_key('trash')
+ end
+
+ it 'restores content elements and renders them' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+ Trash.new(entry.draft).add_content_elements([content_element],
+ origin_section: section,
+ origin_position: 0)
+
+ authorize_for_editor_controller(entry)
+ post(:restore,
+ params: {entry_type: 'scrolled', entry_id: entry,
+ id: content_element.reload.section.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(200)
+ expect(response.body).to include_json(
+ [{id: content_element.id, permaId: content_element.perma_id,
+ sectionId: section.id, position: 0}]
+ )
+ end
+
+ it 'responds with unprocessable entity if no chapter is left' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ origin_chapter = section.chapter
+ Trash.new(entry.draft).add_section(section)
+ origin_chapter.destroy
+
+ authorize_for_editor_controller(entry)
+ post(:restore,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(422)
+ end
+
+ it 'does not allow restoring trash items of other entries' do
+ entry = create(:entry, type_name: 'scrolled')
+ other_entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: other_entry.draft)
+ Trash.new(other_entry.draft).add_section(section)
+
+ authorize_for_editor_controller(entry)
+ post(:restore,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ describe '#destroy' do
+ it 'requires authentication' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ Trash.new(entry.draft).add_section(section)
+
+ delete(:destroy,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(401)
+ end
+
+ it 'permanently deletes trash item with its content' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+ other_section = create(:section, revision: entry.draft)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+ trash.add_section(other_section)
+
+ authorize_for_editor_controller(entry)
+ delete(:destroy,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(204)
+ expect(trash.items.map(&:id)).to eq([other_section.reload.chapter_id])
+ expect(Section.exists?(section.id)).to eq(false)
+ expect(ContentElement.exists?(content_element.id)).to eq(false)
+ end
+
+ it 'does not allow deleting trash items of other entries' do
+ entry = create(:entry, type_name: 'scrolled')
+ other_entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: other_entry.draft)
+ Trash.new(other_entry.draft).add_section(section)
+
+ authorize_for_editor_controller(entry)
+ delete(:destroy,
+ params: {entry_type: 'scrolled', entry_id: entry, id: section.reload.chapter_id},
+ format: 'json')
+
+ expect(response.status).to eq(404)
+ expect(Section.exists?(section.id)).to eq(true)
+ end
+ end
+
+ describe '#empty' do
+ it 'requires authentication' do
+ entry = create(:entry, type_name: 'scrolled')
+
+ delete(:empty, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(response.status).to eq(401)
+ end
+
+ it 'permanently deletes all trash items' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+ trash.add_chapter(chapter)
+
+ authorize_for_editor_controller(entry)
+ delete(:empty, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(response.status).to eq(204)
+ expect(trash.items).to be_empty
+ expect(Chapter.exists?(chapter.id)).to eq(false)
+ expect(Section.exists?(section.id)).to eq(false)
+ end
+
+ it 'keeps content of other entries' do
+ entry = create(:entry, type_name: 'scrolled')
+ other_entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: other_entry.draft)
+ Trash.new(other_entry.draft).add_section(section)
+
+ authorize_for_editor_controller(entry)
+ delete(:empty, params: {entry_type: 'scrolled', entry_id: entry}, format: 'json')
+
+ expect(Section.exists?(section.id)).to eq(true)
+ end
+ end
+ end
+end
diff --git a/entry_types/scrolled/spec/factories/chapters.rb b/entry_types/scrolled/spec/factories/chapters.rb
index 346329a2b6..e57c0a8e9b 100644
--- a/entry_types/scrolled/spec/factories/chapters.rb
+++ b/entry_types/scrolled/spec/factories/chapters.rb
@@ -9,9 +9,7 @@ module PageflowScrolled
if chapter.storyline.nil?
revision = evaluator.revision || build(:revision)
chapter.storyline = Storyline.all_for_revision(revision).first ||
- create(:scrolled_storyline,
- revision:,
- configuration: {main: true})
+ create(:scrolled_storyline, revision:)
end
end
diff --git a/entry_types/scrolled/spec/factories/storylines.rb b/entry_types/scrolled/spec/factories/storylines.rb
index 5ea006ef43..c99d868dd3 100644
--- a/entry_types/scrolled/spec/factories/storylines.rb
+++ b/entry_types/scrolled/spec/factories/storylines.rb
@@ -2,11 +2,7 @@ module PageflowScrolled
FactoryBot.define do
factory :scrolled_storyline, class: Storyline do
revision
- configuration do
- {
- main: true
- }
- end
+ role { 'main' }
end
end
end
diff --git a/entry_types/scrolled/spec/helpers/pageflow_scrolled/entry_json_seed_helper_spec.rb b/entry_types/scrolled/spec/helpers/pageflow_scrolled/entry_json_seed_helper_spec.rb
index 0882947828..a9f4475cc9 100644
--- a/entry_types/scrolled/spec/helpers/pageflow_scrolled/entry_json_seed_helper_spec.rb
+++ b/entry_types/scrolled/spec/helpers/pageflow_scrolled/entry_json_seed_helper_spec.rb
@@ -16,13 +16,24 @@ def render(helper, entry, options = {})
end
context 'storylines' do
- it 'renders storylines with id, perma_id, position and configuration' do
+ it 'renders role of storylines' do
+ entry = create(:published_entry, type_name: 'scrolled')
+ create(:scrolled_storyline, revision: entry.revision, role: nil,
+ configuration: {main: true})
+
+ result = render(helper, entry)
+
+ expect(result).to include_json(collections: {storylines: [{role: 'main'}]})
+ end
+
+ it 'renders storylines with id, perma_id, role, position and configuration' do
entry = create(:published_entry, type_name: 'scrolled')
main_storyline = create(
:scrolled_storyline,
revision: entry.revision,
+ role: 'main',
position: 0,
- configuration: {main: true}
+ configuration: {some: 'value'}
)
excursion_storyline = create(
:scrolled_storyline,
@@ -38,9 +49,10 @@ def render(helper, entry, options = {})
{
id: main_storyline.id,
permaId: main_storyline.perma_id,
+ role: 'main',
position: 0,
configuration: {
- main: true
+ some: 'value'
}
},
{
@@ -53,6 +65,43 @@ def render(helper, entry, options = {})
end
end
+ context 'trash' do
+ it 'omits trashed content from published entries' do
+ entry = create(:published_entry, type_name: 'scrolled')
+ create(:content_element, revision: entry.revision)
+ trashed_content_element = create_trashed_content_element(entry.revision)
+
+ result = JSON.parse(render(helper, entry))
+
+ expect(result['collections']['storylines'].pluck('id'))
+ .not_to include(trashed_content_element.section.chapter.storyline_id)
+ expect(result['collections']['chapters'].pluck('id'))
+ .not_to include(trashed_content_element.section.chapter_id)
+ expect(result['collections']['sections'].pluck('id'))
+ .not_to include(trashed_content_element.section_id)
+ expect(result['collections']['contentElements'].pluck('id'))
+ .not_to include(trashed_content_element.id)
+ end
+
+ it 'omits trashed content from draft entries' do
+ entry = create(:draft_entry, type_name: 'scrolled')
+ trashed_content_element = create_trashed_content_element(entry.revision)
+
+ result = JSON.parse(render(helper, entry, include_hidden_sections: true))
+
+ expect(result['collections']['sections'].pluck('id'))
+ .not_to include(trashed_content_element.section_id)
+ expect(result['collections']['contentElements'].pluck('id'))
+ .not_to include(trashed_content_element.id)
+ end
+
+ def create_trashed_content_element(revision)
+ trash_storyline = Storyline.find_or_create_trash_for(revision)
+ chapter = create(:scrolled_chapter, storyline: trash_storyline)
+ create(:content_element, section: create(:section, chapter:))
+ end
+ end
+
context 'entries' do
it 'renders single-element entry array' do
entry = create(:published_entry,
@@ -157,7 +206,7 @@ def render(helper, entry, options = {})
:scrolled_storyline,
revision: entry.revision,
position: 0,
- configuration: {main: true}
+ role: 'main'
)
excursions_storyline = create(
:scrolled_storyline,
@@ -313,7 +362,7 @@ def render(helper, entry, options = {})
:scrolled_storyline,
revision: entry.revision,
position: 0,
- configuration: {main: true}
+ role: 'main'
)
excursions_storyline = create(
:scrolled_storyline,
@@ -806,7 +855,7 @@ def json_config(result)
:scrolled_storyline,
revision: entry.revision,
position: 0,
- configuration: {main: true}
+ role: 'main'
)
excursions_storyline = create(
:scrolled_storyline,
diff --git a/entry_types/scrolled/spec/helpers/pageflow_scrolled/themes_helper_spec.rb b/entry_types/scrolled/spec/helpers/pageflow_scrolled/themes_helper_spec.rb
index 74301e6bee..d8a520cfa8 100644
--- a/entry_types/scrolled/spec/helpers/pageflow_scrolled/themes_helper_spec.rb
+++ b/entry_types/scrolled/spec/helpers/pageflow_scrolled/themes_helper_spec.rb
@@ -71,6 +71,23 @@ module PageflowScrolled
end
describe '#scrolled_theme_properties_style_tag' do
+ it 'supports including section thumbnail rules' do
+ theme = Pageflow::Theme.new(:test,
+ properties: {
+ root: {
+ section_default_padding_top:
+ 'max(10em, calc(20 * var(--svh, 1svh)))'
+ }
+ })
+
+ html = helper.scrolled_theme_properties_style_tag(theme,
+ include_section_thumbnail_rules: true)
+
+ expect(html).to have_css('style',
+ text: '[data-section-thumbnail]',
+ visible: false)
+ end
+
it 'renders style tag with custom color properties for theme' do
theme = Pageflow::Theme.new(:test,
colors: {
@@ -672,6 +689,52 @@ def upload_font(entry, file_name)
CSS
end
+ it 'declares viewport dependent root properties again for section thumbnails' do
+ theme = Pageflow::Theme.new(:test,
+ properties: {
+ root: {
+ widget_surface_color: '#fff',
+ section_default_padding_top:
+ 'max(10em, calc(20 * var(--svh, 1svh)))'
+ }
+ })
+
+ css = helper.scrolled_theme_properties_rules(theme, include_section_thumbnail_rules: true)
+
+ expect(css).to include(<<~CSS)
+ [data-section-thumbnail] {
+ --theme-section-default-padding-top: max(10em, calc(20 * var(--svh, 1svh)));
+ }
+ CSS
+ end
+
+ it 'does not render section thumbnail rule without viewport dependent root properties' do
+ theme = Pageflow::Theme.new(:test,
+ properties: {
+ root: {
+ widget_surface_color: '#fff'
+ }
+ })
+
+ css = helper.scrolled_theme_properties_rules(theme, include_section_thumbnail_rules: true)
+
+ expect(css).not_to include('data-section-thumbnail')
+ end
+
+ it 'does not render section thumbnail rule unless requested' do
+ theme = Pageflow::Theme.new(:test,
+ properties: {
+ root: {
+ section_default_padding_top:
+ 'max(10em, calc(20 * var(--svh, 1svh)))'
+ }
+ })
+
+ css = helper.scrolled_theme_properties_rules(theme)
+
+ expect(css).not_to include('data-section-thumbnail')
+ end
+
it 'supports media queries' do
theme = Pageflow::Theme.new(:test,
properties: {
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/chapter_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/chapter_spec.rb
index 8803f6df0b..88a3067e77 100644
--- a/entry_types/scrolled/spec/models/pageflow_scrolled/chapter_spec.rb
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/chapter_spec.rb
@@ -26,6 +26,17 @@ module PageflowScrolled
expect(result).to eq([chapter1, chapter2])
end
+
+ it 'excludes chapters in trash storyline' do
+ revision = create(:revision)
+ chapter = create(:scrolled_chapter, revision:)
+ trash_storyline = Storyline.find_or_create_trash_for(revision)
+ create(:scrolled_chapter, storyline: trash_storyline)
+
+ result = Chapter.all_for_revision(revision)
+
+ expect(result).to eq([chapter])
+ end
end
describe '.create_section' do
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/content_element_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/content_element_spec.rb
index d44b22e5e4..406841f0c3 100644
--- a/entry_types/scrolled/spec/models/pageflow_scrolled/content_element_spec.rb
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/content_element_spec.rb
@@ -15,6 +15,32 @@ module PageflowScrolled
expect(result).to eq([content_element1, content_element2, content_element3])
end
+
+ it 'excludes content elements in trash storyline' do
+ revision = create(:revision)
+ content_element = create(:content_element, revision:)
+ trash_storyline = Storyline.find_or_create_trash_for(revision)
+ trash_chapter = create(:scrolled_chapter, storyline: trash_storyline)
+ create(:content_element, section: create(:section, chapter: trash_chapter))
+
+ result = ContentElement.all_for_revision(revision)
+
+ expect(result).to eq([content_element])
+ end
+ end
+
+ describe '.all_for_revision_including_trash' do
+ it 'includes content elements in trash storyline' do
+ revision = create(:revision)
+ content_element = create(:content_element, revision:)
+ trash_storyline = Storyline.find_or_create_trash_for(revision)
+ trash_chapter = create(:scrolled_chapter, storyline: trash_storyline)
+ trashed = create(:content_element, section: create(:section, chapter: trash_chapter))
+
+ result = ContentElement.all_for_revision_including_trash(revision)
+
+ expect(result).to eq([content_element, trashed])
+ end
end
end
end
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/linked_entry_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/linked_entry_spec.rb
index 524fcf9fa0..b6764e20c2 100644
--- a/entry_types/scrolled/spec/models/pageflow_scrolled/linked_entry_spec.rb
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/linked_entry_spec.rb
@@ -29,6 +29,16 @@ module PageflowScrolled
expect(linked_entry.chapters.map(&:perma_id)).to eq([chapter.perma_id])
end
+ it 'skips chapters in trash storyline' do
+ entry = create(:entry, type_name: 'scrolled')
+ trash_storyline = Storyline.find_or_create_trash_for(entry.draft)
+ chapter = create(:scrolled_chapter, storyline: trash_storyline)
+
+ linked_entry = LinkedEntry.all(Pageflow::Entry.all, entry.id => [chapter.perma_id]).first
+
+ expect(linked_entry.chapters).to eq([])
+ end
+
it 'skips chapters that can not be found' do
entry = create(:published_entry, type_name: 'scrolled')
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/revision_content_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/revision_content_spec.rb
index db319a8b99..e0caa19b94 100644
--- a/entry_types/scrolled/spec/models/pageflow_scrolled/revision_content_spec.rb
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/revision_content_spec.rb
@@ -5,18 +5,15 @@ module PageflowScrolled
describe '#main_storyline' do
it 'returns storyline marked as main' do
revision = create(:revision)
- create(:scrolled_storyline, revision:, position: 0, configuration: {})
- main_storyline = create(:scrolled_storyline,
- revision:,
- position: 1,
- configuration: {main: true})
+ create(:scrolled_storyline, revision:, position: 0, role: 'excursions')
+ main_storyline = create(:scrolled_storyline, revision:, position: 1, role: 'main')
expect(RevisionContent.new(revision).main_storyline).to eq(main_storyline)
end
it 'returns nil if no storyline is marked as main' do
revision = create(:revision)
- create(:scrolled_storyline, revision:, configuration: {})
+ create(:scrolled_storyline, revision:, role: 'excursions')
expect(RevisionContent.new(revision).main_storyline).to be_nil
end
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/section_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/section_spec.rb
index 9e1bc08cfb..fa1ef6cb3c 100644
--- a/entry_types/scrolled/spec/models/pageflow_scrolled/section_spec.rb
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/section_spec.rb
@@ -14,6 +14,17 @@ module PageflowScrolled
expect(result).to eq([section1, section2])
end
+
+ it 'excludes sections in trash storyline' do
+ revision = create(:revision)
+ section = create(:section, revision:)
+ trash_storyline = Storyline.find_or_create_trash_for(revision)
+ create(:section, chapter: create(:scrolled_chapter, storyline: trash_storyline))
+
+ result = Section.all_for_revision(revision)
+
+ expect(result).to eq([section])
+ end
end
end
end
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/storyline_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/storyline_spec.rb
index 825fb32ae4..bcdbbc7067 100644
--- a/entry_types/scrolled/spec/models/pageflow_scrolled/storyline_spec.rb
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/storyline_spec.rb
@@ -12,6 +12,14 @@ module PageflowScrolled
expect(storylines.map(&:position)).to eq([0, 1])
end
+ it 'assigns main and excursions roles to default storylines' do
+ entry = create(:entry, type_name: 'scrolled')
+
+ storylines = Storyline.all_for_revision(entry.draft)
+
+ expect(storylines.map(&:role)).to eq(%w[main excursions])
+ end
+
it 'copies a duplicate of itself to new revision' do
Pageflow.config.revision_components.register(Storyline)
revision = create(:revision)
@@ -25,6 +33,129 @@ module PageflowScrolled
expect(copied_storylines.first).not_to eq(storyline)
expect(copied_storylines.first.configuration['some']).to eq('value')
end
+
+ it 'removes trash storyline with its content from published revisions' do
+ entry = create(:entry, type_name: 'scrolled')
+ create_trashed_section(entry.draft)
+
+ entry.publish(creator: create(:user))
+
+ published_revision = entry.reload.published_revision
+ expect(Storyline.where(revision: published_revision, role: 'trash')).to be_empty
+ expect(Chapter.joins(:storyline)
+ .where(pageflow_scrolled_storylines: {revision_id: published_revision}))
+ .to have(0).items
+ end
+
+ it 'removes trash storyline from duplicated entries' do
+ entry = create(:entry, type_name: 'scrolled')
+ create_trashed_section(entry.draft)
+
+ duplicate = entry.duplicate
+
+ expect(Storyline.where(revision: duplicate.draft, role: 'trash')).to be_empty
+ end
+
+ it 'removes trash storyline from revisions copied without purpose' do
+ entry = create(:entry, type_name: 'scrolled')
+ create_trashed_section(entry.draft)
+
+ copied_revision = entry.draft.copy
+
+ expect(Storyline.where(revision: copied_revision, role: 'trash')).to be_empty
+ end
+
+ it 'keeps trash storyline in snapshots' do
+ entry = create(:entry, type_name: 'scrolled')
+ create_trashed_section(entry.draft)
+
+ snapshot = entry.snapshot(creator: create(:user))
+
+ expect(Storyline.where(revision: snapshot, role: 'trash')).to have(1).item
+ end
+
+ it 'restores trash of snapshot with configuration of trashed chapters' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create_trashed_section(
+ entry.draft,
+ chapter_configuration: {'trashedAt' => '2026-10-01T12:00:00Z'}
+ )
+ snapshot = entry.snapshot(creator: create(:user))
+ section.chapter.destroy
+
+ entry.restore(revision: snapshot, creator: create(:user))
+
+ trash_storyline = Storyline.find_by(revision: entry.reload.draft, role: 'trash')
+ expect(trash_storyline.chapters.first.configuration)
+ .to include('trashedAt' => '2026-10-01T12:00:00Z')
+ end
+ end
+
+ def create_trashed_section(revision, chapter_configuration: {})
+ trash_storyline = Storyline.find_or_create_trash_for(revision)
+ chapter = create(:scrolled_chapter,
+ storyline: trash_storyline,
+ configuration: chapter_configuration)
+ create(:section, chapter:)
+ end
+
+ describe '.all_for_revision' do
+ it 'excludes trash storyline' do
+ entry = create(:entry, type_name: 'scrolled')
+ Storyline.find_or_create_trash_for(entry.draft)
+
+ storylines = Storyline.all_for_revision(entry.draft)
+
+ expect(storylines.map(&:role)).to eq(%w[main excursions])
+ end
+
+ it 'includes storylines without role' do
+ revision = create(:revision)
+ storyline = create(:scrolled_storyline, revision:, role: nil)
+
+ storylines = Storyline.all_for_revision(revision)
+
+ expect(storylines).to eq([storyline])
+ end
+ end
+
+ describe '.find_or_create_trash_for' do
+ it 'creates trash storyline after existing storylines' do
+ entry = create(:entry, type_name: 'scrolled')
+
+ trash_storyline = Storyline.find_or_create_trash_for(entry.draft)
+
+ expect(trash_storyline).to have_attributes(role: 'trash', position: 2)
+ end
+
+ it 'returns existing trash storyline' do
+ entry = create(:entry, type_name: 'scrolled')
+ trash_storyline = Storyline.find_or_create_trash_for(entry.draft)
+
+ result = Storyline.find_or_create_trash_for(entry.draft)
+
+ expect(result).to eq(trash_storyline)
+ end
+ end
+
+ describe '#role' do
+ it 'returns stored role' do
+ storyline = build(:scrolled_storyline, role: 'trash', configuration: {'main' => true})
+
+ expect(storyline.role).to eq('trash')
+ end
+
+ it 'falls back to main for storylines with main flag' do
+ storyline = build(:scrolled_storyline, role: nil, configuration: {'main' => true})
+
+ expect(storyline.role).to eq('main')
+ end
+
+ it 'falls back to excursions for other storylines' do
+ storyline = build(:scrolled_storyline, role: nil, configuration: {})
+
+ expect(storyline.role).to eq('excursions')
+ end
end
end
end
diff --git a/entry_types/scrolled/spec/models/pageflow_scrolled/trash_spec.rb b/entry_types/scrolled/spec/models/pageflow_scrolled/trash_spec.rb
new file mode 100644
index 0000000000..74eda4976e
--- /dev/null
+++ b/entry_types/scrolled/spec/models/pageflow_scrolled/trash_spec.rb
@@ -0,0 +1,470 @@
+require 'spec_helper'
+
+module PageflowScrolled
+ RSpec.describe Trash do
+ include ActiveSupport::Testing::TimeHelpers
+
+ describe '#add_section' do
+ it 'removes section from revision' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+
+ Trash.new(entry.draft).add_section(section)
+
+ expect(Section.all_for_revision(entry.draft)).to be_empty
+ end
+
+ it 'moves section into container chapter in trash storyline' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+
+ Trash.new(entry.draft).add_section(section)
+
+ expect(section.reload.chapter.storyline)
+ .to eq(Storyline.find_or_create_trash_for(entry.draft))
+ end
+
+ it 'records kind, origin and trash time in container chapter configuration' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ create(:section, chapter:, position: 0)
+ section = create(:section, chapter:, position: 1)
+
+ travel_to(Time.utc(2026, 10, 1, 12)) do
+ Trash.new(entry.draft).add_section(section)
+ end
+
+ expect(section.reload.chapter.configuration['trash']).to eq(
+ 'kind' => 'section',
+ 'originPermaId' => chapter.perma_id,
+ 'originPosition' => 1,
+ 'trashedAt' => '2026-10-01T12:00:00Z'
+ )
+ end
+
+ it 'appends container chapters after existing items' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ first_section = create(:section, chapter:)
+ second_section = create(:section, chapter:)
+ trash = Trash.new(entry.draft)
+
+ trash.add_section(first_section)
+ trash.add_section(second_section)
+
+ expect(second_section.reload.chapter.position)
+ .to be > first_section.reload.chapter.position
+ end
+
+ it 'keeps perma_ids of section and its content elements' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+
+ expect {
+ Trash.new(entry.draft).add_section(section)
+ }.not_to(change { [section.reload.perma_id, content_element.reload.perma_id] })
+ end
+ end
+
+ describe '#add_chapter' do
+ it 'removes chapter and its sections from revision' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ create(:section, chapter:)
+
+ Trash.new(entry.draft).add_chapter(chapter)
+
+ expect(Chapter.all_for_revision(entry.draft)).to be_empty
+ expect(Section.all_for_revision(entry.draft)).to be_empty
+ end
+
+ it 'moves chapter into trash storyline without container' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ section = create(:section, chapter:)
+
+ Trash.new(entry.draft).add_chapter(chapter)
+
+ expect(chapter.reload.storyline)
+ .to eq(Storyline.find_or_create_trash_for(entry.draft))
+ expect(section.reload.chapter).to eq(chapter)
+ end
+
+ it 'records kind, origin and trash time next to chapter configuration' do
+ entry = create(:entry, type_name: 'scrolled')
+ storyline = Storyline.all_for_revision(entry.draft).first
+ create(:scrolled_chapter, storyline:, position: 0)
+ chapter = create(:scrolled_chapter, storyline:, position: 1,
+ configuration: {'title' => 'Intro'})
+
+ travel_to(Time.utc(2026, 10, 1, 12)) do
+ Trash.new(entry.draft).add_chapter(chapter)
+ end
+
+ expect(chapter.reload.configuration).to eq(
+ 'title' => 'Intro',
+ 'trash' => {
+ 'kind' => 'chapter',
+ 'originPermaId' => storyline.perma_id,
+ 'originPosition' => 1,
+ 'trashedAt' => '2026-10-01T12:00:00Z'
+ }
+ )
+ end
+
+ it 'appends chapter after existing items' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ trash = Trash.new(entry.draft)
+
+ trash.add_section(section)
+ trash.add_chapter(chapter)
+
+ expect(trash.items.map(&:id)).to eq([chapter.id, section.reload.chapter_id])
+ end
+
+ it 'keeps perma_ids of chapter and its sections' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ section = create(:section, chapter:)
+
+ expect {
+ Trash.new(entry.draft).add_chapter(chapter)
+ }.not_to(change { [chapter.reload.perma_id, section.reload.perma_id] })
+ end
+ end
+
+ describe '#add_content_elements' do
+ it 'moves content elements into container section keeping their order' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ first = create(:content_element, section:, position: 0)
+ second = create(:content_element, section:, position: 1)
+
+ Trash.new(entry.draft).add_content_elements([first, second],
+ origin_section: section,
+ origin_position: 0)
+
+ container_section = first.reload.section
+ expect(container_section.chapter.storyline)
+ .to eq(Storyline.find_or_create_trash_for(entry.draft))
+ expect(container_section.content_elements).to eq([first, second.reload])
+ expect(section.reload.content_elements).to be_empty
+ end
+
+ it 'records kind, origin section and position in container chapter configuration' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+
+ travel_to(Time.utc(2026, 10, 1, 12)) do
+ Trash.new(entry.draft).add_content_elements([content_element],
+ origin_section: section,
+ origin_position: 2)
+ end
+
+ expect(content_element.reload.section.chapter.configuration['trash']).to eq(
+ 'kind' => 'contentElements',
+ 'originPermaId' => section.perma_id,
+ 'originPosition' => 2,
+ 'trashedAt' => '2026-10-01T12:00:00Z'
+ )
+ end
+
+ it 'copies invert and layout of origin section to container section' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft,
+ configuration: {'invert' => true,
+ 'layout' => 'right',
+ 'backdrop' => {'image' => 5}})
+ content_element = create(:content_element, section:)
+
+ Trash.new(entry.draft).add_content_elements([content_element],
+ origin_section: section,
+ origin_position: 0)
+
+ expect(content_element.reload.section.configuration)
+ .to eq('invert' => true, 'layout' => 'right')
+ end
+
+ it 'keeps perma_ids of content elements' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+
+ expect {
+ Trash.new(entry.draft).add_content_elements([content_element],
+ origin_section: section,
+ origin_position: 0)
+ }.not_to(change { content_element.reload.perma_id })
+ end
+ end
+
+ describe '#restore with trashed section' do
+ it 'moves section back to origin chapter at origin position' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ first_section = create(:section, chapter:, position: 0)
+ section = create(:section, chapter:, position: 1)
+ last_section = create(:section, chapter:, position: 2)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+
+ trash.find_item(section.reload.chapter_id).restore
+
+ expect(chapter.reload.sections).to eq([first_section, section, last_section])
+ end
+
+ it 'shifts positions of sections at or after origin position' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ section = create(:section, chapter:, position: 0)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+ new_section = create(:section, chapter:, position: 0)
+
+ trash.find_item(section.reload.chapter_id).restore
+
+ expect(chapter.reload.sections.map(&:position)).to eq([0, 1])
+ expect(chapter.sections).to eq([section, new_section])
+ end
+
+ it 'destroys container chapter' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+
+ trash.find_item(section.reload.chapter_id).restore
+
+ expect(trash.items).to be_empty
+ end
+
+ it 'returns restored section' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+
+ result = trash.find_item(section.reload.chapter_id).restore
+
+ expect(result).to eq(section)
+ end
+
+ it 'keeps perma_ids of section and its content elements' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+
+ trash.find_item(section.reload.chapter_id).restore
+
+ expect(ContentElement.all_for_revision(entry.draft).map(&:perma_id))
+ .to eq([content_element.perma_id])
+ expect(Section.all_for_revision(entry.draft).map(&:perma_id))
+ .to eq([section.perma_id])
+ end
+
+ it 'moves section to end of first chapter if origin chapter no longer exists' do
+ entry = create(:entry, type_name: 'scrolled')
+ storyline = Storyline.all_for_revision(entry.draft).first
+ first_chapter = create(:scrolled_chapter, storyline:, position: 0)
+ existing_section = create(:section, chapter: first_chapter, position: 0)
+ origin_chapter = create(:scrolled_chapter, storyline:, position: 1)
+ section = create(:section, chapter: origin_chapter, position: 0)
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+ origin_chapter.destroy
+
+ trash.find_item(section.reload.chapter_id).restore
+
+ expect(first_chapter.reload.sections).to eq([existing_section, section])
+ end
+
+ it 'raises if no chapter is left' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ origin_chapter = section.chapter
+ trash = Trash.new(entry.draft)
+ trash.add_section(section)
+ origin_chapter.destroy
+
+ expect {
+ trash.find_item(section.reload.chapter_id).restore
+ }.to raise_error(Trash::DestinationMissing)
+ end
+ end
+
+ describe '#restore with trashed chapter' do
+ it 'moves chapter back to origin storyline at origin position' do
+ entry = create(:entry, type_name: 'scrolled')
+ storyline = Storyline.all_for_revision(entry.draft).first
+ first_chapter = create(:scrolled_chapter, storyline:, position: 0)
+ chapter = create(:scrolled_chapter, storyline:, position: 1)
+ last_chapter = create(:scrolled_chapter, storyline:, position: 2)
+ trash = Trash.new(entry.draft)
+ trash.add_chapter(chapter)
+
+ trash.find_item(chapter.id).restore
+
+ expect(storyline.reload.chapters).to eq([first_chapter, chapter, last_chapter])
+ end
+
+ it 'shifts positions of chapters at or after origin position' do
+ entry = create(:entry, type_name: 'scrolled')
+ storyline = Storyline.all_for_revision(entry.draft).first
+ chapter = create(:scrolled_chapter, storyline:, position: 0)
+ trash = Trash.new(entry.draft)
+ trash.add_chapter(chapter)
+ new_chapter = create(:scrolled_chapter, storyline:, position: 0)
+
+ trash.find_item(chapter.id).restore
+
+ expect(storyline.reload.chapters.map(&:position)).to eq([0, 1])
+ expect(storyline.chapters).to eq([chapter, new_chapter])
+ end
+
+ it 'restores excursion chapters to excursions storyline' do
+ entry = create(:entry, type_name: 'scrolled')
+ excursions = Storyline.all_for_revision(entry.draft).find_by(role: 'excursions')
+ chapter = create(:scrolled_chapter, storyline: excursions)
+ trash = Trash.new(entry.draft)
+ trash.add_chapter(chapter)
+
+ trash.find_item(chapter.id).restore
+
+ expect(chapter.reload.storyline).to eq(excursions)
+ end
+
+ it 'clears trash metadata and keeps chapter configuration' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft,
+ configuration: {'title' => 'Intro'})
+ trash = Trash.new(entry.draft)
+ trash.add_chapter(chapter)
+
+ trash.find_item(chapter.id).restore
+
+ expect(chapter.reload.configuration).to eq('title' => 'Intro')
+ end
+
+ it 'keeps sections and returns restored chapter' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ section = create(:section, chapter:)
+ trash = Trash.new(entry.draft)
+ trash.add_chapter(chapter)
+
+ result = trash.find_item(chapter.id).restore
+
+ expect(result).to eq(chapter)
+ expect(Section.all_for_revision(entry.draft)).to eq([section])
+ end
+ end
+
+ describe '#restore with trashed content elements' do
+ it 'moves content elements back to origin section at origin position' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ first = create(:content_element, section:, position: 0)
+ trashed = create_list(:content_element, 2, section:)
+ trash = Trash.new(entry.draft)
+ trash.add_content_elements(trashed, origin_section: section, origin_position: 1)
+ last = create(:content_element, section:, position: 1)
+
+ trash.find_item(trashed.first.reload.section.chapter_id).restore
+
+ expect(section.reload.content_elements).to eq([first, *trashed, last])
+ expect(section.content_elements.map(&:position)).to eq([0, 1, 2, 3])
+ end
+
+ it 'destroys container chapter and section' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+ trash = Trash.new(entry.draft)
+ trash.add_content_elements([content_element], origin_section: section,
+ origin_position: 0)
+ container_section = content_element.reload.section
+
+ trash.find_item(container_section.chapter_id).restore
+
+ expect(trash.items).to be_empty
+ expect(Section.exists?(container_section.id)).to eq(false)
+ end
+
+ it 'returns restored content elements keeping their perma_ids' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+ trash = Trash.new(entry.draft)
+ trash.add_content_elements([content_element], origin_section: section,
+ origin_position: 0)
+
+ result = trash.find_item(content_element.reload.section.chapter_id).restore
+
+ expect(result).to eq([content_element])
+ expect(result.first.perma_id).to eq(content_element.perma_id)
+ end
+
+ it 'appends content elements to first section if origin section has been trashed' do
+ entry = create(:entry, type_name: 'scrolled')
+ first_section = create(:section, revision: entry.draft)
+ existing = create(:content_element, section: first_section, position: 0)
+ section = create(:section, chapter: first_section.chapter, position: 1)
+ content_element = create(:content_element, section:)
+ trash = Trash.new(entry.draft)
+ trash.add_content_elements([content_element], origin_section: section,
+ origin_position: 0)
+ trash.add_section(section)
+
+ trash.find_item(content_element.reload.section.chapter_id).restore
+
+ expect(first_section.reload.content_elements).to eq([existing, content_element])
+ end
+
+ it 'raises if no section is left' do
+ entry = create(:entry, type_name: 'scrolled')
+ section = create(:section, revision: entry.draft)
+ content_element = create(:content_element, section:)
+ trash = Trash.new(entry.draft)
+ trash.add_content_elements([content_element], origin_section: section,
+ origin_position: 0)
+ trash.add_section(section)
+
+ expect {
+ trash.find_item(content_element.reload.section.chapter_id).restore
+ }.to raise_error(Trash::DestinationMissing)
+ end
+ end
+
+ describe '#items' do
+ it 'returns items newest first' do
+ entry = create(:entry, type_name: 'scrolled')
+ chapter = create(:scrolled_chapter, revision: entry.draft)
+ first_section = create(:section, chapter:)
+ second_section = create(:section, chapter:)
+ trash = Trash.new(entry.draft)
+ trash.add_section(first_section)
+ trash.add_section(second_section)
+
+ result = Trash.new(entry.draft).items
+
+ expect(result.map(&:id))
+ .to eq([second_section.reload.chapter_id, first_section.reload.chapter_id])
+ end
+
+ it 'does not create trash storyline' do
+ entry = create(:entry, type_name: 'scrolled')
+
+ result = Trash.new(entry.draft).items
+
+ expect(result).to be_empty
+ expect(Storyline.where(revision: entry.draft, role: 'trash')).to be_empty
+ end
+ end
+ end
+end
diff --git a/lib/pageflow/revision_components.rb b/lib/pageflow/revision_components.rb
index ff656f5f36..2c5791c36f 100644
--- a/lib/pageflow/revision_components.rb
+++ b/lib/pageflow/revision_components.rb
@@ -5,16 +5,23 @@ class RevisionComponents # rubocop:todo Style/Documentation
def initialize
@revision_components = []
@create_defaults_hooks = []
+ @after_copy_hooks = []
end
- def register(revision_component, create_defaults: false)
+ def register(revision_component, create_defaults: false, after_copy: false)
return if @revision_components.include?(revision_component)
@revision_components << revision_component
- return unless create_defaults
+ if create_defaults
+ @create_defaults_hooks << ->(revision) { revision_component.create_defaults(revision) }
+ end
- @create_defaults_hooks << ->(revision) { revision_component.create_defaults(revision) }
+ return unless after_copy
+
+ @after_copy_hooks << lambda do |revision, purpose|
+ revision_component.after_copy(revision, purpose:)
+ end
end
def each(&)
@@ -24,5 +31,9 @@ def each(&)
def create_defaults(revision)
@create_defaults_hooks.each { |hook| hook.call(revision) }
end
+
+ def after_copy(revision, purpose:)
+ @after_copy_hooks.each { |hook| hook.call(revision, purpose) }
+ end
end
end
diff --git a/spec/models/pageflow/entry_spec.rb b/spec/models/pageflow/entry_spec.rb
index 752e7a632e..2841daaaca 100644
--- a/spec/models/pageflow/entry_spec.rb
+++ b/spec/models/pageflow/entry_spec.rb
@@ -182,6 +182,27 @@ def self.create_defaults(draft)
end
describe '#publish' do
+ it 'passes publish purpose to after copy hooks of revision components' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ config.revision_components.register(revision_component, after_copy: true)
+ end
+ entry = create(:entry)
+ TestRevisionComponent.create!(revision: entry.draft, text: 'draft')
+
+ entry.publish(creator: create(:user))
+
+ expect(TestRevisionComponent.all_for_revision(entry.reload.published_revision))
+ .to contain_exactly(have_attributes(text: 'publish'))
+ expect(TestRevisionComponent.all_for_revision(entry.draft))
+ .to contain_exactly(have_attributes(text: 'draft'))
+ end
+
it 'creates a revision' do
creator = create(:user)
entry = create(:entry)
@@ -415,6 +436,26 @@ def self.create_defaults(draft)
expect(draft_before_restore.reload).to be_frozen
end
+ it 'passes restore purpose to after copy hooks of revision components' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ config.revision_components.register(revision_component, after_copy: true)
+ end
+ entry = create(:entry)
+ earlier_revision = create(:revision, :published, entry:)
+ TestRevisionComponent.create!(revision: earlier_revision, text: 'earlier')
+
+ entry.restore(revision: earlier_revision, creator: create(:user))
+
+ expect(TestRevisionComponent.all_for_revision(entry.reload.draft))
+ .to contain_exactly(have_attributes(text: 'restore'))
+ end
+
it 'turns previous draft into snapshot of type before_restore' do
creator = create(:user)
entry = create(:entry)
@@ -566,6 +607,46 @@ def self.create_defaults(draft)
expect { entry.duplicate }.to(change { Entry.count })
end
+
+ it 'passes duplicate purpose to after copy hooks of revision components' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ config.revision_components.register(revision_component, after_copy: true)
+ end
+ entry = create(:entry)
+ TestRevisionComponent.create!(revision: entry.draft, text: 'draft')
+
+ duplicate = entry.duplicate
+
+ expect(TestRevisionComponent.all_for_revision(duplicate.draft))
+ .to contain_exactly(have_attributes(text: 'duplicate'))
+ end
+ end
+
+ describe '#snapshot' do
+ it 'passes snapshot purpose to after copy hooks of revision components' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ config.revision_components.register(revision_component, after_copy: true)
+ end
+ entry = create(:entry)
+ TestRevisionComponent.create!(revision: entry.draft, text: 'draft')
+
+ revision = entry.snapshot(creator: create(:user))
+
+ expect(TestRevisionComponent.all_for_revision(revision))
+ .to contain_exactly(have_attributes(text: 'snapshot'))
+ end
end
describe '.include_account_name' do
diff --git a/spec/models/pageflow/revision_spec.rb b/spec/models/pageflow/revision_spec.rb
index cf318133da..6ed6dd5198 100644
--- a/spec/models/pageflow/revision_spec.rb
+++ b/spec/models/pageflow/revision_spec.rb
@@ -79,6 +79,67 @@ module Pageflow
end
describe '#copy' do
+ it 'passes duplicate purpose to after copy hooks by default' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ config.revision_components.register(revision_component, after_copy: true)
+ end
+ revision = create(:revision)
+ TestRevisionComponent.create!(revision:, text: 'original')
+
+ copied_revision = revision.copy
+
+ expect(TestRevisionComponent.all_for_revision(copied_revision))
+ .to contain_exactly(have_attributes(text: 'duplicate'))
+ end
+
+ it 'does not call after copy hooks registered for other entry types' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ rainbow_entry_type = TestEntryType.register(config, name: 'rainbow')
+
+ config.for_entry_type(rainbow_entry_type) do |c|
+ c.revision_components.register(revision_component, after_copy: true)
+ end
+ end
+ revision = create(:entry).draft
+ TestRevisionComponent.create!(revision:, text: 'original')
+
+ copied_revision = revision.copy
+
+ expect(TestRevisionComponent.all_for_revision(copied_revision))
+ .to contain_exactly(have_attributes(text: 'original'))
+ end
+
+ it 'passes given purpose to after copy hooks' do
+ revision_component = Class.new(TestRevisionComponent) do
+ def self.after_copy(revision, purpose:)
+ all_for_revision(revision).update_all(text: purpose.to_s)
+ end
+ end
+
+ pageflow_configure do |config|
+ config.revision_components.register(revision_component, after_copy: true)
+ end
+ revision = create(:revision)
+ TestRevisionComponent.create!(revision:, text: 'original')
+
+ copied_revision = revision.copy(purpose: :snapshot)
+
+ expect(TestRevisionComponent.all_for_revision(copied_revision))
+ .to contain_exactly(have_attributes(text: 'snapshot'))
+ end
+
it 'creates a new revision' do
revision = create(:revision)