Refining textual context concept

Author: mattmassicotte

Sources/TextFormation/PatternMatcher.swift

@@ -1,25 +1,18 @@
 import Rearrange
 
 public struct TextualContext<TextRange: Bounded> {
-	public struct Line {
-		public let range: TextRange
-		public let nonwhitespaceContent: String
-		
-		public init(range: TextRange, nonwhitespaceContent: String) {
-			self.range = range
-			self.nonwhitespaceContent = nonwhitespaceContent
-		}
-	}
-	
-    public let current: Line
-    public let preceding: Line
+	public let current: String
+	public let preceding: String
+	public let precedingLeadingWhitespaceRange: TextRange
 
 	public init(
-		current: Line,
-		preceding: Line
+		current: String,
+		preceding: String,
+		precedingLeadingWhitespaceRange: TextRange
 	) {
         self.current = current
         self.preceding = preceding
+		self.precedingLeadingWhitespaceRange = precedingLeadingWhitespaceRange
     }
 }
 
@@ -39,11 +32,11 @@ public struct PreceedingLineSuffixIndenter<TextRange: Bounded> {
 
 extension PreceedingLineSuffixIndenter: PatternMatcher {
     public func action(for context: TextualContext<TextRange>) -> Indentation<TextRange>? {
-		if context.preceding.nonwhitespaceContent.hasSuffix(suffix) == false {
+		if context.preceding.hasSuffix(suffix) == false {
             return nil
         }
 
-		return .relativeIncrease(context.preceding.range)
+		return .relativeIncrease(context.precedingLeadingWhitespaceRange)
     }
 }
 
@@ -57,11 +50,11 @@ public struct PreceedingLinePrefixIndenter<TextRange: Bounded> {
 
 extension PreceedingLinePrefixIndenter: PatternMatcher {
     public func action(for context: TextualContext<TextRange>) -> Indentation<TextRange>? {
-        if context.preceding.nonwhitespaceContent.hasPrefix(prefix) == false {
+        if context.preceding.hasPrefix(prefix) == false {
             return nil
         }
 
-        return .relativeIncrease(context.preceding.range)
+        return .relativeIncrease(context.precedingLeadingWhitespaceRange)
     }
 }
 
@@ -75,11 +68,11 @@ public struct CurrentLinePrefixOutdenter<TextRange: Bounded> {
 
 extension CurrentLinePrefixOutdenter: PatternMatcher {
     public func action(for context: TextualContext<TextRange>) -> Indentation<TextRange>? {
-		if context.current.nonwhitespaceContent.hasPrefix(prefix) == false {
+		if context.current.hasPrefix(prefix) == false {
             return nil
         }
 
-		return .relativeDecrease(context.preceding.range)
+		return .relativeDecrease(context.precedingLeadingWhitespaceRange)
     }
 }
 
@@ -99,7 +92,7 @@ extension PreceedingLineConditionalMatcher: PatternMatcher {
             return nil
         }
 
-        if context.preceding.nonwhitespaceContent.hasPrefix(previousPrefix) {
+        if context.preceding.hasPrefix(previousPrefix) {
             return nil
         }
 

Sources/TextFormation/TextSystemInterface.swift

@@ -27,6 +27,14 @@ extension TextSystemInterface {
 
 		return try substring(in: range)
 	}
+
+	func insert(at position: Position, string: String) throws -> Output? {
+		guard let range = textRange(from: position, to: position) else {
+			return nil
+		}
+
+		return try applyMutation(range, string: string)
+	}
 }
 
 #if canImport(Foundation)

Sources/TextFormation/TextualIndenter.swift

@@ -3,25 +3,19 @@ import Rearrange
 #if compiler(>=6.1)
 @available(macOS 13, iOS 16, tvOS 16, watchOS 9, *)
 public struct TextualIndenter<TextRange: Bounded> where TextRange: Hashable {
-	public typealias ContextProvider = (Position) throws -> TextualContext<TextRange>
 	public typealias IndentationResult = Result<Indentation<TextRange>, IndentationError>
 	public typealias Matcher = any PatternMatcher<TextRange>
 	public typealias Position = TextRange.Bound
 
 	public let patterns: [Matcher]
-	public let provider: ContextProvider
 
 	public init(
-		patterns: [Matcher],
-		provider: @escaping ContextProvider
+		patterns: [Matcher] = Self.basicPatterns
 	) {
 		self.patterns = patterns
-		self.provider = provider
 	}
 
-	public func computeIndentation(at position: Position) throws -> Indentation<TextRange> {
-		let context = try provider(position)
-		
+	public func computeIndentation(at position: Position, context: TextualContext<TextRange>) throws -> Indentation<TextRange> {
         // unique them, just in case two matches produce the same identical action
         let potentialIndents = Set(patterns.compactMap({ $0.action(for: context) }))
 
@@ -31,7 +25,7 @@ public struct TextualIndenter<TextRange: Bounded> where TextRange: Hashable {
 
         // we have no matches, or conflicting matches
 
-		return .equal(context.preceding.range)
+		return .equal(context.precedingLeadingWhitespaceRange)
 	}
 
 //	func computeTextualContent(at position: Position) throws -> TextualContext {

Tests/TextFormationTests/TextualIndenterTests.swift

@@ -3,42 +3,22 @@ import Testing
 
 import TextFormation
 
-#if compiler(>=6.1) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS))
-extension TextualContext where TextRange == NSRange {
-	init<R: RangeExpression>(
-		preceding: R,
-		_ precedingContent: String,
-		current: R,
-		_ currentContent: String
-	) where R.Bound == TextRange.Bound {
-		self.init(
-			current: Self.Line(range: NSRange(current), nonwhitespaceContent: currentContent),
-			preceding: Self.Line(range: NSRange(preceding), nonwhitespaceContent: currentContent)
-		)
-	}
-}
-
+#if compiler(>=6.1)
 struct TextualIndenterTests {
 	@available(macOS 13, iOS 16, tvOS 16, watchOS 9, *)
 	@Test func emptyString() throws {
-		let indenter = TextualIndenter<NSRange>(patterns: TextualIndenter.basicPatterns, provider: { pos in
-			try #require(pos == 0)
+		let indenter = TextualIndenter<NSRange>(patterns: TextualIndenter.basicPatterns)
+		let context = TextualContext(current: "", preceding: "", precedingLeadingWhitespaceRange: NSRange.zero)
 
-			throw IndentationError.unableToComputeReferenceRange
-		})
-		
-		#expect(throws: (any Error).self) { try indenter.computeIndentation(at: 0) }
+		#expect(try indenter.computeIndentation(at: 0, context: context) == .equal(NSRange(0..<0)))
 	}
 
 	@available(macOS 13, iOS 16, tvOS 16, watchOS 9, *)
 	@Test func propagatesPreviousLineIndentation() throws {
-		let indenter = TextualIndenter<NSRange>(patterns: TextualIndenter.basicPatterns, provider: { pos in
-			try #require(pos == 0)
-			
-			return TextualContext(preceding: 0..<1, "\t", current: 2..<2, "")
-		})
-		
-		#expect(try indenter.computeIndentation(at: 0) == .equal(NSRange(0..<1)))
+		let indenter = TextualIndenter<NSRange>(patterns: TextualIndenter.basicPatterns)
+		let context = TextualContext(current: "", preceding: "\t", precedingLeadingWhitespaceRange: NSRange(0..<1))
+
+		#expect(try indenter.computeIndentation(at: 0, context: context) == .equal(NSRange(0..<1)))
 	}
 }