fix(inspector): name CSV row undo/redo consistently and preserve the Paste label

Author: datlechin

Plugins/CSVInspectorPlugin/CSVDocument.swift

@@ -187,68 +187,71 @@ public final class CSVDocument: NSDocument, InspectorDocument {
     }
 
     public func appendRow() {
+        let name = String(localized: "Add Row")
         let index = store.appendRow(values: [])
         registerUndo { document in
-            document.removeRow(at: index, suppressUndo: false)
+            document.removeRow(at: index, suppressUndo: false, actionName: name)
         }
-        setUndoActionName(String(localized: "Add Row"))
+        setUndoActionName(name)
         onChange?()
     }
 
     public func insertRow(at index: Int) {
+        let name = String(localized: "Insert Row")
         store.insertRow([], at: index)
         registerUndo { document in
-            document.removeRow(at: index, suppressUndo: false)
+            document.removeRow(at: index, suppressUndo: false, actionName: name)
         }
-        setUndoActionName(String(localized: "Insert Row"))
+        setUndoActionName(name)
         onChange?()
     }
 
     public func removeRow(at index: Int) {
-        removeRow(at: index, suppressUndo: false)
-        setUndoActionName(String(localized: "Delete Row"))
+        removeRow(at: index, suppressUndo: false, actionName: String(localized: "Delete Row"))
     }
 
-    private func removeRow(at index: Int, suppressUndo: Bool) {
+    private func removeRow(at index: Int, suppressUndo: Bool, actionName: String) {
         guard let removed = store.removeRow(at: index) else { return }
         if !suppressUndo {
             registerUndo { document in
-                document.reinsertRow(removed, at: index)
+                document.reinsertRow(removed, at: index, actionName: actionName)
             }
+            setUndoActionName(actionName)
         }
         onChange?()
     }
 
-    private func reinsertRow(_ values: [String], at index: Int) {
+    private func reinsertRow(_ values: [String], at index: Int, actionName: String) {
         store.insertRow(values, at: index)
         registerUndo { document in
-            document.removeRow(at: index, suppressUndo: false)
+            document.removeRow(at: index, suppressUndo: false, actionName: actionName)
         }
+        setUndoActionName(actionName)
         onChange?()
     }
 
     public func removeRows(at indices: IndexSet) {
         let removed = store.removeRows(at: indices)
         guard !removed.isEmpty else { return }
+        let name = removed.count == 1
+            ? String(localized: "Delete Row")
+            : String(localized: "Delete Rows")
         registerUndo { document in
-            document.reinsertRows(removed)
+            document.reinsertRows(removed, actionName: name)
         }
-        setUndoActionName(
-            removed.count == 1
-                ? String(localized: "Delete Row")
-                : String(localized: "Delete Rows")
-        )
+        setUndoActionName(name)
         onChange?()
     }
 
-    private func reinsertRows(_ rows: [(index: Int, cells: [String])]) {
+    private func reinsertRows(_ rows: [(index: Int, cells: [String])], actionName: String) {
         for entry in rows.sorted(by: { $0.index < $1.index }) {
             store.insertRow(entry.cells, at: entry.index)
         }
         let originalIndices = IndexSet(rows.map(\.index))
         registerUndo { document in
             document.removeRows(at: originalIndices)
         }
+        setUndoActionName(actionName)
         onChange?()
     }
 

TablePro/TableProApp.swift

@@ -605,17 +605,17 @@ struct AppMenuCommands: Commands {
 
             Divider()
 
-            Button(String(localized: "Insert Row Above")) {
+            Button("Insert Row Above") {
                 NSApp.sendAction(#selector(InspectorViewController.inspectorInsertRowAbove(_:)), to: nil, from: nil)
             }
             .disabled(!keyWindowIsInspector)
 
-            Button(String(localized: "Insert Row Below")) {
+            Button("Insert Row Below") {
                 NSApp.sendAction(#selector(InspectorViewController.inspectorInsertRowBelow(_:)), to: nil, from: nil)
             }
             .disabled(!keyWindowIsInspector)
 
-            Button(String(localized: "Delete Rows")) {
+            Button("Delete Rows") {
                 NSApp.sendAction(#selector(InspectorViewController.inspectorDeleteSelectedRows(_:)), to: nil, from: nil)
             }
             .disabled(!keyWindowIsInspector)

TablePro/Views/Inspector/InspectorRowInsertion.swift

@@ -0,0 +1,17 @@
+//
+//  InspectorRowInsertion.swift
+//  TablePro
+//
+
+import Foundation
+
+enum InspectorRowInsertion {
+    static func storeIndex(anchorDisplayRow: Int?, below: Bool, displayToStore: [Int], rowCount: Int) -> Int {
+        guard let displayRow = anchorDisplayRow,
+              displayRow >= 0, displayRow < displayToStore.count else {
+            return below ? rowCount : 0
+        }
+        let storeRow = displayToStore[displayRow]
+        return below ? storeRow + 1 : storeRow
+    }
+}

TablePro/Views/Inspector/InspectorViewController.swift

@@ -143,14 +143,14 @@ final class InspectorViewController: NSViewController, NSUserInterfaceValidation
 
         let undoManager = nsDocument?.undoManager
         undoManager?.beginUndoGrouping()
-        undoManager?.setActionName(String(localized: "Paste"))
         for row in rows {
             let newRowIndex = inspectorDocument.rowCount
             inspectorDocument.appendRow()
             for (column, value) in row.enumerated() {
                 inspectorDocument.setCell(row: newRowIndex, column: column, to: value)
             }
         }
+        undoManager?.setActionName(String(localized: "Paste"))
         undoManager?.endUndoGrouping()
     }
 
@@ -233,20 +233,19 @@ final class InspectorViewController: NSViewController, NSUserInterfaceValidation
     }
 
     private func insertStoreIndex(anchoredBy sender: Any?, below: Bool) -> Int {
-        let rowCount = inspectorDocument?.rowCount ?? 0
         let anchorDisplayRow: Int? = if let item = sender as? NSMenuItem {
             item.tag
         } else if below {
             state.selectedRowIndices.max()
         } else {
             state.selectedRowIndices.min()
         }
-        guard let displayRow = anchorDisplayRow,
-              displayRow >= 0, displayRow < displayToStore.count else {
-            return below ? rowCount : 0
-        }
-        let storeRow = displayToStore[displayRow]
-        return below ? storeRow + 1 : storeRow
+        return InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: anchorDisplayRow,
+            below: below,
+            displayToStore: displayToStore,
+            rowCount: inspectorDocument?.rowCount ?? 0
+        )
     }
 
     @objc func inspectorAddColumn(_ sender: Any?) {

TableProTests/PluginTestSources/CSVDocument.swift

@@ -0,0 +1 @@
+../../Plugins/CSVInspectorPlugin/CSVDocument.swift

TableProTests/Plugins/CSVDocumentUndoTests.swift

@@ -0,0 +1,53 @@
+//
+//  CSVDocumentUndoTests.swift
+//  TableProTests
+//
+//  Tests CSVDocument (compiled via symlink from Plugins/CSVInspectorPlugin/).
+//
+
+import AppKit
+import Foundation
+import TableProPluginKit
+import Testing
+
+@MainActor
+@Suite("CSVDocument undo naming")
+struct CSVDocumentUndoTests {
+    private func makeDocument(_ contents: String) throws -> CSVDocument {
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("\(UUID().uuidString).csv")
+        try contents.data(using: .utf8)!.write(to: url)
+        let document = CSVDocument()
+        try document.read(from: url, ofType: "public.comma-separated-values-text")
+        try? FileManager.default.removeItem(at: url)
+        return document
+    }
+
+    @Test("Insert Row keeps its name through undo and redo")
+    func insertRowNaming() throws {
+        let document = try makeDocument("a,b\n1,2\n")
+        document.insertRow(at: 0)
+        #expect(document.undoManager?.undoActionName == "Insert Row")
+        document.undoManager?.undo()
+        #expect(document.undoManager?.redoActionName == "Insert Row")
+        document.undoManager?.redo()
+        #expect(document.undoManager?.undoActionName == "Insert Row")
+    }
+
+    @Test("Delete Rows keeps its name through undo")
+    func deleteRowsNaming() throws {
+        let document = try makeDocument("a,b\n1,2\n3,4\n5,6\n")
+        document.removeRows(at: IndexSet([0, 1]))
+        #expect(document.undoManager?.undoActionName == "Delete Rows")
+        document.undoManager?.undo()
+        #expect(document.undoManager?.redoActionName == "Delete Rows")
+    }
+
+    @Test("Add Row keeps its name through undo and redo")
+    func addRowNaming() throws {
+        let document = try makeDocument("a,b\n1,2\n")
+        document.appendRow()
+        #expect(document.undoManager?.undoActionName == "Add Row")
+        document.undoManager?.undo()
+        #expect(document.undoManager?.redoActionName == "Add Row")
+    }
+}

TableProTests/Views/InspectorRowInsertionTests.swift

@@ -0,0 +1,44 @@
+//
+//  InspectorRowInsertionTests.swift
+//  TableProTests
+//
+
+@testable import TablePro
+import Testing
+
+@Suite("InspectorRowInsertion")
+struct InspectorRowInsertionTests {
+    @Test("A clicked row maps through displayToStore for above and below")
+    func mapsClickedRow() {
+        let displayToStore = [10, 11, 12]
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: 1, below: false, displayToStore: displayToStore, rowCount: 3) == 11)
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: 1, below: true, displayToStore: displayToStore, rowCount: 3) == 12)
+    }
+
+    @Test("A non-identity displayToStore (filtered or sorted view) resolves the store row")
+    func nonIdentityMapping() {
+        let displayToStore = [4, 0, 9]
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: 0, below: false, displayToStore: displayToStore, rowCount: 10) == 4)
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: 2, below: true, displayToStore: displayToStore, rowCount: 10) == 10)
+    }
+
+    @Test("No anchor inserts at the top for above and appends for below")
+    func emptySelectionFallback() {
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: nil, below: false, displayToStore: [0, 1], rowCount: 2) == 0)
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: nil, below: true, displayToStore: [0, 1], rowCount: 2) == 2)
+    }
+
+    @Test("An out-of-range anchor falls back to top or append")
+    func outOfRangeFallback() {
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: 5, below: false, displayToStore: [0, 1], rowCount: 2) == 0)
+        #expect(InspectorRowInsertion.storeIndex(
+            anchorDisplayRow: -1, below: true, displayToStore: [0, 1], rowCount: 2) == 2)
+    }
+}

docs/features/csv-inspector.mdx

@@ -34,7 +34,7 @@ Rows load in pages. The page size comes from the Default page size setting in [S
 
 - Double-click a cell (or press Return on it) to edit. Return commits and closes the editor. Tab commits and moves to the next cell, wrapping to the next row.
 - The toolbar `Add Row` button appends a new row, scrolls to it, and selects it.
-- Right-click a row and choose **Insert Row Above** or **Insert Row Below** to add a blank row next to it. Both also appear in the Edit menu, where they act on the selected row.
+- Right-click a row and choose **Insert Row Above** or **Insert Row Below** to add a blank row next to it. Both also appear in the Edit menu, where they insert next to the selected row, or at the top or bottom when nothing is selected.
 - Select rows and press `Delete` (the toolbar `Delete` button, or right-click a row and choose Delete) to remove them. The next row takes selection so arrow keys keep working from where you were.
 - Deleting rows that hold data asks you to confirm first. Deleting blank rows skips the prompt.
 - Cmd+Z and Cmd+Shift+Z undo and redo every change. Each insert, a bulk delete, or a paste is a single undo step.