Improved: Prefix edge case. Tests: Prefix & Suffix.

Author: oscbyspro

Sources/DiffableTextKit/Models/Offset.swift

@@ -92,7 +92,13 @@ AdditiveArithmetic, ExpressibleByIntegerLiteral {
 // MARK: * Offset x Int [...]
 //*============================================================================*
 
-public extension Int { @inlinable init<T>(_ offset: Offset<T>) { self = offset.distance } }
+public extension Int {
+    
+    @inlinable @inline(__always)
+    init<T>(_ offset: Offset<T>) {
+        self = offset.distance
+    }
+}
 
 //*============================================================================*
 // MARK: * Offsets [...]

Sources/DiffableTextKit/Styles/Prefix.swift

@@ -17,8 +17,6 @@ public struct PrefixTextStyle<Base: DiffableTextStyle>: WrapperTextStyle {
     public typealias Cache = Base.Cache
     public typealias Value = Base.Value
 
-    @usableFromInline typealias Characters = Offset<Character>
-    
     //=------------------------------------------------------------------------=
     // MARK: State
     //=------------------------------------------------------------------------=
@@ -62,12 +60,15 @@ public struct PrefixTextStyle<Base: DiffableTextStyle>: WrapperTextStyle {
     @inlinable func label(_ commit: inout Commit<Value>) {
         guard !prefix.isEmpty else { return }
         let selection = commit.snapshot.selection
+        let prefix = Snapshot(prefix,as:.phantom)
 
-        commit.snapshot = Snapshot(prefix, as: .phantom) + commit.snapshot
+        commit.snapshot = prefix + commit.snapshot
 
         guard let selection else { return }
-        let offsets = selection.map({ Characters(prefix.count + $0.attribute) })
-        commit.snapshot.select(commit.snapshot.indices(at: offsets.positions()))
+        let offsets = selection.map({ prefix.count + $0.attribute })
+        let lower = commit.snapshot.index(commit.snapshot.startIndex, offsetBy: offsets.lower)
+        let upper = commit.snapshot.index(lower/*-*/, offsetBy: offsets.upper - offsets.lower)
+        commit.snapshot.select(Range(uncheckedBounds: (lower, upper)))
     }
 }
 

Tests/DiffableTextKitTests/Mock.swift

@@ -21,13 +21,16 @@ struct Mock: DiffableTextStyle {
     // MARK: State
     //=------------------------------------------------------------------------=
 
-    var locale: Locale
+    var locale:  Locale
+    var selection: Bool
 
     //=------------------------------------------------------------------------=
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    init(locale: Locale = .autoupdatingCurrent) { self.locale = locale }
+    init(locale: Locale = .autoupdatingCurrent, selection: Bool = false) {
+        self.locale = locale; self.selection = selection
+    }
 
     //=------------------------------------------------------------------------=
     // MARK: Transformations
@@ -46,7 +49,9 @@ struct Mock: DiffableTextStyle {
     }
 
     func interpret(_ value: Value, with cache: inout Void) -> Commit<Value> {
-        Commit(value, Snapshot(value))
+        var snapshot = Snapshot(value)
+        if selection { snapshot.selection = .max(snapshot) }
+        return Commit(value, snapshot)
     }
 
     func resolve(_ proposal: Proposal, with cache: inout Void) throws -> Commit<Value> {

Tests/DiffableTextKitTests/Styles/Prefix.swift

@@ -18,26 +18,30 @@ import XCTest
 //*============================================================================*
 
 final class PrefixTests: XCTestCase {
-
+    
+    typealias C = Offset<Character>
+    
     //=------------------------------------------------------------------------=
-    // MARK: Assertions
+    // MARK: Tests
     //=------------------------------------------------------------------------=
 
-    func OK(prefix: String, value: String, format: String) {
-        let style = Mock().prefix(prefix); XCTAssertEqual(style.format(value), format)
+    func testFormat() {
+        XCTAssertEqual(Mock().prefix("🇸🇪").format("🇺🇸"), "🇸🇪🇺🇸")
     }
 
-    func OK(prefix: String, value: String, interpret: Commit<String>) {
-        let style = Mock().prefix(prefix); XCTAssertEqual(style.interpret(value), interpret)
+    func testInterpret() {
+        XCTAssertEqual(Mock().prefix("🇸🇪").interpret("🇺🇸"),
+        Commit("🇺🇸",  Snapshot("🇸🇪", as: .phantom) + "🇺🇸"))
     }
 
-    //=------------------------------------------------------------------------=
-    // MARK: Tests
-    //=------------------------------------------------------------------------=
-    
-    func test() {
-        OK(prefix: "🇸🇪", value: "🇺🇸", format: "🇸🇪🇺🇸")
-        OK(prefix: "🇸🇪", value: "🇺🇸", interpret: Commit("🇺🇸", Snapshot("🇸🇪", as: .phantom) + "🇺🇸"))
+    func testSelectionInBaseIsOffsetByPrefixSize() {
+        let characters = "0123456789"
+        
+        let normal = Mock(selection: true)/*----------*/.interpret(characters).snapshot
+        let prefix = Mock(selection: true).prefix("...").interpret(characters).snapshot
+        
+        XCTAssertEqual(normal.selection!.positions(), normal.indices(at: C(0) ..< C(10)))
+        XCTAssertEqual(prefix.selection!.positions(), prefix.indices(at: C(3) ..< C(13)))
     }
 }
 

Tests/DiffableTextKitTests/Styles/Suffix.swift

@@ -19,25 +19,29 @@ import XCTest
 
 final class SuffixTests: XCTestCase {
 
+    typealias C = Offset<Character>
+    
     //=------------------------------------------------------------------------=
-    // MARK: Assertions
+    // MARK: Tests
     //=------------------------------------------------------------------------=
 
-    func OK(value: String, suffix: String, format: String) {
-        let style = Mock().suffix(suffix); XCTAssertEqual(style.format(value), format)
+    func testFormat() {
+        XCTAssertEqual(Mock().suffix("🇸🇪").format("🇺🇸"), "🇺🇸🇸🇪")
     }
 
-    func OK(value: String, suffix: String, interpret: Commit<String>) {
-        let style = Mock().suffix(suffix); XCTAssertEqual(style.interpret(value), interpret)
+    func testInterpret() {
+        XCTAssertEqual(Mock().suffix("🇸🇪").interpret("🇺🇸"),
+        Commit("🇺🇸", "🇺🇸" + Snapshot("🇸🇪", as: .phantom)))
     }
 
-    //=------------------------------------------------------------------------=
-    // MARK: Tests
-    //=------------------------------------------------------------------------=
-    
-    func test() {
-        OK(value: "🇸🇪", suffix: "🇺🇸", format: "🇸🇪🇺🇸")
-        OK(value: "🇸🇪", suffix: "🇺🇸", interpret: Commit("🇸🇪", "🇸🇪" + Snapshot("🇺🇸", as: .phantom)))
+    func testSelectionIsSame() {
+        let characters = "0123456789"
+        
+        let normal = Mock(selection: true)/*----------*/.interpret(characters).snapshot
+        let suffix = Mock(selection: true).suffix("...").interpret(characters).snapshot
+        
+        XCTAssertEqual(normal.selection!.positions(), normal.indices(at: C(0) ..< C(10)))
+        XCTAssertEqual(suffix.selection!.positions(), suffix.indices(at: C(0) ..< C(10)))
     }
 }