Toggle Folding State

Author: thecoolwinter

Sources/CodeEditSourceEditor/Controller/TextViewController+Lifecycle.swift

@@ -143,6 +143,7 @@ extension TextViewController {
             - (self?.scrollView.contentInsets.top ?? 0)
 
             self?.gutterView.needsDisplay = true
+            self?.gutterView.foldingRibbon.needsDisplay = true
             self?.guideView?.updatePosition(in: textView)
             self?.scrollView.needsLayout = true
         }

Sources/CodeEditSourceEditor/Gutter/GutterView.swift

@@ -101,7 +101,7 @@ public class GutterView: NSView {
     }
 
     /// The view that draws the fold decoration in the gutter.
-    private var foldingRibbon: FoldingRibbonView
+    var foldingRibbon: FoldingRibbonView
 
     /// Syntax helper for determining the required space for the folding ribbon.
     private var foldingRibbonWidth: CGFloat {

Sources/CodeEditSourceEditor/LineFolding/FoldProviders/IndentationLineFoldProvider.swift

@@ -9,7 +9,7 @@ import AppKit
 import CodeEditTextView
 
 final class IndentationLineFoldProvider: LineFoldProvider {
-    func foldLevelAtLine(_ lineNumber: Int, substring: NSString) -> Int? {
+    func indentLevelAtLine(substring: NSString) -> Int? {
         for idx in 0..<substring.length {
             let character = UnicodeScalar(substring.character(at: idx))
             if character?.properties.isWhitespace == false {
@@ -18,4 +18,34 @@ final class IndentationLineFoldProvider: LineFoldProvider {
         }
         return nil
     }
+
+    func foldLevelAtLine(
+        lineNumber: Int,
+        lineRange: NSRange,
+        currentDepth: Int,
+        text: NSTextStorage
+    ) -> LineFoldProviderLineInfo? {
+        guard let leadingIndent = text.leadingRange(in: lineRange, within: .whitespacesWithoutNewlines)?.length,
+              leadingIndent > 0 else {
+            return nil
+        }
+
+        if leadingIndent < currentDepth {
+            // End the fold at the start of whitespace
+            return .endFold(rangeEnd: lineRange.location + leadingIndent, newDepth: leadingIndent)
+        }
+
+        // Check if the next line has more indent
+        let maxRange = NSRange(start: lineRange.max, end: text.length)
+        guard let nextIndent = text.leadingRange(in: maxRange, within: .whitespacesWithoutNewlines)?.length,
+              nextIndent > 0 else {
+            return nil
+        }
+
+        if nextIndent > currentDepth, let trailingWhitespace = text.trailingWhitespaceRange(in: lineRange) {
+            return .startFold(rangeStart: trailingWhitespace.location, newDepth: nextIndent)
+        }
+
+        return nil
+    }
 }

Sources/CodeEditSourceEditor/LineFolding/FoldProviders/LineFoldProvider.swift

@@ -8,6 +8,34 @@
 import AppKit
 import CodeEditTextView
 
+enum LineFoldProviderLineInfo {
+    case startFold(rangeStart: Int, newDepth: Int)
+    case endFold(rangeEnd: Int, newDepth: Int)
+
+    var depth: Int {
+        switch self {
+        case .startFold(_, let newDepth):
+            return newDepth
+        case .endFold(_, let newDepth):
+            return newDepth
+        }
+    }
+
+    var rangeIndice: Int {
+        switch self {
+        case .startFold(let rangeStart, _):
+            return rangeStart
+        case .endFold(let rangeEnd, _):
+            return rangeEnd
+        }
+    }
+}
+
 protocol LineFoldProvider: AnyObject {
-    func foldLevelAtLine(_ lineNumber: Int, substring: NSString) -> Int?
+    func foldLevelAtLine(
+        lineNumber: Int,
+        lineRange: NSRange,
+        currentDepth: Int,
+        text: NSTextStorage
+    ) -> LineFoldProviderLineInfo?
 }

Sources/CodeEditSourceEditor/LineFolding/Model/FoldRange.swift

@@ -12,15 +12,24 @@ class FoldRange {
     var lineRange: ClosedRange<Int>
     var range: NSRange
     var depth: Int
+    var collapsed: Bool
     /// Ordered array of ranges that are nested in this fold.
     var subFolds: [FoldRange]
 
     weak var parent: FoldRange?
 
-    init(lineRange: ClosedRange<Int>, range: NSRange, depth: Int, parent: FoldRange?, subFolds: [FoldRange]) {
+    init(
+        lineRange: ClosedRange<Int>,
+        range: NSRange,
+        depth: Int,
+        collapsed: Bool,
+        parent: FoldRange?,
+        subFolds: [FoldRange]
+    ) {
         self.lineRange = lineRange
         self.range = range
         self.depth = depth
+        self.collapsed = collapsed
         self.subFolds = subFolds
         self.parent = parent
     }

Sources/CodeEditSourceEditor/LineFolding/Model/LineFoldCalculator.swift

@@ -15,6 +15,12 @@ import Combine
 /// Fold information is emitted via `rangesPublisher`.
 /// Notify the calculator it should re-calculate
 class LineFoldCalculator {
+    private struct LineInfo {
+        let lineNumber: Int
+        let providerInfo: LineFoldProviderLineInfo
+        let collapsed: Bool
+    }
+
     weak var foldProvider: LineFoldProvider?
     weak var textView: TextView?
 
@@ -48,15 +54,21 @@ class LineFoldCalculator {
             var currentDepth: Int = 0
             var iterator = textView.layoutManager.linesInRange(textView.documentRange)
 
-            var lines = self.getMoreLines(textView: textView, iterator: &iterator, foldProvider: foldProvider)
+            var lines = self.getMoreLines(
+                textView: textView,
+                iterator: &iterator,
+                lastDepth: currentDepth,
+                foldProvider: foldProvider
+            )
             while let lineChunk = lines {
-                for (lineNumber, foldDepth) in lineChunk {
+                for lineInfo in lineChunk {
                     // Start a new fold, going deeper to a new depth.
-                    if foldDepth > currentDepth {
+                    if lineInfo.providerInfo.depth > currentDepth {
                         let newFold = FoldRange(
-                            lineRange: (lineNumber - 1)...(lineNumber - 1),
-                            range: .zero,
-                            depth: foldDepth,
+                            lineRange: lineInfo.lineNumber...lineInfo.lineNumber,
+                            range: NSRange(location: lineInfo.providerInfo.rangeIndice, length: 0),
+                            depth: lineInfo.providerInfo.depth,
+                            collapsed: lineInfo.collapsed,
                             parent: currentFold,
                             subFolds: []
                         )
@@ -67,24 +79,31 @@ class LineFoldCalculator {
                             currentFold?.subFolds.append(newFold)
                         }
                         currentFold = newFold
-                    } else if foldDepth < currentDepth {
+                    } else if lineInfo.providerInfo.depth < currentDepth {
                         // End this fold, go shallower "popping" folds deeper than the new depth
-                        while let fold = currentFold, fold.depth > foldDepth {
+                        while let fold = currentFold, fold.depth > lineInfo.providerInfo.depth {
                             // close this fold at the current line
-                            fold.lineRange = fold.lineRange.lowerBound...lineNumber
+                            fold.lineRange = fold.lineRange.lowerBound...lineInfo.lineNumber
+                            fold.range = NSRange(start: fold.range.location, end: lineInfo.providerInfo.rangeIndice)
                             // move up
                             currentFold = fold.parent
                         }
                     }
 
-                    currentDepth = foldDepth
+                    currentDepth = lineInfo.providerInfo.depth
                 }
-                lines = self.getMoreLines(textView: textView, iterator: &iterator, foldProvider: foldProvider)
+                lines = self.getMoreLines(
+                    textView: textView,
+                    iterator: &iterator,
+                    lastDepth: currentDepth,
+                    foldProvider: foldProvider
+                )
             }
 
             // Clean up any hanging folds.
             while let fold = currentFold {
-                fold.lineRange = fold.lineRange.lowerBound...textView.layoutManager.lineCount
+                fold.lineRange = fold.lineRange.lowerBound...textView.layoutManager.lineCount - 1
+                fold.range = NSRange(start: fold.range.location, end: textView.documentRange.length)
                 currentFold = fold.parent
             }
 
@@ -95,24 +114,36 @@ class LineFoldCalculator {
     private func getMoreLines(
         textView: TextView,
         iterator: inout TextLayoutManager.RangeIterator,
+        lastDepth: Int,
         foldProvider: LineFoldProvider
-    ) -> [(index: Int, foldDepth: Int)]? {
+    ) -> [LineInfo]? {
         DispatchQueue.main.asyncAndWait {
-            var results: [(index: Int, foldDepth: Int)] = []
+            var results: [LineInfo] = []
             var count = 0
+            var lastDepth = lastDepth
             while count < 50, let linePosition = iterator.next() {
-                guard textView.textStorage.length <= linePosition.range.max,
-                      let substring = textView.textStorage.substring(from: linePosition.range) as NSString?,
-                      let foldDepth = foldProvider.foldLevelAtLine(
-                        linePosition.index,
-                        substring: substring
-                      ) else {
+                guard let foldInfo = foldProvider.foldLevelAtLine(
+                    lineNumber: linePosition.index,
+                    lineRange: linePosition.range,
+                    currentDepth: lastDepth,
+                    text: textView.textStorage
+                ) else {
                     count += 1
                     continue
                 }
+                let attachments = textView.layoutManager.attachments
+                    .getAttachmentsOverlapping(linePosition.range)
+                    .compactMap({ $0.attachment as? LineFoldPlaceholder })
 
-                results.append((linePosition.index, foldDepth))
+                results.append(
+                    LineInfo(
+                        lineNumber: linePosition.index,
+                        providerInfo: foldInfo,
+                        collapsed: !attachments.isEmpty
+                    )
+                )
                 count += 1
+                lastDepth = foldInfo.depth
             }
             if results.isEmpty && count == 0 {
                 return nil

Sources/CodeEditSourceEditor/LineFolding/Placeholder/LineFoldPlaceholder.swift

@@ -0,0 +1,27 @@
+//
+//  LineFoldPlaceholder.swift
+//  CodeEditSourceEditor
+//
+//  Created by Khan Winter on 5/9/25.
+//
+
+import AppKit
+import CodeEditTextView
+
+class LineFoldPlaceholder: TextAttachment {
+    var width: CGFloat { 17 }
+
+    func draw(in context: CGContext, rect: NSRect) {
+        context.saveGState()
+
+        let centerY = rect.midY - 1.5
+
+        context.setFillColor(NSColor.secondaryLabelColor.cgColor)
+        context.addEllipse(in: CGRect(x: rect.minX + 2, y: centerY, width: 3, height: 3))
+        context.addEllipse(in: CGRect(x: rect.minX + 7, y: centerY, width: 3, height: 3))
+        context.addEllipse(in: CGRect(x: rect.minX + 12, y: centerY, width: 3, height: 3))
+        context.fillPath()
+
+        context.restoreGState()
+    }
+}

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

@@ -76,7 +76,9 @@ extension FoldingRibbonView {
 
         let maxYPosition = maxPosition.yPos + maxPosition.height
 
-        if let hoveringFold,
+        if fold.collapsed {
+            drawCollapsedFold(minYPosition: minYPosition, maxYPosition: maxYPosition, in: context)
+        } else if let hoveringFold,
            hoveringFold.depth == markerContext.depth,
            fold.lineRange == hoveringFold.range {
             drawHoveredFold(
@@ -100,6 +102,39 @@ extension FoldingRibbonView {
         }
     }
 
+    private func drawCollapsedFold(
+        minYPosition: CGFloat,
+        maxYPosition: CGFloat,
+        in context: CGContext
+    ) {
+        context.saveGState()
+
+        let fillRect = CGRect(x: 0, y: minYPosition, width: Self.width, height: maxYPosition - minYPosition)
+
+        let height = 5.0
+        let minX = 2.0
+        let maxX = Self.width - 2.0
+        let centerY = minYPosition + (maxYPosition - minYPosition)/2
+        let minY = centerY - (height/2)
+        let maxY = centerY + (height/2)
+        let chevron = CGMutablePath()
+
+        chevron.move(to: CGPoint(x: minX, y: minY))
+        chevron.addLine(to: CGPoint(x: maxX, y: centerY))
+        chevron.addLine(to: CGPoint(x: minX, y: maxY))
+
+        context.setStrokeColor(NSColor.secondaryLabelColor.cgColor)
+        context.setLineCap(.round)
+        context.setLineJoin(.round)
+        context.setLineWidth(1.3)
+
+        context.fill(fillRect)
+        context.addPath(chevron)
+        context.strokePath()
+
+        context.restoreGState()
+    }
+
     private func drawHoveredFold(
         markerContext: FoldMarkerDrawingContext,
         minYPosition: CGFloat,

Sources/CodeEditSourceEditor/LineFolding/View/FoldingRibbonView.swift

@@ -113,6 +113,11 @@ class FoldingRibbonView: NSView {
         foldUpdateCancellable?.cancel()
     }
 
+    override public func resetCursorRects() {
+        // Don't use an iBeam in this view
+        addCursorRect(bounds, cursor: .arrow)
+    }
+
     // MARK: - Hover
 
     override func updateTrackingAreas() {
@@ -126,6 +131,30 @@ class FoldingRibbonView: NSView {
         addTrackingArea(area)
     }
 
+    var attachments: [LineFoldPlaceholder] = []
+
+    override func mouseDown(with event: NSEvent) {
+        let clickPoint = convert(event.locationInWindow, from: nil)
+        guard event.type == .leftMouseDown,
+              let lineNumber = model.textView?.layoutManager.textLineForPosition(clickPoint.y)?.index,
+              let fold = model.getCachedFoldAt(lineNumber: lineNumber) else {
+            super.mouseDown(with: event)
+            return
+        }
+        if let attachment = model.textView?.layoutManager.attachments.getAttachmentsStartingIn(fold.range.range).first {
+            model.textView?.layoutManager.attachments.remove(atOffset: attachment.range.location)
+            fold.range.collapsed = false
+            attachments.removeAll(where: { $0 === attachment.attachment })
+        } else {
+            let placeholder = LineFoldPlaceholder()
+            model.textView?.layoutManager.attachments.add(placeholder, for: fold.range.range)
+            attachments.append(placeholder)
+            fold.range.collapsed = true
+        }
+
+        model.textView?.needsLayout = true
+    }
+
     override func mouseMoved(with event: NSEvent) {
         let pointInView = convert(event.locationInWindow, from: nil)
         guard let lineNumber = model.textView?.layoutManager.textLineForPosition(pointInView.y)?.index,