fix(editor): restore the cursor and selection when a query tab reopens (#2049)

Author: datlechin

.github/workflows/macos-tests.yml

@@ -66,6 +66,12 @@ jobs:
       - name: Run editor package tests
         run: swift test --package-path LocalPackages/CodeEditTextView
 
+      # Scoped to the controller suite on purpose. The rest of this package's tests
+      # (HighlighterTests, TagEditingTests) already fail on main and one of them aborts
+      # the runner, so gating on the whole package would keep CI permanently red.
+      - name: Run source editor controller tests
+        run: swift test --package-path LocalPackages/CodeEditSourceEditor --filter TextViewControllerTests
+
   app-tests:
     name: macOS App Tests
     runs-on: macos-26

CHANGELOG.md

@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- The SQL editor now returns the cursor to where you left it when a tab is reopened or the app restarts, and restores what you had selected, not just the caret. The saved position was never applied.
 - Autocomplete now keeps suggesting tables and columns after a connection drops and reconnects on its own. The reconnect cleared the schema it had loaded and never asked for it again, so a window that looked connected offered nothing but keywords for the rest of the session.
 - The JSON view of a result now updates when you run another query. It kept showing the previous result until you switched to the data grid and back, and a query that returned the same number of rows never updated at all.
 - The JSON view shows the whole result again when no row is selected. A selection left over from an earlier query made it show an empty list, and a column filter made it show the wrong rows.

LocalPackages/CodeEditSourceEditor/Sources/CodeEditSourceEditor/SourceEditor/SourceEditor.swift

@@ -162,7 +162,7 @@ public struct SourceEditor: NSViewControllerRepresentable {
     }
 
     private func updateControllerWithState(_ state: SourceEditorState, controller: TextViewController) {
-        if let cursorPositions = state.cursorPositions, cursorPositions != state.cursorPositions {
+        if let cursorPositions = state.cursorPositions, cursorPositions != controller.cursorPositions {
             controller.setCursorPositions(cursorPositions)
         }
 

LocalPackages/CodeEditSourceEditor/Tests/CodeEditSourceEditorTests/Controller/TextViewControllerTests.swift

@@ -391,6 +391,26 @@ final class TextViewControllerTests: XCTestCase {
         XCTAssertEqual(controller.cursorPositions[1].start.column, 2)
     }
 
+    func test_setCursorPositionsClampsARangeBeyondTheText() {
+        controller.setText("Hello")
+
+        controller.setCursorPositions([CursorPosition(range: NSRange(location: 2, length: 500))])
+
+        XCTAssertEqual(controller.cursorPositions.count, 1)
+        XCTAssertEqual(controller.cursorPositions[0].range.location, 2)
+        XCTAssertEqual(controller.cursorPositions[0].range.length, 3)
+    }
+
+    func test_setCursorPositionsClampsALocationBeyondTheText() {
+        controller.setText("Hello")
+
+        controller.setCursorPositions([CursorPosition(range: NSRange(location: 900, length: 0))])
+
+        XCTAssertEqual(controller.cursorPositions.count, 1)
+        XCTAssertEqual(controller.cursorPositions[0].range.location, 5)
+        XCTAssertEqual(controller.cursorPositions[0].range.length, 0)
+    }
+
     func test_cursorPositionRowColInit() {
         _ = controller.textView.becomeFirstResponder()
         controller.setText("Hello World")

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager.swift

@@ -89,9 +89,12 @@ public class TextSelectionManager: NSObject {
         let oldRanges = textSelections.map(\.range)
 
         textSelections.forEach { $0.view?.removeFromSuperview() }
-        // Remove duplicates, clamp out-of-bounds ranges, update suggested X position.
+        // Remove duplicates, drop malformed ranges, clamp stale ones, update suggested X position.
+        // A negative location is malformed and is discarded. A location past the end is a stale but
+        // well-formed range, which happens whenever the text shrinks under an existing selection;
+        // clamping keeps a usable selection there instead of leaving the view with none at all.
         let storageLength = textStorage?.length ?? 0
-        textSelections = Set(ranges.map { $0.clamped(toLength: storageLength) })
+        textSelections = Set(ranges.filter { $0.location >= 0 }.map { $0.clamped(toLength: storageLength) })
             .sorted(by: { $0.location < $1.location })
             .map {
                 let selection = TextSelection(range: $0)

TablePro/Extensions/NSRange+ClampToText.swift

@@ -0,0 +1,19 @@
+//
+//  NSRange+ClampToText.swift
+//  TablePro
+//
+
+import Foundation
+
+internal extension NSRange {
+    /// Moves the range inside `0..<length`, keeping as much of it as still fits.
+    ///
+    /// A selection restored from disk was measured against the text as it was when the tab was
+    /// saved. The query can be shorter now, so the saved range has to be clamped against the text
+    /// the editor actually holds before it is applied.
+    func clampedToTextLength(_ length: Int) -> NSRange {
+        let start = Swift.min(Swift.max(location, 0), length)
+        let end = Swift.min(Swift.max(location + self.length, 0), length)
+        return NSRange(location: start, length: Swift.max(0, end - start))
+    }
+}

TablePro/Models/Query/QueryTab.swift

@@ -35,12 +35,20 @@ struct QueryTab: Identifiable, Equatable {
     var pendingRestoredSort: [PersistedSortColumn]?
     var restoredPage: Int?
     var restoredCursorOffset: Int?
+    var restoredCursorLength: Int?
 
     private static func clampedCursorOffset(_ offset: Int?, in query: String) -> Int? {
         guard let offset, offset >= 0 else { return nil }
         return min(offset, (query as NSString).length)
     }
 
+    private static func clampedCursorLength(_ length: Int?, from offset: Int?, in query: String) -> Int? {
+        guard let length, length > 0, let start = clampedCursorOffset(offset, in: query) else { return nil }
+        let available = (query as NSString).length - start
+        guard available > 0 else { return nil }
+        return min(length, available)
+    }
+
     init(
         id: UUID = UUID(),
         title: String = "Query",
@@ -70,6 +78,7 @@ struct QueryTab: Identifiable, Equatable {
         self.pendingRestoredSort = nil
         self.restoredPage = nil
         self.restoredCursorOffset = nil
+        self.restoredCursorLength = nil
     }
 
     init(from persisted: PersistedTab, defaultPageSize: Int) {
@@ -105,6 +114,11 @@ struct QueryTab: Identifiable, Equatable {
         self.pendingRestoredSort = persisted.sortColumns
         self.restoredPage = persisted.restoredPage.map { max(1, $0) }
         self.restoredCursorOffset = Self.clampedCursorOffset(persisted.cursorOffset, in: persisted.query)
+        self.restoredCursorLength = Self.clampedCursorLength(
+            persisted.cursorLength,
+            from: persisted.cursorOffset,
+            in: persisted.query
+        )
     }
 
     @MainActor static func buildBaseTableQuery(
@@ -182,6 +196,11 @@ struct QueryTab: Identifiable, Equatable {
             sortColumns: persistedSort,
             restoredPage: restoredPage,
             cursorOffset: Self.clampedCursorOffset(restoredCursorOffset, in: persistedQuery),
+            cursorLength: Self.clampedCursorLength(
+                restoredCursorLength,
+                from: restoredCursorOffset,
+                in: persistedQuery
+            ),
             columnWidths: widths,
             windowGroupIndex: windowGroupIndex
         )

TablePro/Models/Query/QueryTabState.swift

@@ -37,6 +37,7 @@ struct PersistedTab: Codable {
     var sortColumns: [PersistedSortColumn]?
     var restoredPage: Int?
     var cursorOffset: Int?
+    var cursorLength: Int?
     var columnWidths: [String: CGFloat]?
     var windowGroupIndex: Int?
 
@@ -58,6 +59,7 @@ struct PersistedTab: Codable {
         sortColumns: [PersistedSortColumn]? = nil,
         restoredPage: Int? = nil,
         cursorOffset: Int? = nil,
+        cursorLength: Int? = nil,
         columnWidths: [String: CGFloat]? = nil,
         windowGroupIndex: Int? = nil
     ) {
@@ -75,14 +77,15 @@ struct PersistedTab: Codable {
         self.sortColumns = sortColumns
         self.restoredPage = restoredPage
         self.cursorOffset = cursorOffset
+        self.cursorLength = cursorLength
         self.columnWidths = columnWidths
         self.windowGroupIndex = windowGroupIndex
     }
 
     private enum CodingKeys: String, CodingKey {
         case id, title, query, tabType, tableName, isView, databaseName, schemaName
         case sourceFileURL, erDiagramSchemaKey, queryParameters
-        case sortColumns, restoredPage, cursorOffset, columnWidths, windowGroupIndex
+        case sortColumns, restoredPage, cursorOffset, cursorLength, columnWidths, windowGroupIndex
         case overflowFileName
     }
 
@@ -102,6 +105,7 @@ struct PersistedTab: Codable {
         sortColumns = try container.decodeIfPresent([PersistedSortColumn].self, forKey: .sortColumns)
         restoredPage = try container.decodeIfPresent(Int.self, forKey: .restoredPage)
         cursorOffset = try container.decodeIfPresent(Int.self, forKey: .cursorOffset)
+        cursorLength = try container.decodeIfPresent(Int.self, forKey: .cursorLength)
         columnWidths = try container.decodeIfPresent([String: CGFloat].self, forKey: .columnWidths)
         windowGroupIndex = try container.decodeIfPresent(Int.self, forKey: .windowGroupIndex)
         overflowFileName = try container.decodeIfPresent(String.self, forKey: .overflowFileName)

TablePro/Views/Editor/QueryEditorView.swift

@@ -24,6 +24,7 @@ struct QueryEditorView: View {
     var connectionAIPolicy: AIConnectionPolicy?
     var tabID: UUID?
     var claimFocusOnAppear: Bool = false
+    var restoredCursorRange: NSRange?
     var onCloseTab: (() -> Void)?
     var onExecuteQuery: (() -> Void)?
     var onExplain: ((ClickHouseExplainVariant?) -> Void)?
@@ -67,6 +68,7 @@ struct QueryEditorView: View {
                 connectionAIPolicy: connectionAIPolicy,
                 tabID: tabID,
                 claimFocusOnAppear: claimFocusOnAppear,
+                restoredCursorRange: restoredCursorRange,
                 vimMode: $vimMode,
                 onCloseTab: onCloseTab,
                 onExecuteQuery: onExecuteQuery,

TablePro/Views/Editor/SQLEditorCoordinator.swift

@@ -52,12 +52,27 @@ final class SQLEditorCoordinator: TextViewCoordinator, TextViewDelegate {
     @ObservationIgnored private var hasInstalledEditorServices = false
     @ObservationIgnored private weak var windowSentinel: WindowAccessorView?
 
+    @ObservationIgnored private var cursorRestorePending: NSRange?
+
     var pendingFocusClaim: Bool { focusClaimPending }
 
+    var pendingCursorRestore: NSRange? { cursorRestorePending }
+
     func scheduleEditorFocusClaim() {
         focusClaimPending = true
     }
 
+    /// Latches a saved selection to apply once, the moment the editor is in a window.
+    ///
+    /// The caller sets this from `body`, which runs many times before the text view exists, so the
+    /// setter is idempotent and the value is consumed exactly once in `installEditorServices`.
+    /// Pushing it through the SwiftUI cursor binding instead would fight live typing, because the
+    /// binding is written on every selection change the user makes.
+    func scheduleCursorRestore(_ range: NSRange) {
+        guard !hasInstalledEditorServices else { return }
+        cursorRestorePending = range
+    }
+
     /// Vim mode for UI observation
     private(set) var vimMode: VimMode = .normal
     @ObservationIgnored private var vimEngine: VimEngine?
@@ -147,7 +162,11 @@ final class SQLEditorCoordinator: TextViewCoordinator, TextViewDelegate {
             Self.logger.debug("Editor focus claim: pending=\(claimPending) isKey=\(window.isKeyWindow) made=\(made)")
         }
 
-        if controller.cursorPositions.isEmpty {
+        if let restored = cursorRestorePending {
+            cursorRestorePending = nil
+            let clamped = restored.clampedToTextLength(textView.textStorage.length)
+            controller.setCursorPositions([CursorPosition(range: clamped)], scrollToVisible: true)
+        } else if controller.cursorPositions.isEmpty {
             controller.setCursorPositions([CursorPosition(range: NSRange(location: 0, length: 0))])
         }
     }