Cleanup. Selection: positions() -> range(). Snapshot: indices(at:) -> range(at:), distances(to:) -> range(to:)

Author: oscbyspro

Sources/DiffableTextKit/Models/Context.swift

@@ -48,8 +48,8 @@ public struct Context<Style: DiffableTextStyle> {
             self.unique()
             self.storage.status = remote.status
             self.storage.layout!.merge(
-            snapshot:   remote.commit!.snapshot,
-            preference: remote.commit!.selection)
+            snapshot:/**/remote.commit!.snapshot,
+            preference:  remote.commit!.selection)
         //=--------------------------------------=
         // Inactive
         //=--------------------------------------=
@@ -128,12 +128,12 @@ extension Context {
     }
 
     @inlinable public var selection: Range<String.Index> {
-        let selection = layout?.selection.map(\.character).positions()
-        return selection ?? Selection(backup! .startIndex).positions()
+        let selection = layout?.selection.map(\.character).range()
+        return selection ?? Selection(backup! .startIndex).range()
     }
 
     @inlinable public func selection<T>(as type: T.Type = T.self) -> Range<Offset<T>> {
-        layout.map({$0.snapshot.distances(to:$0.selection.positions())}) ?? 0 ..< 0
+        layout.map({ $0.snapshot.range(to: $0.selection .range()) }) ?? 0 ..< 0
     }
 }
 
@@ -206,8 +206,8 @@ extension Context {
         self.storage.status.value = commit.value
         self.storage.layout!.selection.collapse()
         self.storage.layout!.merge(
-        snapshot:   commit.snapshot,
-        preference: commit.selection)
+        snapshot:/**/commit.snapshot,
+        preference:  commit.selection)
         //=--------------------------------------=
         // Return
         //=--------------------------------------=
@@ -230,7 +230,8 @@ extension Context {
         //=--------------------------------------=
         // Values
         //=--------------------------------------=
-        let selection = Selection(layout!.snapshot.indices(at: selection))
+        let selection = Selection(
+        layout!.snapshot.range(at: selection))
         //=--------------------------------------=
         // Update
         //=--------------------------------------=

Sources/DiffableTextKit/Models/Offset.swift

@@ -141,10 +141,10 @@ public extension Offsets {
         distance(from: start, to: end)
     }
 
-    @inlinable @inline(__always) func distances<T>(
-    to indices: Range<Index>, as type: T.Type = T.self) -> Range<Offset<T>> {
-        let lower: Offset<T> = distance(from:         startIndex, to: indices.lowerBound)
-        let count: Offset<T> = distance(from: indices.lowerBound, to: indices.upperBound)
+    @inlinable @inline(__always) func range<T>(
+    to  positions: Range<Index>, as type: T.Type = T.self) -> Range<Offset<T>> {
+        let lower: Offset<T> = distance(from: /*-----*/ startIndex, to: positions.lowerBound)
+        let count: Offset<T> = distance(from: positions.lowerBound, to: positions.upperBound)
         return lower ..< lower + count
     }
 
@@ -158,12 +158,12 @@ public extension Offsets {
     }
 
     @inlinable @inline(__always) func index<T>(
-    at distances: Offset<T>, as type: T.Type = T.self) -> Index {
-        index(from: startIndex, move: distances)
+    at  distance: Offset<T>, as type: T.Type = T.self) -> Index {
+        index(from: startIndex, move: distance)
     }
 
-    @inlinable @inline(__always) func indices<T>(
-    at distances: Range<Offset<T>>, as type: T.Type = T.self) -> Range<Index> {
+    @inlinable @inline(__always) func range<T>(
+    at  distances: Range<Offset<T>>, as type: T.Type = T.self) -> Range<Index> {
         let lower = index(from: startIndex, move: distances.lowerBound)
         return lower ..< index(from: lower, move: Offset<T>(distances.count))
     }
@@ -257,13 +257,13 @@ public extension Encoding {
 
     @inlinable @inline(__always) static func distance(
     from start: Snapshot.Index, to end: Snapshot.Index,
-    in collection: Snapshot) -> Offset<Self> {
+    in  collection: Snapshot) -> Offset<Self> {
         distance(from: start.character, to: end.character, in: collection.characters)
     }
 
     @inlinable static func index(
     from start: Snapshot.Index, move distance: Offset<Self>,
-    in collection: Snapshot) -> Snapshot.Index {
+    in  collection: Snapshot) -> Snapshot.Index {
         var character  = index(from: start.character, move: distance, in: collection.characters)
         if  character != collection.characters.endIndex {
             character  = collection.characters.rangeOfComposedCharacterSequence(at: character).lowerBound
@@ -288,13 +288,13 @@ public extension Character {
 
     @inlinable @inline(__always) static func distance(
     from start: String.Index, to end: String.Index,
-    in collection: some StringProtocol) -> Offset<Self> {
+    in  collection: some StringProtocol) -> Offset<Self> {
         Offset(collection.distance(from: start, to: end))
     }
 
     @inlinable @inline(__always) static func index(
     from start: String.Index, move distance: Offset<Self>,
-    in collection: some StringProtocol) -> String.Index {
+    in  collection: some StringProtocol) -> String.Index {
         collection.index(start, offsetBy: Int(distance))
     }
 
@@ -304,13 +304,13 @@ public extension Character {
 
     @inlinable @inline(__always) static func distance(
     from start: Snapshot.Index, to end: Snapshot.Index,
-    in collection: Snapshot) -> Offset<Self> {
+    in  collection: Snapshot) -> Offset<Self> {
         Offset(collection.distance(from: start, to: end))
     }
 
     @inlinable @inline(__always) static func index(
     from start: Snapshot.Index, move distance: Offset<Self>,
-    in collection: Snapshot) -> Snapshot.Index {
+    in  collection: Snapshot) -> Snapshot.Index {
         collection.index(start, offsetBy: Int(distance))
     }
 }
@@ -328,13 +328,13 @@ public extension Unicode.Scalar {
 
     @inlinable @inline(__always) static func distance(
     from start: String.Index, to end: String.Index,
-    in collection: some StringProtocol) -> Offset<Self> {
+    in  collection: some StringProtocol) -> Offset<Self> {
         Offset(collection.unicodeScalars.distance(from: start, to: end))
     }
 
     @inlinable @inline(__always) static func index(
     from start: String.Index, move distance: Offset<Self>,
-    in collection: some StringProtocol) -> String.Index {
+    in  collection: some StringProtocol) -> String.Index {
         collection.unicodeScalars.index(start, offsetBy: Int(distance))
     }
 }
@@ -352,13 +352,13 @@ public extension UTF16 {
 
     @inlinable @inline(__always) static func distance(
     from start: String.Index, to end: String.Index,
-    in collection: some StringProtocol) -> Offset<Self> {
+    in  collection: some StringProtocol) -> Offset<Self> {
         Offset(collection.utf16.distance(from: start, to: end))
     }
 
     @inlinable @inline(__always) static func index(
     from start: String.Index, move distance: Offset<Self>,
-    in collection: some StringProtocol) -> String.Index {
+    in  collection: some StringProtocol) -> String.Index {
         collection.utf16.index(start, offsetBy: Int(distance))
     }
 }
@@ -376,13 +376,13 @@ public extension UTF8 {
 
     @inlinable @inline(__always) static func distance(
     from start: String.Index, to end: String.Index,
-    in collection: some StringProtocol) -> Offset<Self> {
+    in  collection: some StringProtocol) -> Offset<Self> {
         Offset(collection.utf8.distance(from: start, to: end))
     }
 
     @inlinable @inline(__always) static func index(
     from start: String.Index, move distance: Offset<Self>,
-    in collection: some StringProtocol) -> String.Index {
+    in  collection: some StringProtocol) -> String.Index {
         collection.utf8.index(start, offsetBy: Int(distance))
     }
 }

Sources/DiffableTextKit/Models/Proposal.swift

@@ -20,18 +20,18 @@ public struct Proposal {
 
     public let base: Snapshot
     public var replacement: Snapshot
-    public var range: Range<Snapshot.Index>
+    public var range: Range<Index>
 
     //=------------------------------------------------------------------------=
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    @inlinable public init(_ base: Snapshot, with replacement: Snapshot, in range: Range<Snapshot.Index>) {
+    @inlinable public init(_ base: Snapshot, with replacement: Snapshot, in range: Range<Index>) {
         self.base = base; self.replacement = replacement; self.range = range
     }
 
     @inlinable public init<T>(_ base: Snapshot, with replacement: Snapshot, in range: Range<Offset<T>>) {
-        self.base = base; self.replacement = replacement; self.range = base.indices(at: range)
+        self.base = base; self.replacement = replacement; self.range = base.range(at: range)
     }
 
     //=------------------------------------------------------------------------=

Sources/DiffableTextKit/Models/Selection.swift

@@ -28,23 +28,23 @@ public struct Selection<Bound: Comparable>: CustomStringConvertible, Equatable {
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    @inlinable public init(unchecked:(lower: Bound, upper: Bound)) {
+    @inlinable public init(unchecked: (lower: Bound, upper: Bound)){
         (self.lower, self.upper) = unchecked; assert(lower <= upper)
     }
 
-    @inlinable public init(_ position: Bound) {
-        self.init(unchecked:(position, position))
+    @inlinable public init(_ bound: Bound){
+        self.init(unchecked:(bound, bound))
     }
 
-    @inlinable public init(_ positions: Range<Bound>) {
-        self.init(unchecked:(positions.lowerBound, positions.upperBound))
+    @inlinable public init(_ range: Range<Bound>) {
+        self.init(unchecked:(range.lowerBound, range.upperBound))
     }
 
     //=------------------------------------------------------------------------=
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    @inlinable public static func max<T>(_ collection: T) -> Self where T: Collection, T.Index == Bound {
+    @inlinable public static func max<T>(_ collection: T) -> Self where T: Collection, Bound == T.Index {
         Self(unchecked: (collection.startIndex, collection.endIndex))
     }
 
@@ -91,14 +91,14 @@ public struct Selection<Bound: Comparable>: CustomStringConvertible, Equatable {
     //=------------------------------------------------------------------------=
 
     @inlinable public func carets() -> Selection<Caret<Bound>> {
-        Selection<Caret>(unchecked: (.lower(lower), .upper(upper)))
+        Selection<Caret>(unchecked:(.lower(lower), .upper(upper)))
     }
 
     @inlinable public func detached() -> (lower: Bound, upper: Bound) {
         (lower, upper)
     }
 
-    @inlinable public func positions() -> Range<Bound> {
-        Range(uncheckedBounds: (lower, upper))
+    @inlinable public func range() -> Range<Bound> {
+        Range(uncheckedBounds:(lower, upper))
     }
 }

Sources/DiffableTextKit/Models/Snapshot.swift

@@ -335,9 +335,9 @@ extension Snapshot {
         //=--------------------------------------=
         // Inspect Initial Index
         //=--------------------------------------=
-        let positions = self.indices
+        let indices = self.indices
 
-        if let adjacent = positions.index(
+        if let adjacent = indices.index(
         from: caret.position,
         towards: caret.affinity,
         jumping: caret.affinity == .forwards ? .to : .through,
@@ -348,7 +348,7 @@ extension Snapshot {
         //=--------------------------------------=
         var direction = caret.momentum ?? caret.affinity
 
-        if let index = positions.index(
+        if let index = indices.index(
         from: caret.position,
         towards: direction,
         jumping: direction == caret.affinity ? .to : .through,
@@ -358,7 +358,7 @@ extension Snapshot {
         //=--------------------------------------=
         direction = direction.reversed()
 
-        if let index = positions.index(
+        if let index = indices.index(
         from: caret.position,
         towards: direction,
         jumping: Jump.to, // direction independent

Sources/DiffableTextKitXUIKit/Models/Downstream.swift

@@ -37,8 +37,8 @@ import UIKit
     }
 
     @inlinable var selection: Range<Offset> {
-        get { view.offsets(at: view.selectedTextRange!) }
-        set { view.selectedTextRange = view.positions(at: newValue) }
+        get { view.range(to: view.selectedTextRange!) /*-----*/ }
+        set { view.selectedTextRange = view.range(at: newValue) }
     }
 
     @inlinable var focus: Focus {

Sources/DiffableTextKitXUIKit/Support/UITextField.swift

@@ -24,23 +24,23 @@ extension UITextField {
     // MARK: Utilities
     //=------------------------------------------------------------------------=
 
-    @inlinable func offset(at position: UITextPosition) -> Offset {
+    @inlinable func distance(to position: UITextPosition) -> Offset {
         Offset(offset(from: beginningOfDocument, to: position))
     }
 
-    @inlinable func offsets(at positions: UITextRange) -> Range<Offset> {
-        let lower = offset(at:   positions.start)
+    @inlinable func range(to positions: UITextRange) -> Range<Offset> {
+        let lower = distance(to: positions.start)
         let count = offset(from: positions.start, to: positions.end)
         return lower ..< lower + Offset(count)
     }
 
-    @inlinable func position(at offset: Offset) -> UITextPosition {
-        position(from: beginningOfDocument, offset: Int(offset))!
+    @inlinable func position(at distance: Offset) -> UITextPosition {
+        position(from: beginningOfDocument, offset: Int(distance))!
     }
 
-    @inlinable func positions(at offsets: Range<Offset>) -> UITextRange {
-        let lower = position(at: offsets.lowerBound)
-        let upper = position(from: lower, offset: offsets.count)!
+    @inlinable func range(at distances: Range<Offset>) -> UITextRange {
+        let lower = position(at: distances.lowerBound)
+        let upper = position(from: lower, offset: distances.count)!
         return textRange(from: lower, to: upper)!
     }
 }

Tests/DiffableTextKitTests/Models/Selection.swift

@@ -65,7 +65,7 @@ final class SelectionTests: XCTestCase {
     //=------------------------------------------------------------------------=
 
     func testPositionsAreLowerToUpperAsRange() {
-        XCTAssertEqual(Selection(3 ..< 7).positions(), 3 ..< 7)
+        XCTAssertEqual(Selection(3 ..< 7).range(), 3 ..< 7)
     }
 
     func testbMapUpperLowerMapsBothWhenUnequal() {

Tests/DiffableTextKitTests/Models/Snapshot.swift

@@ -155,17 +155,17 @@ final class SnapshotTests: XCTestCase {
     //=------------------------------------------------------------------------=
 
     func testReplaceSubrangeWithSymbols() {
-        snapshot = Snapshot(repeating: " ", count: 4)
-        snapshot.replaceSubrange(snapshot.indices(at: C(0) ..< 2), with: Snapshot("AA", as: .content))
-        snapshot.replaceSubrange(snapshot.indices(at: C(2) ..< 4), with: Snapshot("BB", as: .phantom))
+        snapshot = Snapshot(repeating: " ",  count: 4)
+        snapshot.replaceSubrange(snapshot.range(at: C(0) ..< 2), with: Snapshot("AA", as: .content))
+        snapshot.replaceSubrange(snapshot.range(at: C(2) ..< 4), with: Snapshot("BB", as: .phantom))
 
         Assert("AABB", [.content, .content, .phantom, .phantom])
     }
 
     func testReplaceSubrangeWithCharacters() {
-        snapshot = Snapshot(repeating: " ", count: 4)
-        snapshot.replaceSubrange(snapshot.indices(at: C(0) ..< 2), with: "AA", as: .content)
-        snapshot.replaceSubrange(snapshot.indices(at: C(2) ..< 4), with: "BB", as: .phantom)
+        snapshot = Snapshot(repeating: " ",  count: 4)
+        snapshot.replaceSubrange(snapshot.range(at: C(0) ..< 2), with: "AA", as: .content)
+        snapshot.replaceSubrange(snapshot.range(at: C(2) ..< 4), with: "BB", as: .phantom)
 
         Assert("AABB", [.content, .content, .phantom, .phantom])
     }

Tests/DiffableTextKitTests/Styles/Prefix.swift

@@ -53,8 +53,8 @@ final class PrefixTextStyleTests: XCTestCase {
         let normal = Mock(selection: true)/*----------*/.interpret(characters)
         let prefix = Mock(selection: true).prefix("...").interpret(characters)
 
-        XCTAssertEqual(normal.selection!.positions(), normal.snapshot.indices(at: C(0) ..< 10))
-        XCTAssertEqual(prefix.selection!.positions(), prefix.snapshot.indices(at: C(3) ..< 13))
+        XCTAssertEqual(normal.selection!.range(), normal.snapshot.range(at: C(0) ..< 10))
+        XCTAssertEqual(prefix.selection!.range(), prefix.snapshot.range(at: C(3) ..< 13))
     }
 }