Add per-node translation management: list, edit, destroy, compare

Replaces the old locale-switch-and-edit-the-same-screen workflow,
which conflated presentation locale with content locale and let an
editor silently drift into editing the wrong language with no
persistent signal that anything had changed. Non-default-locale
content now has its own explicit routes and screens, never sharing
a route param with the ambient chrome locale.

- PageTranslationsController: index/show/edit/update/destroy,
  scoped to Page.non_default_locales; update handles first-time
  creation too, so there's no separate new/create step.
- Reads go through the actual PageTranslation row
  (Page#translation_summary), never through the Globalize
  fallback-bearing accessor -- fallback is correct for public
  rendering but wrong for editing, where a missing translation
  needs to look empty, not borrowed from another locale.
- Translations ride on the page's own draft/head cycle; no
  independent publish state.
- nodes#show gains a Translations section (per-locale Lock+Edit /
  Create+Lock, Destroy, a link into the read-only Compare view) and
  a locale indicator on its own default-locale content; nodes#edit,
  nodes#update, and nodes#autosave are pinned to the default locale
  via Globalize.with_locale regardless of the ambient route locale.
- nodes#show no longer double-loads the node or calls wipe_draft!
  on every view (see previous commit for why that's now safe).
- .preview_link_row is renamed .aligned_action_row now that it has
  a second real consumer.

2 files changed, 107 insertions, 3 deletions

diff --git a/app/controllers/nodes_controller.rb b/app/controllers/nodes_controller.rb
index c1468be..249602d 100644
--- a/app/controllers/nodes_controller.rb
+++ b/app/controllers/nodes_controller.rb
@@ -16,6 +16,8 @@ class NodesController < ApplicationController
                               :revert
                             ]
 
+  around_action :pin_to_default_locale, :only => [:show, :edit, :update, :autosave]
+
   def index
     @nodes = Node.root.descendants.includes(:head, :draft)
       .order('id DESC')
@@ -59,9 +61,9 @@ class NodesController < ApplicationController
   end
 
   def show
-    node = Node.find(params[:id])
-    node.wipe_draft!
-    @page = node.draft || node.head
+    @page = @node.draft || @node.head
+    @default_translation = @page.translations.find_by(:locale => I18n.default_locale)
+    @translations = @page.translation_summary
   end
 
   def edit
@@ -248,6 +250,10 @@ class NodesController < ApplicationController
       end
     end
 
+    def pin_to_default_locale
+      Globalize.with_locale(I18n.default_locale) { yield }
+    end
+
     def descendant_counts_for(ordered_with_level)
       counts = Hash.new(0)
       stack = [] # [node, level, index]
diff --git a/app/controllers/page_translations_controller.rb b/app/controllers/page_translations_controller.rb
new file mode 100644
index 0000000..47f01f7
--- /dev/null
+++ b/app/controllers/page_translations_controller.rb
@@ -0,0 +1,98 @@
+class PageTranslationsController < ApplicationController
+  layout 'admin'
+
+  before_action :login_required
+  before_action :find_node
+  before_action :find_locale, :only => [:show, :edit, :update, :destroy]
+
+  def index
+    page = @node.draft || @node.head
+    @translations = page ? page.translation_summary : []
+  end
+
+  def show
+    @page = @node.draft || @node.head
+    @translation         = @page.translations.find_by(:locale => @locale)
+    @default_translation = @page.translations.find_by(:locale => I18n.default_locale)
+  end
+
+  def edit
+    @node.lock_for_editing!(current_user)
+    @page = @node.draft || @node.head
+    @translation = @page.translations.find_by(:locale => @locale)
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  def update
+    draft = ensure_editable_draft
+    Globalize.with_locale(@locale) { draft.update!(translation_params) }
+    flash[:notice] = "#{@locale.upcase} translation saved. Publish the draft to make it live."
+
+    if params[:commit] == "Save + Unlock + Exit"
+      @node.unlock!
+      redirect_to node_path(@node)
+    else
+      redirect_to edit_node_translation_path(@node, @locale)
+    end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  def destroy
+    base = @node.draft || @node.head
+    unless base && base.translated_locales.include?(@locale)
+      flash[:error] = "No #{@locale.to_s.upcase} translation exists to remove."
+      return redirect_to node_path(@node)
+    end
+
+    if (base.translated_locales - [@locale]).empty?
+      flash[:error] = "Can't remove the only remaining translation."
+      return redirect_to node_path(@node)
+    end
+
+    draft = ensure_editable_draft
+    draft.translations.where(:locale => @locale).delete_all
+    draft.reload
+
+    flash[:notice] = "#{@locale.upcase} translation removed from the draft. Publish to make this permanent."
+    redirect_to node_path(@node)
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  private
+
+    def find_node
+      @node = Node.find(params[:node_id])
+    end
+
+    # Every remaining action's :translation_locale is already
+    # router-constrained to non-default locales, so this should never
+    # actually fire in practice -- it's a deliberate second check, kept
+    # as a drift detector in case the route constraint and this list
+    # (both driven by Page.non_default_locales) ever disagree.
+    def find_locale
+      candidate = params[:translation_locale].to_s.to_sym
+      unless Page.non_default_locales.include?(candidate)
+        raise ActionController::RoutingError, "Unknown or default locale"
+      end
+      @locale = candidate
+    end
+
+    # Never mutates head directly. Locks first (same guard as the
+    # primary editor), then reuses an existing draft or creates one --
+    # deliberately not going through the autosave buffer: this is a
+    # plain, explicit Save, not a live-typing surface.
+    def ensure_editable_draft
+      @node.lock_for_editing!(current_user)
+      @node.draft || @node.create_new_draft(current_user)
+    end
+
+    def translation_params
+      params.fetch(:page, {}).permit(:title, :abstract, :body)
+    end
+end