fix(datagrid): route Cmd+V to row paste when clipboard holds copied rows (#935)

* fix(datagrid): route Cmd+V to row paste when clipboard holds copied rows

Cmd+C on a row selection writes TSV via ClipboardService and Cmd+V then routed through pasteCellsFromClipboard, which overwrote cells starting at the focused cell with the source row's values, instead of inserting a new row. The asymmetry was: Cmd+C always operated on selectedRowIndexes (row level), Cmd+V chose cell paste whenever any cell was focused, so copying then pasting in the same selection looked like the row's tail columns silently mutated.

Two signals now defer cell paste to dataGridPasteRows (which inserts):
  1. The clipboard was written by this app's row-copy path. ClipboardProvider gains a writeRows(tsv:html:?) method that tags the pasteboard with com.TablePro.gridRows. pasteCellsFromClipboard checks hasGridRows first and bails when set.
  2. The clipboard's TSV shape is full-row (every line has exactly numberOfDataColumns values). Catches external row-shaped data the user clearly intended as a row insert.

Migrates RowOperationsManager.copySelectedRowsToClipboard and TableViewCoordinator.copyRows / copyRowsWithHeaders from writeText / writeTabular to writeRows. Drops the now-unused writeTabular method from the protocol.

Cell paste continues to work for external single-column or shape-mismatched TSV (clearly cell-shaped data from spreadsheets etc.). Right-click row > Paste and Cmd+V with no cell focus already went straight to row paste; unchanged.

* test(datagrid): add regression tests for pasteCellsFromClipboard routing

Locks the contract that pasteCellsFromClipboard returns false (deferring to dataGridPasteRows) on the two new signals: clipboard carries the gridRows tag, or every TSV line matches the table's column count. Without these tests, the bug from this same PR could regress silently if someone changes the pasteboard tag string or removes the shape check.

Also covers the cell-paste happy path (shape-mismatched TSV) and the read-only short-circuit.

Author: datlechin

TablePro/Core/Services/Infrastructure/ClipboardService.swift

@@ -12,12 +12,14 @@ import UniformTypeIdentifiers
 protocol ClipboardProvider {
     func readText() -> String?
     func writeText(_ text: String)
-    func writeTabular(tsv: String, html: String)
+    func writeRows(tsv: String, html: String?)
     var hasText: Bool { get }
+    var hasGridRows: Bool { get }
 }
 
 struct NSPasteboardClipboardProvider: ClipboardProvider {
     private static let tsvType = NSPasteboard.PasteboardType("public.utf8-tab-separated-values-text")
+    private static let gridRowsType = NSPasteboard.PasteboardType("com.TablePro.gridRows")
 
     func readText() -> String? {
         NSPasteboard.general.string(forType: .string)
@@ -30,17 +32,24 @@ struct NSPasteboardClipboardProvider: ClipboardProvider {
         pb.setString(text, forType: NSPasteboard.PasteboardType(UTType.utf8PlainText.identifier))
     }
 
-    func writeTabular(tsv: String, html: String) {
+    func writeRows(tsv: String, html: String?) {
         let pb = NSPasteboard.general
         pb.clearContents()
         pb.setString(tsv, forType: .string)
         pb.setString(tsv, forType: Self.tsvType)
-        pb.setString(html, forType: .html)
+        if let html {
+            pb.setString(html, forType: .html)
+        }
+        pb.setString("1", forType: Self.gridRowsType)
     }
 
     var hasText: Bool {
         NSPasteboard.general.string(forType: .string) != nil
     }
+
+    var hasGridRows: Bool {
+        NSPasteboard.general.types?.contains(Self.gridRowsType) == true
+    }
 }
 
 @MainActor

TablePro/Core/Services/Query/RowOperationsManager.swift

@@ -281,7 +281,7 @@ final class RowOperationsManager {
             result.append("\n(truncated, showing first \(Self.maxClipboardRows) of \(totalSelected) rows)")
         }
 
-        ClipboardService.shared.writeText(result)
+        ClipboardService.shared.writeRows(tsv: result, html: nil)
     }
 
     func pasteRowsFromClipboard(

TablePro/Views/Results/DataGridView+RowActions.swift

@@ -49,7 +49,7 @@ extension TableViewCoordinator {
 
         let tsv = tsvRows.joined(separator: "\n")
         let html = HtmlTableEncoder.encode(rows: htmlRows)
-        ClipboardService.shared.writeTabular(tsv: tsv, html: html)
+        ClipboardService.shared.writeRows(tsv: tsv, html: html)
     }
 
     func copyRowsWithHeaders(at indices: Set<Int>) {
@@ -69,7 +69,7 @@ extension TableViewCoordinator {
 
         let tsv = tsvRows.joined(separator: "\n")
         let html = HtmlTableEncoder.encode(rows: htmlRows, headers: columns)
-        ClipboardService.shared.writeTabular(tsv: tsv, html: html)
+        ClipboardService.shared.writeRows(tsv: tsv, html: html)
     }
 
     @MainActor

TablePro/Views/Results/Extensions/DataGridView+CellPaste.swift

@@ -8,15 +8,21 @@ import AppKit
 extension TableViewCoordinator {
     func pasteCellsFromClipboard(anchorRow: Int, anchorColumn: Int) -> Bool {
         guard isEditable else { return false }
+        if ClipboardService.shared.hasGridRows { return false }
         guard let text = ClipboardService.shared.readText(), !text.isEmpty else { return false }
 
         let grid = text.components(separatedBy: "\n")
             .filter { !$0.isEmpty }
             .map { $0.components(separatedBy: "\t") }
         guard !grid.isEmpty, grid[0].count > 1 || grid.count > 1 else { return false }
 
+        let dataColumnCount = tableRowsProvider().columns.count
+        if dataColumnCount > 0, grid.allSatisfy({ $0.count == dataColumnCount }) {
+            return false
+        }
+
         let maxRow = min(anchorRow + grid.count, cachedRowCount)
-        let maxCol = min(anchorColumn + (grid.first?.count ?? 0), tableRowsProvider().columns.count)
+        let maxCol = min(anchorColumn + (grid.first?.count ?? 0), dataColumnCount)
         guard anchorRow < maxRow, anchorColumn < maxCol else { return false }
 
         let undoManager = tableView?.window?.undoManager

TableProTests/Core/Services/RowOperationsManagerCopyTests.swift

@@ -5,18 +5,22 @@ import Testing
 private final class MockClipboardProvider: ClipboardProvider {
     var lastWrittenText: String?
     var textToRead: String?
+    var lastWasGridRows = false
 
     func readText() -> String? { textToRead }
 
     func writeText(_ text: String) {
         lastWrittenText = text
+        lastWasGridRows = false
     }
 
-    func writeTabular(tsv: String, html: String) {
+    func writeRows(tsv: String, html: String?) {
         lastWrittenText = tsv
+        lastWasGridRows = true
     }
 
     var hasText: Bool { textToRead != nil }
+    var hasGridRows: Bool { lastWasGridRows }
 }
 
 @MainActor

TableProTests/Views/Results/Extensions/CellPasteRoutingTests.swift

@@ -0,0 +1,103 @@
+//
+//  CellPasteRoutingTests.swift
+//  TableProTests
+//
+//  Locks the contract that pasteCellsFromClipboard defers to row paste
+//  when the clipboard carries the in-app gridRows tag or has a row-shaped
+//  TSV. Without these checks, Cmd+V on a focused cell after Cmd+C on a row
+//  silently overwrites the row's tail columns.
+//
+
+import AppKit
+import Foundation
+import SwiftUI
+import Testing
+@testable import TablePro
+
+@MainActor
+private final class StubClipboard: ClipboardProvider {
+    var text: String?
+    var hasGridRowsValue = false
+
+    func readText() -> String? { text }
+    func writeText(_ text: String) { self.text = text; hasGridRowsValue = false }
+    func writeRows(tsv: String, html: String?) { self.text = tsv; hasGridRowsValue = true }
+    var hasText: Bool { text != nil }
+    var hasGridRows: Bool { hasGridRowsValue }
+}
+
+@Suite("pasteCellsFromClipboard routing")
+@MainActor
+struct CellPasteRoutingTests {
+    private func makeCoordinator(columns: [String], rowCount: Int) -> TableViewCoordinator {
+        let coordinator = TableViewCoordinator(
+            changeManager: AnyChangeManager(DataChangeManager()),
+            isEditable: true,
+            selectedRowIndices: .constant([]),
+            delegate: nil
+        )
+        let columnTypes: [ColumnType] = Array(repeating: .text(rawType: nil), count: columns.count)
+        let rows = (0..<rowCount).map { i in (0..<columns.count).map { c in "r\(i)c\(c)" } }
+        let tableRows = TableRows.from(queryRows: rows, columns: columns, columnTypes: columnTypes)
+        coordinator.tableRowsProvider = { tableRows }
+        coordinator.updateCache()
+        return coordinator
+    }
+
+    @Test("Defers to row paste when clipboard has gridRows tag")
+    func defersOnGridRowsTag() {
+        let stub = StubClipboard()
+        stub.text = "anything\twith\ttabs"
+        stub.hasGridRowsValue = true
+        ClipboardService.shared = stub
+
+        let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
+        let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+
+        #expect(result == false)
+    }
+
+    @Test("Defers to row paste when every TSV line matches column count")
+    func defersOnRowShapedTSV() {
+        let stub = StubClipboard()
+        stub.text = "x\ty\tz\nq\tw\te"
+        stub.hasGridRowsValue = false
+        ClipboardService.shared = stub
+
+        let coordinator = makeCoordinator(columns: ["a", "b", "c"], rowCount: 5)
+        let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+
+        #expect(result == false)
+    }
+
+    @Test("Cell pastes shape-mismatched TSV into focused range")
+    func cellPastesShapeMismatchedTSV() {
+        let stub = StubClipboard()
+        stub.text = "x\ty"
+        stub.hasGridRowsValue = false
+        ClipboardService.shared = stub
+
+        let coordinator = makeCoordinator(columns: ["a", "b", "c", "d", "e"], rowCount: 5)
+        let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+
+        #expect(result == true)
+    }
+
+    @Test("Returns false when not editable")
+    func refusesWhenReadOnly() {
+        let stub = StubClipboard()
+        stub.text = "x\ty"
+        ClipboardService.shared = stub
+
+        let coordinator = TableViewCoordinator(
+            changeManager: AnyChangeManager(DataChangeManager()),
+            isEditable: false,
+            selectedRowIndices: .constant([]),
+            delegate: nil
+        )
+
+        let result = coordinator.pasteCellsFromClipboard(anchorRow: 0, anchorColumn: 0)
+
+        #expect(result == false)
+    }
+}