pageflow 17.1.0 → 17.2.0

data/app/models/pageflow/comment.rb

@@ -0,0 +1,30 @@
+module Pageflow
+  # @api private
+  class Comment < ApplicationRecord
+    include NestedRevisionComponent
+
+    # Quotes are recorded by the client, so cut rather than reject: an
+    # unexpectedly long selection must not keep a comment from being saved.
+    # Kept in sync with the limit quote extraction applies in
+    # entry_types/scrolled/package/src/review/subjectQuote.js, so that a
+    # recorded quote stays comparable to the text as it reads later on.
+    QUOTE_LIMIT = 4_000
+
+    belongs_to :comment_thread
+    belongs_to :creator, class_name: 'User'
+
+    validates :body, presence: true
+
+    before_validation :truncate_quote
+
+    def entry_for_auto_generated_perma_id
+      comment_thread.revision.entry
+    end
+
+    private
+
+    def truncate_quote
+      self.quote = quote[0, QUOTE_LIMIT] if quote
+    end
+  end
+end

data/app/models/pageflow/comment_thread.rb

@@ -0,0 +1,65 @@
+module Pageflow
+  # @api private
+  class CommentThread < ApplicationRecord
+    include RevisionComponent
+
+    serialize :subject_range, coder: JSON
+
+    belongs_to :creator, class_name: 'User'
+    belongs_to :resolver, class_name: 'User', foreign_key: :resolved_by_id, optional: true
+    # Ordered because clients read position as meaning: the first comment
+    # is the topic, the rest are replies.
+    has_many :comments, -> { order(:id) }, dependent: :destroy
+
+    nested_revision_components :comments
+
+    validates :subject_type, :subject_id, presence: true
+
+    def resolve(user)
+      update!(resolved_at: Time.current, resolver: user) unless resolved_at
+    end
+
+    def unresolve
+      update!(resolved_at: nil, resolver: nil)
+    end
+
+    def self.migrate_to_subject(revision:, subject_type:, subject_id:, thread_ids:)
+      return if thread_ids.blank?
+
+      where(revision_id: revision.id,
+            subject_type:,
+            id: thread_ids).update_all(subject_id:, updated_at: Time.current)
+    end
+
+    def self.update_subject_ranges_for(revision:, subject_type:, subject_id:, ranges:)
+      return if ranges.blank?
+
+      where(revision_id: revision.id,
+            subject_type:, subject_id:,
+            id: ranges.keys).update_all(
+              sanitize_sql_array(
+                ["subject_range = #{subject_range_case_sql(ranges)}, updated_at = ?",
+                 Time.current]
+              )
+            )
+    end
+
+    def self.update_section_perma_id_for(revision:, subject_type:, subject_id:, section_perma_id:)
+      return if subject_id.blank?
+
+      where(revision_id: revision.id,
+            subject_type:,
+            subject_id:)
+        .where.not(section_perma_id:)
+        .update_all(section_perma_id:, updated_at: Time.current)
+    end
+
+    def self.subject_range_case_sql(ranges)
+      when_clauses = ranges.map do |id, range|
+        sanitize_sql_array(['WHEN ? THEN ?', id.to_i, range.to_json])
+      end
+      "CASE id #{when_clauses.join(' ')} END"
+    end
+    private_class_method :subject_range_case_sql
+  end
+end

data/app/models/pageflow/comment_thread_read.rb

@@ -0,0 +1,22 @@
+module Pageflow
+  # Records when a user last read a comment thread. Keyed by perma id
+  # so read state survives comment threads being copied to a new
+  # revision.
+  #
+  # @api private
+  class CommentThreadRead < ApplicationRecord
+    belongs_to :entry
+    belongs_to :user
+
+    def self.read_at_by_perma_id(entry:, user:)
+      where(entry:, user:).pluck(:comment_thread_perma_id, :read_at).to_h
+    end
+
+    def self.mark(entry:, user:, comment_thread_perma_ids:, read_at: Time.current)
+      comment_thread_perma_ids.each do |perma_id|
+        find_or_initialize_by(entry:, user:, comment_thread_perma_id: perma_id)
+          .update!(read_at:)
+      end
+    end
+  end
+end

data/app/models/pageflow/customized_theme.rb

@@ -1,9 +1,9 @@
 module Pageflow
   # @api private
   class CustomizedTheme < SimpleDelegator
-    def initialize(theme, overrides, files)
+    def initialize(theme, transformed_options, overrides, files)
       super(theme)
-      @options = __getobj__.options.deep_merge(overrides || {})
+      @options = transformed_options.deep_merge(overrides || {})
       @files = files
     end
 
@@ -24,6 +24,7 @@ module Pageflow
       config = Pageflow.config_for(entry)
 
       new(theme,
+          config.themes.apply_default_options(theme.options, entry:),
           config.transform_theme_customization_overrides.call(
             theme_customization.overrides,
             entry:,

data/app/models/pageflow/draft_entry.rb

@@ -31,15 +31,18 @@ module Pageflow
     def create_file!(file_type, attributes)
       check_foreign_key_custom_attributes(file_type.custom_attributes, attributes)
 
-      file = file_type.model.create!(
-        attributes
-          .except(:configuration, :display_name)
-          .merge(file_name: generate_file_name(attributes[:display_name]))
-      ) { |f| f.entry = entry }
+      file_attributes = attributes.except(:configuration, :display_name, :folder_perma_id)
+
+      if file_name_attribute?(file_type)
+        file_attributes[:file_name] = generate_file_name(attributes[:display_name])
+      end
+
+      file = file_type.model.create!(file_attributes) { |f| f.entry = entry }
 
       usage = revision.file_usages.create!(file:,
                                            configuration: attributes[:configuration],
-                                           display_name: attributes[:display_name])
+                                           display_name: attributes[:display_name],
+                                           folder_perma_id: attributes[:folder_perma_id])
       UsedFile.new(file, usage)
     end
 
@@ -59,10 +62,15 @@ module Pageflow
       file.destroy if file.usages.reload.empty?
     end
 
-    def use_file(file)
+    def create_folder!(attributes)
+      draft.file_folders.create!(attributes)
+    end
+
+    def use_file(file, folder_perma_id: nil)
       draft.file_usages.create!(file: file.to_model,
                                 configuration: file.configuration,
-                                display_name: file.display_name)
+                                display_name: file.display_name,
+                                folder_perma_id:)
     end
 
     def save!
@@ -115,6 +123,10 @@ module Pageflow
         end
     end
 
+    def file_name_attribute?(file_type)
+      file_type.model.new.respond_to?(:file_name=)
+    end
+
     def generate_file_name(file_name)
       return nil if file_name.blank?
 

data/app/models/pageflow/entry.rb

@@ -33,6 +33,8 @@ module Pageflow
 
     has_many :imports, class_name: 'Pageflow::FileImport', dependent: :destroy
 
+    has_many :comment_thread_reads, dependent: :destroy
+
     has_one :draft, -> { editable }, class_name: 'Revision', inverse_of: :entry
     has_one :published_revision, -> { published }, class_name: 'Revision', inverse_of: :entry
 

data/app/models/pageflow/entry_at_revision.rb

@@ -26,18 +26,22 @@ module Pageflow
              :type_name,
              to: :entry)
 
-    delegate(:title, :summary, :credits,
+    delegate(:layout_version,
+             :title, :summary, :credits,
              :widgets,
              :storylines, :main_storyline_chapters, :chapters, :pages,
              :share_url, :share_image_id, :share_image_x, :share_image_y,
              :share_providers, :active_share_providers,
              :find_files, :find_file, :find_file_by_perma_id,
+             :file_folders,
              :image_files, :video_files, :audio_files,
              :locale,
              :author, :publisher, :keywords,
              :published_at,
              :noindex?,
+             :comment_threads,
              :configuration,
+             :structured_data_type_name,
              to: :revision)
 
     def resolve_widgets(options = {})
@@ -48,6 +52,10 @@ module Pageflow
       @theme ||= CustomizedTheme.find(entry: self, theme: revision.theme)
     end
 
+    def legal_info
+      @legal_info ||= site.legal_info(locale:)
+    end
+
     def home_button
       HomeButton.new(revision, site)
     end

data/app/models/pageflow/entry_comment_summary.rb

@@ -0,0 +1,114 @@
+module Pageflow
+  # Counts of comment topics and of activity the user has not seen, for
+  # displaying an indicator next to an entry in lists of entries.
+  #
+  # Built for a whole page of entries at once: rendering a list must not
+  # query per row.
+  #
+  # @api private
+  class EntryCommentSummary
+    attr_reader :topic_count, :unread_topic_count, :unread_reply_count, :unread_resolution_count
+
+    def self.for_entries(entries, user:)
+      entries = entries.to_a
+      return {} if entries.empty?
+
+      threads = threads_by_entry_id(entries)
+      read_at = read_at_by_entry_id(entries, user)
+
+      entries.to_h do |entry|
+        [entry.id, build(threads.fetch(entry.id, []),
+                         read_at: read_at.fetch(entry.id, {}),
+                         user:)]
+      end
+    end
+
+    def initialize(topic_count:, unread_topic_count:, unread_reply_count:,
+                   unread_resolution_count: 0)
+      @topic_count = topic_count
+      @unread_topic_count = unread_topic_count
+      @unread_reply_count = unread_reply_count
+      @unread_resolution_count = unread_resolution_count
+    end
+
+    # Unread activity shows even where no topic is left open: the last
+    # one being resolved is exactly what the user should not miss.
+    def any?
+      topic_count.positive? || unread?
+    end
+
+    def unread?
+      unread_topic_count.positive? ||
+        unread_reply_count.positive? ||
+        unread_resolution_count.positive?
+    end
+
+    # Comment threads live on the draft revision, so entries are reached
+    # through their editable revision rather than directly. Resolved ones
+    # come along: somebody resolving a thread is activity of its own.
+    def self.threads_by_entry_id(entries)
+      entry_id_by_revision_id =
+        Revision.editable.where(entry_id: entries.map(&:id)).pluck(:id, :entry_id).to_h
+
+      CommentThread
+        .where(revision_id: entry_id_by_revision_id.keys)
+        .includes(:comments)
+        .group_by { |thread| entry_id_by_revision_id[thread.revision_id] }
+    end
+    private_class_method :threads_by_entry_id
+
+    def self.read_at_by_entry_id(entries, user)
+      CommentThreadRead
+        .where(user:, entry_id: entries.map(&:id))
+        .pluck(:entry_id, :comment_thread_perma_id, :read_at)
+        .group_by(&:first)
+        .transform_values do |rows|
+          rows.to_h { |(_entry_id, perma_id, read_at)| [perma_id, read_at] }
+        end
+    end
+    private_class_method :read_at_by_entry_id
+
+    def self.build(threads, read_at:, user:)
+      unread = threads.map { |thread| unread_activity(thread, read_at:, user:) }
+
+      new(topic_count: threads.count { |thread| thread.resolved_at.nil? },
+          unread_topic_count: unread.count { |kinds| kinds.include?(:topic) },
+          unread_reply_count: unread.sum { |kinds| kinds.count(:reply) },
+          unread_resolution_count: unread.count { |kinds| kinds.include?(:resolution) })
+    end
+    private_class_method :build
+
+    # What the user has not seen in a thread, as one symbol per event.
+    # The resolution goes by the thread's read mark like the comments do,
+    # having none of its own.
+    def self.unread_activity(thread, read_at:, user:)
+      seen_up_to = [read_at[thread.perma_id], user.unread_comments_since_at].compact.max
+      first, *replies = thread.comments.sort_by(&:id)
+
+      unread_replies = replies.count do |reply|
+        unread?(reply.creator_id, reply.created_at, seen_up_to, user)
+      end
+
+      kinds = Array.new(unread_replies, :reply)
+      kinds << :topic if first && unread?(first.creator_id, first.created_at, seen_up_to, user)
+      kinds << :resolution if unread_resolution?(thread, seen_up_to, user)
+      kinds
+    end
+    private_class_method :unread_activity
+
+    def self.unread_resolution?(thread, seen_up_to, user)
+      thread.resolved_at &&
+        unread?(thread.resolved_by_id, thread.resolved_at, seen_up_to, user)
+    end
+    private_class_method :unread_resolution?
+
+    # Mirrors the unread rule of the review interface: the user's own
+    # activity never counts, and neither does anything from before their
+    # baseline. Kept in sync with isUnread in
+    # entry_types/scrolled/package/src/review/unreadActivity.js.
+    def self.unread?(creator_id, created_at, seen_up_to, user)
+      creator_id != user.id && (seen_up_to.nil? || created_at > seen_up_to)
+    end
+    private_class_method :unread?
+  end
+end

data/app/models/pageflow/file_folder.rb

@@ -0,0 +1,74 @@
+module Pageflow
+  # Groups the file usages of a revision. Folders refer to their parent
+  # folder by perma id since row ids would not survive copying a
+  # revision.
+  #
+  # @api private
+  class FileFolder < ApplicationRecord
+    include RevisionComponent
+
+    validates :name, presence: true
+    validate :parent_belongs_to_revision
+    validate :parent_is_not_nested_inside_folder
+
+    def parent
+      return if parent_folder_perma_id.blank?
+
+      folders_of_revision.find_by(perma_id: parent_folder_perma_id)
+    end
+
+    # Broken data with a folder nested inside one of its own descendants
+    # would make walking up the tree loop forever.
+    def ancestors
+      result = []
+      current = parent
+
+      while current && result.exclude?(current)
+        result.unshift(current)
+        current = current.parent
+      end
+
+      result
+    end
+
+    def children
+      folders_of_revision.where(parent_folder_perma_id: perma_id)
+    end
+
+    def file_usages
+      revision.file_usages.where(folder_perma_id: perma_id)
+    end
+
+    def empty?
+      children.none? && file_usages.none?
+    end
+
+    private
+
+    # A folder from another revision would leave this folder unreachable
+    # in any folder tree.
+    def parent_belongs_to_revision
+      return if parent_folder_perma_id.blank? || revision.blank?
+      return if folders_of_revision.exists?(perma_id: parent_folder_perma_id)
+
+      errors.add(:parent_folder_perma_id, 'unknown folder')
+    end
+
+    # Nesting a folder inside itself or inside one of its own subfolders
+    # would detach the whole subtree from the folder tree.
+    def parent_is_not_nested_inside_folder
+      return if parent_folder_perma_id.blank? || revision.blank?
+
+      parent_folder = parent
+
+      return if parent_folder.blank?
+      return if [parent_folder, *parent_folder.ancestors].exclude?(self)
+
+      errors.add(:parent_folder_perma_id, 'nested inside folder')
+    end
+
+    def folders_of_revision
+      FileFolder.all_for_revision(revision)
+    end
+  end
+end

data/app/models/pageflow/file_reuse.rb

@@ -2,15 +2,16 @@ module Pageflow
   class FileReuse # rubocop:todo Style/Documentation
     attr_accessor :source_entry, :destination_entry, :file_type, :file
 
-    def initialize(destination_entry, source_entry, file_type, file_id)
+    def initialize(destination_entry, source_entry, file_type, file_id, folder_perma_id: nil)
       @source_entry = source_entry
       @destination_entry = destination_entry
       @file_type = file_type
       @file = source_entry.find_file(file_type.model, file_id)
+      @folder_perma_id = folder_perma_id
     end
 
     def save! # rubocop:todo Metrics/AbcSize
-      destination_entry.use_file(file)
+      destination_entry.use_file(file, folder_perma_id: @folder_perma_id)
 
       file_type.nested_file_types.each do |nested_file_type|
         source_entry.find_files(nested_file_type.model).each do |nested_file|

data/app/models/pageflow/file_usage.rb

@@ -8,6 +8,7 @@ module Pageflow
     belongs_to :file, polymorphic: true
 
     validate :display_name_extension_matches
+    validate :folder_belongs_to_revision
 
     private
 
@@ -17,5 +18,12 @@ module Pageflow
 
       errors.add(:display_name, 'extension mismatch')
     end
+
+    def folder_belongs_to_revision
+      return if folder_perma_id.blank? || revision.blank?
+      return if FileFolder.all_for_revision(revision).exists?(perma_id: folder_perma_id)
+
+      errors.add(:folder_perma_id, 'unknown folder')
+    end
   end
 end

data/app/models/pageflow/image_file.rb

@@ -40,26 +40,30 @@ module Pageflow
 
       Pageflow
         .config.thumbnail_styles.transform_values { |options| options.merge(style_defaults) }
-        .merge(
-          print: {geometry: '300x300>',
-                  **style_defaults,
-                  convert_options: '-quality 10 -interlace Plane'},
-          medium: {geometry: '1024x1024>',
-                   **style_defaults,
-                   convert_options: '-quality 70 -interlace Plane'},
-          large: {geometry: '1920x1920>',
-                  **style_defaults,
-                  convert_options: '-quality 70 -interlace Plane'},
-          ultra: {geometry: '3840x3840>',
-                  **style_defaults,
-                  convert_options: '-quality 90 -interlace Plane'},
-          panorama_medium: {geometry: ImageFile.scale_down_to_cover(1024, 1024),
-                            format: panorama_format,
-                            convert_options: '-quality 90 -interlace Plane'},
-          panorama_large: {geometry: ImageFile.scale_down_to_cover(1920, 1080),
-                           format: panorama_format,
-                           convert_options: '-quality 90 -interlace Plane'}
-        )
+                                .merge(
+                                  print: {geometry: '300x300>',
+                                          **style_defaults,
+                                          convert_options: '-quality 10 -interlace Plane'},
+                                  medium: {geometry: '1024x1024>',
+                                           **style_defaults,
+                                           convert_options: '-quality 70 -interlace Plane'},
+                                  large: {geometry: '1920x1920>',
+                                          **style_defaults,
+                                          convert_options: '-quality 70 -interlace Plane'},
+                                  ultra: {geometry: '3840x3840>',
+                                          **style_defaults,
+                                          convert_options: '-quality 90 -interlace Plane'},
+                                  panorama_medium: {
+                                    geometry: ImageFile.scale_down_to_cover(1024, 1024),
+                                    format: panorama_format,
+                                    convert_options: '-quality 90 -interlace Plane'
+                                  },
+                                  panorama_large: {
+                                    geometry: ImageFile.scale_down_to_cover(1920, 1080),
+                                    format: panorama_format,
+                                    convert_options: '-quality 90 -interlace Plane'
+                                  }
+                                )
         .merge(social_image_styles)
     end
 

data/app/models/pageflow/image_file_url_templates.rb

@@ -1,10 +1,10 @@
 module Pageflow
   class ImageFileUrlTemplates # rubocop:todo Style/Documentation
     def call
-      styles.each_with_object({}) do |style, result|
-        result[style] = replace_extension_with_placeholder(
+      styles.to_h do |style|
+        [style, replace_extension_with_placeholder(
           UrlTemplate.from_attachment(example_file.attachment, style)
-        )
+        )]
       end
     end
 

data/app/models/pageflow/legal_info.rb

@@ -0,0 +1,38 @@
+module Pageflow
+  # Legal info of a site, resolved for a single locale. Each attribute
+  # falls back to the value stored in the site's column when there is
+  # no translation for the locale.
+  #
+  # @since 17.2
+  class LegalInfo
+    Link = Struct.new(:label, :url, keyword_init: true)
+
+    def initialize(site, locale)
+      @site = site
+      @locale = locale
+    end
+
+    def imprint
+      @imprint ||= link('imprint')
+    end
+
+    def copyright
+      @copyright ||= link('copyright')
+    end
+
+    def privacy_url
+      translated(:privacy_link_url)
+    end
+
+    private
+
+    def link(kind)
+      Link.new(label: translated("#{kind}_link_label"),
+               url: translated("#{kind}_link_url"))
+    end
+
+    def translated(attribute)
+      @site.translated(attribute, locale: @locale)
+    end
+  end
+end

data/app/models/pageflow/nested_revision_component_copy.rb

@@ -166,7 +166,7 @@ module Pageflow
       "#{[*chain, model].first.old_foreign_key} = #{@old_root_id}"
     end
 
-    Model = Struct.new(:klass, :foreign_key, :level, keyword_init: true) do
+    Model = Struct.new(:klass, :foreign_key, :level) do
       def self.for(revision_components:)
         revision_components.map do |revision_component|
           Model.new(klass: revision_component, foreign_key: 'revision_id', level: 1)

data/app/models/pageflow/permalink.rb

@@ -53,6 +53,7 @@ module Pageflow
 
     def create_redirect
       directory.redirects.where(slug:).delete_all
+      PermalinkRedirect.where(slug: slug_was, directory_id: directory_id_was).delete_all
       entry.permalink_redirects.create!(slug: slug_was,
                                         directory_id: directory_id_was)
     end

data/app/models/pageflow/revision.rb

@@ -27,7 +27,10 @@ module Pageflow
     has_many :chapters, -> { order(CHAPTER_ORDER) }, through: :storylines
     has_many :pages, -> { reorder(PAGE_ORDER) }, through: :storylines
 
+    has_many :comment_threads, dependent: :destroy
+
     has_many :file_usages, dependent: :destroy
+    has_many :file_folders, dependent: :destroy
 
     has_many :image_files, -> { extending WithFileUsageExtension },
              through: :file_usages, source: :file, source_type: 'Pageflow::ImageFile'
@@ -183,7 +186,8 @@ module Pageflow
         from: self,
         to: revision
       ).perform_for(
-        revision_components: Pageflow.config.revision_components.to_a + [FileUsage]
+        revision_components: Pageflow.config.revision_components.to_a +
+                             [FileFolder, FileUsage]
       )
 
       revision
@@ -212,7 +216,7 @@ module Pageflow
         'manual_start' => manual_start,
         'overview_button_enabled' => overview_button_enabled
       }.delete_if { |_k, v| v.nil? }
-        .merge(read_attribute(:configuration) || {})
+       .merge(read_attribute(:configuration) || {})
     end
 
     def self.ransackable_attributes(_auth_object = nil)

data/app/models/pageflow/site.rb

@@ -1,5 +1,7 @@
 module Pageflow
   class Site < ApplicationRecord # rubocop:todo Style/Documentation
+    include TranslatedAttributes
+
     belongs_to :account
     belongs_to :custom_404_entry, class_name: 'Entry', optional: true
 
@@ -7,6 +9,10 @@ module Pageflow
     has_many :entries
     has_many :permalink_directories, -> { order('path ASC') }
 
+    translated_attributes :imprint_link_label, :imprint_link_url,
+                          :copyright_link_label, :copyright_link_url,
+                          :privacy_link_url
+
     scope :with_home_url, -> { where.not(home_url: '') }
     scope :for_request, ->(request) { Pageflow.config.site_request_scope.call(all, request) }
 
@@ -16,6 +22,10 @@ module Pageflow
 
     delegate :enabled_feature_names, to: :account
 
+    def legal_info(locale:)
+      LegalInfo.new(self, locale)
+    end
+
     def display_name
       name.presence || I18n.t('pageflow.admin.sites.default_name')
     end

data/app/models/pageflow/used_file.rb

@@ -10,9 +10,11 @@ module Pageflow
       @usage.configuration
     end
 
+    USAGE_ATTRIBUTES = [:configuration, :display_name, :folder_perma_id].freeze
+
     def update!(attributes)
-      super(attributes.except(:configuration, :display_name))
-      @usage.update!(attributes.slice(:configuration, :display_name))
+      super(attributes.except(*USAGE_ATTRIBUTES))
+      @usage.update!(attributes.slice(*USAGE_ATTRIBUTES))
     end
 
     def usage_id
@@ -27,6 +29,10 @@ module Pageflow
       @usage.display_name
     end
 
+    def folder_perma_id
+      @usage.folder_perma_id
+    end
+
     def cache_key
       [@file.cache_key, @usage.cache_key].join('-')
     end