pageflow 17.0.5 → 17.2.0

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
 
@@ -11,8 +11,8 @@ module Pageflow
 
     def self.find(entry:, theme:)
       build(
-        entry: entry,
-        theme: theme,
+        entry:,
+        theme:,
         theme_customization: Pageflow.theme_customizations.get(
           site: entry.site,
           entry_type_name: entry.type_name
@@ -24,15 +24,16 @@ 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: entry,
-            theme: theme
+            entry:,
+            theme:
           ),
           config.transform_theme_customization_files.call(
             theme_customization.selected_files.transform_values(&:urls),
-            entry: entry,
-            theme: theme
+            entry:,
+            theme:
           ))
     end
   end

data/app/models/pageflow/draft_entry.rb

@@ -1,3 +1,5 @@
+require 'securerandom'
+
 module Pageflow
   # A merged view of an entry and its draft revision
   class DraftEntry < EntryAtRevision
@@ -14,20 +16,38 @@ module Pageflow
       entry.title
     end
 
+    def translations(scope = -> { self }, **)
+      return [] unless entry.translation_group
+
+      PublishedEntry.wrap_all_drafts(
+        entry.translation_group.entries.instance_exec(&scope)
+      )
+    end
+
+    def cutoff_mode_enabled_for?(_request)
+      false
+    end
+
     def create_file!(file_type, attributes)
       check_foreign_key_custom_attributes(file_type.custom_attributes, attributes)
 
-      file = file_type.model.create!(attributes.except(:configuration)) do |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
 
-      usage = revision.file_usages.create_with_lock!(file: file,
-                                                     configuration: attributes[:configuration])
+      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],
+                                           folder_perma_id: attributes[:folder_perma_id])
       UsedFile.new(file, usage)
     end
 
-    def remove_file(file)
-      draft.file_usages.where(file: file).destroy_all
+    def remove_file(file) # rubocop:todo Metrics/AbcSize
+      draft.file_usages.where(file:).destroy_all
 
       file.file_type.nested_file_types.each do |nested_file_type|
         nested_file_ids = file.nested_files(nested_file_type.model).map(&:id)
@@ -42,9 +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)
+                                configuration: file.configuration,
+                                display_name: file.display_name,
+                                folder_perma_id:)
     end
 
     def save!
@@ -77,6 +103,10 @@ module Pageflow
       draft.cache_key
     end
 
+    def published_revision?
+      false
+    end
+
     private
 
     def check_foreign_key_custom_attributes(custom_attributes, attributes)
@@ -93,8 +123,18 @@ 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?
+
+      "#{SecureRandom.alphanumeric(8).downcase}#{File.extname(file_name)}"
+    end
+
     def file_is_used(file_type, file_id)
-      draft.file_usages.where(file_type: file_type, file_id: file_id).exists?
+      draft.file_usages.where(file_type:, file_id:).exists?
     end
   end
 end

data/app/models/pageflow/edit_lock.rb

@@ -1,17 +1,17 @@
 module Pageflow
-  class EditLock < ApplicationRecord
+  class EditLock < ApplicationRecord # rubocop:todo Style/Documentation
     scope :active, (lambda do
       time = Time.now - EditLock.time_to_live
       where('pageflow_edit_locks.updated_at >= ?', time)
     end)
 
-    class Error < RuntimeError
+    class Error < RuntimeError # rubocop:todo Style/Documentation
       def code
         self.class.name.split('::').last.underscore
       end
     end
 
-    class HeldByOtherUserError < Error
+    class HeldByOtherUserError < Error # rubocop:todo Style/Documentation
       attr_reader :user
 
       def initialize(user)
@@ -23,7 +23,7 @@ module Pageflow
     class NotHeldError < Error; end
 
     belongs_to :user
-    belongs_to :entry, :inverse_of => :edit_lock
+    belongs_to :entry, inverse_of: :edit_lock
 
     def self.time_to_live
       timer_tolerance = 2.3
@@ -45,33 +45,32 @@ module Pageflow
     def acquire(current_user, options = {})
       verify!(current_user, options)
     rescue Error
-      if options[:force] || timed_out?
-        entry.create_edit_lock(:user => current_user)
-      else
-        raise
-      end
+      raise unless options[:force] || timed_out?
+
+      entry.create_edit_lock(user: current_user)
     end
 
     def release(current_user)
-      if user == current_user
-        destroy
-      end
+      return unless user == current_user
+
+      destroy
     end
 
     def verify!(current_user, options)
-      raise HeldByOtherUserError.new(user) unless held_by?(current_user)
+      raise HeldByOtherUserError, user unless held_by?(current_user)
       raise HeldByOtherSessionError unless matches?(options[:id])
+
       touch
     end
 
-    class Null
+    class Null # rubocop:todo Style/Documentation
       attr_reader :entry
 
       def initialize(entry)
         @entry = entry
       end
 
-      def held_by?(user)
+      def held_by?(_user)
         false
       end
 
@@ -79,15 +78,14 @@ module Pageflow
         true
       end
 
-      def acquire(user, options = {})
-        entry.create_edit_lock!(:user => user)
+      def acquire(user, _options = {})
+        entry.create_edit_lock!(user:)
       end
 
-      def release(user)
-      end
+      def release(user); end
 
-      def verify!(user, options = {})
-        raise NotHeldError.new
+      def verify!(_user, _options = {})
+        raise NotHeldError
       end
     end
   end

data/app/models/pageflow/encoding_confirmation.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class EncodingConfirmation
+  class EncodingConfirmation # rubocop:todo Style/Documentation
     class QuotaExceededError < RuntimeError
     end
 
@@ -29,7 +29,7 @@ module Pageflow
     end
 
     def assumed_quota
-      @assumed_quota ||= encoding_quota.assume(files: files)
+      @assumed_quota ||= encoding_quota.assume(files:)
     end
 
     def files

data/app/models/pageflow/entries_feed.rb

@@ -1,6 +1,6 @@
 module Pageflow
   # @api private
-  EntriesFeed = Struct.new(:title, :locale, :custom_url, :root_url, :entries) do
+  EntriesFeed = Struct.new(:title, :locale, :custom_url, :root_url, :entries) do # rubocop:disable Lint/StructNewOverride
     def updated_at
       entries.map(&:published_at).max
     end
@@ -23,7 +23,7 @@ module Pageflow
           site
             .entries
             .published_without_password_protection
-            .where(pageflow_revisions: {locale: locale})
+            .where(pageflow_revisions: {locale:})
             .order('first_published_at DESC')
         )
       end

data/app/models/pageflow/entry.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class Entry < ApplicationRecord
+  class Entry < ApplicationRecord # rubocop:todo Style/Documentation
     class PasswordMissingError < StandardError
     end
 
@@ -7,9 +7,11 @@ module Pageflow
     include EntryPublicationStates
     include Permalinkable
     include SerializationBlacklist
+    include Translatable
 
     extend FriendlyId
-    friendly_id :slug_candidates, :use => [:finders, :slugged]
+
+    friendly_id :slug_candidates, use: [:finders, :slugged]
 
     belongs_to :account, counter_cache: true
     belongs_to :folder, optional: true
@@ -17,11 +19,13 @@ module Pageflow
 
     has_many :revisions, -> { order('frozen_at DESC') }
 
-    has_many :chapters, -> { order('pageflow_chapters.position ASC') }, :through => :revisions
-    has_many :pages, -> { order('pageflow_chapters.position ASC, pageflow_pages.position ASC') }, :through => :chapters
+    has_many :chapters, -> { order('pageflow_chapters.position ASC') }, through: :revisions
+    has_many :pages, lambda {
+                       order('pageflow_chapters.position ASC, pageflow_pages.position ASC')
+                     }, through: :chapters
 
     has_many :memberships, as: :entity, dependent: :destroy
-    has_many :users, :through => :memberships, :class_name => '::User'
+    has_many :users, through: :memberships, class_name: '::User'
 
     has_many :image_files
     has_many :video_files
@@ -29,14 +33,16 @@ 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
 
-    has_one :edit_lock, :dependent => :destroy
+    has_one :edit_lock, dependent: :destroy
 
     has_secure_password validations: false
 
-    validates :account, :site, :presence => true
+    validates :account, :site, presence: true
     validates :title, presence: true
     validate :entry_type_is_available_for_account
     validate :folder_belongs_to_same_account
@@ -52,7 +58,7 @@ module Pageflow
 
     after_create unless: :skip_draft_creation do
       create_draft!
-      draft.storylines.create!(configuration: {main: true})
+      create_default_revision_components
       entry_template.copy_defaults_to(draft)
     end
 
@@ -74,8 +80,8 @@ module Pageflow
       account.feature_state(name)
     end
 
-    def publish(options = {})
-      ActiveRecord::Base.transaction do
+    def publish(options = {}) # rubocop:todo Metrics/AbcSize
+      transaction do
         self.first_published_at ||= Time.now
         update_password!(options.slice(:password, :password_protected))
 
@@ -94,25 +100,30 @@ module Pageflow
     end
 
     def snapshot(options)
-      draft.copy do |revision|
-        revision.creator = options[:creator]
-        revision.frozen_at = Time.now
-        revision.snapshot_type = options.fetch(:type, 'auto')
+      transaction do
+        draft.copy do |revision|
+          revision.creator = options[:creator]
+          revision.frozen_at = Time.now
+          revision.snapshot_type = options.fetch(:type, 'auto')
+        end
       end
     end
 
     def restore(options)
-      restored_revision = options.fetch(:revision)
-      draft.update!(:frozen_at => Time.now, :creator => options[:creator], :snapshot_type => 'before_restore')
-
-      restored_revision.copy do |revision|
-        revision.restored_from = restored_revision
-        revision.frozen_at = nil
-        revision.snapshot_type = nil
-        revision.published_at = nil
-        revision.published_until = nil
-        revision.password_protected = nil
-        revision.noindex = nil
+      transaction do
+        restored_revision = options.fetch(:revision)
+        draft.update!(frozen_at: Time.now, creator: options[:creator],
+                      snapshot_type: 'before_restore')
+
+        restored_revision.copy do |revision|
+          revision.restored_from = restored_revision
+          revision.frozen_at = nil
+          revision.snapshot_type = nil
+          revision.published_at = nil
+          revision.published_until = nil
+          revision.password_protected = nil
+          revision.noindex = nil
+        end
       end
     end
 
@@ -151,19 +162,24 @@ module Pageflow
     private
 
     def folder_belongs_to_same_account
-      errors.add(:folder, :must_be_same_account) if folder.present? && folder.account_id != account_id
+      return unless folder.present? && folder.account_id != account_id
+
+      errors.add(:folder,
+                 :must_be_same_account)
     end
 
     def entry_type_is_available_for_account
       return if Pageflow.config_for(account).entry_types.map(&:name).include?(type_name)
 
-      errors.add(:type_name, :must_be_available_for_account, type_name: type_name)
+      errors.add(:type_name, :must_be_available_for_account, type_name:)
+    end
+
+    def create_default_revision_components
+      Pageflow.config_for(self).revision_components.create_defaults(draft)
     end
 
     def update_password!(options)
-      if options[:password].present?
-        self.password = options[:password]
-      end
+      self.password = options[:password] if options[:password].present?
 
       if options[:password_protected]
         raise PasswordMissingError if password_digest.blank?

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 = {})
@@ -45,7 +49,11 @@ module Pageflow
     end
 
     def theme
-      @theme ||= CustomizedTheme.find(entry: entry, theme: revision.theme)
+      @theme ||= CustomizedTheme.find(entry: self, theme: revision.theme)
+    end
+
+    def legal_info
+      @legal_info ||= site.legal_info(locale:)
     end
 
     def home_button
@@ -67,5 +75,9 @@ module Pageflow
     def emphasize_new_pages
       revision.configuration['emphasize_new_pages']
     end
+
+    def self.wrap_all_drafts(entries)
+      entries.includes(:draft).map { |entry| new(entry, entry.draft) }
+    end
   end
 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/entry_duplicate.rb

@@ -1,11 +1,13 @@
 module Pageflow
-  class EntryDuplicate < Struct.new(:original_entry)
+  EntryDuplicate = Struct.new(:original_entry) do
     def create!
-      create_entry
+      ActiveRecord::Base.transaction do
+        create_entry
 
-      copy_permalink
-      copy_draft
-      copy_memberships
+        copy_permalink
+        copy_draft
+        copy_memberships
+      end
 
       new_entry
     end
@@ -47,6 +49,7 @@ module Pageflow
         account: original_entry.account,
         site: original_entry.site,
         features_configuration: original_entry.features_configuration,
+        perma_id_counter: original_entry.perma_id_counter,
 
         skip_draft_creation: true
       }

data/app/models/pageflow/entry_publication.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class EntryPublication
+  class EntryPublication # rubocop:todo Style/Documentation
     attr_reader :entry, :attributes, :quota, :user
 
     def initialize(entry, attributes, published_entries_quota, user)
@@ -17,7 +17,7 @@ module Pageflow
       assumed_quota.verify_not_exceeded!
       entry.publish(attributes.merge(creator: user))
 
-      Pageflow.config.hooks.invoke(:entry_published, entry: entry)
+      Pageflow.config.hooks.invoke(:entry_published, entry:)
     end
 
     private

data/app/models/pageflow/entry_role_query.rb

@@ -1,6 +1,6 @@
 module Pageflow
-  class EntryRoleQuery < ApplicationQuery
-    class Scope < Scope
+  class EntryRoleQuery < ApplicationQuery # rubocop:todo Style/Documentation
+    class Scope < Scope # rubocop:todo Style/Documentation
       attr_reader :user, :scope
 
       def initialize(user, scope, table_alias_prefix: nil)
@@ -68,14 +68,14 @@ module Pageflow
       def entry_account_membership_has_at_least_role(role)
         membership_has_at_least_role(
           table_alias: table_alias_for('entry_account'),
-          role: role
+          role:
         )
       end
 
       def entry_membership_has_at_least_role(role)
         membership_has_at_least_role(
           table_alias: table_alias_for('entry'),
-          role: role
+          role:
         )
       end
 

data/app/models/pageflow/entry_template.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class EntryTemplate < ApplicationRecord
+  class EntryTemplate < ApplicationRecord # rubocop:todo Style/Documentation
     include ThemeReferencer
     include SerializedConfiguration
 
@@ -55,8 +55,8 @@ module Pageflow
         publisher: default_publisher.presence || Pageflow.config.default_publisher_meta_tag,
         keywords: default_keywords.presence || Pageflow.config.default_keywords_meta_tag,
         share_providers: default_share_providers,
-        theme_name: theme_name,
-        configuration: configuration,
+        theme_name:,
+        configuration:,
         locale: default_locale
       )
     end
@@ -66,7 +66,7 @@ module Pageflow
     end
 
     def hashify_provider_array(arr)
-      Hash[arr.reject(&:blank?).map { |v| [v.to_s, true] }]
+      arr.reject(&:blank?).to_h { |v| [v.to_s, true] }
     end
   end
 end