Add revert!/discard and rebuild nodes#edit around the new hierarchy

revert! discards exactly the topmost non-empty layer -- autosave if
present, else draft -- and reveals whatever's beneath it, releasing the
lock only once nothing is left to protect. Guards against destroying a
brand-new, never-published node's only draft, which would violate the
(head | draft) invariant every other method here assumes holds; the
view's Destroy/Discard button is gated the same way.

nodes#edit now calls lock_for_editing! instead of find_or_create_draft,
and always displays autosave || draft || head, resurrecting an
abandoned session's unsaved content by default with an explicit flash
explaining what's shown and how to get back to the last saved version.

The view drops content_for :subnavigation entirely: Show becomes
"Unlock + Back", Preview stays a plain link, metadata's own <details>
already replaced the old toggle, and Publish moves off this page for
good, per the earlier decision to manage the publish lifecycle
entirely from nodes#show. Save Draft and Save + Unlock + Exit appear
both above and below the form, given the body field alone runs 600px
on desktop.

3 files changed, 112 insertions, 10 deletions

diff --git a/app/controllers/nodes_controller.rb b/app/controllers/nodes_controller.rb
index 042963b..6fd000b 100644
--- a/app/controllers/nodes_controller.rb
+++ b/app/controllers/nodes_controller.rb
@@ -12,7 +12,8 @@ class NodesController < ApplicationController
                               :destroy,
                               :publish,
                               :unlock,
-                              :autosave
+                              :autosave,
+                              :revert
                             ]
 
   def index
@@ -59,16 +60,17 @@ class NodesController < ApplicationController
   end
 
   def edit
-    begin
-      @draft = @node.find_or_create_draft( current_user )
-    rescue LockedByAnotherUser => e
-      flash[:error] = e.message
-      if request.referer
-        redirect_to request.referer || node_path(@node)
-      else
-        redirect_to node_path(@node)
-      end
+    @node.lock_for_editing!( current_user )
+    @page = @node.autosave || @node.draft || @node.head
+
+    if @node.autosave
+      flash.now[:notice] =
+        "This page has unsaved changes from a previous session, shown below. " \
+        "Save to keep them, or use \"Discard changes\" below to go back to the last saved version."
     end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to(request.referer || node_path(@node))
   end
 
   def update
@@ -104,6 +106,18 @@ class NodesController < ApplicationController
     render plain: "Autosave failed", status: :internal_server_error
   end
 
+  def revert
+    @node.revert!(current_user)
+    if @node.draft
+      redirect_to edit_node_path(@node)
+    else
+      redirect_to node_path(@node)
+    end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
   def destroy
     @node.destroy
   end
diff --git a/config/routes.rb b/config/routes.rb
index 1569a15..da46e5c 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -41,6 +41,7 @@ Cccms::Application.routes.draw do
         put :generate_shared_preview
         put :revoke_shared_preview
         put :autosave
+        put :revert
       end
 
       resources :revisions do
diff --git a/test/models/node_test.rb b/test/models/node_test.rb
index bdf556d..2138c19 100644
--- a/test/models/node_test.rb
+++ b/test/models/node_test.rb
@@ -379,6 +379,93 @@ class NodeTest < ActiveSupport::TestCase
     assert_nil node.autosave
     assert_nil node.lock_owner
   end
+
+  test "revert! is a safe no-op on a fresh node with only a draft" do
+    node = create_node_with_draft
+    node.lock_for_editing!(@user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_not_nil node.draft
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "revert! discards an autosave on a fresh node without touching its only draft" do
+    node = create_node_with_draft
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "typing" }, @user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_not_nil node.draft
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "revert! does nothing when a published node has no draft or autosave" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_not_nil node.head
+    assert_nil node.draft
+  end
+
+  test "revert! discards a fresh autosave and releases the lock when no draft exists" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "in progress" }, @user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_nil node.draft
+    assert_nil node.lock_owner
+  end
+
+  test "revert! destroys an existing draft and releases the lock" do
+    node = create_node_with_published_page
+    head_title = node.head.title
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "second version" }, @user1)
+    node.save_draft!(@user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.draft
+    assert_equal head_title, node.head.title
+    assert_nil node.lock_owner
+  end
+
+  test "revert! discards only the autosave when a draft survives beneath it" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "second version" }, @user1)
+    node.save_draft!(@user1)
+    node.autosave!({ :title => "third version, still typing" }, @user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_not_nil node.draft
+    assert_equal "second version", node.draft.title
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "revert! raises LockedByAnotherUser for a non-owner" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+
+    assert_raise(LockedByAnotherUser) { node.revert!(@user2) }
+    assert_equal @user1, node.reload.lock_owner
+  end
   
   def create_revisions node, count
     count.times do