pageflow 17.1.0 → 17.2.0

data/app/controllers/pageflow/entries_controller.rb

@@ -15,7 +15,9 @@ module Pageflow
       )
 
       if entry
-        handle_public_entry_request(entry)
+        respond_to do |format|
+          format.html { handle_public_entry_request(entry) }
+        end
       elsif site.home_url.present?
         redirect_to(site.home_url, allow_other_host: true)
       else
@@ -85,11 +87,13 @@ module Pageflow
     end
 
     def handle_public_entry_request(entry)
-      return if redirect_according_to_entry_redirect(entry)
+      config = Pageflow.config_for(entry)
+
+      return if redirect_according_to_entry_redirect(entry, config)
       return if redirect_according_to_public_https_mode
       return unless check_entry_password_protection(entry)
 
-      delegate_to_entry_type_frontend_app!(entry)
+      delegate_to_entry_type_frontend_app!(entry, config:)
     end
 
     def redirect_according_to_permalink_redirect
@@ -107,23 +111,21 @@ module Pageflow
       true
     end
 
-    def redirect_according_to_entry_redirect(entry)
-      return false unless (redirect_location = entry_redirect(entry))
+    def redirect_according_to_entry_redirect(entry, config)
+      return false unless (redirect_location = config.public_entry_redirect.call(entry, request))
 
       redirect_to(redirect_location, status: :moved_permanently, allow_other_host: true)
       true
     end
 
-    def entry_redirect(entry)
-      Pageflow.config.public_entry_redirect.call(entry, request)
-    end
-
-    def delegate_to_entry_type_frontend_app!(entry, override_status: nil)
-      EntriesControllerEnvHelper.add_entry_info_to_env(request.env, entry:, mode: :published)
+    def delegate_to_entry_type_frontend_app!(entry, config:, override_status: nil)
+      EntriesControllerEnvHelper.add_entry_info_to_env(request.env,
+                                                       entry:,
+                                                       mode: :published,
+                                                       embed: params[:embed].present?)
 
       delegate_to_rack_app!(entry.entry_type.frontend_app) do |result|
         status, headers, body = result
-        config = Pageflow.config_for(entry)
 
         allow_iframe_for_embed(headers)
         apply_additional_headers(entry, config, headers)
@@ -155,7 +157,9 @@ module Pageflow
 
       if site&.custom_404_entry&.published_without_password_protection?
         entry = PublishedEntry.new(site.custom_404_entry)
-        delegate_to_entry_type_frontend_app!(entry, override_status: 404)
+        config = Pageflow.config_for(entry)
+
+        delegate_to_entry_type_frontend_app!(entry, config:, override_status: 404)
       else
         # Fallback to ApplicationController's handler method
         render_static_404_error_page

data/app/controllers/pageflow/review/comment_thread_reads_controller.rb

@@ -0,0 +1,30 @@
+module Pageflow
+  module Review
+    # @api private
+    class CommentThreadReadsController < Pageflow::ApplicationController
+      respond_to :json
+      before_action :authenticate_user!
+
+      def create
+        entry = DraftEntry.find(params[:entry_id])
+        authorize!(:read, entry.to_model)
+
+        CommentThreadRead.mark(entry: entry.to_model,
+                               user: current_user,
+                               comment_thread_perma_ids: known_perma_ids(entry))
+
+        head :no_content
+      end
+
+      private
+
+      # Guards against read records piling up for comment threads that
+      # do not exist in the entry.
+      def known_perma_ids(entry)
+        entry.comment_threads
+             .where(perma_id: params.fetch(:comment_thread_perma_ids, []))
+             .pluck(:perma_id)
+      end
+    end
+  end
+end

data/app/controllers/pageflow/review/comment_threads_controller.rb

@@ -0,0 +1,60 @@
+module Pageflow
+  module Review
+    # @api private
+    class CommentThreadsController < Pageflow::ApplicationController
+      respond_to :json
+      before_action :authenticate_user!
+
+      def index
+        entry = DraftEntry.find(params[:entry_id])
+        authorize!(:read, entry.to_model)
+
+        @comment_threads = entry.comment_threads.includes(:resolver, comments: :creator)
+        @read_at_by_perma_id =
+          CommentThreadRead.read_at_by_perma_id(entry: entry.to_model, user: current_user)
+      end
+
+      def create
+        entry = DraftEntry.find(params[:entry_id])
+        authorize!(:read, entry.to_model)
+
+        @comment_thread = entry.comment_threads.build(thread_params)
+        @comment_thread.creator = current_user
+
+        first_comment = @comment_thread.comments.build(first_comment_params)
+        first_comment.creator = current_user
+
+        @comment_thread.save!
+        render :create, status: :created
+      end
+
+      def update
+        entry = DraftEntry.find(params[:entry_id])
+        authorize!(:read, entry.to_model)
+
+        @comment_thread = entry.comment_threads.find(params[:id])
+
+        if ActiveModel::Type::Boolean.new.cast(params[:comment_thread][:resolved])
+          @comment_thread.resolve(current_user)
+        else
+          @comment_thread.unresolve
+        end
+
+        render :create
+      end
+
+      private
+
+      def thread_params
+        permitted = params.require(:comment_thread)
+                          .permit(:subject_type, :subject_id, :section_perma_id)
+        permitted[:subject_range] = params[:comment_thread][:subject_range]&.permit!
+        permitted
+      end
+
+      def first_comment_params
+        params.require(:comment_thread).require(:comment).permit(:body, :quote)
+      end
+    end
+  end
+end

data/app/controllers/pageflow/review/comments_controller.rb

@@ -0,0 +1,53 @@
+module Pageflow
+  module Review
+    # @api private
+    class CommentsController < Pageflow::ApplicationController
+      respond_to :json
+      before_action :authenticate_user!
+
+      def create
+        entry = DraftEntry.find(params[:entry_id])
+        authorize!(:read, entry.to_model)
+
+        thread = entry.comment_threads.find(params[:comment_thread_id])
+        @comment = thread.comments.build(comment_params)
+        @comment.creator = current_user
+        @comment.save!
+
+        render :create, status: :created
+      end
+
+      def update
+        entry = DraftEntry.find(params[:entry_id])
+        authorize!(:read, entry.to_model)
+
+        @comment = find_comment(entry)
+
+        return head(:forbidden) unless @comment.creator == current_user
+
+        @comment.update!(update_params.merge(edited_at: Time.current))
+
+        render :create
+      end
+
+      private
+
+      def find_comment(entry)
+        entry.comment_threads
+             .find(params[:comment_thread_id])
+             .comments
+             .find(params[:id])
+      end
+
+      def comment_params
+        params.require(:comment).permit(:body, :quote)
+      end
+
+      # The quote records the wording the comment referred to when it was
+      # written. Editing must not make it describe some later version.
+      def update_params
+        params.require(:comment).permit(:body)
+      end
+    end
+  end
+end

data/app/controllers/pageflow/revisions_controller.rb

@@ -39,7 +39,10 @@ module Pageflow
     end
 
     def delegate_to_entry_type_frontend_app!(entry)
-      EntriesControllerEnvHelper.add_entry_info_to_env(request.env, entry:, mode: :preview)
+      EntriesControllerEnvHelper.add_entry_info_to_env(request.env,
+                                                       entry:,
+                                                       mode: :preview,
+                                                       ui_locale: I18n.locale)
       delegate_to_rack_app!(entry.entry_type.frontend_app)
     end
   end

data/app/helpers/pageflow/admin/entries_helper.rb

@@ -19,6 +19,46 @@ module Pageflow
         end
       end
 
+      def entry_comments_indicator(entry, summaries: entry_comment_summaries)
+        summary = summaries[entry.id]
+        return unless summary&.any?
+
+        content_tag(:span,
+                    class: 'entry_comments_indicator',
+                    data: {tooltip: entry_comments_tooltip(summary)}) do
+          safe_join([summary.topic_count.to_s,
+                     (content_tag(:span, '', class: 'unread_dot') if summary.unread?)].compact)
+        end
+      end
+
+      # Built for the whole page at once, so that rendering a row does
+      # not query. Views without an index table collection pass their own
+      # summaries instead.
+      def entry_comment_summaries
+        @entry_comment_summaries ||=
+          EntryCommentSummary.for_entries(collection, user: current_user)
+      end
+
+      def entry_comments_tooltip(summary)
+        scope = 'pageflow.admin.entries.comments'
+
+        parts = [t("#{scope}.topic_count", count: summary.topic_count)]
+
+        if summary.unread_topic_count.positive?
+          parts << t("#{scope}.unread_topic_count", count: summary.unread_topic_count)
+        end
+
+        if summary.unread_reply_count.positive?
+          parts << t("#{scope}.unread_reply_count", count: summary.unread_reply_count)
+        end
+
+        if summary.unread_resolution_count.positive?
+          parts << t("#{scope}.unread_resolution_count", count: summary.unread_resolution_count)
+        end
+
+        t("#{scope}.tooltip", summary: parts.join(', '))
+      end
+
       def entry_type_collection(entry_types = Pageflow.config.entry_types)
         entry_types.map(&:name).index_by do |type|
           I18n.t(type, scope: 'activerecord.values.pageflow/entry.type_names')

data/app/helpers/pageflow/admin/widgets_helper.rb

@@ -9,8 +9,8 @@ module Pageflow
       end
 
       def admin_widget_types_collection_for_role(config, role)
-        config.widget_types.find_all_by_role(role).each_with_object({}) do |widget_type, result|
-          result[I18n.t(widget_type.translation_key)] = widget_type.name
+        config.widget_types.find_all_by_role(role).to_h do |widget_type|
+          [I18n.t(widget_type.translation_key), widget_type.name]
         end
       end
     end

data/app/helpers/pageflow/common_entry_seed_helper.rb

@@ -10,7 +10,9 @@ module Pageflow
       config = Pageflow.config_for(entry)
 
       json.locale entry.locale
-      json.site entry.site.as_json(only: [:privacy_link_url])
+      json.site do
+        json.privacy_link_url entry.legal_info.privacy_url
+      end
       json.enabled_feature_names entry.enabled_feature_names
       json.page_types PageTypesSeed.new(config).as_json
 
@@ -26,8 +28,8 @@ module Pageflow
       end
 
       def as_json
-        config.page_types.each_with_object({}) do |page_type, result|
-          result[page_type.name.to_sym] = page_type_seed(page_type)
+        config.page_types.to_h do |page_type|
+          [page_type.name.to_sym, page_type_seed(page_type)]
         end
       end
 

data/app/helpers/pageflow/editor/config_helper.rb

@@ -5,7 +5,9 @@ module Pageflow
       include RenderJsonHelper
 
       def editor_config_seeds(entry)
-        render_json_partial('pageflow/editor/config/seeds', entry:)
+        render_json_partial('pageflow/editor/config/seeds',
+                            entry:,
+                            entry_config: Pageflow.config_for(entry))
       end
     end
   end

data/app/helpers/pageflow/entries_helper.rb

@@ -72,10 +72,12 @@ module Pageflow
     end
 
     def entry_privacy_link_url(entry)
-      return unless entry.site.privacy_link_url.present?
-      return entry.site.privacy_link_url if entry.site.privacy_link_url.start_with?('javascript:')
+      url = entry.legal_info.privacy_url
 
-      "#{entry.site.privacy_link_url}?lang=#{entry.locale}"
+      return unless url.present?
+      return url if url.start_with?('javascript:')
+
+      "#{url}?lang=#{entry.locale}"
     end
 
     def entry_file_rights(entry)
@@ -94,50 +96,30 @@ module Pageflow
       end
     end
 
-    # rubocop:todo Metrics/PerceivedComplexity
-    # rubocop:todo Metrics/CyclomaticComplexity
     def entry_global_links(entry) # rubocop:todo Metrics/AbcSize
-      links = []
-
-      if entry.site.imprint_link_label.present? && entry.site.imprint_link_url.present?
-        links << link_to(
-          raw(entry.site.imprint_link_label),
-          entry.site.imprint_link_url,
-          target: entry.site.imprint_link_url.start_with?('javascript:') ? nil : '_blank',
-          tabindex: 2,
-          class: 'legal'
-        )
-      end
-
-      if entry.site.copyright_link_label.present? && entry.site.copyright_link_url.present?
-        links << link_to(
-          raw(entry.site.copyright_link_label),
-          entry.site.copyright_link_url,
-          target: entry.site.copyright_link_url.start_with?('javascript:') ? nil : '_blank',
-          tabindex: 2,
-          class: 'copy'
-        )
+      legal_info = entry.legal_info
+
+      candidates = [
+        [legal_info.imprint.label, legal_info.imprint.url, 'legal'],
+        [legal_info.copyright.label, legal_info.copyright.url, 'copy'],
+        [I18n.t('pageflow.public.privacy_notice'), entry_privacy_link_url(entry), 'privacy']
+      ]
+
+      links = candidates.filter_map do |label, url, css_class|
+        next if label.blank? || url.blank?
+
+        link_to(raw(label),
+                url,
+                target: url.start_with?('javascript:') ? nil : '_blank',
+                tabindex: 2,
+                class: css_class)
       end
 
-      if entry.site.privacy_link_url.present?
-        links << link_to(
-          I18n.t('pageflow.public.privacy_notice'),
-          entry_privacy_link_url(entry),
-          target: entry.site.privacy_link_url.start_with?('javascript:') ? nil : '_blank',
-          tabindex: 2,
-          class: 'privacy'
-        )
-      end
+      return '' if links.empty?
 
-      if links.any?
-        content_tag(:span, I18n.t('pageflow.helpers.entries.global_links'),
-                    class: 'hidden') + safe_join(links, ''.html_safe)
-      else
-        ''
-      end
+      content_tag(:span, I18n.t('pageflow.helpers.entries.global_links'),
+                  class: 'hidden') + safe_join(links, ''.html_safe)
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
 
     def entry_theme_stylesheet_link_tag(entry)
       stylesheet_link_tag(entry.theme.stylesheet_path,

data/app/helpers/pageflow/entry_json_seed_helper.rb

@@ -51,14 +51,14 @@ module Pageflow
     end
 
     def entry_file_ids_seed(entry)
-      Pageflow.config.file_types.with_thumbnail_support.each_with_object({}) do |file_type, result|
-        result[file_type.collection_name] = entry.find_files(file_type.model).map(&:perma_id)
+      Pageflow.config.file_types.with_thumbnail_support.to_h do |file_type|
+        [file_type.collection_name, entry.find_files(file_type.model).map(&:perma_id)]
       end
     end
 
     def entry_audio_files_json_seed(entry)
-      seed = entry.find_files(AudioFile).each_with_object({}) do |audio_file, result|
-        result[audio_file.perma_id] = audio_file_sources(audio_file)
+      seed = entry.find_files(AudioFile).to_h do |audio_file|
+        [audio_file.perma_id, audio_file_sources(audio_file)]
       end
 
       sanitize_json(seed.to_json).html_safe

data/app/helpers/pageflow/public_i18n_helper.rb

@@ -11,14 +11,15 @@ module Pageflow
         value.presence || fallback
       end
 
-      {
-        pageflow: {
-          public: I18n.t('pageflow.public', locale: I18n.default_locale)
-                      .dup
-                      .deep_merge(I18n.t('pageflow.public', locale: entry.locale),
-                                  &merge_ignoring_nil)
-        }
-      }
+      locales = [I18n.default_locale, *I18n.fallbacks[entry.locale].reverse].uniq &
+                I18n.available_locales
+
+      translations = locales.reduce({}) do |result, locale|
+        result.deep_merge(I18n.t('pageflow.public', locale:, default: {}),
+                          &merge_ignoring_nil)
+      end
+
+      {pageflow: {public: translations}}
     end
   end
 end

data/app/helpers/pageflow/structured_data_helper.rb

@@ -6,10 +6,13 @@ module Pageflow
     include MetaTagsHelper
 
     def structured_data_for_entry(entry)
+      custom_properties = Pageflow.config_for(entry).entry_structured_data_types.for(entry)
+
       content_tag(:script, type: 'application/ld+json') do
         render_json_partial('pageflow/structured_data/entry',
                             entry:,
-                            meta_data: meta_tags_data_for_entry(entry))
+                            meta_data: meta_tags_data_for_entry(entry),
+                            custom_properties:)
       end
     end
 

data/app/helpers/pageflow/themes_helper.rb

@@ -3,9 +3,7 @@ module Pageflow
     include RenderJsonHelper
 
     def themes_options_json_seed(config = Pageflow.config)
-      config.themes.each_with_object({}) { |theme, options|
-        options[theme.name] = theme.options
-      }.to_json.html_safe
+      config.themes.to_h { |theme| [theme.name, theme.options] }.to_json.html_safe
     end
 
     def theme_json_seeds(config)

data/app/helpers/pageflow/widgets_helper.rb

@@ -33,7 +33,8 @@ module Pageflow
           result[role] << {
             name: widget_type.name,
             translationKey: widget_type.translation_key,
-            insertPoint: widget_type.insert_point
+            insertPoint: widget_type.insert_point,
+            enabledInEditor: widget_type.enabled_in_editor?
           }
         end
       }.to_json.html_safe

data/app/inputs/pageflow_permalink_input.rb

@@ -30,8 +30,12 @@ class PageflowPermalinkInput
   def permalink_inputs_html
     return '' if options[:site].permalink_directories.empty? || options[:only_root]
 
-    builder.select(:directory_id, directory_select_options) <<
-      builder.text_field(:slug, data: {placeholder: options[:slug_placeholder]})
+    template.content_tag(
+      :div,
+      builder.select(:directory_id, directory_select_options) <<
+      builder.text_field(:slug, data: {placeholder: options[:slug_placeholder]}),
+      class: 'permalink_inputs'
+    )
   end
 
   def error_keys

data/app/models/concerns/pageflow/auto_generated_perma_id.rb

@@ -14,10 +14,17 @@ module Pageflow
 
       entry = entry_for_auto_generated_perma_id
 
-      entry.with_lock do
-        entry.increment!(:perma_id_counter)
-        self.perma_id = entry.perma_id_counter
-      end
+      self.perma_id =
+        if entry.new_record?
+          # No other process can see the entry yet, so there is nothing
+          # to lock.
+          entry.increment(:perma_id_counter).perma_id_counter
+        else
+          entry.with_lock do
+            entry.increment!(:perma_id_counter)
+            entry.perma_id_counter
+          end
+        end
     end
 
     def entry_for_auto_generated_perma_id

data/app/models/concerns/pageflow/reusable_file.rb

@@ -4,7 +4,7 @@ module Pageflow
 
     included do
       belongs_to :uploader, class_name: 'User', optional: true
-      belongs_to :entry, optional: true
+      belongs_to :entry, class_name: 'Pageflow::Entry', optional: true
       belongs_to :parent_file, polymorphic: true, foreign_type: :parent_file_model_type,
                                optional: true
 

data/app/models/concerns/pageflow/serialization_blacklist.rb

@@ -2,10 +2,8 @@ module Pageflow
   # @api private
   module SerializationBlacklist
     def serializable_hash(options = nil)
-      options ||= {}
-
-      options[:except] = Array(options[:except])
-      options[:except].concat(blacklist_for_serialization)
+      options = (options || {}).dup
+      options[:except] = Array(options[:except]) + blacklist_for_serialization
 
       super
     end

data/app/models/concerns/pageflow/translated_attributes.rb

@@ -0,0 +1,101 @@
+module Pageflow
+  # Store per locale overrides for a set of attributes in an
+  # `attribute_translations` column. The attribute itself keeps holding
+  # the value used for locales without translation. Since that value is
+  # read via the attribute's reader, overriding the reader also changes
+  # the value locales without translation fall back to.
+  #
+  # Not to be confused with {Translatable}, which groups entries that
+  # are translations of each other.
+  #
+  # @api private
+  module TranslatedAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :translated_attribute_names, default: []
+
+      serialize :attribute_translations, coder: JSON
+
+      validate :attribute_translations_are_known_locales_and_attributes
+    end
+
+    module ClassMethods # rubocop:todo Style/Documentation
+      # Declare which attributes can be overridden per locale. Defines
+      # a `<name>_translations` reader and writer for each of them,
+      # mapping locales to values.
+      def translated_attributes(*names)
+        self.translated_attribute_names = names.map(&:to_s)
+
+        names.each do |name|
+          define_method(:"#{name}_translations") { translations_for(name) }
+
+          define_method(:"#{name}_translations=") do |translations|
+            assign_translations(name, translations)
+          end
+        end
+      end
+    end
+
+    def attribute_translations
+      self[:attribute_translations] || {}
+    end
+
+    # Returns the translation for the given locale, or the value of the
+    # attribute itself if there is none. The fallback goes through the
+    # attribute's reader, so models can override it to compute a
+    # default. Such an override must not call `translated` itself, since
+    # that would recurse.
+    def translated(attribute, locale:)
+      locale_chain(locale)
+        .lazy
+        .map { |candidate| attribute_translations.dig(candidate, attribute.to_s) }
+        .find(&:present?) || public_send(attribute)
+    end
+
+    private
+
+    def translations_for(attribute)
+      attribute_translations.each_with_object({}) do |(locale, values), result|
+        value = values[attribute.to_s]
+        result[locale] = value if value.present?
+      end
+    end
+
+    # Translations of other attributes are preserved, while the given
+    # translations replace all translations previously stored for this
+    # attribute. Removing a translation in a form therefore does not
+    # require sending a separate delete instruction.
+    def assign_translations(attribute, translations)
+      result = attribute_translations.deep_dup
+      result.each_value { |values| values.delete(attribute.to_s) }
+
+      translations.each do |locale, value|
+        next if value.blank?
+
+        (result[locale.to_s] ||= {})[attribute.to_s] = value
+      end
+
+      self[:attribute_translations] = result.reject { |_locale, values| values.empty? }
+    end
+
+    # Regional locales fall back to their base locale, matching how
+    # translations are looked up for the entry's locale elsewhere.
+    def locale_chain(locale)
+      [locale.to_s, locale.to_s.split('-').first].uniq
+    end
+
+    def attribute_translations_are_known_locales_and_attributes
+      available_locales = Pageflow.config.available_public_locales.map(&:to_s)
+
+      attribute_translations.each do |locale, values|
+        unless available_locales.include?(locale)
+          errors.add(:attribute_translations, :unknown_locale)
+        end
+
+        unknown = values.keys - translated_attribute_names
+        errors.add(:attribute_translations, :not_translatable) if unknown.any?
+      end
+    end
+  end
+end

data/app/models/concerns/pageflow/uploadable_file.rb

@@ -20,7 +20,7 @@ module Pageflow
                           ))
 
       validates_attachment_presence :attachment_on_s3
-      validates_attachment_file_name :attachment_on_s3, matches: %r{^[^/\\]+\.\w{3,4}$}
+      validates_attachment_file_name :attachment_on_s3, matches: %r{^[^/\\]+\.\w{3,6}$}
       do_not_validate_attachment_file_type :attachment_on_s3
 
       state_machine initial: 'uploading' do