Fix Lint Errors, Clean Up Calculator

Author: thecoolwinter

Sources/CodeEditSourceEditor/Extensions/NSBezierPath+RoundedCorners.swift

@@ -24,6 +24,7 @@ extension NSBezierPath {
         public static let bottomRight = Corners(rawValue: 1 << 3)
     }
 
+    // swiftlint:disable:next function_body_length
     convenience init(rect: CGRect, roundedCorners corners: Corners, cornerRadius: CGFloat) {
         self.init()
 
@@ -95,7 +96,6 @@ extension NSBezierPath {
         close()
     }
 
-
     convenience init(roundingRect: CGRect, capTop: Bool, capBottom: Bool, cornerRadius radius: CGFloat) {
         switch (capTop, capBottom) {
         case (true, true):

Sources/CodeEditSourceEditor/LineFolding/Model/LineFoldCalculator.swift

@@ -56,15 +56,13 @@ actor LineFoldCalculator {
         // Depth: Open range
         var openFolds: [Int: LineFoldStorage.RawFold] = [:]
         var currentDepth: Int = 0
-        var iterator = await controller.textView.layoutManager.lineStorage.makeIterator()
-
-        var lines = await self.getMoreLines(
+        var lineIterator = await ChunkedLineIterator(
             controller: controller,
-            iterator: &iterator,
-            previousDepth: currentDepth,
-            foldProvider: foldProvider
+            foldProvider: foldProvider,
+            textIterator: await controller.textView.layoutManager.lineStorage.makeIterator()
         )
-        while let lineChunk = lines {
+
+        for await lineChunk in lineIterator {
             for lineInfo in lineChunk {
                 // Start a new fold, going deeper to a new depth.
                 if lineInfo.depth > currentDepth {
@@ -88,12 +86,6 @@ actor LineFoldCalculator {
 
                 currentDepth = lineInfo.depth
             }
-            lines = await self.getMoreLines(
-                controller: controller,
-                iterator: &iterator,
-                previousDepth: currentDepth,
-                foldProvider: foldProvider
-            )
         }
 
         // Clean up any hanging folds.
@@ -106,6 +98,14 @@ actor LineFoldCalculator {
             )
         }
 
+        await yieldNewStorage(newFolds: foldCache, controller: controller, documentRange: documentRange)
+    }
+
+    private func yieldNewStorage(
+        newFolds: [LineFoldStorage.RawFold],
+        controller: TextViewController,
+        documentRange: NSRange
+    ) async {
         let attachments = await controller.textView.layoutManager.attachments
             .getAttachmentsOverlapping(documentRange)
             .compactMap { attachmentBox -> LineFoldStorage.DepthStartPair? in
@@ -116,39 +116,55 @@ actor LineFoldCalculator {
             }
 
         let storage = LineFoldStorage(
-            documentLength: foldCache.max(
+            documentLength: newFolds.max(
                 by: { $0.range.upperBound < $1.range.upperBound }
             )?.range.upperBound ?? documentRange.length,
-            folds: foldCache.sorted(by: { $0.range.lowerBound < $1.range.lowerBound }),
+            folds: newFolds.sorted(by: { $0.range.lowerBound < $1.range.lowerBound }),
             collapsedRanges: Set(attachments)
         )
         valueStreamContinuation.yield(storage)
     }
 
     @MainActor
-    private func getMoreLines(
-        controller: TextViewController,
-        iterator: inout TextLineStorage<TextLine>.TextLineStorageIterator,
-        previousDepth: Int,
-        foldProvider: LineFoldProvider
-    ) -> [LineFoldProviderLineInfo]? {
-        var results: [LineFoldProviderLineInfo] = []
-        var count = 0
-        var previousDepth: Int = previousDepth
-        while count < 50, let linePosition = iterator.next() {
-            let foldInfo = foldProvider.foldLevelAtLine(
-                lineNumber: linePosition.index,
-                lineRange: linePosition.range,
-                previousDepth: previousDepth,
-                controller: controller
-            )
-            results.append(contentsOf: foldInfo)
-            count += 1
-            previousDepth = foldInfo.max(by: { $0.depth < $1.depth })?.depth ?? previousDepth
+    struct ChunkedLineIterator: AsyncSequence, AsyncIteratorProtocol {
+        var controller: TextViewController
+        var foldProvider: LineFoldProvider
+        private var previousDepth: Int = 0
+        var textIterator: TextLineStorage<TextLine>.TextLineStorageIterator
+
+        init(
+            controller: TextViewController,
+            foldProvider: LineFoldProvider,
+            textIterator: TextLineStorage<TextLine>.TextLineStorageIterator
+        ) {
+            self.controller = controller
+            self.foldProvider = foldProvider
+            self.textIterator = textIterator
+        }
+
+        nonisolated func makeAsyncIterator() -> ChunkedLineIterator {
+            self
         }
-        if results.isEmpty && count == 0 {
-            return nil
+
+        mutating func next() async -> [LineFoldProviderLineInfo]? {
+            var results: [LineFoldProviderLineInfo] = []
+            var count = 0
+            var previousDepth: Int = previousDepth
+            while count < 50, let linePosition = textIterator.next() {
+                let foldInfo = foldProvider.foldLevelAtLine(
+                    lineNumber: linePosition.index,
+                    lineRange: linePosition.range,
+                    previousDepth: previousDepth,
+                    controller: controller
+                )
+                results.append(contentsOf: foldInfo)
+                count += 1
+                previousDepth = foldInfo.max(by: { $0.depth < $1.depth })?.depth ?? previousDepth
+            }
+            if results.isEmpty && count == 0 {
+                return nil
+            }
+            return results
         }
-        return results
     }
 }

Sources/CodeEditSourceEditor/LineFolding/View/FoldingRibbonView+Draw.swift

@@ -9,46 +9,6 @@ import AppKit
 import CodeEditTextView
 
 extension FoldingRibbonView {
-    struct FoldCapInfo {
-        let startIndices: Set<Int>
-        let endIndices: Set<Int>
-
-        init(_ folds: [DrawingFoldInfo]) {
-            self.startIndices = folds.reduce(into: Set<Int>(), { $0.insert($1.startLine.index) })
-            self.endIndices = folds.reduce(into: Set<Int>(), { $0.insert($1.endLine.index) })
-        }
-
-        func foldNeedsTopCap(_ fold: DrawingFoldInfo) -> Bool {
-            endIndices.contains(fold.startLine.index)
-        }
-
-        func foldNeedsBottomCap(_ fold: DrawingFoldInfo) -> Bool {
-            startIndices.contains(fold.endLine.index)
-        }
-
-        func adjustFoldRect(
-            using fold: DrawingFoldInfo,
-            rect: NSRect
-        ) -> NSRect {
-            let capTop = foldNeedsTopCap(fold)
-            let capBottom = foldNeedsBottomCap(fold)
-            let yDelta = capTop ? fold.startLine.height / 2.0 : 0.0
-            let heightDelta: CGFloat = if capTop && capBottom {
-                -fold.startLine.height
-            } else if capTop || capBottom {
-                -(fold.startLine.height / 2.0)
-            } else {
-                0.0
-            }
-            return NSRect(
-                x: rect.origin.x,
-                y: rect.origin.y + yDelta,
-                width: rect.size.width,
-                height: rect.size.height + heightDelta
-            )
-        }
-    }
-
     struct DrawingFoldInfo {
         let fold: FoldRange
         let startLine: TextLineStorage<TextLine>.TextLinePosition
@@ -273,8 +233,7 @@ extension FoldingRibbonView {
                 foldInfo: foldInfo,
                 foldCaps: foldCaps,
                 originalPath: roundedRect.cgPathFallback,
-                minYPosition: minYPosition,
-                maxYPosition: maxYPosition,
+                yPosition: minYPosition...maxYPosition,
                 in: context
             )
         }
@@ -295,15 +254,19 @@ extension FoldingRibbonView {
         foldInfo: DrawingFoldInfo,
         foldCaps: FoldCapInfo,
         originalPath: CGPath,
-        minYPosition: CGFloat,
-        maxYPosition: CGFloat,
+        yPosition: ClosedRange<CGFloat>,
         in context: CGContext
     ) {
         context.saveGState()
 
         let plainRect = foldCaps.adjustFoldRect(
             using: foldInfo,
-            rect: NSRect(x: -0.5, y: minYPosition, width: frame.width + 1.0, height: maxYPosition - minYPosition)
+            rect: NSRect(
+                x: -0.5,
+                y: yPosition.lowerBound,
+                width: frame.width + 1.0,
+                height: yPosition.upperBound - yPosition.lowerBound
+            )
         )
         let radius = plainRect.width / 2.0
         let roundedRect = NSBezierPath(
@@ -318,7 +281,14 @@ extension FoldingRibbonView {
         combined.addPath(roundedRect.cgPathFallback)
         combined.addPath(originalPath)
 
-        context.clip(to: CGRect(x: 0, y: minYPosition, width: 7, height: maxYPosition - minYPosition))
+        context.clip(
+            to: CGRect(
+                x: 0,
+                y: yPosition.lowerBound,
+                width: 7,
+                height: yPosition.upperBound - yPosition.lowerBound
+            )
+        )
         context.addPath(combined)
         context.setFillColor(markerBorderColor)
         context.drawPath(using: .eoFill)

Sources/CodeEditSourceEditor/LineFolding/View/FoldingRibbonView+FoldCapInfo.swift

@@ -0,0 +1,50 @@
+//
+//  FoldCapInfo.swift
+//  CodeEditSourceEditor
+//
+//  Created by Khan Winter on 6/3/25.
+//
+
+import AppKit
+
+extension FoldingRibbonView {
+    struct FoldCapInfo {
+        let startIndices: Set<Int>
+        let endIndices: Set<Int>
+
+        init(_ folds: [DrawingFoldInfo]) {
+            self.startIndices = folds.reduce(into: Set<Int>(), { $0.insert($1.startLine.index) })
+            self.endIndices = folds.reduce(into: Set<Int>(), { $0.insert($1.endLine.index) })
+        }
+
+        func foldNeedsTopCap(_ fold: DrawingFoldInfo) -> Bool {
+            endIndices.contains(fold.startLine.index)
+        }
+
+        func foldNeedsBottomCap(_ fold: DrawingFoldInfo) -> Bool {
+            startIndices.contains(fold.endLine.index)
+        }
+
+        func adjustFoldRect(
+            using fold: DrawingFoldInfo,
+            rect: NSRect
+        ) -> NSRect {
+            let capTop = foldNeedsTopCap(fold)
+            let capBottom = foldNeedsBottomCap(fold)
+            let yDelta = capTop ? fold.startLine.height / 2.0 : 0.0
+            let heightDelta: CGFloat = if capTop && capBottom {
+                -fold.startLine.height
+            } else if capTop || capBottom {
+                -(fold.startLine.height / 2.0)
+            } else {
+                0.0
+            }
+            return NSRect(
+                x: rect.origin.x,
+                y: rect.origin.y + yDelta,
+                width: rect.size.width,
+                height: rect.size.height + heightDelta
+            )
+        }
+    }
+}

Sources/CodeEditSourceEditor/RangeStore/RangeStore+FindIndex.swift

@@ -12,7 +12,7 @@ extension RangeStore {
     func findIndex(at offset: Int) -> (index: Index, remaining: Int) {
         _guts.find(at: offset, in: OffsetMetric(), preferEnd: false)
     }
-    
+
     /// Finds the value stored at a given string offset.
     /// - Parameter offset: The offset to query for.
     /// - Returns: The element stored, if any.