Merge branch 'main' into feat/code-folding

Author: thecoolwinter

.github/workflows/CI-pull-request.yml

@@ -1,7 +1,7 @@
 name: CI - Pull Request
 on: 
   pull_request:
-    branches:
+    branches: 
       - 'main'
   workflow_dispatch:
 jobs:

Example/CodeEditSourceEditorExample/CodeEditSourceEditorExample/Documents/CodeEditSourceEditorExampleDocument.swift

@@ -8,10 +8,14 @@
 import SwiftUI
 import UniformTypeIdentifiers
 
-struct CodeEditSourceEditorExampleDocument: FileDocument {
-    var text: String
+struct CodeEditSourceEditorExampleDocument: FileDocument, @unchecked Sendable {
+    enum DocumentError: Error {
+        case failedToEncode
+    }
+
+    var text: NSTextStorage
 
-    init(text: String = "") {
+    init(text: NSTextStorage = NSTextStorage(string: "")) {
         self.text = text
     }
 
@@ -25,11 +29,31 @@ struct CodeEditSourceEditorExampleDocument: FileDocument {
         guard let data = configuration.file.regularFileContents else {
             throw CocoaError(.fileReadCorruptFile)
         }
-        text = String(decoding: data, as: UTF8.self)
+        var nsString: NSString?
+        NSString.stringEncoding(
+            for: data,
+            encodingOptions: [
+                // Fail if using lossy encoding.
+                .allowLossyKey: false,
+                // In a real app, you'll want to handle more than just this encoding scheme. Check out CodeEdit's
+                // implementation for a more involved solution.
+                .suggestedEncodingsKey: [NSUTF8StringEncoding],
+                .useOnlySuggestedEncodingsKey: true
+            ],
+            convertedString: &nsString,
+            usedLossyConversion: nil
+        )
+        if let nsString {
+            self.text = NSTextStorage(string: nsString as String)
+        } else {
+            fatalError("Failed to read file")
+        }
     }
 
     func fileWrapper(configuration: WriteConfiguration) throws -> FileWrapper {
-        let data = Data(text.utf8)
+        guard let data = (text.string as NSString?)?.data(using: NSUTF8StringEncoding) else {
+            throw DocumentError.failedToEncode
+        }
         return .init(regularFileWithContents: data)
     }
 }

Example/CodeEditSourceEditorExample/CodeEditSourceEditorExample/Views/ContentView.swift

@@ -40,7 +40,7 @@ struct ContentView: View {
     var body: some View {
         GeometryReader { proxy in
             CodeEditSourceEditor(
-                $document.text,
+                document.text,
                 language: language,
                 theme: theme,
                 font: font,

Example/CodeEditSourceEditorExample/CodeEditSourceEditorExample/Views/StatusBar.swift

@@ -31,7 +31,7 @@ struct StatusBar: View {
     var body: some View {
         HStack {
             Menu {
-                IndentPicker(indentOption: $indentOption, enabled: document.text.isEmpty)
+                IndentPicker(indentOption: $indentOption, enabled: document.text.length == 0)
                     .buttonStyle(.borderless)
                 Toggle("Wrap Lines", isOn: $wrapLines)
                 Toggle("Show Minimap", isOn: $showMinimap)
@@ -108,8 +108,8 @@ struct StatusBar: View {
         guard let fileURL else { return nil  }
         return CodeLanguage.detectLanguageFrom(
             url: fileURL,
-            prefixBuffer: document.text.getFirstLines(5),
-            suffixBuffer: document.text.getLastLines(5)
+            prefixBuffer: document.text.string.getFirstLines(5),
+            suffixBuffer: document.text.string.getLastLines(5)
         )
     }
 

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+Lifecycle.swift

@@ -208,6 +208,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, "/"):
@@ -216,9 +217,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()
+    }
+}

Sources/CodeEditSourceEditor/Find/FindMethod.swift

@@ -0,0 +1,29 @@
+//
+//  FindMethod.swift
+//  CodeEditSourceEditor
+//
+//  Created by Austin Condiff on 5/2/25.
+//
+
+enum FindMethod: CaseIterable {
+    case contains
+    case matchesWord
+    case startsWith
+    case endsWith
+    case regularExpression
+
+    var displayName: String {
+        switch self {
+        case .contains:
+            return "Contains"
+        case .matchesWord:
+            return "Matches Word"
+        case .startsWith:
+            return "Starts With"
+        case .endsWith:
+            return "Ends With"
+        case .regularExpression:
+            return "Regular Expression"
+        }
+    }
+}