pageflow 17.0.5 → 17.2.0

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

@@ -1,21 +1,22 @@
 module Pageflow
-  module ReusableFile
+  module ReusableFile # rubocop:todo Style/Documentation
     extend ActiveSupport::Concern
 
     included do
       belongs_to :uploader, class_name: 'User', optional: true
-      belongs_to :entry, optional: true
-      belongs_to :parent_file, polymorphic: true, foreign_type: :parent_file_model_type, 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
 
-      has_many :usages, :as => :file, :class_name => 'Pageflow::FileUsage', :dependent => :destroy
+      has_many :usages, as: :file, class_name: 'Pageflow::FileUsage', dependent: :destroy
       has_one  :import,
                as: :file,
                class_name: 'Pageflow::FileImport',
                required: false,
                dependent: :destroy
-      has_many :using_revisions, :through => :usages, :source => :revision
-      has_many :using_entries, :through => :using_revisions, :source => :entry
-      has_many :using_accounts, :through => :using_entries, :source => :account
+      has_many :using_revisions, through: :usages, source: :revision
+      has_many :using_entries, through: :using_revisions, source: :entry
+      has_many :using_accounts, through: :using_entries, source: :account
 
       validate :parent_allows_type_for_nesting, :parent_belongs_to_same_entry
 
@@ -25,30 +26,29 @@ module Pageflow
     end
 
     def parent_allows_type_for_nesting
-      if parent_file.present?
-        parent_class = parent_file.class
-        file_type_of_parent = Pageflow.config.file_types.find_by_model!(parent_class)
-        models_of_nested_file_types = file_type_of_parent.nested_file_types.map(&:model)
-        unless models_of_nested_file_types.include?(self.class)
-          errors.add(:base, 'File type of provided parent file does not permit nesting files of '\
-                            "type #{self.class.name}")
-        end
-      end
+      return unless parent_file.present?
+
+      parent_class = parent_file.class
+      file_type_of_parent = Pageflow.config.file_types.find_by_model!(parent_class)
+      models_of_nested_file_types = file_type_of_parent.nested_file_types.map(&:model)
+      return if models_of_nested_file_types.include?(self.class)
+
+      errors.add(:base, 'File type of provided parent file does not permit nesting files of ' \
+                        "type #{self.class.name}")
     end
 
     def parent_belongs_to_same_entry
-      if parent_file.present?
-        unless parent_file.using_entries.include?(entry)
-          errors.add(:base, 'Parent file does not belong to same entry as nested file')
-        end
-      end
+      return unless parent_file.present?
+      return if parent_file.using_entries.include?(entry)
+
+      errors.add(:base, 'Parent file does not belong to same entry as nested file')
     end
 
     def nested_files(model)
       model_table_name = model.table_name
       model
         .select("#{model_table_name}.*")
-        .where("#{model_table_name}.parent_file_id = #{id} AND "\
+        .where("#{model_table_name}.parent_file_id = #{id} AND " \
                "#{model_table_name}.parent_file_model_type = '#{self.class.name}'")
     end
 
@@ -65,7 +65,6 @@ module Pageflow
       "#{super}-#{state}"
     end
 
-
     # The following are method defaults for file types that do not require processing/encoding.
     # They are overwritten with default values in UploadableFile for files that are uploaded
     # through the editor.
@@ -131,7 +130,8 @@ module Pageflow
       raise 'Not implemented!'
     end
 
-    # Gets called to trigger the `file_uploaded` event in the upload state machine of UploadableFile.
+    # Gets called to trigger the `file_uploaded` event in the upload state
+    # machine of UploadableFile.
     # Files that are not uploaded through the editor (and therefore not using the
     # upload state machine of UploadableFile) can overwrite this method to trigger whatever
     # the file does (i.e. processing/transcoding), depending on the including class'

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

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

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

@@ -1,5 +1,5 @@
 module Pageflow
-  module Suspendable
+  module Suspendable # rubocop:todo Style/Documentation
     def active_for_authentication?
       super && !suspended?
     end
@@ -10,14 +10,16 @@ module Pageflow
 
     def suspend!
       return if suspended?
+
       self.suspended_at = Time.zone.now
-      save(:validate => false)
+      save(validate: false)
     end
 
     def unsuspend!
       return unless suspended?
+
       self.suspended_at = nil
-      save(:validate => false)
+      save(validate: false)
     end
   end
 end

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

@@ -1,5 +1,5 @@
 module Pageflow
-  module ThemeReferencer
+  module ThemeReferencer # rubocop:todo Style/Documentation
     extend ActiveSupport::Concern
 
     included do

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

@@ -0,0 +1,62 @@
+module Pageflow
+  # @api private
+  module Translatable
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to(:translation_group,
+                 optional: true,
+                 class_name: 'EntryTranslationGroup')
+
+      has_many(:translations,
+               through: :translation_group,
+               source: :entries)
+
+      after_destroy do
+        if translation_group&.single_item_or_empty?
+          translation_group.destroy
+        elsif default_translation?
+          translation_group.update(default_translation: nil)
+        end
+      end
+    end
+
+    def mark_as_translation_of(entry)
+      transaction do
+        ensure_translation_group(entry)
+
+        if !entry.translation_group
+          entry.update!(translation_group:)
+        elsif entry.translation_group != translation_group
+          entry.translation_group.merge_into(translation_group)
+        end
+      end
+    end
+
+    def remove_from_translation_group
+      if translation_group.entries.count <= 2
+        translation_group.destroy
+      else
+        translation_group.update(default_translation: nil) if default_translation?
+        update!(translation_group: nil)
+      end
+    end
+
+    def mark_as_default_translation
+      translation_group.update!(default_translation: self)
+    end
+
+    def default_translation?
+      translation_group&.default_translation == self
+    end
+
+    private
+
+    def ensure_translation_group(other_entry)
+      return if translation_group
+
+      update!(translation_group: other_entry.translation_group ||
+              build_translation_group(default_translation: self))
+    end
+  end
+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

@@ -1,5 +1,5 @@
 module Pageflow
-  module UploadableFile
+  module UploadableFile # rubocop:todo Style/Documentation
     extend ActiveSupport::Concern
     include ReusableFile
 
@@ -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
@@ -76,9 +76,9 @@ module Pageflow
     end
 
     def url
-      if attachment.present?
-        attachment.url
-      end
+      return unless attachment.present?
+
+      attachment.url
     end
 
     def basename
@@ -109,7 +109,7 @@ module Pageflow
       file_uploaded!
     end
 
-    module ClassMethods
+    module ClassMethods # rubocop:todo Style/Documentation
       def processing_state_machine(&block)
         state_machine do
           extend StateMachineJob::Macro

data/app/models/pageflow/account.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class Account < ApplicationRecord
+  class Account < ApplicationRecord # rubocop:todo Style/Documentation
     include FeatureTarget
     include SerializationBlacklist
 
@@ -10,17 +10,18 @@ module Pageflow
     has_many :entry_memberships, through: :entries, source: :memberships
 
     has_many :sites, dependent: :destroy
-    belongs_to :default_site, :class_name => 'Site'
+    belongs_to :default_site, class_name: 'Site'
 
-    validates :default_site, :presence => true
+    validates :default_site, presence: true
 
-    accepts_nested_attributes_for :default_site, :update_only => true
+    accepts_nested_attributes_for :default_site, update_only: true
 
-    scope :with_landing_page, -> { where.not(:landing_page_name => '') }
+    scope :with_landing_page, -> { where.not(landing_page_name: '') }
 
     def build_default_site(*args)
       super.tap do |site|
         site.account = self
+        site.build_root_permalink_directory
       end
     end
 

data/app/models/pageflow/account_member_query.rb

@@ -1,7 +1,7 @@
 module Pageflow
   # Query accounts for members, e.g. based on role
   class AccountMemberQuery < ApplicationQuery
-    class Scope < ApplicationQuery::Scope
+    class Scope < ApplicationQuery::Scope # rubocop:todo Style/Documentation
       # Account whose members we scope
       # @return [Pageflow::Account]
       attr_reader :account

data/app/models/pageflow/account_role_query.rb

@@ -59,7 +59,7 @@ module Pageflow
       @user
         .memberships
         .where(role: Roles.at_least(role))
-        .where('(entity_id = :account_id AND '\
+        .where('(entity_id = :account_id AND ' \
                "entity_type = 'Pageflow::Account')",
                account_id: @account.id)
         .any?

data/app/models/pageflow/application_query.rb

@@ -1,7 +1,7 @@
 module Pageflow
   # Abstraction layer for Pageflow's query interface
   class ApplicationQuery
-    class Scope
+    class Scope # rubocop:todo Style/Documentation
       protected
 
       # @api private

data/app/models/pageflow/application_record.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class ApplicationRecord < ActiveRecord::Base
+  class ApplicationRecord < ActiveRecord::Base # rubocop:todo Style/Documentation
     self.abstract_class = true
   end
 end

data/app/models/pageflow/audio_file.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class AudioFile < ApplicationRecord
+  class AudioFile < ApplicationRecord # rubocop:todo Style/Documentation
     include UploadableFile
     include MediaEncodingStateMachine
 
@@ -21,15 +21,15 @@ module Pageflow
     end
 
     def m4a
-      ZencoderAttachment.new(self, "audio.m4a")
+      ZencoderAttachment.new(self, 'audio.m4a')
     end
 
     def mp3
-      ZencoderAttachment.new(self, "audio.mp3")
+      ZencoderAttachment.new(self, 'audio.mp3')
     end
 
     def ogg
-      ZencoderAttachment.new(self, "audio.ogg")
+      ZencoderAttachment.new(self, 'audio.ogg')
     end
 
     def output_definition

data/app/models/pageflow/audio_file_url_templates.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class AudioFileUrlTemplates
+  class AudioFileUrlTemplates # rubocop:todo Style/Documentation
     def call
       {
         original: url_template(:attachment, :original),

data/app/models/pageflow/authentication_token.rb

@@ -4,7 +4,7 @@ module Pageflow
   # AuthenticationToken stores the tokens with expiry time against user and provider
   class AuthenticationToken < ApplicationRecord
     belongs_to :user, class_name: 'User'
-    default_scope -> { where(['expiry_time > :expiry', expiry: Time.zone.now]) }
+    default_scope -> { where(['expiry_time > :expiry', {expiry: Time.zone.now}]) }
 
     def auth_token
       SymmetricEncryption.decrypt(read_attribute(:auth_token))
@@ -31,7 +31,7 @@ module Pageflow
 
     def self.find_auth_token(current_user, provider)
       where(user_id: current_user.id,
-            provider: provider)
+            provider:)
     end
   end
 end

data/app/models/pageflow/chapter.rb

@@ -1,7 +1,8 @@
 module Pageflow
-  class Chapter < ApplicationRecord
+  class Chapter < ApplicationRecord # rubocop:todo Style/Documentation
     include SerializedConfiguration
     include NestedRevisionComponent
+    include AutoGeneratedPermaId
 
     belongs_to :storyline, touch: true
     has_many :pages, -> { order('position ASC') }, dependent: :destroy, inverse_of: :chapter
@@ -15,5 +16,9 @@ module Pageflow
     def pages
       super.tap { |p| p.first.is_first = true if is_first && p.present? }
     end
+
+    def entry_for_auto_generated_perma_id
+      storyline.revision.entry
+    end
   end
 end

data/app/models/pageflow/chapter_scaffold.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class ChapterScaffold
+  class ChapterScaffold # rubocop:todo Style/Documentation
     def initialize(chapter, options)
       @chapter = chapter
       @options = options
@@ -8,9 +8,7 @@ module Pageflow
     delegate :save!, to: :@chapter
 
     def build
-      if @options[:depth] == 'page'
-        @page = @chapter.pages.build(template: 'background_image')
-      end
+      @page = @chapter.pages.build(template: 'background_image') if @options[:depth] == 'page'
 
       self
     end

data/app/models/pageflow/cname_site_request_scope.rb

@@ -1,5 +1,5 @@
 module Pageflow
-  class CnameSiteRequestScope
+  class CnameSiteRequestScope # rubocop:todo Style/Documentation
     def call(sites, request)
       sites.where(<<-SQL, host: request.host)
         cname = :host OR

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