Merge branch 'main' into use-better-storage-example

Author: thecoolwinter

Sources/CodeEditSourceEditor/Controller/TextViewController+IndentLines.swift

@@ -67,7 +67,7 @@ extension TextViewController {
         var selectionIndex = 0
         textView.editSelections { textView, selection in
             // get lineindex, i.e line-numbers+1
-            guard let lineIndexes = getHighlightedLines(for: selection.range) else { return }
+            guard let lineIndexes = getOverlappingLines(for: selection.range) else { return }
 
             adjustIndentation(lineIndexes: lineIndexes, inwards: inwards)
 
@@ -129,7 +129,24 @@ extension TextViewController {
         return false
     }
 
-    private func getHighlightedLines(for range: NSRange) -> ClosedRange<Int>? {
+    /// Find the range of lines overlapping a text range.
+    ///
+    /// Use this method to determine what lines to apply a text transformation on using a text selection. For instance,
+    /// when indenting a selected line.
+    ///
+    /// Does not determine the *visible* lines, which is a very slight change from most
+    /// ``CodeEditTextView/TextLayoutManager`` APIs.
+    /// Given the text:
+    /// ```
+    /// A
+    /// B
+    /// ```
+    /// This method will return lines `0...0` for the text range `0..<2`. The layout manager might return lines
+    /// `0...1`, as the text range contains the newline, which appears *visually* in line index `1`.
+    ///
+    /// - Parameter range: The text range in the document to find contained lines for.
+    /// - Returns: A closed range of line indexes (0-indexed) where each line is overlapping the given text range.
+    func getOverlappingLines(for range: NSRange) -> ClosedRange<Int>? {
         guard let startLineInfo = textView.layoutManager.textLineForOffset(range.lowerBound) else {
             return nil
         }
@@ -139,7 +156,16 @@ extension TextViewController {
             return startLineInfo.index...startLineInfo.index
         }
 
-        return startLineInfo.index...endLineInfo.index
+        // If we've selected up to the start of a line (just over the newline character), the layout manager tells us
+        // we've selected the next line. However, we aren't overlapping the *text line* with that range, so we
+        // decrement it if it's not the end of the document
+        var endLineIndex = endLineInfo.index
+        if endLineInfo.range.lowerBound == range.upperBound
+            && endLineInfo.index != textView.layoutManager.lineCount - 1 {
+            endLineIndex -= 1
+        }
+
+        return startLineInfo.index...endLineIndex
     }
 
     private func adjustIndentation(lineIndexes: ClosedRange<Int>, inwards: Bool) {

Sources/CodeEditSourceEditor/Controller/TextViewController+LoadView.swift

@@ -201,6 +201,7 @@ extension TextViewController {
 
     func handleCommand(event: NSEvent, modifierFlags: UInt) -> NSEvent? {
         let commandKey = NSEvent.ModifierFlags.command.rawValue
+        let commandOptionKey = NSEvent.ModifierFlags.command.union(.option).rawValue
 
         switch (modifierFlags, event.charactersIgnoringModifiers) {
         case (commandKey, "/"):
@@ -209,9 +210,15 @@ extension TextViewController {
         case (commandKey, "["):
             handleIndent(inwards: true)
             return nil
+        case (commandOptionKey, "["):
+            moveLinesUp()
+            return nil
         case (commandKey, "]"):
             handleIndent()
             return nil
+        case (commandOptionKey, "]"):
+            moveLinesDown()
+            return nil
         case (commandKey, "f"):
             _ = self.textView.resignFirstResponder()
             self.findViewController?.showFindPanel()

Sources/CodeEditSourceEditor/Controller/TextViewController+MoveLines.swift

@@ -0,0 +1,71 @@
+//
+//  TextViewController+MoveLines.swift
+//  CodeEditSourceEditor
+//
+//  Created by Bogdan Belogurov on 01/06/2025.
+//
+
+import Foundation
+
+extension TextViewController {
+    /// Moves the selected lines up by one line.
+    public func moveLinesUp() {
+        guard !cursorPositions.isEmpty else { return }
+
+        textView.undoManager?.beginUndoGrouping()
+
+        textView.editSelections { textView, selection in
+            guard let lineIndexes = getOverlappingLines(for: selection.range) else { return }
+            let lowerBound = lineIndexes.lowerBound
+            guard lowerBound > .zero,
+                  let prevLineInfo = textView.layoutManager.textLineForIndex(lowerBound - 1),
+                  let prevString = textView.textStorage.substring(from: prevLineInfo.range),
+                  let lastSelectedString = textView.layoutManager.textLineForIndex(lineIndexes.upperBound) else {
+                return
+            }
+
+            textView.insertString(prevString, at: lastSelectedString.range.upperBound)
+            textView.replaceCharacters(in: [prevLineInfo.range], with: String())
+
+            let rangeToSelect = NSRange(
+                start: prevLineInfo.range.lowerBound,
+                end: lastSelectedString.range.location - prevLineInfo.range.length + lastSelectedString.range.length
+            )
+
+            setCursorPositions([CursorPosition(range: rangeToSelect)], scrollToVisible: true)
+        }
+
+        textView.undoManager?.endUndoGrouping()
+    }
+
+    /// Moves the selected lines down by one line.
+    public func moveLinesDown() {
+        guard !cursorPositions.isEmpty else { return }
+
+        textView.undoManager?.beginUndoGrouping()
+
+        textView.editSelections { textView, selection in
+            guard let lineIndexes = getOverlappingLines(for: selection.range) else { return }
+            let totalLines = textView.layoutManager.lineCount
+            let upperBound = lineIndexes.upperBound
+            guard upperBound + 1 < totalLines,
+                  let nextLineInfo = textView.layoutManager.textLineForIndex(upperBound + 1),
+                  let nextString = textView.textStorage.substring(from: nextLineInfo.range),
+                  let firstSelectedString = textView.layoutManager.textLineForIndex(lineIndexes.lowerBound) else {
+                return
+            }
+
+            textView.replaceCharacters(in: [nextLineInfo.range], with: String())
+            textView.insertString(nextString, at: firstSelectedString.range.lowerBound)
+
+            let rangeToSelect = NSRange(
+                start: firstSelectedString.range.location + nextLineInfo.range.length,
+                end: nextLineInfo.range.upperBound
+            )
+
+            setCursorPositions([CursorPosition(range: rangeToSelect)], scrollToVisible: true)
+        }
+
+        textView.undoManager?.endUndoGrouping()
+    }
+}

Tests/CodeEditSourceEditorTests/Controller/TextViewController+MoveLinesTests.swift

@@ -0,0 +1,107 @@
+//
+//  TextViewController+MoveLinesTests.swift
+//  CodeEditSourceEditor
+//
+//  Created by Bogdan Belogurov on 01/06/2025.
+//
+
+import XCTest
+@testable import CodeEditSourceEditor
+@testable import CodeEditTextView
+import CustomDump
+
+final class TextViewControllerMoveLinesTests: XCTestCase {
+    var controller: TextViewController!
+
+    override func setUpWithError() throws {
+        controller = Mock.textViewController(theme: Mock.theme())
+
+        controller.loadView()
+    }
+
+    func testHandleMoveLinesUpForSingleLine() {
+        let strings: [(NSString, Int)] = [
+            ("This is a test string\n", 0),
+            ("With multiple lines\n", 22)
+        ]
+        for (insertedString, location) in strings {
+            controller.textView.replaceCharacters(
+                in: [NSRange(location: location, length: 0)],
+                with: insertedString as String
+            )
+        }
+
+        let cursorRange = NSRange(location: 40, length: 0)
+        controller.textView.selectionManager.textSelections = [.init(range: cursorRange)]
+        controller.cursorPositions = [CursorPosition(range: cursorRange)]
+
+        controller.moveLinesUp()
+        let expectedString = "With multiple lines\nThis is a test string\n"
+        expectNoDifference(controller.string, expectedString)
+    }
+
+    func testHandleMoveLinesDownForSingleLine() {
+        let strings: [(NSString, Int)] = [
+            ("This is a test string\n", 0),
+            ("With multiple lines\n", 22)
+        ]
+        for (insertedString, location) in strings {
+            controller.textView.replaceCharacters(
+                in: [NSRange(location: location, length: 0)],
+                with: insertedString as String
+            )
+        }
+
+        let cursorRange = NSRange(location: 0, length: 0)
+        controller.textView.selectionManager.textSelections = [.init(range: cursorRange)]
+        controller.cursorPositions = [CursorPosition(range: cursorRange)]
+
+        controller.moveLinesDown()
+        let expectedString = "With multiple lines\nThis is a test string\n"
+        expectNoDifference(controller.string, expectedString)
+    }
+
+    func testHandleMoveLinesUpForMultiLine() {
+        let strings: [(NSString, Int)] = [
+            ("This is a test string\n", 0),
+            ("With multiple lines\n", 22),
+            ("And additional info\n", 42)
+        ]
+        for (insertedString, location) in strings {
+            controller.textView.replaceCharacters(
+                in: [NSRange(location: location, length: 0)],
+                with: insertedString as String
+            )
+        }
+
+        let cursorRange = NSRange(location: 40, length: 15)
+        controller.textView.selectionManager.textSelections = [.init(range: cursorRange)]
+        controller.cursorPositions = [CursorPosition(range: cursorRange)]
+
+        controller.moveLinesUp()
+        let expectedString = "With multiple lines\nAnd additional info\nThis is a test string\n"
+        expectNoDifference(controller.string, expectedString)
+    }
+
+    func testHandleMoveLinesDownForMultiLine() {
+        let strings: [(NSString, Int)] = [
+            ("This is a test string\n", 0),
+            ("With multiple lines\n", 22),
+            ("And additional info\n", 42)
+        ]
+        for (insertedString, location) in strings {
+            controller.textView.replaceCharacters(
+                in: [NSRange(location: location, length: 0)],
+                with: insertedString as String
+            )
+        }
+
+        let cursorRange = NSRange(location: 0, length: 30)
+        controller.textView.selectionManager.textSelections = [.init(range: cursorRange)]
+        controller.cursorPositions = [CursorPosition(range: cursorRange)]
+
+        controller.moveLinesDown()
+        let expectedString = "And additional info\nThis is a test string\nWith multiple lines\n"
+        expectNoDifference(controller.string, expectedString)
+    }
+}

Tests/CodeEditSourceEditorTests/Controller/TextViewControllerTests.swift

@@ -461,5 +461,31 @@ final class TextViewControllerTests: XCTestCase {
         XCTAssertEqual(controller.minimapView.frame.width, MinimapView.maxWidth)
         XCTAssertEqual(controller.textViewInsets.right, MinimapView.maxWidth)
     }
+
+    // MARK: - Get Overlapping Lines
+
+    func test_getOverlappingLines() {
+        controller.setText("A\nB\nC")
+
+        // Select the entire first line, shouldn't include the second line
+        var lines = controller.getOverlappingLines(for: NSRange(location: 0, length: 2))
+        XCTAssertEqual(0...0, lines)
+
+        // Select the first char of the second line
+        lines = controller.getOverlappingLines(for: NSRange(location: 0, length: 3))
+        XCTAssertEqual(0...1, lines)
+
+        // Select the newline in the first line, and part of the second line
+        lines = controller.getOverlappingLines(for: NSRange(location: 1, length: 2))
+        XCTAssertEqual(0...1, lines)
+
+        // Select until the end of the document
+        lines = controller.getOverlappingLines(for: NSRange(location: 3, length: 2))
+        XCTAssertEqual(1...2, lines)
+
+        // Select just the last line of the document
+        lines = controller.getOverlappingLines(for: NSRange(location: 4, length: 1))
+        XCTAssertEqual(2...2, lines)
+    }
 }
 // swiftlint:enable all