I've Since Realized This Is Incorrect

Author: thecoolwinter

Sources/CodeEditSourceEditor/Highlighting/Highlighter.swift

@@ -155,168 +155,6 @@ extension Highlighter: NSTextStorageDelegate {
         changeInLength delta: Int
     ) {
         guard editedMask.contains(.editedCharacters) else { return }
-
-<<<<<<< Updated upstream
-        queryHighlights(for: rangesToQuery)
-    }
-
-    /// Highlights the given ranges
-    /// - Parameter ranges: The ranges to request highlights for.
-    func queryHighlights(for rangesToHighlight: [NSRange]) {
-        guard let textView else { return }
-
-        DispatchQueue.dispatchMainIfNot {
-            for range in rangesToHighlight {
-                self.highlightProvider?.queryHighlightsFor(textView: textView, range: range) { [weak self] highlights in
-                    assert(Thread.isMainThread, "Highlighted ranges called on non-main thread.")
-                    self?.applyHighlightResult(highlights, rangeToHighlight: range)
-                }
-            }
-        }
-    }
-
-    /// Applies a highlight query result to the text view.
-    /// - Parameters:
-    ///   - results: The result of a highlight query.
-    ///   - rangeToHighlight: The range to apply the highlight to.
-    private func applyHighlightResult(_ results: Result<[HighlightRange], Error>, rangeToHighlight: NSRange) {
-        pendingSet.remove(integersIn: rangeToHighlight)
-
-        switch results {
-        case let .failure(error):
-            if case HighlightProvidingError.operationCancelled = error {
-                invalidate(range: rangeToHighlight)
-            } else {
-                Self.logger.error("Failed to query highlight range: \(error)")
-            }
-        case let .success(results):
-            guard let attributeProvider = self.attributeProvider,
-                  visibleSet.intersects(integersIn: rangeToHighlight) else {
-                return
-            }
-            validSet.formUnion(IndexSet(integersIn: rangeToHighlight))
-
-            // Loop through each highlight and modify the textStorage accordingly.
-            textView?.textStorage.beginEditing()
-
-            // Create a set of indexes that were not highlighted.
-            var ignoredIndexes = IndexSet(integersIn: rangeToHighlight)
-
-            // Apply all highlights that need color
-            for highlight in results
-            where textView?.documentRange.upperBound ?? 0 > highlight.range.upperBound {
-                textView?.textStorage.setAttributes(
-                    attributeProvider.attributesFor(highlight.capture),
-                    range: highlight.range
-                )
-
-                // Remove highlighted indexes from the "ignored" indexes.
-                ignoredIndexes.remove(integersIn: highlight.range)
-            }
-
-            // For any indices left over, we need to apply normal attributes to them
-            // This fixes the case where characters are changed to have a non-text color, and then are skipped when
-            // they need to be changed back.
-            for ignoredRange in ignoredIndexes.rangeView
-            where textView?.documentRange.upperBound ?? 0 > ignoredRange.upperBound {
-                textView?.textStorage.setAttributes(attributeProvider.attributesFor(nil), range: NSRange(ignoredRange))
-            }
-
-            textView?.textStorage.endEditing()
-            textView?.layoutManager.invalidateLayoutForRange(rangeToHighlight)
-        }
-    }
-
-    /// Gets the next `NSRange` to highlight based on the invalid set, visible set, and pending set.
-    /// - Returns: An `NSRange` to highlight if it could be fetched.
-    func getNextRange() -> NSRange? {
-        let set: IndexSet = IndexSet(integersIn: textView?.documentRange ?? .zero) // All text
-            .subtracting(validSet) // Subtract valid = Invalid set
-            .intersection(visibleSet) // Only visible indexes
-            .subtracting(pendingSet) // Don't include pending indexes
-
-        guard let range = set.rangeView.first else {
-            return nil
-        }
-
-        // Chunk the ranges in sets of rangeChunkLimit characters.
-        return NSRange(
-            location: range.lowerBound,
-            length: min(rangeChunkLimit, range.upperBound - range.lowerBound)
-        )
-    }
-}
-
-// MARK: - Visible Content Updates
-
-private extension Highlighter {
-    private func updateVisibleSet(textView: TextView) {
-        if let newVisibleRange = textView.visibleTextRange {
-            visibleSet = IndexSet(integersIn: newVisibleRange)
-        }
-    }
-
-    /// Updates the view to highlight newly visible text when the textview is scrolled or bounds change.
-    @objc func visibleTextChanged(_ notification: Notification) {
-        let textView: TextView
-        if let clipView = notification.object as? NSClipView,
-           let documentView = clipView.enclosingScrollView?.documentView as? TextView {
-            textView = documentView
-        } else if let scrollView = notification.object as? NSScrollView,
-                  let documentView = scrollView.documentView as? TextView {
-            textView = documentView
-        } else {
-            return
-        }
-
-        updateVisibleSet(textView: textView)
-
-        // Any indices that are both *not* valid and in the visible text range should be invalidated
-        let newlyInvalidSet = visibleSet.subtracting(validSet)
-
-        for range in newlyInvalidSet.rangeView.map({ NSRange($0) }) {
-            invalidate(range: range)
-        }
-    }
-}
-
-// MARK: - Editing
-
-extension Highlighter {
-    func storageDidEdit(editedRange: NSRange, delta: Int) {
-        guard let textView else { return }
-
-        let range = NSRange(location: editedRange.location, length: editedRange.length - delta)
-        if delta > 0 {
-            visibleSet.insert(range: editedRange)
-        }
-
-        updateVisibleSet(textView: textView)
-
-        highlightProvider?.applyEdit(textView: textView, range: range, delta: delta) { [weak self] result in
-            switch result {
-            case let .success(invalidIndexSet):
-                let indexSet = invalidIndexSet.union(IndexSet(integersIn: editedRange))
-
-                for range in indexSet.rangeView {
-                    self?.invalidate(range: NSRange(range))
-                }
-            case let .failure(error):
-                if case HighlightProvidingError.operationCancelled = error {
-                    self?.invalidate(range: range)
-                    return
-                } else {
-                    Self.logger.error("Failed to apply edit. Query returned with error: \(error)")
-                }
-            }
-        }
-    }
-
-    func storageWillEdit(editedRange: NSRange) {
-        guard let textView else { return }
-        highlightProvider?.willApplyEdit(textView: textView, range: editedRange)
-=======
 //        self.storageWillEdit(editedRange: editedRange)
->>>>>>> Stashed changes
     }
 }

Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/RangeStore+Node.swift

@@ -7,12 +7,12 @@
 
 extension RangeStore {
     final class Node {
-        let order: Int
-        var keys: [KeyValue]
-        var children: [Node]
-        var maxContainingEndpoint: UInt32
+        private let order: Int
+        private var keys: [KeyValue]
+        private var children: [Node]
+        private var maxContainingEndpoint: UInt32
 
-        var isLeaf: Bool { children.isEmpty }
+        private var isLeaf: Bool { children.isEmpty }
 
         init(order: Int) {
             self.order = order
@@ -24,15 +24,15 @@ extension RangeStore {
             self.children.reserveCapacity(order)
         }
 
-        func max() -> KeyValue? {
+        private func max() -> KeyValue? {
             var node = self
             while !node.isLeaf {
                 node = node.children[node.children.count - 1]
             }
             return node.keys.last
         }
 
-        func min() -> KeyValue? {
+        private func min() -> KeyValue? {
             var node = self
             while !node.isLeaf {
                 node = node.children[0]

Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/RangeStore.swift

@@ -16,21 +16,30 @@ fileprivate extension Range<UInt32> {
     var generic: Range<Int> {
         return Int(startIndex)..<Int(endIndex)
     }
-
+    
+    /// Determines if the given range is entirely contained by this range.
+    /// - Parameter other: The range to compare.
+    /// - Returns: If the range's indices are equal to or inside this range's indices, returns true.
     func strictContains(_ other: Range<UInt32>) -> Bool {
         other.startIndex >= startIndex && other.endIndex <= endIndex
     }
-
-    func subtract(_ other: Range<UInt32>) -> Range<UInt32> {
-        assert(!strictContains(other), "Subtract cannot act on a range that is larger than the given range")
-        if startIndex < other.startIndex {
-            return startIndex..<other.startIndex
-        } else {
-            return other.endIndex..<endIndex
-        }
-    }
 }
 
+/// A `RangeStore` is a generic, B-tree-backed data structure that stores key-value pairs where the keys are ranges.
+///
+/// This class allows efficient insertion, deletion, and querying of ranges, offering the flexibility to clear entire ranges
+/// of values or remove single values. The underlying B-tree gives logarithmic time complexity for most operations.
+///
+/// - Note: The internal keys are stored as `Range<UInt32>` to optimize memory usage, and are converted from `Range<Int>`
+///   when interacting with public
+///
+/// ```swift
+/// let store = RangeStore<String>()
+/// store.insert(value: "A", range: 1..<5)
+/// store.delete(overlapping: 3..<4) // Clears part of a range.
+/// let results = store.ranges(overlapping: 1..<6)
+/// ```
+
 package final class RangeStore<Element> {
     /// Using UInt32 as we can halve the memory use of keys in the tree for the small cost of converting them
     /// in public calls.
@@ -44,35 +53,84 @@ package final class RangeStore<Element> {
     private let order: Int
     private var root: Node
 
+    /// Initialize the store.
+    /// - Parameter order: The order of the internal B-tree. Defaults to `4`.
     init(order: Int = 4) {
         self.order = order
         self.root = Node(order: self.order)
     }
 
+    /// Insert a key-value pair into the store.
+    /// - Parameters:
+    ///   - value: The value to insert.
+    ///   - range: The range to insert the value at.
     func insert(value: Element, range: Range<Int>) {
         let key = Key.from(range)
         root.insert(value: value, range: key)
     }
 
+    /// Delete a range from the store.
+    /// The range must match exactly with a range in the store, or it will not be deleted.
+    /// See ``delete(overlapping:)`` for deleting unknown ranges.
+    /// - Parameter range: The range to remove.
+    /// - Returns: Whether or not a value was removed from the store.
     @discardableResult
     func delete(range: Range<Int>) -> Bool {
         let key = Key.from(range)
         return root.delete(range: key)
     }
 
-//    func deleteRanges(overlapping range: Range<Int>) {
-//        let key = Key.from(range)
-//        let keyPairs = ranges(overlapping: range)
-//        for pair in keyPairs {
-//            root.delete(range: pair.key)
-//            if !key.strictContains(pair.key) {
-//                root.insert(value: pair.value, range: key.)
-//            }
-//        }
-//    }
+    /// Clears a range and all associated values.
+    ///
+    /// This is different from `delete`, which deletes a single already-known range from the store. This method removes
+    /// a range entirely, trimming ranges to effectively clear a range of values.
+    ///
+    /// ```
+    /// 1  2  3  4  5  6  # Indices
+    /// |-----|  |-----|  # Stored Ranges
+    ///
+    /// - Call `delete` 3..<5
+    ///
+    /// 1  2  3  4  5  6 # Indices
+    /// |--|        |--| # Stored Ranges
+    /// ```
+    ///
+    /// - Complexity: `O(n)` worst case, `O(m log n)` for small ranges where `m` is the number of results returned.
+    /// - Parameter range: The range to clear.
+    func delete(overlapping range: Range<Int>) {
+        let key = Key.from(range)
+        let keySet = IndexSet(integersIn: key.range)
 
-    func ranges(overlapping range: Range<Int>) -> [KeyValue] {
+        let keyPairs = root.findRanges(overlapping: key)
+        for pair in keyPairs {
+            root.delete(range: pair.key)
+
+            // Re-Insert any ranges that overlapped with the key but weren't encapsulated.
+            if !key.strictContains(pair.key) {
+                let remainingSet = IndexSet(integersIn: pair.key.range).subtracting(keySet)
+                for range in remainingSet.rangeView {
+                    let newKey = Key.from(range)
+                    root.insert(value: pair.value, range: newKey)
+                }
+            }
+        }
+    }
+
+    /// Search for all ranges overlapping the given range.
+    /// ```
+    /// 1  2  3  4  5  6  # Indices
+    /// |-----|  |-----|  # Stored Ranges
+    ///
+    ///  - Call `ranges(overlapping:)` 1..<5
+    ///  - Returns: [1..<4, 4..<7]
+    /// ```
+    /// - Complexity: `O(n)` worst case, `O(m log n)` for small ranges where `m` is the number of results returned.
+    /// - Parameter range: The range to search.
+    /// - Returns: All key-value pairs that overlap the given range.
+    func ranges(overlapping range: Range<Int>) -> [(key: Range<Int>, value: Element)] {
         let key = Key.from(range)
-        return root.findRanges(overlapping: key)
+        return root.findRanges(overlapping: key).map { keyValue in
+            (keyValue.key.generic, keyValue.value)
+        }
     }
 }

Tests/CodeEditSourceEditorTests/Highlighting/RangeStoreBenchmarks.swift

@@ -4,6 +4,7 @@ import XCTest
 class RangeStoreBenchmarkTests: XCTestCase {
     var rng = RandomNumberGeneratorWithSeed(seed: 942)
 
+    // to keep these stable
     struct RandomNumberGeneratorWithSeed: RandomNumberGenerator {
         init(seed: Int) { srand48(seed) }
         func next() -> UInt64 { return UInt64(drand48() * Double(UInt64.max)) } // swiftlint:disable:this legacy_random