Cleanup. Renamed some dev stuff.

Author: oscbyspro

Sources/DiffableTextKit/DiffableTextStyle.swift

@@ -56,7 +56,7 @@ public protocol DiffableTextStyle: Equatable {
     /// - Thrown errors result in input cancellation.
     /// - Thrown errors have their descriptions printed in DEBUG mode.
     ///
-    @inlinable func merge(_ proposal: Proposal) throws -> Commit<Value>
+    @inlinable func resolve(_ proposal: Proposal) throws -> Commit<Value>
 }
 
 //=----------------------------------------------------------------------------=
@@ -110,20 +110,20 @@ extension DiffableTextStyleWrapper {
 
     @inlinable @inline(__always)
     public func format(_ value: Value) -> String
-    where Style.Value == Value {
+    where Value == Style.Value {
         style.format(value)
     }
 
     @inlinable @inline(__always)
     public func interpret(_ value: Value) -> Commit<Value>
-    where Style.Value == Value {
+    where Value == Style.Value {
         style.interpret(value)
     }
 
     @inlinable @inline(__always)
-    public func merge(_ proposal: Proposal) throws -> Commit<Value>
-    where Style.Value == Value {
-        try style.merge(proposal)
+    public func resolve(_ proposal: Proposal) throws -> Commit<Value>
+    where Value == Style.Value {
+        try style.resolve(proposal)
     }
 
     //=------------------------------------------------------------------------=

Sources/DiffableTextKit/Helpers/Carets.swift

@@ -16,69 +16,75 @@
 /// An instance with equal bounds represents a single upper caret.
 /// This distinction matters for transformations such as map(lower:upper:).
 ///
-@usableFromInline struct Carets<Bound: Comparable>: Equatable {
+@usableFromInline struct Carets<Caret: Comparable>: Equatable {
 
     //=------------------------------------------------------------------------=
     // MARK: State
     //=------------------------------------------------------------------------=
 
-    @usableFromInline let range: Range<Bound>
+    @usableFromInline let range: Range<Caret>
 
     //=------------------------------------------------------------------------=
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    @inlinable init(_ range: Range<Bound>) {
+    @inlinable init(_ range: Range<Caret>) {
         self.range  = range
     }
 
-    @inlinable init(_ bound: Bound) {
+    @inlinable init(_ bound: Caret) {
         self.init(Range(uncheckedBounds: (bound, bound)))
     }
 
-    @inlinable static func unchecked(_ bounds: (lower: Bound, upper: Bound)) -> Self {
+    @inlinable static func unchecked(_ bounds: (Caret, Caret)) -> Self {
         Self.init(Range(uncheckedBounds: bounds))
     }
 
     //=------------------------------------------------------------------------=
     // MARK: Accessors
     //=------------------------------------------------------------------------=
 
-    @inlinable var lowerBound: Bound {
+    @inlinable var lower: Caret {
         range.lowerBound
     }
 
-    @inlinable var upperBound: Bound {
+    @inlinable var upper: Caret {
         range.upperBound
     }
 
     //=------------------------------------------------------------------------=
     // MARK: Transformations
     //=------------------------------------------------------------------------=
 
-    @inlinable func map<T>(caret: (Bound) -> T) -> Carets<T> {
+    @inlinable mutating func collapse() {
+        self = Self(upper)
+    }
+    
+    //=------------------------------------------------------------------------=
+    // MARK: Transformations
+    //=------------------------------------------------------------------------=
+    
+    @inlinable func map<T>(caret: (Caret) -> T) -> Carets<T> {
         //=--------------------------------------=
         // Return
         //=--------------------------------------=
         self.map(lower: caret, upper: caret)
     }
 
-    @inlinable func map<T>(lower: (Bound) -> T, upper: (Bound) -> T) -> Carets<T> {
+    @inlinable func map<T>(lower: (Caret) -> T, upper: (Caret) -> T) -> Carets<T> {
         //=--------------------------------------=
         // Single
         //=--------------------------------------=
-        let upperBound = upper(range.upperBound)
-        var lowerBound = upperBound
+        let max = upper(self.upper); var min = max
         //=--------------------------------------=
         // Double
         //=--------------------------------------=
         if !range.isEmpty {
-            lowerBound = lower(range.lowerBound)
-            lowerBound = Swift.min(lowerBound, upperBound)
+            min = Swift.min(lower(self.lower), max)
         }
         //=--------------------------------------=
         // Return
         //=--------------------------------------=
-        return .unchecked((lowerBound, upperBound))
+        return .unchecked((min, max))
     }
 }

Sources/DiffableTextKit/Helpers/Directions.swift

@@ -36,7 +36,7 @@
     }
 
     @inlinable init<T>(from start: Carets<T>, to end: Carets<T>) {
-        self.lower = Direction(start.lowerBound, to: end.lowerBound)
-        self.upper = Direction(start.upperBound, to: end.upperBound)
+        self.lower = Direction(from: start.lower, to: end.lower)
+        self.upper = Direction(from: start.upper, to: end.upper)
     }
 }

Sources/DiffableTextKit/Models/Changes.swift

@@ -11,7 +11,7 @@
 // MARK: Declaration
 //*============================================================================*
 
-/// Used to store state comparison results in order to avoid multiple comparisons.
+/// A model used to capture comparison results.
 public struct Changes: OptionSet {
 
     //=------------------------------------------------------------------------=

Sources/DiffableTextKit/Models/Context.swift

@@ -163,27 +163,42 @@ public extension Context {
 // MARK: Transformations
 //=----------------------------------------------------------------------------=
 
-public extension Context {
+extension Context {
 
     //=------------------------------------------------------------------------=
     // MARK: Context
     //=------------------------------------------------------------------------=
 
-    @inlinable internal mutating func merge(_ other: Self) {
+    @inlinable mutating func merge(_ other: Self) {
         //=--------------------------------------=
-        // Focused
+        // Active
         //=--------------------------------------=
         if other.focus == true {
             self.write {
                 $0.status = other.status
                 $0.layout.merge(snapshot: other.snapshot)
             }
         //=--------------------------------------=
-        // Unfocused
+        // Inactive
         //=--------------------------------------=
         } else { self = other }
     }
 
+    //=------------------------------------------------------------------------=
+    // MARK: Selection
+    //=------------------------------------------------------------------------=
+    
+    @inlinable mutating func collapse() {
+        self.write({ $0.layout.selection.collapse() })
+    }
+}
+
+//=----------------------------------------------------------------------------=
+// MARK: Transformations
+//=----------------------------------------------------------------------------=
+
+public extension Context {
+    
     //=------------------------------------------------------------------------=
     // MARK: Status
     //=------------------------------------------------------------------------=
@@ -201,7 +216,7 @@ public extension Context {
         //=--------------------------------------=
         // Update
         //=--------------------------------------=
-        self.merge(Self.init(next))
+        self.merge(Self(next))
         //=--------------------------------------=
         // Return
         //=--------------------------------------=
@@ -218,13 +233,13 @@ public extension Context {
         //=--------------------------------------=
         // Values
         //=--------------------------------------=
-        let carets = layout.indices(at: Carets(range))
-        let commit = try style.merge(Proposal(
-        snapshot, with: characters, in: carets.range))
+        let commit = try style.resolve(Proposal(
+        update:  snapshot, with: characters, in:
+        layout.indices(at: Carets(range)).range))
         //=--------------------------------------=
         // Update
         //=--------------------------------------=
-        self.set(selection: carets.upperBound)
+        self.collapse()
         self.merge(Self.focused(style, commit))
         //=--------------------------------------=
         // Return
@@ -236,12 +251,20 @@ public extension Context {
     // MARK: Selection
     //=------------------------------------------------------------------------=
 
-    @inlinable internal mutating func set(selection: Index) {
-        self.write({ $0.layout.selection = Carets(selection) })
-    }
-    
-    @inlinable mutating func merge<T>(selection: Range<T.Position>, momentums: Bool) -> Update where T: Offset {
-        self.write({ $0.layout .merge(selection: Carets(selection), momentums: momentums) })
-        return Update.selection(selection != self.selection())
+    @inlinable mutating func merge<T>(
+    selection: Range<T.Position>,
+    momentums: Bool) -> Update where T: Offset {
+        //=--------------------------------------=
+        // Update
+        //=--------------------------------------=
+        self.write {
+            $0.layout.merge(
+            selection: Carets(selection),
+            momentums: momentums)
+        }
+        //=--------------------------------------=
+        // Return
+        //=--------------------------------------=
+        return .selection(selection != self.selection())
     }
 }

Sources/DiffableTextKit/Models/Direction.swift

@@ -25,7 +25,7 @@
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    @inlinable public init?<T>(_ start: T, to end: T) where T: Comparable {
+    @inlinable public init?<T>(from start: T, to end: T) where T: Comparable {
         if      start < end { self =  .forwards }
         else if start > end { self = .backwards }
         else { return   nil }

Sources/DiffableTextKit/Models/Position.swift

@@ -43,22 +43,3 @@ public struct Position<Offset: DiffableTextKit.Offset>: Comparable {
         lhs.offset <  rhs.offset
     }
 }
-
-//*============================================================================*
-// MARK: Range
-//*============================================================================*
-
-public extension Range {
-    
-    //=------------------------------------------------------------------------=
-    // MARK: Initializers
-    //=------------------------------------------------------------------------=
-    
-    @inlinable init<T>(nsrange: NSRange,
-    as position: Position<T>.Type = Position<T>.self)
-    where T: Offset, Bound == Position<T> {
-        self.init(uncheckedBounds: (
-        Position(nsrange.lowerBound),
-        Position(nsrange.upperBound)))
-    }
-}

Sources/DiffableTextKit/Models/Proposal.swift

@@ -26,10 +26,8 @@ public struct Proposal {
     // MARK: Initializers
     //=------------------------------------------------------------------------=
 
-    @inlinable init(_ snapshot: Snapshot, with characters: String, in range: Range<Index>) {
-        self.snapshot = snapshot
-        self.replacement = Snapshot(characters, as: .content)
-        self.range = range
+    @inlinable init(update snapshot: Snapshot, with characters: String, in range: Range<Index>) {
+        self.snapshot = snapshot; self.replacement = Snapshot(characters); self.range = range
     }
 
     //=------------------------------------------------------------------------=
@@ -38,8 +36,6 @@ public struct Proposal {
 
     /// Returns a new snapshot with the proposed change applied to it.
     @inlinable public func merged() -> Snapshot {
-        var result = snapshot
-        result.replaceSubrange(range, with: replacement)
-        return result
+        var result = snapshot; result.replaceSubrange(range, with: replacement); return result
     }
 }

Sources/DiffableTextKit/Models/Snapshot.swift

@@ -18,10 +18,9 @@
 /// |x|o|o|o|x|o|o|o|o|o|o|o|x|x|x|x|~
 /// ```
 ///
-/// Set the anchor to force selection of the caret represented by its index. This is required
-/// when a snapshot contains only formatting characters, and you want the caret to appear
-/// at a location. As an example, a pattern style bound to an enmpty value may want to set
-/// the anchor at the index of the first placeholder character.
+/// Set the anchor to select the caret represented by its index. This may be done
+/// on snapshots containing only formatting characters. As an example, a pattern text style
+/// that is bound to an empty value may anchor at the first placeholder character.
 ///
 public struct Snapshot: BidirectionalCollection, RangeReplaceableCollection {
     @usableFromInline typealias Target = (Index) -> Bool
@@ -47,19 +46,19 @@ public struct Snapshot: BidirectionalCollection, RangeReplaceableCollection {
     // MARK: Initializers: Attribute
     //=------------------------------------------------------------------------=
 
-    @inlinable public init(_ characters: String, as attribute: Attribute) {
+    @inlinable public init(_ characters: String, as attribute: Attribute = []) {
         self._characters = characters
         self._attributes = Array(repeating: attribute, count: characters.count)
     }
 
-    @inlinable public init<C>(_ characters: C, as attribute: Attribute) where
-    C: RandomAccessCollection, C.Element == Character {
+    @inlinable public init<C>(_ characters: C, as attribute: Attribute = [])
+    where C: RandomAccessCollection, C.Element == Character {
         self._characters = String(characters)
         self._attributes = Array(repeating: attribute, count: characters.count)
     }
 
-    @inlinable public init<S>(_ characters: S, as attribute: Attribute) where
-    S: Sequence, S.Element == Character { self.init()
+    @inlinable public init<S>(_ characters: S, as attribute: Attribute = [])
+    where S: Sequence, S.Element == Character { self.init()
         for character in characters {
             self._characters.append(character)
             self._attributes.append(attribute)

Sources/DiffableTextKit/Models/Status.swift

@@ -38,34 +38,34 @@ public struct Status<Style: DiffableTextStyle> {
     //=------------------------------------------------------------------------=
 
     @inlinable public mutating func merge(_ other: Self) -> Changes {
-        let update = (self .!= other)
+        let changes = (self .!= other)
         //=--------------------------------------=
         // Update
         //=--------------------------------------=
-        if update.contains(.style) { self.style = other.style }
-        if update.contains(.value) { self.value = other.value }
-        if update.contains(.focus) { self.focus = other.focus }
+        if changes.contains(.style) { self.style = other.style }
+        if changes.contains(.value) { self.value = other.value }
+        if changes.contains(.focus) { self.focus = other.focus }
         //=--------------------------------------=
         // Return
         //=--------------------------------------=
-        return update
+        return changes
     }
 
     //=------------------------------------------------------------------------=
     // MARK: Utilities
     //=------------------------------------------------------------------------=
 
     @inlinable static func .!= (lhs: Self, rhs: Self) -> Changes {
-        var update = Changes()
+        var changes = Changes()
         //=--------------------------------------=
         // Compare
         //=--------------------------------------=
-        if lhs.style != rhs.style { update.formUnion(.style) }
-        if lhs.value != rhs.value { update.formUnion(.value) }
-        if lhs.focus != rhs.focus { update.formUnion(.focus) }
+        if lhs.style != rhs.style { changes.formUnion(.style) }
+        if lhs.value != rhs.value { changes.formUnion(.value) }
+        if lhs.focus != rhs.focus { changes.formUnion(.focus) }
         //=--------------------------------------=
         // Return
         //=--------------------------------------=
-        return update
+        return changes
     }
 }