6 files changed, 564 insertions, 81 deletions

diff --git a/app/models/concerns/nested_tree.rb b/app/models/concerns/nested_tree.rb
new file mode 100644
index 0000000..9a2eb0e
--- /dev/null
+++ b/app/models/concerns/nested_tree.rb
@@ -0,0 +1,86 @@
+# app/models/concerns/nested_tree.rb
+#
+# Minimal parent_id-based replacement for the tree-traversal subset of
+# awesome_nested_set actually used by this app (descendants, ancestors,
+# level, root, move_to_child_of)
+module NestedTree
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :parent, class_name: name, foreign_key: :parent_id, optional: true, inverse_of: :children
+    has_many :children, -> { order(:id) }, class_name: name, foreign_key: :parent_id, inverse_of: :parent
+
+    before_destroy :delete_descendants
+  end
+
+  class_methods do
+    def root
+      roots.first
+    end
+
+    def roots
+      where(parent_id: nil)
+    end
+
+    def valid?
+      # Every non-root row's parent_id must point at a real, existing row.
+      where.not(parent_id: nil).where.missing(:parent).none?
+    end
+  end
+
+  def root?
+    parent_id.nil?
+  end
+
+  def ancestors
+    result = []
+    current = parent
+    while current
+      result << current
+      current = current.parent
+    end
+    result
+  end
+
+  def level
+    ancestors.size
+  end
+
+  def descendants
+    ids = []
+    queue = self.class.where(parent_id: id).pluck(:id)
+    until queue.empty?
+      ids.concat(queue)
+      queue = self.class.where(parent_id: queue).pluck(:id)
+    end
+    self.class.where(id: ids)
+  end
+
+  def self_and_descendants
+    self.class.where(id: [id] + descendants.pluck(:id))
+  end
+
+  def self_and_descendants_ordered_with_level
+    nodes = [self] + descendants.to_a
+    children_by_parent = nodes.group_by(&:parent_id)
+    children_by_parent.each_value { |list| list.sort_by!(&:id) }
+
+    result = []
+    visit = ->(node, level) do
+      result << [node, level]
+      (children_by_parent[node.id] || []).each { |child| visit.call(child, level + 1) }
+    end
+    visit.call(self, 0)
+    result
+  end
+
+  def move_to_child_of(new_parent)
+    update!(parent_id: new_parent.id)
+  end
+
+  private
+
+  def delete_descendants
+    self.class.where(id: descendants.pluck(:id)).delete_all
+  end
+end
diff --git a/app/models/concerns/rrule_humanizer.rb b/app/models/concerns/rrule_humanizer.rb
new file mode 100644
index 0000000..8231de8
--- /dev/null
+++ b/app/models/concerns/rrule_humanizer.rb
@@ -0,0 +1,91 @@
+module RruleHumanizer
+  extend ActiveSupport::Concern
+
+  WEEKDAY_NAMES = {
+    de: { "MO"=>"Montag","TU"=>"Dienstag","WE"=>"Mittwoch","TH"=>"Donnerstag","FR"=>"Freitag","SA"=>"Samstag","SU"=>"Sonntag" },
+    en: { "MO"=>"Monday","TU"=>"Tuesday","WE"=>"Wednesday","TH"=>"Thursday","FR"=>"Friday","SA"=>"Saturday","SU"=>"Sunday" }
+  }.freeze
+
+  WEEKDAY_NAMES_ADVERBIAL = {
+    de: { "MO"=>"montags","TU"=>"dienstags","WE"=>"mittwochs","TH"=>"donnerstags","FR"=>"freitags","SA"=>"samstags","SU"=>"sonntags" }
+  }.freeze
+
+  WEEKDAY_NAMES_ABBR = {
+    de: { "MO"=>"Mo","TU"=>"Di","WE"=>"Mi","TH"=>"Do","FR"=>"Fr","SA"=>"Sa","SU"=>"So" }
+  }.freeze
+
+  ORDINAL_NAMES = {
+    de: { 1=>"ersten", 2=>"zweiten", 3=>"dritten", 4=>"vierten", -1=>"letzten", -2=>"vorletzten" },
+    en: { 1=>"first", 2=>"second", 3=>"third", 4=>"fourth", -1=>"last", -2=>"second-to-last" }
+  }.freeze
+
+  MONTH_NAMES = {
+    de: %w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember],
+    en: %w[January February March April May June July August September October November December]
+  }.freeze
+
+  def humanize_rrule(locale = I18n.locale)
+    return nil if rrule.blank?
+    parts = Hash[rrule.split(";").map { |p| p.split("=", 2) }]
+    return nil if parts["COUNT"] || parts["UNTIL"] # old one-off data, don't guess
+
+    freq, interval, byday, bymonth = parts["FREQ"], parts["INTERVAL"].to_i, parts["BYDAY"], parts["BYMONTH"]
+    loc = locale.to_sym
+    weekdays = WEEKDAY_NAMES[loc] || WEEKDAY_NAMES[:en]
+    ordinals = ORDINAL_NAMES[loc] || ORDINAL_NAMES[:en]
+    months   = MONTH_NAMES[loc]   || MONTH_NAMES[:en]
+
+    days = byday&.split(",")&.map do |d|
+     if d =~ /^(-?\d+)([A-Z]{2})$/
+        "#{ordinals[$1.to_i]} #{weekdays[$2]}"
+      else
+        weekdays[d]
+      end
+    end
+
+    base =
+      case loc
+      when :de
+        case freq
+        when "WEEKLY"
+          if days
+            if interval == 2
+              adverbial = byday.split(",").map { |d| WEEKDAY_NAMES_ADVERBIAL[:de][d] }
+              "Alle zwei Wochen #{adverbial.join(' und ')}"
+            else
+              "Jeden #{days.join(' und ')}"
+            end
+          else
+            interval == 2 ? "Alle zwei Wochen" : "Wöchentlich"
+          end
+        when "MONTHLY"
+          days ? "Jeden #{days.join(' und ')} im Monat" : "Monatlich"
+        end
+      else
+        case freq
+        when "WEEKLY"
+          days ? "#{interval == 2 ? 'Every other' : 'Every'} #{days.join(' and ')}" : (interval == 2 ? "Every other week" : "Weekly")
+        when "MONTHLY"
+          days ? "Every #{days.join(' and ')} of the month" : "Monthly"
+        end
+      end
+    return nil unless base
+
+    if bymonth
+      included = bymonth.split(",").map(&:to_i)
+      missing = ((1..12).to_a - included)
+      if missing.size == 1
+        excluded_name = months[missing.first - 1]
+        base += (loc == :de ? ", außer im #{excluded_name}" : ", except in #{excluded_name}")
+      end
+      # more than one missing month: bymonth pattern more complex than we handle, leave base as-is silently
+    end
+
+    base
+  end
+
+  def self.wday_abbr(time, locale)
+    code = %w[SU MO TU WE TH FR SA][time.wday]
+    (WEEKDAY_NAMES_ABBR[locale.to_sym] || WEEKDAY_NAMES_ABBR[:de])[code]
+  end
+end
diff --git a/app/models/event.rb b/app/models/event.rb
index 94a22e3..b8651a8 100644
--- a/app/models/event.rb
+++ b/app/models/event.rb
@@ -1,25 +1,27 @@
 class Event < ApplicationRecord
-  
-  # Associations
-  
-  has_many    :occurrences
-  belongs_to  :node
-  
-  # Callbacks
-  
-  after_save  :generate_occurences
-  
-  # Instance Methods
-  
+  include RruleHumanizer
+
+  belongs_to :node, optional: true
+  has_many   :occurrences, dependent: :destroy
+  acts_as_taggable_on :tags
+
+  validates :title, presence: true, unless: -> { node_id.present? }
+
+  after_save :generate_occurrences
+
   def occurrences_in_range start_time, end_time
     self.occurrences.where(
       "start_time > ? AND end_time < ?",
       start_time, end_time
     )
-  end 
+  end
+
+  def display_title
+    title.presence || node&.head&.title || "Untitled event"
+  end
 
   private
-    def generate_occurences
+    def generate_occurrences
       Occurrence.generate self
     end
 end
diff --git a/app/models/node.rb b/app/models/node.rb
index 92ecc12..73eefd1 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -1,13 +1,14 @@
 class Node < ApplicationRecord
   # Mixins and Plugins
-  acts_as_nested_set
+  include NestedTree
 
   # Associations
   has_many    :pages, -> { order("revision ASC") }, :dependent => :destroy
   belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id, :dependent => :destroy, optional: true
   belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id, :dependent => :destroy, optional: true
+  belongs_to  :autosave, :class_name => "Page", :foreign_key => :autosave_id, :dependent => :destroy, optional: true
   has_many    :permissions, :dependent => :destroy
-  has_one     :event, :dependent => :destroy
+  has_many    :events, :dependent => :destroy
   belongs_to  :lock_owner, :class_name => "User", :foreign_key => :locking_user_id, optional: true
 
   # Callbacks
@@ -16,21 +17,11 @@ class Node < ApplicationRecord
   after_save    :update_unique_names_of_children
 
   # Validations
-  validates_length_of     :slug, :within => 1..255,    :unless => -> { parent_id.nil? }
+  validates_length_of     :slug, :within => 1..255,    :unless => -> { parent_id.nil? || slug.blank? }
   validates_presence_of   :slug,                       :unless => -> { parent_id.nil? }
   validates_uniqueness_of :slug, :scope => :parent_id, :unless => -> { parent_id.nil? }
   validates_presence_of   :parent_id,                  :unless => -> { Node.root.nil? }
 
-  validate :borders       # This should never ever happen.
-
-  # Index for Fulltext Search
-  # define_index do
-  #   indexes head.translations.title
-  #   indexes slug
-  #   indexes unique_name
-  #   indexes head.translations.body
-  # end
-
   # Class methods
 
   # Returns a page for a given node. If no revision is supplied, it returns
@@ -59,6 +50,101 @@ class Node < ApplicationRecord
 
   # Instance Methods
 
+  # Acquires (or reaffirms) the editing lock without creating a draft or
+  # an autosave -- both are now deferred until there is real content to
+  # hold.
+  def lock_for_editing! current_user
+    if self.lock_owner.nil? || self.lock_owner == current_user
+      lock_for! current_user
+      if self.draft
+        self.draft.user = current_user if self.draft.user.nil?
+        self.draft.editor = current_user
+        self.draft.save!
+      end
+      self
+    else
+      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
+  end
+
+  # Creates or updates the autosave buffer from the given attributes.
+  # Autosave rows are never associated to the node via node_id -- they
+  # must never appear in self.pages / the revisions list, which is the
+  # whole reason autosave exists as a separate, unversioned layer.
+  def autosave! attributes, current_user
+    assert_locked_by! current_user
+
+    unless self.autosave
+      self.autosave = Page.create!(:editor => current_user)
+      self.autosave.clone_attributes_from(self.draft || self.head) if self.draft || self.head
+      self.save!
+    end
+    self.autosave.assign_attributes(attributes)
+    self.autosave.save!
+    self.autosave
+  end
+
+  # Promotes the current autosave into the draft (creating the draft if
+  # none exists yet) and destroys the autosave afterward. This is what
+  # the explicit "Save" action does; it never creates a new revision --
+  # same as any other in-place draft edit. The new draft is created via
+  # self.pages.create! rather than by repointing the autosave's own
+  # node_id, because acts_as_list assigns the revision number at create
+  # time, scoped to node_id -- a page created with node_id nil and
+  # reassigned afterward would carry a wrong or missing revision number.
+  def save_draft! current_user
+    assert_locked_by! current_user
+    return unless self.autosave
+
+    if self.draft
+      preserved_published_at = self.draft.published_at
+      self.draft.clone_attributes_from self.autosave
+      self.draft.published_at = preserved_published_at
+      self.draft.user_id = self.autosave.user_id if self.autosave.user_id
+      self.draft.editor  = current_user
+      self.draft.save!
+    else
+      empty_page = self.pages.create!
+      empty_page.clone_attributes_from self.autosave
+      empty_page.user         = self.autosave.user_id ? self.autosave.user : (self.head ? self.head.user : current_user)
+      empty_page.editor       = current_user
+      empty_page.published_at = self.head.published_at if self.head
+      empty_page.save!
+      self.draft = empty_page
+      self.save!
+    end
+
+    self.autosave.destroy
+    self.autosave_id = nil
+    self.save!
+    self.draft.reload
+  end
+
+  def resolve_page_reference ref
+    case ref.to_s
+    when "head" then head
+    when "draft" then draft
+    when "autosave" then autosave
+    else pages.find_by_revision(ref)
+    end
+  end
+
+  # Which layer-pairs are meaningful to compare right now, given this
+  # node's actual state. Head vs autosave only shows up when no draft
+  # sits between them -- with a draft present, autosave is compared
+  # against the draft, never past it straight to head.
+  def available_layer_pairs
+    pairs = []
+    pairs << [:head, :draft]     if head && draft
+    pairs << [:draft, :autosave] if draft && autosave
+    pairs << [:head, :autosave]  if head && autosave && !draft
+    pairs
+  end
+
   def find_or_create_draft current_user
     self.wipe_draft!
     if draft && self.lock_owner == current_user
@@ -94,6 +180,36 @@ class Node < ApplicationRecord
     self.draft.reload
   end
 
+  # Discards exactly the topmost non-empty layer -- autosave if present,
+  # else draft -- and reveals whatever's beneath it. Releases the lock
+  # only once nothing is left to protect (no draft survives); leaves it
+  # alone whenever a draft remains, since #edit still has real content
+  # open.
+  def revert! current_user
+    assert_locked_by! current_user
+
+    if self.autosave
+      self.autosave.destroy
+      self.autosave_id = nil
+      self.save!
+    elsif self.draft && self.head
+      self.draft.destroy
+      self.draft_id = nil
+      self.save!
+    end
+
+    self.unlock! unless self.draft
+    self.reload
+  end
+
+  def staged_slug=(value)
+    if head.blank?
+      self.slug = value
+    else
+      super
+    end
+  end
+
   def publish_draft!
     # Return nil if nothing to publish and no staged changes
     return nil unless self.draft || staged_slug || staged_parent_id
@@ -112,6 +228,11 @@ class Node < ApplicationRecord
 
     if staged_parent_id && (staged_parent_id != parent_id)
       new_parent = Node.find(staged_parent_id)
+
+      if new_parent == self || self.descendants.include?(new_parent)
+        raise ActiveRecord::RecordInvalid.new(self), "Cannot move a node under itself or one of its own descendants"
+      end
+
       self.staged_parent_id = nil
       self.save!
       self.move_to_child_of(new_parent)
@@ -128,11 +249,22 @@ class Node < ApplicationRecord
     self
   end
 
-  # removes a draft and the lock if it is older than a day and still
-  # identical to head
+  # Releases whatever's stale and abandoned; never anything actively in
+  # use. Three independent cases share one rule -- nothing is touched
+  # unless it's been sitting untouched for over a day:
+  #  - a lock held with no draft or autosave at all (the editor opened
+  #    the page and never actually wrote anything)
+  #  - a fresh autosave older than a day, never promoted to a draft
+  #  - a draft older than a day that's still identical to head
   def wipe_draft!
+    return if self.autosave && self.autosave.updated_at > 1.day.ago
+
     unless self.draft
+      return if self.autosave.nil? && self.locked? && self.updated_at > 1.day.ago
+      self.autosave&.destroy
+      self.autosave_id = nil
       self.unlock!
+      self.save!
       return
     end
     return unless self.head
@@ -203,6 +335,10 @@ class Node < ApplicationRecord
     unique_path.length == 3 && unique_path[0] == "updates"
   end
 
+  def editable_page
+    autosave || draft || head
+  end
+
   # Returns immutable node id for all new nodes so that the atom feed entry ids
   # stay the same eventhough the slug or positions changes.
   # Can be removed after a year or so ;)
@@ -220,12 +356,59 @@ class Node < ApplicationRecord
       .distinct
   end
 
+  # This one is for admin-only views, where finding a draft is the point.
+  # Substring match on whichever of head/draft is present.
+  def self.editor_search(term)
+    words = term.to_s.split(/\s+/).reject(&:blank?)
+    return none if words.empty?
+
+    conditions = []
+    binds = {}
+
+    words.each_with_index do |word, i|
+      key = "term#{i}"
+      binds[key.to_sym] = "%#{sanitize_sql_like(word)}%"
+      conditions << "(head_translations.title ILIKE :#{key} OR head_translations.abstract ILIKE :#{key} " \
+                    "OR draft_translations.title ILIKE :#{key} OR draft_translations.abstract ILIKE :#{key})"
+    end
+
+    joins("LEFT JOIN page_translations head_translations ON head_translations.page_id = nodes.head_id")
+      .joins("LEFT JOIN page_translations draft_translations ON draft_translations.page_id = nodes.draft_id")
+      .where(conditions.join(" AND "), binds)
+      .distinct
+  end
+
+  def self.drafts_and_autosaves(current_user_id: nil)
+    scope = where("draft_id IS NOT NULL OR autosave_id IS NOT NULL")
+    return scope.order("updated_at DESC") unless current_user_id
+
+    scope.order(
+      Arel.sql(sanitize_sql_array(["CASE WHEN locking_user_id = ? THEN 0 ELSE 1 END, updated_at DESC", current_user_id]))
+    )
+  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
       self.save
     end
 
+    def assert_locked_by! current_user
+      return if self.lock_owner == current_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
+
     # Creates an empty page and associates it to the given node. This means
     # freshly created node has an empty draft. A user can create nodes as he
     # wants to which will not appear on the public page until the author edits
@@ -246,10 +429,13 @@ class Node < ApplicationRecord
     # Watch out recursion ahead! update_unique_name itself triggers this
     # after_save callback which invokes update_unique_name on its children.
     # Hopefully until no childrens occur
+    #
+    # Queries parent_id directly rather than the NestedTree#children
+    # association out of habit from the old awesome_nested_set-avoidance
+    # workaround - no longer strictly necessary now that children is
+    # equally safe, but left as-is since it already works correctly.
     def update_unique_names_of_children
       unless root?
-        # Use parent_id-based traversal instead of lft/rgt descendants
-        # due to awesome_nested_set not refreshing parent lft/rgt in memory
         Node.where(:parent_id => self.id).each do |child|
           child.reload
           child.update_unique_name
@@ -257,10 +443,4 @@ class Node < ApplicationRecord
         end
       end
     end
-
-    def borders
-      if lft && rgt && (lft > rgt)
-        errors.add("Fuck!. lft should never be smaller than rgt")
-      end
-    end
 end
diff --git a/app/models/occurrence.rb b/app/models/occurrence.rb
index 3baf447..c6a2380 100644
--- a/app/models/occurrence.rb
+++ b/app/models/occurrence.rb
@@ -1,19 +1,19 @@
-# TODO Make a gem out of the c wrapper
 require 'chaos_calendar'
 
 class Occurrence < ApplicationRecord
   
   # Associations
   
-  belongs_to :node
+  belongs_to :node,  optional: true
   belongs_to :event
-  
+
   # Class Methods
   
   def self.find_in_range start_time, end_time
-    includes(:node)
-      .where("start_time > ? AND end_time < ?", start_time, end_time)
-      .order("start_time")
+    joins(:event)
+      .includes(:node)
+      .where("occurrences.start_time > ? AND occurrences.end_time < ?", start_time, end_time)
+      .order("occurrences.start_time")
   end
 
   def self.find_next
@@ -27,6 +27,7 @@ class Occurrence < ApplicationRecord
   # event are then calculated and created.
   def self.generate event
     self.where(:event_id => event.id).delete_all
+    return if event.start_time.nil?
     
     node        = event.node
     duration    = (event.end_time - event.start_time)
@@ -36,7 +37,7 @@ class Occurrence < ApplicationRecord
       self.create(
         :start_time => occurrence,
         :end_time   => (occurrence + duration),
-        :node_id    => node.id,
+        :node_id    => node&.id,
         :event_id   => event.id
       )
     end
@@ -49,10 +50,11 @@ class Occurrence < ApplicationRecord
   # Return value is always an array of Time objects.
   def self.generate_dates event
     if event.rrule && !event.rrule.empty?
-      ChaosCalendar::occurrences( 
+      ChaosCalendar::occurrences_for_timezone( 
         event.start_time, 
         (Time.now + 5.years), 
-        event.rrule
+        event.rrule,
+        Time.zone.tzinfo.identifier
       )
     else
       [event.start_time]
@@ -64,7 +66,7 @@ class Occurrence < ApplicationRecord
   # Instance Methods
   
   def summary
-    node.head.title
+    node&.head&.title || event.display_title
   end
-  
+
 end
diff --git a/app/models/page.rb b/app/models/page.rb
index e6baf20..e5a8d9d 100644
--- a/app/models/page.rb
+++ b/app/models/page.rb
@@ -63,7 +63,21 @@ class Page < ApplicationRecord
       end
     end
 
-    scope.order("#{options[:order_by]} #{options[:order_direction]}")
+    if options[:node] && options[:children] == "direct"
+      scope = scope.where(nodes: { parent_id: options[:node].id })
+    elsif options[:node] && options[:children] == "all"
+      scope = scope.where(nodes: { id: options[:node].descendants.pluck(:id) })
+    end
+
+    direction = %w[ASC DESC].include?(options[:order_direction]&.upcase) ? options[:order_direction].upcase : "ASC"
+
+    if options[:order_by] == "title"
+      return scope
+        .order(Arel.sql("(SELECT pt.title FROM page_translations pt WHERE pt.page_id = pages.id AND pt.locale = #{ActiveRecord::Base.connection.quote(I18n.locale.to_s)}) #{direction}"))
+        .paginate(:page => page, :per_page => options[:limit])
+    end
+
+    scope.order("#{options[:order_by]} #{direction}")
       .paginate(:page => page, :per_page => options[:limit])
   end
 
@@ -73,6 +87,27 @@ class Page < ApplicationRecord
     end
   end
 
+  def self.non_default_locales
+    I18n.available_locales - [:root, I18n.default_locale]
+  end
+
+  # One row per non-default locale, read from the actual translation
+  # row -- never through the locale-dependent accessor, so a locale
+  # with no real translation yet reports as absent rather than quietly
+  # showing a fallback value borrowed from another locale.
+  def translation_summary
+    Page.non_default_locales.map do |locale|
+      translation = translations.find_by(:locale => locale)
+      {
+        :locale     => locale,
+        :exists     => translation.present?,
+        :title      => translation&.title,
+        :updated_at => translation&.updated_at,
+        :outdated   => translation.present? && outdated_translations?(:locale => locale)
+      }
+    end
+  end
+
   def self.untranslated(options = {:locale => :de})
     PageTranslation.all.group_by(&:page_id).select do |k,v|
       v.size == 1 && v.map{|x| x.locale}.include?(options[:locale])
@@ -128,22 +163,47 @@ class Page < ApplicationRecord
     "/#{node.unique_name}"
   end
 
+  def ensure_preview_token!
+    update!(preview_token: SecureRandom.urlsafe_base64(24)) unless preview_token.present?
+    preview_token
+  end
+
+  def revoke_preview_token!
+    update!(preview_token: nil)
+  end
+
   def clone_attributes_from page
     return nil unless page
 
     self.reload
+    page.translations.reload
 
     # Clone untranslated attributes
     self.tag_list         = page.tag_list
     self.template_name  ||= page.template_name
     self.published_at     = page.published_at
 
-    # Getting rid of the auto-generated empty translations
-    self.translations.delete_all
+    # Clone translated attributes -- update each locale in place rather
+    # than delete-and-recreate, so a locale whose content is genuinely
+    # unchanged keeps its real created_at/updated_at instead of looking
+    # freshly touched on every single save (which was silently defeating
+    # Page.find_with_outdated_translations' whole staleness comparison).
+    # search_vector is excluded deliberately: it's DB-trigger-maintained
+    # from title/abstract, not real content, and comparing a precomputed
+    # tsvector risked a false "changed" from representation noise alone.
+    source_locales = page.translations.map(&:locale)
+    self.translations.where.not(:locale => source_locales).destroy_all
+
+    page.translations.each do |source_translation|
+      attrs = source_translation.attributes.except("id", "page_id", "created_at", "updated_at", "search_vector")
+      mine  = self.translations.find_by(:locale => source_translation.locale)
 
-    # Clone translated attributes
-    page.translations.each do |translation|
-      self.translations.create!(translation.attributes.except("id", "page_id", "created_at", "updated_at"))
+      if mine
+        changed_attrs = attrs.reject { |k, v| mine.public_send(k) == v }
+        mine.update!(changed_attrs) if changed_attrs.any?
+      else
+        self.translations.create!(attrs)
+      end
     end
 
     # Clone asset references
@@ -152,6 +212,54 @@ class Page < ApplicationRecord
     self.save
   end
 
+  def diff_against other, view: :inline, locale: nil
+    if locale
+      mine, theirs = translations.find_by(:locale => locale), other.translations.find_by(:locale => locale)
+      my_title, my_abstract, my_body          = mine&.title,   mine&.abstract,   mine&.body
+      their_title, their_abstract, their_body = theirs&.title, theirs&.abstract, theirs&.body
+    else
+      my_title, my_abstract, my_body          = title, abstract, body
+      their_title, their_abstract, their_body = other.title, other.abstract, other.body
+    end
+
+    text_diffs =
+      if view == :side_by_side
+        {
+          title:    HtmlWordDiff.side_by_side(their_title.to_s,    my_title.to_s),
+          abstract: HtmlWordDiff.side_by_side(their_abstract.to_s, my_abstract.to_s),
+          body:     HtmlWordDiff.side_by_side(their_body.to_s,     my_body.to_s)
+        }
+      else
+        {
+          title:    HtmlWordDiff.inline(their_title.to_s,    my_title.to_s),
+          abstract: HtmlWordDiff.inline(their_abstract.to_s, my_abstract.to_s),
+          body:     HtmlWordDiff.inline(their_body.to_s,     my_body.to_s)
+        }
+      end
+
+    text_diffs.merge(
+      tags:          { added: tag_list.to_a - other.tag_list.to_a, removed: other.tag_list.to_a - tag_list.to_a },
+      template_name: { from: other.template_name, to: template_name, changed: template_name != other.template_name },
+      assets:        { added: assets.to_a - other.assets.to_a, removed: other.assets.to_a - assets.to_a }
+    )
+  end
+
+  def locale_diff_summary other
+    (translated_locales | other.translated_locales).sort_by(&:to_s).map do |locale|
+      mine   = translations.find_by(:locale => locale)
+      theirs = other.translations.find_by(:locale => locale)
+      {
+        :locale       => locale,
+        :exists_here  => mine.present?,
+        :exists_there => theirs.present?,
+        :changed      => mine.present? != theirs.present? ||
+                          mine&.title != theirs&.title ||
+                          mine&.abstract != theirs&.abstract ||
+                          mine&.body != theirs&.body
+      }
+    end
+  end
+
   def public?
     published_at.nil? ? true : published_at < Time.now
   end
@@ -208,46 +316,60 @@ class Page < ApplicationRecord
 
   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
+  # Rails' schema dumper can represent -- a database rebuilt from
+  # schema.rb rather than replayed migrations silently loses it.
+  def self.ensure_search_vector_trigger!
+    connection.execute(<<~SQL)
+      CREATE OR REPLACE FUNCTION page_translations_search_vector_update()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.search_vector := to_tsvector(
+          'simple',
+          coalesce(NEW.title, '') || ' ' ||
+          coalesce(NEW.abstract, '') || ' ' ||
+          coalesce(NEW.body, '')
+        );
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE OR REPLACE TRIGGER page_translations_search_vector_trigger
+      BEFORE INSERT OR UPDATE ON page_translations
+      FOR EACH ROW EXECUTE PROCEDURE page_translations_search_vector_update();
+    SQL
+  end
+
   private
 
     def set_page_title
-      if title.nil?
-        title = "Untitled"
-      end
+      self.title = "Untitled" if title.nil?
     end
 
     def set_template
-      if node && node.update?
-        self.template_name = "update"
-      end
+      return if template_name.present?
+      self.template_name = node&.default_template_name || (node&.update? ? "update" : nil)
     end
 
     def rewrite_links_in_body
-      begin
-        if self.body
-          tmp_body    = "<div>#{self.body}</div>"
-          xml_string  = XML::Parser.string( tmp_body )
-          xml_doc     = xml_string.parse
-          links       = xml_doc.find("//a[not(starts-with(@href, 'http://'))]")
-          links       = links.reject { |l| l[:href] =~ /system\/uploads/ }
-          locales     = I18n.available_locales.reject {|l| l == :root}
+      return unless self.body
 
-          links.each do |link|
-            unless locales.include? link[:href].slice(1,2).to_sym
-              unless link[:href] =~ /sytem\/uploads/
-                link[:href] = link[:href].sub(/^\//, "/#{I18n.locale}/")
-              end
-            end
-          end
+      doc = Nokogiri::HTML::DocumentFragment.parse(self.body)
+      locales = I18n.available_locales.reject { |l| l == :root }
 
-          tmp_body = xml_doc.to_s.gsub(/(\n\<div\>|\<\/div\>\n)/, "")
-          tmp_body.gsub!("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "")
+      doc.css('a').each do |link|
+        href = link['href']
+        next unless href
+        next if href.start_with?('http://', 'https://')
+        next if href =~ /system\/uploads/
 
-          self.body = tmp_body
+        unless locales.include?(href.slice(1, 2)&.to_sym)
+          link['href'] = href.sub(/^\//, "/#{I18n.locale}/")
         end
-      rescue
-        nil
       end
-    end
 
+      self.body = doc.to_html
+    end
 end