Merge pull request #2504 from tf/fragments

Fragments

Author: tf

app/assets/stylesheets/pageflow/editor/files_explorer.scss

@@ -171,7 +171,7 @@
     border-left-color: var(--ui-on-surface-color-lightest);
     border-top-left-radius: 0;
     border-bottom-left-radius: 0;
-    background-color: #{mix(#06202a, #fff, 3%)};
+    background-color: var(--ui-secondary-surface-color);
     overflow: auto;
   }
 

app/assets/stylesheets/pageflow/ui/properties.scss

@@ -15,6 +15,7 @@
   --ui-font-size: 13px;
 
   --ui-surface-color: #fff;
+  --ui-secondary-surface-color: #{mix(#06202a, #fff, 3%)};
   --ui-backdrop-color: rgba(6, 32, 42, 0.6);
 
   --ui-on-surface-color: hsl(197, 26%, 23%);

db/migrate/20260914000000_add_fragment_library_to_entries.rb

@@ -0,0 +1,5 @@
+class AddFragmentLibraryToEntries < ActiveRecord::Migration[7.1]
+  def change
+    add_column :pageflow_entries, :fragment_library, :string
+  end
+end

entry_types/scrolled/app/controllers/pageflow_scrolled/editor/fragment_extractions_controller.rb

@@ -0,0 +1,24 @@
+module PageflowScrolled
+  module Editor
+    # @api private
+    class FragmentExtractionsController < ActionController::Base
+      include Pageflow::EditorController
+
+      before_action do
+        head :not_found unless @entry.feature_state('fragments')
+      end
+
+      def create
+        chapter = Chapter.all_for_revision(@entry.draft).find(params[:chapter_id])
+        library = FragmentLibrary.shared_for_account(@entry.account)
+
+        authorize!(:update, library)
+        library.extract_fragment_from(entry: @entry, chapter:, title: params[:title])
+
+        head :created
+      rescue ActiveRecord::RecordNotFound
+        head :not_found
+      end
+    end
+  end
+end

entry_types/scrolled/app/controllers/pageflow_scrolled/editor/fragment_insertions_controller.rb

@@ -0,0 +1,32 @@
+module PageflowScrolled
+  module Editor
+    # @api private
+    class FragmentInsertionsController < ActionController::Base
+      include Pageflow::EditorController
+
+      before_action do
+        head :not_found unless @entry.feature_state('fragments')
+      end
+
+      def create
+        chapter = Chapter.all_for_revision(@entry.draft).find(params[:chapter_id])
+
+        @sections = authorized_scope(:read, FragmentLibrary)
+                    .find(fragment_params[:entry_id])
+                    .copy_fragment_to(fragment_perma_id: fragment_params[:chapter_perma_id],
+                                      entry: @entry,
+                                      chapter:)
+
+        render :create, status: :created
+      rescue ActiveRecord::RecordNotFound
+        head :not_found
+      end
+
+      private
+
+      def fragment_params
+        params.require(:fragment).permit(:entry_id, :chapter_perma_id)
+      end
+    end
+  end
+end

entry_types/scrolled/app/controllers/pageflow_scrolled/editor/fragment_libraries_controller.rb

@@ -0,0 +1,18 @@
+module PageflowScrolled
+  module Editor
+    # @api private
+    class FragmentLibrariesController < ActionController::Base
+      include Pageflow::EditorController
+
+      helper Pageflow::FilesHelper
+
+      before_action do
+        head :not_found unless @entry.feature_state('fragments')
+      end
+
+      def index
+        @libraries = authorized_scope(:read, FragmentLibrary.where(account: @entry.account))
+      end
+    end
+  end
+end

entry_types/scrolled/app/helpers/pageflow_scrolled/editor/seed_html_helper.rb

@@ -14,27 +14,47 @@ module SeedHtmlHelper
       include WebpackPublicPathHelper
 
       def scrolled_editor_iframe_seed_html_script_tag(entry)
-        html = render(template: 'pageflow_scrolled/entries/show',
-                      locals: {
-                        entry:,
-                        entry_mode: :editor,
-                        skip_ssr: true,
-                        skip_structured_data: true,
-                        skip_feed_link_tags: true,
-                        skip_hreflang_link_tags: true,
-                        seed_options: {
-                          skip_collections: true,
-                          include_unused_additional_seed_data: true,
-                          include_unused_file_reference_locations: true,
-                          include_theme_translations: true,
-                          load_inline_editing: true
-                        }
-                      })
+        seed_html_script_tag(entry, template: 'iframe_seed', load_inline_editing: true)
+      end
+
+      def scrolled_editor_fragment_preview_seed_html_script_tag(entry)
+        seed_html_script_tag(entry,
+                             template: 'fragment_preview_seed',
+                             accept_collection_resets: true)
+      end
+
+      private
 
+      def seed_html_script_tag(entry, template:, **seed_options)
         content_tag(:script,
-                    html.gsub('</', '<\/').html_safe,
+                    seed_html(entry, **seed_options).gsub('</', '<\/').html_safe,
                     type: 'text/html',
-                    data: {template: 'iframe_seed'})
+                    data: {template:})
+      end
+
+      def seed_html(entry, **seed_options)
+        separate_view.render(template: 'pageflow_scrolled/entries/show',
+                             locals: {
+                               entry:,
+                               entry_mode: :editor,
+                               skip_ssr: true,
+                               skip_structured_data: true,
+                               skip_feed_link_tags: true,
+                               skip_hreflang_link_tags: true,
+                               seed_options: {
+                                 skip_collections: true,
+                                 include_unused_additional_seed_data: true,
+                                 include_unused_file_reference_locations: true,
+                                 include_theme_translations: true,
+                                 **seed_options
+                               }
+                             })
+      end
+
+      # Shakapacker allows a single pack tag per view and collects the
+      # packs of all documents rendered by it.
+      def separate_view
+        self.class.new(lookup_context, assigns, controller).extend(SeedHtmlHelper)
       end
     end
   end

entry_types/scrolled/app/models/pageflow_scrolled/fragment_library.rb

@@ -0,0 +1,141 @@
+module PageflowScrolled
+  # @api private
+  class FragmentLibrary
+    attr_reader :entry, :account
+
+    delegate :id, to: :entry
+
+    def self.all
+      Query.new(Pageflow::Entry.where(fragment_library: 'shared'))
+    end
+
+    def self.where(...)
+      all.where(...)
+    end
+
+    def self.shared_for_account(account)
+      entry = Pageflow::Entry
+              .where(account:, type_name: 'scrolled', fragment_library: 'shared')
+              .order(:id)
+              .first
+
+      new(entry && Pageflow::DraftEntry.new(entry), account:)
+    end
+
+    def initialize(entry, account: entry.account)
+      @entry = entry
+      @account = account
+    end
+
+    def persisted?
+      entry.present?
+    end
+
+    def title
+      entry.entry_title
+    end
+
+    def storylines
+      Storyline.all_for_revision(entry.draft)
+    end
+
+    def chapters
+      Chapter.all_for_revision(entry.draft)
+    end
+
+    def sections
+      Section.all_for_revision(entry.draft)
+    end
+
+    def content_elements
+      ContentElement.all_for_revision(entry.draft)
+    end
+
+    def copy_fragment_to(fragment_perma_id:, entry:, chapter:)
+      SectionsCopy
+        .new(source_entry: self.entry, destination_entry: entry)
+        .perform(chapters.find_by!(perma_id: fragment_perma_id).sections, chapter:)
+    end
+
+    def extract_fragment_from(entry:, chapter:, title: nil)
+      ActiveRecord::Base.transaction do
+        @entry ||= create_entry(locale: entry.locale)
+
+        SectionsCopy
+          .new(source_entry: entry, destination_entry: self.entry)
+          .perform(chapter.sections, chapter: create_fragment_chapter(chapter, title))
+      end
+    end
+
+    private
+
+    def create_entry(locale:)
+      Pageflow::DraftEntry.new(
+        Pageflow::Entry.create!(
+          account:,
+          site: account.default_site,
+          type_name: 'scrolled',
+          fragment_library: 'shared',
+          title: I18n.t('pageflow_scrolled.fragment_library.title',
+                        account_name: account.name,
+                        locale: locale == 'de' ? :de : :en)
+        )
+      )
+    end
+
+    def create_fragment_chapter(chapter, title)
+      storyline = storylines.detect { |candidate| candidate.configuration['main'] }
+
+      storyline.chapters.create!(position: (storyline.chapters.maximum(:position) || -1) + 1,
+                                 configuration: fragment_configuration(chapter, title))
+    end
+
+    def fragment_configuration(chapter, title)
+      title = title.presence&.strip
+      title ? chapter.configuration.merge('title' => title) : chapter.configuration
+    end
+
+    # @api private
+    class Query
+      include Enumerable
+
+      def initialize(entries)
+        @entries = entries
+      end
+
+      def model
+        FragmentLibrary
+      end
+
+      def all
+        self
+      end
+
+      def none
+        Query.new(@entries.none)
+      end
+
+      def where(...)
+        Query.new(@entries.where(...))
+      end
+
+      def merge(entries)
+        Query.new(@entries.merge(entries))
+      end
+
+      def find(id)
+        library(@entries.find(id))
+      end
+
+      def each(&)
+        @entries.order(:id).map { |entry| library(entry) }.each(&)
+      end
+
+      private
+
+      def library(entry)
+        FragmentLibrary.new(Pageflow::DraftEntry.new(entry))
+      end
+    end
+  end
+end

entry_types/scrolled/app/policies/pageflow_scrolled/fragment_library_policy.rb

@@ -0,0 +1,45 @@
+module PageflowScrolled
+  # @api private
+  class FragmentLibraryPolicy
+    # @api private
+    class Scope
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      def read
+        return @scope if @user.admin?
+
+        @scope.merge(
+          Pageflow::EntryRoleQuery::Scope.new(@user, Pageflow::Entry).with_role_at_least(:previewer)
+        )
+      end
+    end
+
+    def initialize(user, library)
+      @user = user
+      @library = library
+    end
+
+    def read?
+      @user.admin? || entry_role_query.has_at_least_role?(:previewer)
+    end
+
+    def update?
+      return true if @user.admin?
+
+      if @library.persisted?
+        entry_role_query.has_at_least_role?(:editor)
+      else
+        Pageflow::AccountRoleQuery.new(@user, @library.account).has_at_least_role?(:editor)
+      end
+    end
+
+    private
+
+    def entry_role_query
+      Pageflow::EntryRoleQuery.new(@user, @library.entry)
+    end
+  end
+end

entry_types/scrolled/app/views/pageflow_scrolled/editor/entries/_body.html.erb

@@ -1 +1,2 @@
 <%= scrolled_editor_iframe_seed_html_script_tag(entry) %>
+<%= scrolled_editor_fragment_preview_seed_html_script_tag(entry) %>