8 files changed, 208 insertions, 50 deletions

diff --git a/app/models/action_participant.rb b/app/models/action_participant.rb
new file mode 100644
index 0000000..f179a48
--- /dev/null
+++ b/app/models/action_participant.rb
@@ -0,0 +1,4 @@
+class ActionParticipant < ApplicationRecord
+  belongs_to :node_action
+  belongs_to :subject, :polymorphic => true
+end
diff --git a/app/models/asset.rb b/app/models/asset.rb
index aca0ee8..73970e2 100644
--- a/app/models/asset.rb
+++ b/app/models/asset.rb
@@ -1,12 +1,43 @@
 class Asset < ApplicationRecord
+  IMAGE_CONTENT_TYPES = ["image/gif", "image/jpeg", "image/png", "image/webp"]
+  PDF_CONTENT_TYPE = "application/pdf"
 
   include FileAttachment
   
   has_many :related_assets, :dependent => :destroy
   has_many :pages, :through => :related_assets
 
-  scope :images,    -> { where(:upload_content_type => ["image/gif", "image/jpeg", "image/png", "image/webp"]) }
+  scope :images,    -> { where(:upload_content_type => IMAGE_CONTENT_TYPES) }
   scope :documents, -> { where(:upload_content_type => ["application/pdf", "text/plain", "text/rtf"]) }
   scope :audio,     -> { where(:upload_content_type => ["audio/mpeg", "audio/x-m4a", "audio/wav", "audio/x-wav"]) }
+  scope :pdfs,      -> { where(:upload_content_type => PDF_CONTENT_TYPE) }
 
+  scope :headline_eligible, -> { where(:upload_content_type => IMAGE_CONTENT_TYPES + [PDF_CONTENT_TYPE]) }
+
+  validates :license_key, inclusion: { in: -> { AssetLicense.keys } }, allow_blank: true
+
+  def image?
+    IMAGE_CONTENT_TYPES.include?(upload_content_type)
+  end
+
+  def pdf?
+    upload_content_type == PDF_CONTENT_TYPE
+  end
+
+  def has_credit?
+    creator.present? || source_url.present? || license_key.present?
+  end
+
+  def show_credit?
+    image? && has_credit?
+  end
+
+  # Nodes whose current lifecycle rows (head, draft or autosave) carry
+  # this asset. Historical revisions also hold RelatedAsset rows; they
+  # are excluded by construction here, since nothing points at them.
+  def attached_nodes
+    page_ids = related_assets.select(:page_id)
+    Node.where("head_id IN (:ids) OR draft_id IN (:ids) OR autosave_id IN (:ids)",
+               :ids => page_ids).distinct
+  end
 end
diff --git a/app/models/asset_license.rb b/app/models/asset_license.rb
new file mode 100644
index 0000000..ca66d40
--- /dev/null
+++ b/app/models/asset_license.rb
@@ -0,0 +1,15 @@
+class AssetLicense
+  Entry = Struct.new(:key, :url, :requires_attribution, :style, keyword_init: true)
+
+  DICTIONARY = YAML.load_file(Rails.root.join("config", "asset_licenses.yml")).freeze
+
+  def self.keys
+    DICTIONARY.keys
+  end
+
+  def self.find(key)
+    entry = DICTIONARY[key.to_s] if key.present?
+    return nil unless entry
+    Entry.new(key: key.to_s, url: entry["url"], requires_attribution: entry["requires_attribution"], style: entry["style"])
+  end
+end
diff --git a/app/models/concerns/file_attachment.rb b/app/models/concerns/file_attachment.rb
index 613a6f0..6221312 100644
--- a/app/models/concerns/file_attachment.rb
+++ b/app/models/concerns/file_attachment.rb
@@ -31,6 +31,7 @@ module FileAttachment
 
   IMAGE_CONTENT_TYPES    = %w[image/jpeg image/gif image/png image/webp].freeze
   VECTOR_CONTENT_TYPES   = %w[image/svg+xml].freeze
+  RASTERIZED_CONTENT_TYPES = %w[application/pdf].freeze
   DISPLAYABLE_AS_IMAGE   = IMAGE_CONTENT_TYPES + VECTOR_CONTENT_TYPES
 
   included do
@@ -52,29 +53,49 @@ module FileAttachment
     build_upload_proxy
   end
 
+  def has_variant?(style)
+    upload_file_name.present? && File.exist?(file_path(style))
+  end
+
+  def previewable?
+    has_variant?(:medium)
+  end
+
+  def variant_filename(style)
+    return upload_file_name if style == :original || !RASTERIZED_CONTENT_TYPES.include?(upload_content_type)
+    File.basename(upload_file_name, ".*") + ".png"
+  end
+
   private
 
   def build_upload_proxy
     @upload = UploadProxy.new(self)
   end
 
+  class_methods do
+    def upload_root
+      Rails.env.test? ? Rails.root.join("tmp", "test_uploads") : Rails.root.join("public", "system", "uploads")
+    end
+  end
+
+  def upload_root
+    self.class.upload_root
+  end
+
   def process_upload
     return unless @pending_upload
     uploaded_file = @pending_upload
     @pending_upload = nil
 
-    old_dir = Rails.root.join("public", "system", "uploads", id.to_s)
+    old_dir = upload_root.join(id.to_s)
+
     FileUtils.rm_rf(old_dir) if Dir.exist?(old_dir)
 
     original_path = file_path(:original)
     FileUtils.mkdir_p(File.dirname(original_path))
     FileUtils.cp(uploaded_file.tempfile.path, original_path)
 
-    if IMAGE_CONTENT_TYPES.include?(upload_content_type)
-      generate_variants(original_path)
-    elsif VECTOR_CONTENT_TYPES.include?(upload_content_type)
-      generate_svg_variants(original_path)
-    end
+    generate_all_variants(original_path)
   end
 
   def generate_variants(original_path)
@@ -93,20 +114,28 @@ module FileAttachment
     end
   end
 
+  def generate_all_variants(original_path)
+    if IMAGE_CONTENT_TYPES.include?(upload_content_type)
+      generate_variants(original_path)
+    elsif VECTOR_CONTENT_TYPES.include?(upload_content_type)
+      generate_svg_variants(original_path)
+    elsif RASTERIZED_CONTENT_TYPES.include?(upload_content_type)
+      generate_variants("#{original_path}[0]")
+    end
+  end
+
   def delete_upload_files
-    dir = Rails.root.join("public", "system", "uploads", id.to_s)
+    dir = upload_root.join(id.to_s)
     FileUtils.rm_rf(dir) if Dir.exist?(dir)
   end
 
   def file_path(style)
-    Rails.root.join(
-      "public", "system", "uploads",
-      id.to_s, style.to_s, upload_file_name
-    ).to_s
+    upload_root.join(id.to_s, style.to_s, variant_filename(style)).to_s
   end
 
   def sanitize_filename(filename)
-    File.basename(filename).gsub(/[^\w\.\-]/, '_')
+    name = File.basename(filename).unicode_normalize(:nfc)
+    name.gsub(/(?u)[^\w\.\-]/, '_')
   end
 
   # Proxy object returned by asset.upload, providing the Paperclip-compatible
@@ -118,7 +147,7 @@ module FileAttachment
 
     def url(style = :original)
       return "" if @record.upload_file_name.blank?
-      "/system/uploads/#{@record.id}/#{style}/#{@record.upload_file_name}"
+      "/system/uploads/#{@record.id}/#{style}/#{@record.variant_filename(style)}"
     end
 
     def content_type
diff --git a/app/models/node.rb b/app/models/node.rb
index a440c2f..7a93e79 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -4,7 +4,14 @@ class Node < ApplicationRecord
 
   # Associations
   has_many    :pages, -> { order("revision ASC") }, :dependent => :destroy
+
+  # Entries where this node is the primary subject (fast-path column).
+  # For a *complete* history -- including subtree trash/destroy entries
+  # recorded at an ancestor -- use participated_actions instead.
   has_many    :node_actions, :dependent => :nullify
+  has_many    :action_participations, :class_name => "ActionParticipant", :as => :subject
+  has_many    :participated_actions, :through => :action_participations, :source => :node_action
+
   belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id, optional: true
   belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id, optional: true
   # Autosave pages carry no node_id, so has_many :pages does not cover
@@ -312,14 +319,14 @@ class Node < ApplicationRecord
       was_published      = head_id.present?
       final_published_at = head&.published_at
 
-      demoted = 0
-      ([self] + descendants.to_a).each do |node|
-        next unless node.head_id
+      subtree = [self] + descendants.to_a
+      demoted_nodes = subtree.select do |node|
+        next false unless node.head_id
         former        = node.head
         node.head     = nil
         node.draft_id = former.id if node.draft_id.nil?
         node.save!
-        demoted += 1
+        true
       end
 
       self.reload
@@ -332,9 +339,10 @@ class Node < ApplicationRecord
       metadata = { :path => { "from" => path_before, "to" => unique_name } }
       metadata[:was_published]      = true if was_published
       metadata[:final_published_at] = final_published_at.iso8601 if final_published_at
-      metadata[:demoted_heads]      = demoted if demoted > 0
+      metadata[:demoted_heads]      = demoted_nodes.size if demoted_nodes.any?
 
-      NodeAction.record!(:node => self, :user => current_user, :action => "trash", **metadata)
+      NodeAction.record!(:participants => subtree, :user => current_user,
+                          :action => "trash", **metadata)
       self
     end
   end
@@ -382,7 +390,8 @@ class Node < ApplicationRecord
       metadata = { :path => unique_name }
       metadata[:destroyed_descendants] = doomed.size - 1 if doomed.size > 1
 
-      NodeAction.record!(:node => self, :user => current_user, :action => "destroy", **metadata)
+      NodeAction.record!(:participants => doomed, :user => current_user,
+                          :action => "destroy", **metadata)
       doomed.each(&:destroy!)
     end
   end
@@ -442,8 +451,65 @@ class Node < ApplicationRecord
     end
   end
 
+  # Attaches an asset to every current lifecycle row -- head, draft and
+  # autosave -- that does not already carry it. Attachments are page-
+  # scoped content (RelatedAsset belongs_to :page; drafts and autosaves
+  # are wholesale clones), so attaching to a single layer is how an
+  # attachment gets silently lost when another layer replaces it at
+  # publish or save. This is the out-of-band counterpart to the
+  # in-editor attach UI; it refuses when someone else holds the editing
+  # lock. Attaching to a head row changes the public page immediately,
+  # by design -- same reasoning as formalizing an already-existing
+  # editorial link.
+  #
+  # headline is a node-level decision: the flag is set on the newly
+  # created joins only when no current row has a headline yet and the
+  # asset is eligible; otherwise the asset is attached plain and the
+  # result says why, so the caller can point the editor at the star in
+  # the editor instead.
+  #
+  # Returns { :attached => n, :already => n,
+  #           :headline => nil | :set | :kept_existing | :not_eligible }
+  def attach_asset! asset, user:, headline: false
+    if in_trash? || trash_node?
+      raise ActiveRecord::RecordInvalid.new(self), "Cannot attach assets to a node in the Trash"
+    end
+
+    if lock_owner && lock_owner != user
+      raise(
+        LockedByAnotherUser,
+        "Page is locked by another user who is working on it! " \
+        "Last modification: #{(self.autosave || self.draft || self.head).updated_at.to_fs(:db)}"
+      )
+    end
+
+    rows      = [head, draft, autosave].compact
+    to_attach = rows.reject { |row| row.related_assets.exists?(:asset_id => asset.id) }
+
+    headline_state =
+      if headline && to_attach.any?
+        if !(asset.image? || asset.pdf?)
+          :not_eligible
+        elsif rows.any? { |row| row.headline_asset.present? }
+          :kept_existing
+        else
+          :set
+        end
+      end
+
+    ActiveRecord::Base.transaction do
+      to_attach.each do |row|
+        row.related_assets.create!(:asset => asset, :headline => headline_state == :set)
+      end
+    end
+
+    { :attached => to_attach.size,
+      :already  => rows.size - to_attach.size,
+      :headline => headline_state }
+  end
+
   def title
-    head ? head.title : draft.title
+    editable_page&.title
   end
 
   def update_unique_names?
@@ -533,13 +599,6 @@ class Node < ApplicationRecord
     throw :abort
   end
 
-  def self.recently_changed
-    includes(:head).where(
-      "pages.updated_at < ? AND pages.updated_at > ? AND nodes.parent_id IS NOT NULL",
-      Time.now, Time.now - 14.days
-    ).order("pages.updated_at desc").references(:head)
-  end
-
   protected
     def lock_for! current_user
       self.lock_owner = current_user
diff --git a/app/models/node_action.rb b/app/models/node_action.rb
index 13bd5ba..8a3dd8b 100644
--- a/app/models/node_action.rb
+++ b/app/models/node_action.rb
@@ -3,6 +3,8 @@ class NodeAction < ApplicationRecord
   belongs_to :page, optional: true
   belongs_to :user, optional: true
 
+  has_many :action_participants, :dependent => :destroy
+
   validates :action, presence: true
   validates :occurred_at, presence: true
 
@@ -81,10 +83,15 @@ class NodeAction < ApplicationRecord
   # This log records; it does not undo. No IP, session, or user
   # agent, ever. Success only.
 
-  def self.record!(node:, action:, user: nil, page: nil, locale: nil,
-                    occurred_at: nil, inferred_from: nil, **extra)
+  def self.record!(node: nil, participants: [], action:, user: nil, page: nil,
+                    locale: nil, occurred_at: nil, inferred_from: nil, **extra)
+    participants = participants.presence || [node].compact
+    raise ArgumentError, "NodeAction.record! needs at least one participant" if participants.empty?
+
+    primary_node = node || (participants.first if participants.first.is_a?(Node))
+
     create!(
-      :node          => node,
+      :node          => primary_node,
       :page          => page,
       :user          => user,
       :action        => action,
@@ -94,10 +101,12 @@ class NodeAction < ApplicationRecord
       :metadata      => {
         "username"                 => user&.login,
         "human_readable_node_name" => Globalize.with_locale(I18n.default_locale) {
-                                        node&.head&.title || node&.draft&.title
+                                        primary_node&.head&.title || primary_node&.draft&.title
                                       },
       }.merge(extra.stringify_keys)
-    )
+    ).tap do |na|
+      participants.each { |subject| na.action_participants.create!(:subject => subject) }
+    end
   end
 
   # Computes the publish-entry diff between an outgoing head and the
@@ -166,4 +175,12 @@ class NodeAction < ApplicationRecord
   def subject_name
     metadata["human_readable_node_name"] || node&.unique_name || "deleted node"
   end
+
+  def diff_link_params
+    prev = NodeAction.where(node_id: node_id, action: "publish")
+                     .where("id < ?", id)
+                     .order(id: :desc).first
+    return nil unless prev&.page && page
+    { start_revision: prev.page.revision, end_revision: page.revision }
+  end
 end
diff --git a/app/models/page.rb b/app/models/page.rb
index f33d88d..817e3bd 100644
--- a/app/models/page.rb
+++ b/app/models/page.rb
@@ -220,7 +220,12 @@ class Page < ApplicationRecord
     end
 
     # Clone asset references
-    self.assets = page.assets
+    self.related_assets.delete_all
+    page.related_assets.each do |related|
+      self.related_assets.create!(:asset_id => related.asset_id,
+                                  :position => related.position,
+                                  :headline => related.headline)
+    end
 
     self.save
   end
@@ -287,6 +292,10 @@ class Page < ApplicationRecord
     end
   end
 
+  def headline_asset
+    related_assets.find_by(headline: true)&.asset
+  end
+
   # Returns true if a page has translations where one of them is significantly
   # older than the other.
   # Takes the I18n.default locale and a second :locale to test if the
@@ -314,21 +323,6 @@ class Page < ApplicationRecord
     end
   end
 
-  def update_assets image_ids
-
-    transaction do
-      self.related_assets.delete_all
-
-      if image_ids
-        image_ids.each_with_index do |id, index|
-          asset = Asset.find(id)
-          self.related_assets.create!(:asset_id => asset.id, :position => index+1)
-        end
-      end
-    end
-
-  end
-
   # Installs (or re-installs) the trigger that keeps page_translations'
   # search_vector in sync. Idempotent, safe to call on every boot.
   # search_vector is populated by a raw Postgres trigger, not anything
diff --git a/app/models/related_asset.rb b/app/models/related_asset.rb
index 8f16460..8f8d49c 100644
--- a/app/models/related_asset.rb
+++ b/app/models/related_asset.rb
@@ -5,4 +5,13 @@ class RelatedAsset < ApplicationRecord
   acts_as_list :scope => :page_id
 
   default_scope -> { order("position ASC") }
+
+  validate :headline_only_for_images
+
+  private
+
+    def headline_only_for_images
+      return unless asset
+      errors.add(:headline, "can only be set on image or PDF assets") if headline? && !(asset.image? || asset.pdf?)
+    end
 end