Abstract Highlighter Object (#139)

Author: thecoolwinter

Sources/CodeEditTextView/CodeEditTextView.swift

@@ -23,6 +23,8 @@ public struct CodeEditTextView: NSViewControllerRepresentable {
     ///   - lineHeight: The line height multiplier (e.g. `1.2`)
     ///   - wrapLines: Whether lines wrap to the width of the editor
     ///   - editorOverscroll: The percentage for overscroll, between 0-1 (default: `0.0`)
+    ///   - highlightProvider: A class you provide to perform syntax highlighting. Leave this as `nil` to use the
+    ///                        built-in `TreeSitterClient` highlighter.
     public init(
         _ text: Binding<String>,
         language: CodeLanguage,
@@ -33,7 +35,8 @@ public struct CodeEditTextView: NSViewControllerRepresentable {
         wrapLines: Binding<Bool>,
         editorOverscroll: Binding<Double> = .constant(0.0),
         cursorPosition: Published<(Int, Int)>.Publisher? = nil,
-        useThemeBackground: Bool = true
+        useThemeBackground: Bool = true,
+        highlightProvider: HighlightProviding? = nil
     ) {
         self._text = text
         self.language = language
@@ -45,6 +48,7 @@ public struct CodeEditTextView: NSViewControllerRepresentable {
         self._wrapLines = wrapLines
         self._editorOverscroll = editorOverscroll
         self.cursorPosition = cursorPosition
+        self.highlightProvider = highlightProvider
     }
 
     @Binding private var text: String
@@ -57,6 +61,7 @@ public struct CodeEditTextView: NSViewControllerRepresentable {
     @Binding private var editorOverscroll: Double
     private var cursorPosition: Published<(Int, Int)>.Publisher?
     private var useThemeBackground: Bool
+    private var highlightProvider: HighlightProviding?
 
     public typealias NSViewControllerType = STTextViewController
 
@@ -70,7 +75,8 @@ public struct CodeEditTextView: NSViewControllerRepresentable {
             wrapLines: wrapLines,
             cursorPosition: cursorPosition,
             editorOverscroll: editorOverscroll,
-            useThemeBackground: useThemeBackground
+            useThemeBackground: useThemeBackground,
+            highlightProvider: highlightProvider
         )
         controller.lineHeightMultiple = lineHeight
         return controller

Sources/CodeEditTextView/Extensions/STTextView+/STTextView+VisibleRange.swift

@@ -31,6 +31,9 @@ extension STTextView {
               let end = textLayoutManager.textLayoutFragment(for: maxPoint)?.rangeInElement.endLocation else {
             return textLayoutManager.documentRange.nsRange(using: textContentStorage)
         }
+        guard start.compare(end) != .orderedDescending else {
+            return NSTextRange(location: end, end: start)?.nsRange(using: textContentStorage)
+        }
 
         // Calculate a range and return it as an `NSRange`
         return NSTextRange(location: start, end: end)?.nsRange(using: textContentStorage)

Sources/CodeEditTextView/Extensions/String+encoding.swift

@@ -0,0 +1,17 @@
+//
+//  String+encoding.swift
+//  
+//
+//  Created by Khan Winter on 1/19/23.
+//
+
+import Foundation
+
+extension String {
+    static var nativeUTF16Encoding: String.Encoding {
+        let dataA = "abc".data(using: .utf16LittleEndian)
+        let dataB = "abc".data(using: .utf16)?.suffix(from: 2)
+
+        return dataA == dataB ? .utf16LittleEndian : .utf16BigEndian
+    }
+}

Sources/CodeEditTextView/Highlighting/HighlightProviding.swift

@@ -0,0 +1,47 @@
+//
+//  HighlightProviding.swift
+//  
+//
+//  Created by Khan Winter on 1/18/23.
+//
+
+import Foundation
+import CodeEditLanguages
+import STTextView
+import AppKit
+
+/// The protocol a class must conform to to be used for highlighting.
+public protocol HighlightProviding {
+    /// A unique identifier for the highlighter object.
+    /// Example: `"CodeEdit.TreeSitterHighlighter"`
+    /// - Note: This does not need to be *globally* unique, merely unique across all the highlighters used.
+    var identifier: String { get }
+
+    /// Updates the highlighter's code language.
+    /// - Parameters:
+    ///   - codeLanguage: The langugage that should be used by the highlighter.
+    func setLanguage(codeLanguage: CodeLanguage)
+
+    /// Notifies the highlighter of an edit and in exchange gets a set of indices that need to be re-highlighted.
+    /// The returned `IndexSet` should include all indexes that need to be highlighted, including any inserted text.
+    /// - Parameters:
+    ///   - textView:The text view to use.
+    ///   - range: The range of the edit.
+    ///   - delta: The length of the edit, can be negative for deletions.
+    ///   - completion: The function to call with an `IndexSet` containing all Indices to invalidate.
+    func applyEdit(textView: HighlighterTextView,
+                   range: NSRange,
+                   delta: Int,
+                   completion: @escaping ((IndexSet) -> Void))
+
+    /// Queries the highlight provider for any ranges to apply highlights to. The highlight provider should return an
+    /// array containing all ranges to highlight, and the capture type for the range. Any ranges or indexes
+    /// excluded from the returned array will be treated as plain text and highlighted as such.
+    /// - Parameters:
+    ///   - textView: The text view to use.
+    ///   - range: The range to operate on.
+    ///   - completion: Function to call with all ranges to highlight
+    func queryHighlightsFor(textView: HighlighterTextView,
+                            range: NSRange,
+                            completion: @escaping (([HighlightRange]) -> Void))
+}

Sources/CodeEditTextView/Highlighting/HighlightRange.swift

@@ -8,7 +8,7 @@
 import Foundation
 
 /// This class represents a range to highlight, as well as the capture name for syntax coloring.
-class HighlightRange {
+public class HighlightRange {
     init(range: NSRange, capture: CaptureName?) {
         self.range = range
         self.capture = capture

Sources/CodeEditTextView/Highlighting/Highlighter.swift

@@ -11,11 +11,6 @@ import STTextView
 import SwiftTreeSitter
 import CodeEditLanguages
 
-/// Classes conforming to this protocol can provide attributes for text given a capture type.
-public protocol ThemeAttributesProviding {
-    func attributesFor(_ capture: CaptureName?) -> [NSAttributedString.Key: Any]
-}
-
 /// The `Highlighter` class handles efficiently highlighting the `STTextView` it's provided with.
 /// It will listen for text and visibility changes, and highlight syntax as needed.
 ///
@@ -49,13 +44,21 @@ class Highlighter: NSObject {
 
     /// The text view to highlight
     private var textView: STTextView
+
+    /// The editor theme
     private var theme: EditorTheme
+
+    /// The object providing attributes for captures.
     private var attributeProvider: ThemeAttributesProviding!
 
-    // MARK: - TreeSitter Client
+    /// The current language of the editor.
+    private var language: CodeLanguage
 
     /// Calculates invalidated ranges given an edit.
-    private var treeSitterClient: TreeSitterClient?
+    private var highlightProvider: HighlightProviding?
+
+    /// The length to chunk ranges into when passing to the highlighter.
+    fileprivate let rangeChunkLimit = 256
 
     // MARK: - Init
 
@@ -65,17 +68,19 @@ class Highlighter: NSObject {
     ///   - treeSitterClient: The tree-sitter client to handle tree updates and highlight queries.
     ///   - theme: The theme to use for highlights.
     init(textView: STTextView,
-         treeSitterClient: TreeSitterClient?,
+         highlightProvider: HighlightProviding?,
          theme: EditorTheme,
-         attributeProvider: ThemeAttributesProviding) {
+         attributeProvider: ThemeAttributesProviding,
+         language: CodeLanguage) {
         self.textView = textView
-        self.treeSitterClient = treeSitterClient
+        self.highlightProvider = highlightProvider
         self.theme = theme
         self.attributeProvider = attributeProvider
+        self.language = language
 
         super.init()
 
-        treeSitterClient?.setText(text: textView.string)
+        highlightProvider?.setLanguage(codeLanguage: language)
 
         guard textView.textContentStorage.textStorage != nil else {
             assertionFailure("Text view does not have a textStorage")
@@ -100,17 +105,22 @@ class Highlighter: NSObject {
     // MARK: - Public
 
     /// Invalidates all text in the textview. Useful for updating themes.
-    func invalidate() {
-        if !(treeSitterClient?.hasSetText ?? true) {
-            treeSitterClient?.setText(text: textView.string)
-        }
+    public func invalidate() {
         invalidate(range: NSRange(entireTextRange))
     }
 
     /// Sets the language and causes a re-highlight of the entire text.
     /// - Parameter language: The language to update to.
-    func setLanguage(language: CodeLanguage) throws {
-        try treeSitterClient?.setLanguage(codeLanguage: language, text: textView.string)
+    public func setLanguage(language: CodeLanguage) {
+        highlightProvider?.setLanguage(codeLanguage: language)
+        invalidate()
+    }
+
+    /// Sets the highlight provider. Will cause a re-highlight of the entire text.
+    /// - Parameter provider: The provider to use for future syntax highlights.
+    public func setHighlightProvider(_ provider: HighlightProviding) {
+        self.highlightProvider = provider
+        highlightProvider?.setLanguage(codeLanguage: language)
         invalidate()
     }
 
@@ -155,7 +165,8 @@ private extension Highlighter {
     func highlight(range rangeToHighlight: NSRange) {
         pendingSet.insert(integersIn: rangeToHighlight)
 
-        treeSitterClient?.queryColorsFor(range: rangeToHighlight) { [weak self] highlightRanges in
+        highlightProvider?.queryHighlightsFor(textView: self.textView,
+                                              range: rangeToHighlight) { [weak self] highlightRanges in
             guard let attributeProvider = self?.attributeProvider,
                   let textView = self?.textView else { return }
 
@@ -222,11 +233,13 @@ private extension Highlighter {
             .intersection(visibleSet) // Only visible indexes
             .subtracting(pendingSet) // Don't include pending indexes
 
-        guard let range = set.rangeView.map({ NSRange($0) }).first else {
+        guard let range = set.rangeView.first else {
             return nil
         }
 
-        return range
+        // Chunk the ranges in sets of rangeChunkLimit characters.
+        return NSRange(location: range.lowerBound,
+                       length: min(rangeChunkLimit, range.upperBound - range.lowerBound))
     }
 
 }
@@ -256,7 +269,6 @@ extension Highlighter: NSTextStorageDelegate {
                      didProcessEditing editedMask: NSTextStorageEditActions,
                      range editedRange: NSRange,
                      changeInLength delta: Int) {
-
         // This method is called whenever attributes are updated, so to avoid re-highlighting the entire document
         // each time an attribute is applied, we check to make sure this is in response to an edit.
         guard editedMask.contains(.editedCharacters) else {
@@ -265,12 +277,9 @@ extension Highlighter: NSTextStorageDelegate {
 
         let range = NSRange(location: editedRange.location, length: editedRange.length - delta)
 
-        guard let edit = InputEdit(range: range, delta: delta, oldEndPoint: .zero) else {
-            return
-        }
-
-        treeSitterClient?.applyEdit(edit,
-                                   text: textStorage.string) { [weak self] invalidatedIndexSet in
+        highlightProvider?.applyEdit(textView: self.textView,
+                                     range: range,
+                                     delta: delta) { [weak self] invalidatedIndexSet in
             let indexSet = invalidatedIndexSet
                 .union(IndexSet(integersIn: editedRange))
                 // Only invalidate indices that aren't visible.

Sources/CodeEditTextView/Highlighting/HighlighterTextView.swift

@@ -0,0 +1,30 @@
+//
+//  HighlighterTextView.swift
+//  
+//
+//  Created by Khan Winter on 1/26/23.
+//
+
+import Foundation
+import AppKit
+import STTextView
+
+/// The object `HighlightProviding` objects are given when asked for highlights.
+public protocol HighlighterTextView {
+    /// The entire range of the document.
+    var documentRange: NSRange { get }
+    /// A substring for the requested range.
+    func stringForRange(_ nsRange: NSRange) -> String?
+}
+
+/// A default implementation for `STTextView` to be passed to `HighlightProviding` objects.
+extension STTextView: HighlighterTextView {
+    public var documentRange: NSRange {
+        return NSRange(location: 0,
+                       length: textContentStorage.textStorage?.length ?? 0)
+    }
+
+    public func stringForRange(_ nsRange: NSRange) -> String? {
+        return textContentStorage.textStorage?.mutableString.substring(with: nsRange)
+    }
+}