Begin StyledRangeContainer

Author: thecoolwinter

Sources/CodeEditSourceEditor/Highlighting/HighlighProviding/HighlightProviderState.swift

@@ -24,7 +24,7 @@ class HighlightProviderState {
     // MARK: - State
 
     /// A unique identifier for this provider. Used by the delegate to determine the source of results.
-    private let id: UUID = UUID()
+    let id: UUID
 
     /// Any indexes that highlights have been requested for, but haven't been applied.
     /// Indexes/ranges are added to this when highlights are requested and removed
@@ -58,18 +58,21 @@ class HighlightProviderState {
     /// Creates a new highlight provider state object.
     /// Sends the `setUp` message to the highlight provider object.
     /// - Parameters:
+    ///   - id: The ID of the provider
     ///   - delegate: The delegate for this provider. Is passed information about ranges to highlight.
     ///   - highlightProvider: The object to query for highlight information.
     ///   - textView: The text view to highlight, used by the highlight provider.
     ///   - visibleRangeProvider: A visible range provider for determining which ranges to query.
     ///   - language: The language to set up the provider with.
     init(
+        id: UUID = UUID(),
         delegate: HighlightProviderStateDelegate,
         highlightProvider: HighlightProviding,
         textView: TextView,
         visibleRangeProvider: VisibleRangeProvider,
         language: CodeLanguage
     ) {
+        self.id = id
         self.delegate = delegate
         self.highlightProvider = highlightProvider
         self.textView = textView

Sources/CodeEditSourceEditor/Highlighting/Highlighter.swift

@@ -87,14 +87,17 @@ class Highlighter: NSObject {
         self.textView = textView
         self.attributeProvider = attributeProvider
         self.visibleRangeProvider = VisibleRangeProvider(textView: textView)
-        self.rangeContainer = StyledRangeContainer()
+
+        let providerIds = providers.indices.map({ _ in UUID() })
+        self.rangeContainer = StyledRangeContainer(documentLength: textView.length, providers: providerIds)
 
         super.init()
 
-        self.providers = providers.map {
+        self.providers = providers.enumerated().map { (idx, provider) in
             HighlightProviderState(
+                id: providerIds[idx],
                 delegate: rangeContainer,
-                highlightProvider: $0,
+                highlightProvider: provider,
                 textView: textView,
                 visibleRangeProvider: visibleRangeProvider,
                 language: language

Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeContainer.swift

@@ -8,15 +8,49 @@
 import Foundation
 
 class StyledRangeContainer {
-    private var storage: [UUID: StyledRangeStore] = [:]
+    typealias Run = StyledRangeStore.Run
+    var _storage: [UUID: StyledRangeStore] = [:]
+
+    init(documentLength: Int, providers: [UUID]) {
+        for provider in providers {
+            _storage[provider] = StyledRangeStore(documentLength: documentLength)
+        }
+    }
+
+    func runsIn(range: NSRange) -> [Run] {
+        
+    }
+
+    func storageUpdated(replacedContentIn range: Range<Int>, withCount newLength: Int) {
+        _storage.values.forEach {
+            $0.storageUpdated(replacedCharactersIn: range, withCount: newLength)
+        }
+    }
 }
 
 extension StyledRangeContainer: HighlightProviderStateDelegate {
     func applyHighlightResult(provider: UUID, highlights: [HighlightRange], rangeToHighlight: NSRange) {
-        guard let storage = storage[provider] else {
+        assert(rangeToHighlight != .notFound, "NSNotFound is an invalid highlight range")
+        guard let storage = _storage[provider] else {
             assertionFailure("No storage found for the given provider: \(provider)")
             return
         }
-        
+        var runs: [Run] = []
+        var lastIndex = rangeToHighlight.lowerBound
+
+        for highlight in highlights {
+            if highlight.range.lowerBound != lastIndex {
+                runs.append(.empty(length: highlight.range.lowerBound - lastIndex))
+            }
+            // TODO: Modifiers
+            runs.append(Run(length: highlight.range.length, capture: highlight.capture, modifiers: []))
+            lastIndex = highlight.range.max
+        }
+
+        if lastIndex != rangeToHighlight.upperBound {
+            runs.append(.empty(length: rangeToHighlight.upperBound - lastIndex))
+        }
+
+        storage.set(runs: runs, for: rangeToHighlight.intRange)
     }
 }

Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore.swift

@@ -25,10 +25,14 @@ final class StyledRangeStore {
     }
 
     /// Consumer-facing value type for the stored values in this container.
-    struct Run {
+    struct Run: Equatable, Hashable, Sendable {
         let length: Int
         let capture: CaptureName?
         let modifiers: Set<CaptureModifiers>
+
+        static func empty(length: Int) -> Self {
+            Run(length: length, capture: nil, modifiers: [])
+        }
     }
 
     // MARK: - Core

Tests/CodeEditSourceEditorTests/Highlighting/StyledRangeContainerTests.swift

@@ -0,0 +1,41 @@
+import XCTest
+@testable import CodeEditSourceEditor
+
+final class StyledRangeContainerTests: XCTestCase {
+    typealias Run = StyledRangeContainer.Run
+
+    func test_init() {
+        let providers = [UUID(), UUID()]
+        let store = StyledRangeContainer(documentLength: 100, providers: providers)
+
+        // Have to do string conversion due to missing Comparable conformance pre-macOS 14
+        XCTAssertEqual(store._storage.keys.map(\.uuidString).sorted(), providers.map(\.uuidString).sorted())
+        XCTAssert(store._storage.values.allSatisfy({ $0.length == 100 }), "One or more providers have incorrect length")
+    }
+
+    func test_setHighlights() {
+        let providers = [UUID(), UUID()]
+        let store = StyledRangeContainer(documentLength: 100, providers: providers)
+
+        store.applyHighlightResult(
+            provider: providers[0],
+            highlights: [HighlightRange(range: NSRange(location: 40, length: 10), capture: .comment)],
+            rangeToHighlight: NSRange(location: 0, length: 100)
+        )
+
+        XCTAssertNotNil(store._storage[providers[0]])
+        XCTAssertEqual(store._storage[providers[0]]!.count, 3)
+        XCTAssertEqual(store._storage[providers[0]]!.runs(in: 0..<100)[0].capture, nil)
+        XCTAssertEqual(store._storage[providers[0]]!.runs(in: 0..<100)[1].capture, .comment)
+        XCTAssertEqual(store._storage[providers[0]]!.runs(in: 0..<100)[2].capture, nil)
+
+        XCTAssertEqual(
+            store.runsIn(range: NSRange(location: 0, length: 100)),
+            [
+                Run(length: 40, capture: nil, modifiers: []),
+                Run(length: 10, capture: .comment, modifiers: []),
+                Run(length: 50, capture: nil, modifiers: [])
+            ]
+        )
+    }
+}