Integrate TextFormation (#135)

Author: thecoolwinter

Package.resolved

@@ -25,13 +25,18 @@ let package = Package(
             url: "https://github.com/lukepistrol/SwiftLintPlugin",
             from: "0.2.2"
         ),
+        .package(
+            url: "https://github.com/ChimeHQ/TextFormation",
+            from: "0.6.7"
+        )
     ],
     targets: [
         .target(
             name: "CodeEditTextView",
             dependencies: [
                 "STTextView",
                 "CodeEditLanguages",
+                "TextFormation"
             ],
             plugins: [
                 .plugin(name: "SwiftLint", package: "SwiftLintPlugin")

Package.swift

@@ -0,0 +1,46 @@
+//
+//  STTextView+TextInterface.swift
+//  
+//
+//  Created by Khan Winter on 1/26/23.
+//
+
+import AppKit
+import STTextView
+import TextStory
+import TextFormation
+
+extension STTextView: TextInterface {
+    public var selectedRange: NSRange {
+        get {
+            return self.selectedRange()
+        }
+        set {
+            if let textRange = NSTextRange(newValue, provider: textContentStorage) {
+                self.setSelectedRange(textRange)
+            }
+        }
+    }
+
+    public var length: Int {
+        textContentStorage.length
+    }
+
+    public func substring(from range: NSRange) -> String? {
+        return textContentStorage.substring(from: range)
+    }
+
+    public func applyMutation(_ mutation: TextStory.TextMutation) {
+        if let manager = undoManager {
+            let inverse = inverseMutation(for: mutation)
+
+            manager.registerUndo(withTarget: self, handler: { (storable) in
+                storable.applyMutation(inverse)
+            })
+        }
+
+        textContentStorage.performEditingTransaction {
+            textContentStorage.applyMutation(mutation)
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+//
+//  DeleteWhitespaceFilter.swift
+//  
+//
+//  Created by Khan Winter on 1/28/23.
+//
+
+import Foundation
+import TextFormation
+import TextStory
+
+/// Filter for quickly deleting indent whitespace
+struct DeleteWhitespaceFilter: Filter {
+    let indentationUnit: String
+
+    func processMutation(_ mutation: TextMutation, in interface: TextInterface) -> FilterAction {
+        guard mutation.string == "" && mutation.range.length == 1 else {
+            return .none
+        }
+
+        // Walk backwards from the mutation, grabbing as much whitespace as possible
+        guard let preceedingNonWhitespace = interface.findPrecedingOccurrenceOfCharacter(
+            in: CharacterSet.whitespaces.inverted,
+            from: mutation.range.max
+        ) else {
+            return .none
+        }
+
+        let length = mutation.range.max - preceedingNonWhitespace
+        let numberOfExtraSpaces = length % indentationUnit.count
+
+        if numberOfExtraSpaces == 0 && length >= indentationUnit.count {
+            interface.applyMutation(
+                TextMutation(delete: NSRange(location: mutation.range.max - indentationUnit.count,
+                                             length: indentationUnit.count),
+                             limit: mutation.limit)
+            )
+            return .discard
+        }
+
+        return .none
+    }
+}

Sources/CodeEditTextView/Filters/DeleteWhitespaceFilter.swift

@@ -0,0 +1,45 @@
+//
+//  NewlineFilter.swift
+//  
+//
+//  Created by Khan Winter on 1/28/23.
+//
+
+import Foundation
+import TextFormation
+import TextStory
+
+/// A newline filter almost entirely similar to `TextFormation`s standard implementation.
+struct NewlineFilter: Filter {
+    private let recognizer: ConsecutiveCharacterRecognizer
+    let providers: WhitespaceProviders
+
+    init(whitespaceProviders: WhitespaceProviders) {
+        self.recognizer = ConsecutiveCharacterRecognizer(matching: "\n")
+        self.providers = whitespaceProviders
+    }
+
+    func processMutation(_ mutation: TextStory.TextMutation,
+                         in interface: TextFormation.TextInterface) -> TextFormation.FilterAction {
+        recognizer.processMutation(mutation)
+
+        switch recognizer.state {
+        case .triggered:
+            return filterHandler(mutation, in: interface)
+        case .tracking, .idle:
+            return .none
+        }
+    }
+
+    private func filterHandler(_ mutation: TextMutation, in interface: TextInterface) -> FilterAction {
+        interface.applyMutation(mutation)
+
+        let range = NSRange(location: mutation.postApplyRange.max, length: 0)
+
+        let value = providers.leadingWhitespace(range, interface)
+
+        interface.insertString(value, at: mutation.postApplyRange.max)
+
+        return .discard
+    }
+}

Sources/CodeEditTextView/Filters/NewlineFilter.swift

@@ -0,0 +1,142 @@
+//
+//  STTextViewController+TextFormation.swift
+//  
+//
+//  Created by Khan Winter on 1/26/23.
+//
+
+import AppKit
+import STTextView
+import TextFormation
+import TextStory
+
+extension STTextViewController {
+
+    // MARK: - Filter Configuration
+
+    /// Initializes any filters for text editing.
+    internal func setUpTextFormation() {
+        textFilters = []
+
+        let indentationUnit = String(repeating: " ", count: tabWidth)
+
+        let pairsToHandle: [(String, String)] = [
+            ("{", "}"),
+            ("[", "]"),
+            ("(", ")"),
+            ("<", ">")
+        ]
+
+        let indenter: TextualIndenter = getTextIndenter()
+        let whitespaceProvider = WhitespaceProviders(
+            leadingWhitespace: indenter.substitionProvider(indentationUnit: indentationUnit,
+                                                           width: tabWidth),
+            trailingWhitespace: { _, _ in "" }
+        )
+
+        // Filters
+
+        setUpOpenPairFilters(pairs: pairsToHandle, whitespaceProvider: whitespaceProvider)
+        setUpNewlineTabFilters(whitespaceProvider: whitespaceProvider,
+                               indentationUnit: indentationUnit)
+        setUpDeletePairFilters(pairs: pairsToHandle)
+        setUpDeleteWhitespaceFilter(indentationUnit: indentationUnit)
+    }
+
+    /// Returns a `TextualIndenter` based on available language configuration.
+    private func getTextIndenter() -> TextualIndenter {
+        switch language.id {
+        case .python:
+            return TextualIndenter(patterns: TextualIndenter.pythonPatterns)
+        case .ruby:
+            return TextualIndenter(patterns: TextualIndenter.rubyPatterns)
+        default:
+            return TextualIndenter(patterns: TextualIndenter.basicPatterns)
+        }
+    }
+
+    /// Configures pair filters and adds them to the `textFilters` array.
+    /// - Parameters:
+    ///   - pairs: The pairs to configure. Eg: `{` and `}`
+    ///   - whitespaceProvider: The whitespace providers to use.
+    private func setUpOpenPairFilters(pairs: [(String, String)], whitespaceProvider: WhitespaceProviders) {
+        for pair in pairs {
+            let filter = StandardOpenPairFilter(open: pair.0, close: pair.1, whitespaceProviders: whitespaceProvider)
+            textFilters.append(filter)
+        }
+    }
+
+    /// Configures newline and tab replacement filters.
+    /// - Parameters:
+    ///   - whitespaceProvider: The whitespace providers to use.
+    ///   - indentationUnit: The unit of indentation to use.
+    private func setUpNewlineTabFilters(whitespaceProvider: WhitespaceProviders, indentationUnit: String) {
+        let newlineFilter: Filter = NewlineFilter(whitespaceProviders: whitespaceProvider)
+        let tabReplacementFilter: Filter = TabReplacementFilter(indentationUnit: indentationUnit)
+
+        textFilters.append(contentsOf: [newlineFilter, tabReplacementFilter])
+    }
+
+    /// Configures delete pair filters.
+    private func setUpDeletePairFilters(pairs: [(String, String)]) {
+        for pair in pairs {
+            let filter = DeleteCloseFilter(open: pair.0, close: pair.1)
+            textFilters.append(filter)
+        }
+    }
+
+    /// Configures up the delete whitespace filter.
+    private func setUpDeleteWhitespaceFilter(indentationUnit: String) {
+        let filter = DeleteWhitespaceFilter(indentationUnit: indentationUnit)
+        textFilters.append(filter)
+    }
+
+    // MARK: - Delegate Methods
+
+    public func textView(_ textView: STTextView,
+                         shouldChangeTextIn affectedCharRange: NSTextRange,
+                         replacementString: String?) -> Bool {
+        guard let range = affectedCharRange.nsRange(using: textView.textContentStorage) else {
+            return true
+        }
+
+        let mutation = TextMutation(string: replacementString ?? "",
+                                    range: range,
+                                    limit: textView.textContentStorage.length)
+
+        textView.undoManager?.beginUndoGrouping()
+
+        let result = shouldApplyMutation(mutation, to: textView)
+
+        textView.undoManager?.endUndoGrouping()
+
+        return result
+    }
+
+    /// Determines whether or not a text mutation should be applied.
+    /// - Parameters:
+    ///   - mutation: The text mutation.
+    ///   - textView: The textView to use.
+    /// - Returns: Return whether or not the mutation should be applied.
+    private func shouldApplyMutation(_ mutation: TextMutation, to textView: STTextView) -> Bool {
+        // don't perform any kind of filtering during undo operations
+        if textView.undoManager?.isUndoing ?? false || textView.undoManager?.isRedoing ?? false {
+            return true
+        }
+
+        for filter in textFilters {
+            let action = filter.processMutation(mutation, in: textView)
+
+            switch action {
+            case .none:
+                break
+            case .stop:
+                return true
+            case .discard:
+                return false
+            }
+        }
+
+        return true
+    }
+}

Sources/CodeEditTextView/Filters/STTextViewController+TextFormation.swift

@@ -0,0 +1,27 @@
+//
+//  TabReplacementFilter.swift
+//  
+//
+//  Created by Khan Winter on 1/28/23.
+//
+
+import Foundation
+import TextFormation
+import TextStory
+
+/// Filter for replacing tab characters with the user-defined indentation unit.
+/// - Note: The undentation unit can be another tab character, this is merely a point at which this can be configured.
+struct TabReplacementFilter: Filter {
+    let indentationUnit: String
+
+    func processMutation(_ mutation: TextMutation, in interface: TextInterface) -> FilterAction {
+        if mutation.string == "\t" {
+            interface.applyMutation(TextMutation(insert: indentationUnit,
+                                                 at: mutation.range.location,
+                                                 limit: mutation.limit))
+            return .discard
+        } else {
+            return .none
+        }
+    }
+}