pageflow 17.0.5 → 17.1.0

data/app/models/pageflow/nested_revision_component_copy.rb

@@ -0,0 +1,263 @@
+module Pageflow
+  # Service object for copying nested revision components between
+  # records using bulk INSERT ... SELECT statements.
+  #
+  # When `reset_perma_ids` is false we reuse the perma_id values from the
+  # source revision. Parents and their copies are joined via perma_id so that
+  # foreign keys of the newly inserted records point at the duplicated parents.
+  #
+  # If `reset_perma_ids` is true we compute an offset for each
+  # association. The offset ensures that the minimum perma_id of the
+  # records being copied becomes `entry.perma_id_counter + 1`. This
+  # yields a range of new perma_ids above the current maximum perma_id
+  # of the entry while preserving the relative order of ids within the
+  # copied set.
+  #
+  # Example for a simple one level association:
+  #
+  #   INSERT INTO test_nested_revision_components (parent_id, perma_id, text)
+  #   SELECT NEW_ROOT_ID, old_items.perma_id + OFFSET, old_items.text
+  #   FROM test_nested_revision_components AS old_items
+  #   WHERE old_items.parent_id = OLD_ROOT_ID;
+  #
+  # Example for a deeply nested association where nested items have parents of
+  # the same type:
+  #
+  #   INSERT INTO test_deeply_nested_revision_components (parent_id, perma_id)
+  #   SELECT new_children.id,
+  #          old_deep_items.perma_id + OFFSET,
+  #          old_deep_items.text
+  #   FROM test_deeply_nested_revision_components AS old_deep_items
+  #   JOIN test_nested_revision_components AS old_children
+  #     ON old_children.id = old_deep_items.parent_id
+  #   JOIN test_nested_revision_components AS new_children
+  #     ON new_children.parent_id = NEW_ROOT_ID
+  #    AND new_children.perma_id = old_children.perma_id + CHILD_OFFSET
+  #   WHERE old_children.parent_id = OLD_ROOT_ID;
+  class NestedRevisionComponentCopy
+    def initialize(from:, to:, reset_perma_ids: false, connection: ActiveRecord::Base.connection)
+      @root_class = from.class
+      @old_root_id = from.id
+      @new_root_id = to.id
+
+      @reset_perma_ids = reset_perma_ids
+      @connection = connection
+
+      @offsets = Hash.new(0)
+      @entry = to.entry_for_auto_generated_perma_id
+    end
+
+    def perform_for(revision_components:)
+      perform(Model.for(revision_components:))
+    end
+
+    def perform_for_nested_revision_components
+      perform(Model.for_nested_revision_components(@root_class))
+    end
+
+    private
+
+    def perform(models)
+      lock_entry_if_resetting_perma_ids do
+        @entry_counter = @entry.perma_id_counter
+        copy_all(models)
+
+        update_perma_id_counter_if_changed
+      end
+    end
+
+    def lock_entry_if_resetting_perma_ids(&block)
+      if @reset_perma_ids
+        @entry.with_lock(&block)
+      else
+        block.call
+      end
+    end
+
+    def update_perma_id_counter_if_changed
+      return unless @entry_counter != @entry.perma_id_counter
+
+      @entry.update!(perma_id_counter: @entry_counter)
+    end
+
+    def copy_all(models, chain: [])
+      models.each do |model|
+        compute_offset(model, chain)
+        bulk_insert(model, chain)
+
+        copy_all(model.nested_models,
+                 chain: chain + [model])
+      end
+    end
+
+    def compute_offset(model, chain)
+      return nil unless @reset_perma_ids
+
+      # When resetting perma_ids, shift old ids so the smallest
+      # becomes entry.perma_id_counter + 1. Example: current_max = 10,
+      # old perma ids=[3, 5] results in offset 10 - 3 + 1 = 8 and
+      # hence new ids [11, 13].
+      min_perma_id, max_perma_id = get_min_max_perma_id(model, chain)
+
+      return nil unless min_perma_id
+
+      offset = @entry_counter - min_perma_id + 1
+
+      @entry_counter = max_perma_id + offset
+      @offsets[model] = offset
+    end
+
+    def get_min_max_perma_id(model, chain)
+      row = @connection.select_one(<<-SQL.squish)
+        SELECT MIN(#{model.old_table_alias}.#{model.perma_id_column}) AS min_perma_id,
+               MAX(#{model.old_table_alias}.#{model.perma_id_column}) AS max_perma_id
+        FROM #{model.table_name} AS #{model.old_table_alias}
+        #{join_old_parents(model, chain)}
+        WHERE #{where_belongs_to_old_root(model, chain)}
+      SQL
+
+      return nil unless row && row['min_perma_id']
+
+      [row['min_perma_id'].to_i, row['max_perma_id'].to_i]
+    end
+
+    def bulk_insert(model, chain)
+      @connection.execute(<<~SQL.squish)
+        INSERT INTO #{model.table_name} (#{model.insert_list})
+        SELECT #{select_with_new_foreign_key_value(model, chain)}
+        FROM #{model.table_name} AS #{model.old_table_alias}
+        #{join_old_parents(model, chain)}
+        #{join_new_parents(chain)}
+        WHERE #{where_belongs_to_old_root(model, chain)}
+      SQL
+    end
+
+    def select_with_new_foreign_key_value(model, chain)
+      model.select_list(
+        new_foreign_key_value: chain.empty? ? @new_root_id : chain.last.new_id,
+        perma_id_offset: @offsets[model]
+      )
+    end
+
+    def join_old_parents(model, chain)
+      [*chain, model].reverse_each.each_cons(2).map { |child, parent|
+        parent.join_as_old_on(id_value: child.old_foreign_key)
+      }.join("\n")
+    end
+
+    def join_new_parents(chain)
+      return '' if chain.empty?
+
+      [
+        chain.first.join_as_new_on_matching_perma_id(
+          foreign_key_value: @new_root_id,
+          perma_id_offset: @offsets[chain.first]
+        ),
+        *chain.each_cons(2).map do |parent, child|
+          child.join_as_new_on_matching_perma_id(
+            foreign_key_value: parent.new_id,
+            perma_id_offset: @offsets[child]
+          )
+        end
+      ].join("\n")
+    end
+
+    def where_belongs_to_old_root(model, chain)
+      "#{[*chain, model].first.old_foreign_key} = #{@old_root_id}"
+    end
+
+    Model = Struct.new(:klass, :foreign_key, :level, keyword_init: true) do
+      def self.for(revision_components:)
+        revision_components.map do |revision_component|
+          Model.new(klass: revision_component, foreign_key: 'revision_id', level: 1)
+        end
+      end
+
+      def self.for_nested_revision_components(klass, level: 1)
+        klass.nested_revision_component_collection_names.map do |collection_name|
+          reflection = klass.reflect_on_association(collection_name)
+          Model.new(klass: reflection.klass, foreign_key: reflection.foreign_key, level:)
+        end
+      end
+
+      def nested_models
+        Model.for_nested_revision_components(klass, level: level + 1)
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def new_table_alias
+        "new_#{level}"
+      end
+
+      def old_table_alias
+        "old_#{level}"
+      end
+
+      def old_foreign_key
+        "#{old_table_alias}.#{foreign_key}"
+      end
+
+      def new_id
+        "#{new_table_alias}.id"
+      end
+
+      def perma_id_column
+        @perma_id_column ||=
+          if klass.column_names.include?('file_perma_id')
+            'file_perma_id'
+          else
+            'perma_id'
+          end
+      end
+
+      def insert_list
+        quoted_list(insert_columns)
+      end
+
+      def select_list(new_foreign_key_value:, perma_id_offset:)
+        insert_columns.map { |column|
+          case column
+          when foreign_key
+            new_foreign_key_value
+          when 'created_at', 'updated_at'
+            'NOW()'
+          when 'perma_id'
+            perma_id_expr(perma_id_offset)
+          else
+            "#{old_table_alias}.#{column}"
+          end
+        }.join(', ')
+      end
+
+      def join_as_old_on(id_value:)
+        "JOIN #{table_name} AS #{old_table_alias} " \
+          "ON #{old_table_alias}.id = #{id_value}"
+      end
+
+      def join_as_new_on_matching_perma_id(foreign_key_value:, perma_id_offset:)
+        "JOIN #{table_name} AS #{new_table_alias} " \
+          "ON #{new_table_alias}.#{foreign_key} = #{foreign_key_value} " \
+          "AND #{new_table_alias}.#{perma_id_column} = #{perma_id_expr(perma_id_offset)}"
+      end
+
+      private
+
+      def insert_columns
+        klass.column_names.reject { |c| c == 'id' }
+      end
+
+      def perma_id_expr(offset)
+        return "#{old_table_alias}.#{perma_id_column}" if offset.zero?
+
+        "#{old_table_alias}.#{perma_id_column} + #{offset}"
+      end
+
+      def quoted_list(columns)
+        columns.map { |c| ActiveRecord::Base.connection.quote_column_name(c) }.join(', ')
+      end
+    end
+  end
+end

data/app/models/pageflow/null_user.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class NullUser
+  class NullUser # rubocop:todo Style/Documentation
     def full_name
       '-'
     end

data/app/models/pageflow/overview_button.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class OverviewButton
+  class OverviewButton # rubocop:todo Style/Documentation
     attr_reader :revision
 
     def initialize(revision)

data/app/models/pageflow/page.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class Page < ApplicationRecord
+  class Page < ApplicationRecord # rubocop:todo Style/Documentation
     include SerializedConfiguration
     include NestedRevisionComponent
     include AutoGeneratedPermaId
@@ -8,9 +8,13 @@ module Pageflow
 
     attr_accessor :is_first
 
-    validates_inclusion_of :template, :in => ->(_) { Pageflow.config.page_types.names }
+    validates_inclusion_of :template, in: ->(_) { Pageflow.config.page_types.names }
 
-    scope :displayed_in_navigation, -> { where(:display_in_navigation => true) }
+    scope :displayed_in_navigation, -> { where(display_in_navigation: true) }
+
+    def entry_for_auto_generated_perma_id
+      chapter.storyline.revision.entry
+    end
 
     def title
       configuration['title'].presence || configuration['additional_title']

data/app/models/pageflow/permalink.rb

@@ -2,6 +2,7 @@ module Pageflow
   # @api private
   class Permalink < ApplicationRecord
     extend FriendlyId
+
     friendly_id :slug_candidates, use: :scoped, scope: :directory
 
     before_validation :set_default_slug
@@ -11,15 +12,29 @@ module Pageflow
     belongs_to :directory, class_name: 'PermalinkDirectory'
 
     validates(:slug,
-              format: /\A[0-9a-zA-Z_-]+\z/,
+              format: {with: /\A[0-9a-zA-Z_-]+\z/, allow_blank: true},
               uniqueness: {scope: :directory})
 
     validate :belongs_to_same_site_as_entry
 
+    before_update(:create_redirect,
+                  if: lambda {
+                        entry.first_published_at.present? && (slug_changed? || directory_changed?)
+                      })
+
+    attr_accessor :allow_root_path
+
     private
 
     def set_default_slug
-      self.slug = entry.default_permalink_slug if slug == ''
+      return unless slug == ''
+      return if allow_emtpy_slug?
+
+      self.slug = entry.default_permalink_slug
+    end
+
+    def allow_emtpy_slug?
+      allow_root_path && directory&.path&.blank?
     end
 
     def slug_candidates
@@ -35,5 +50,11 @@ module Pageflow
 
       errors.add(:directory, :invalid)
     end
+
+    def create_redirect
+      directory.redirects.where(slug:).delete_all
+      entry.permalink_redirects.create!(slug: slug_was,
+                                        directory_id: directory_id_was)
+    end
   end
 end

data/app/models/pageflow/permalink_directory.rb

@@ -6,5 +6,12 @@ module Pageflow
     validates(:path,
               format: %r{\A([0-9a-zA-Z-]+/)*\z},
               uniqueness: {scope: :site_id})
+
+    has_many(:permalinks,
+             foreign_key: :directory_id)
+
+    has_many(:redirects,
+             class_name: 'PermalinkRedirect',
+             foreign_key: :directory_id)
   end
 end

data/app/models/pageflow/permalink_redirect.rb

@@ -0,0 +1,7 @@
+module Pageflow
+  # @api private
+  class PermalinkRedirect < ApplicationRecord
+    belongs_to :entry
+    belongs_to :directory, class_name: 'PermalinkDirectory'
+  end
+end

data/app/models/pageflow/positioned_file.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class PositionedFile
+  class PositionedFile # rubocop:todo Style/Documentation
     attr_reader :file, :position_x, :position_y
 
     delegate :thumbnail_url, :perma_id, to: :file
@@ -11,7 +11,7 @@ module Pageflow
     end
 
     def ==(other)
-      super(other) ||
+      super ||
         other == file ||
         (other.is_a?(PositionedFile) && other.file == file) ||
         (other.class == file.class && other.id == file.id)
@@ -29,13 +29,13 @@ module Pageflow
       Null.new
     end
 
-    class Null < PositionedFile
+    class Null < PositionedFile # rubocop:todo Style/Documentation
       def initialize
         super(nil)
       end
 
-      def thumbnail_url(*args)
-        ImageFile.new.attachment.url(*args)
+      def thumbnail_url(*)
+        ImageFile.new.attachment.url(*)
       end
 
       def blank?

data/app/models/pageflow/potential_entry_translations.rb

@@ -0,0 +1,55 @@
+module Pageflow
+  # @api private
+  class PotentialEntryTranslations
+    def initialize(entry)
+      @entry = entry
+    end
+
+    def self.for(entry)
+      new(entry)
+    end
+
+    def resolve
+      preload(
+        group_by_translation_group(
+          exclude_translations(
+            other_entries_of_account
+          )
+        )
+      )
+    end
+
+    private
+
+    def other_entries_of_account
+      @entry.account.entries.where.not(id: @entry.id)
+    end
+
+    def exclude_translations(scope)
+      return scope unless @entry.translation_group
+
+      scope
+        .where.not(translation_group_id: @entry.translation_group)
+        .or(scope.where(translation_group: nil))
+    end
+
+    def group_by_translation_group(scope)
+      scope
+        # Use MIN(id) to choose an arbitrary entry to represent its
+        # translation group. MIN(translation_group_id) is needed since
+        # technically translation_group_id is not part of the GROUP BY
+        # clause.
+        .select(<<-SQL)
+          MIN(id) as id,
+          GROUP_CONCAT(title) as title,
+          MIN(translation_group_id) as translation_group_id
+        SQL
+        .group('IFNULL(translation_group_id, id)')
+        .order('title ASC')
+    end
+
+    def preload(scope)
+      scope.includes(translation_group: :entries)
+    end
+  end
+end

data/app/models/pageflow/potential_memberships.rb

@@ -23,6 +23,7 @@ module Pageflow
 
     def users_for_entry(entry)
       return User.none unless manages_entry?(entry)
+
       exclude_users_with_membership(entry, entry.account.users)
     end
 
@@ -88,8 +89,8 @@ module Pageflow
                           'existing_memberships.user_id = :user_id AND ' \
                           "existing_memberships.entity_id = #{entity_model.table_name}.id AND " \
                           'existing_memberships.entity_type = :entity_type',
-                          user_id: user.id,
-                          entity_type: entity_model.name])
+                          {user_id: user.id,
+                           entity_type: entity_model.name}])
     end
 
     def existing_memberships_on(entity)
@@ -97,8 +98,8 @@ module Pageflow
                           'existing_memberships.user_id = users.id AND ' \
                           'existing_memberships.entity_id = :entity_id AND ' \
                           'existing_memberships.entity_type = :entity_type',
-                          entity_id: entity.id,
-                          entity_type: entity.class.name])
+                          {entity_id: entity.id,
+                           entity_type: entity.class.name}])
     end
 
     def existing_membership_is_missing

data/app/models/pageflow/published_entry.rb

@@ -5,12 +5,14 @@ module Pageflow
 
     attr_accessor :share_target
 
-    delegate(:authenticate, to: :entry)
+    delegate(:authenticate,
+             :default_translation?,
+             to: :entry)
 
     delegate(:password_protected?, to: :revision)
 
     def initialize(entry, revision = nil, theme: nil)
-      super(entry, revision || entry.published_revision, theme: theme)
+      super(entry, revision || entry.published_revision, theme:)
       @custom_revision = revision
     end
 
@@ -18,6 +20,24 @@ module Pageflow
       revision.title.presence || entry.title
     end
 
+    def translations(scope = -> { self }, include_noindex: false)
+      return [] unless entry.translation_group
+
+      if published_revision?
+        self.class.wrap_all(
+          published_translation_entries(include_noindex:).instance_exec(&scope)
+        )
+      else
+        self.class.wrap_all_drafts(
+          entry.translation_group.entries.instance_exec(&scope)
+        )
+      end
+    end
+
+    def cutoff_mode_enabled_for?(request)
+      Pageflow.config.cutoff_modes.enabled_for?(self, request)
+    end
+
     def stylesheet_model
       custom_revision? ? revision : entry
     end
@@ -26,8 +46,8 @@ module Pageflow
       revision.cache_key_with_version
     end
 
-    def thumbnail_url(*args)
-      thumbnail_file.thumbnail_url(*args)
+    def thumbnail_url(*)
+      thumbnail_file.thumbnail_url(*)
     end
 
     def thumbnail_file
@@ -38,6 +58,7 @@ module Pageflow
 
     def page_thumbnail_file(page)
       return unless page.present?
+
       ThumbnailFileResolver.new(self, page.page_type.thumbnail_candidates, page.configuration)
                            .find_thumbnail
     end
@@ -46,19 +67,30 @@ module Pageflow
       PublishedEntry.new(scope.published.find(id))
     end
 
-    def self.find_by_permalink(directory: nil, slug:, scope:)
+    def self.find_by_permalink(slug:, scope:, directory: nil)
       wrap(
         scope.published.includes(permalink: :directory).where(
           pageflow_permalink_directories: {path: directory || ''},
-          pageflow_permalinks: {slug: slug}
+          pageflow_permalinks: {slug:}
         ).first
       )
     end
 
-    def self.wrap_all(scope)
-      scope
-        .includes(:published_revision)
-        .map { |entry| new(entry) }
+    def self.find_by_permalink_redirect(site:, slug:, directory: nil)
+      wrap(
+        PermalinkRedirect.joins(:entry, :directory).merge(Entry.published).where(
+          slug:,
+          pageflow_permalink_directories: {
+            path: directory || '',
+            site:
+          }
+        ).first&.entry
+      )
+    end
+
+    def self.wrap_all(entries)
+      entries = entries.includes(:published_revision) unless entries.loaded?
+      entries.map { |entry| new(entry) }
     end
 
     def cache_key
@@ -78,14 +110,33 @@ module Pageflow
       ].compact.join('-').presence
     end
 
+    def published_revision?
+      !custom_revision?
+    end
+
     private
 
+    def published_translation_entries(include_noindex:)
+      translation_group = entry.translation_group
+
+      if password_protected? && include_noindex
+        translation_group.published_entries
+      elsif password_protected?
+        translation_group.entries_published_without_noindex
+      elsif include_noindex
+        translation_group.entries_published_without_password_protection
+      else
+        translation_group.publicly_visible_entries
+      end
+    end
+
     def custom_revision?
       @custom_revision
     end
 
     def share_image_file
-      PositionedFile.wrap(find_file_by_perma_id(ImageFile, share_image_id), share_image_x, share_image_y)
+      PositionedFile.wrap(find_file_by_perma_id(ImageFile, share_image_id), share_image_x,
+                          share_image_y)
     end
 
     class << self