Change property wrappers to intuitive names (#82)

DevYeom · web-flow · commit bc687d5f5d21 · 2024-06-01T12:55:05.000+09:00
diff --git a/README.md b/README.md
@@ -148,11 +148,11 @@ for await number in store.states.number {
 // Prints "10", "20"
 ```
 
-If you want to continue receiving the value even when the same value is assigned to the `State`, you can use `@Sensitive`. For explanations of other useful property wrappers(e.g. [@CopyOnWrite](https://swiftpackageindex.com/devyeom/oneway/main/documentation/oneway/copyonwrite), [@Insensitive](https://swiftpackageindex.com/devyeom/oneway/main/documentation/oneway/insensitive)), refer to [here](https://swiftpackageindex.com/devyeom/oneway/main/documentation/oneway/sensitive).
+If you want to continue receiving the value even when the same value is assigned to the `State`, you can use `@Triggered`. For explanations of other useful property wrappers(e.g. [@CopyOnWrite](https://swiftpackageindex.com/devyeom/oneway/main/documentation/oneway/copyonwrite), [@Ignored](https://swiftpackageindex.com/devyeom/oneway/main/documentation/oneway/ignored)), refer to [here](https://swiftpackageindex.com/devyeom/oneway/main/documentation/oneway/triggered).
 
 ```swift
 struct State: Sendable, Equatable {
-    @Sensitive var number: Int
+    @Triggered var number: Int
 }
 
 // number <- 10, 10, 20 ,20
diff --git a/Sources/OneWay/OneWay.docc/OneWay.md b/Sources/OneWay/OneWay.docc/OneWay.md
@@ -78,7 +78,7 @@ OneWay is released under the MIT license. See LICENSE for details.
 ### PropertyWrappers
 
 - ``CopyOnWrite``
-- ``Insensitive``
-- ``Sensitive``
+- ``Ignored``
+- ``Triggered``
 
 ### Articles
diff --git a/Sources/OneWay/PropertyWrappers/Ignored.swift b/Sources/OneWay/PropertyWrappers/Ignored.swift
@@ -11,28 +11,31 @@
 /// useful when the actual value of the `State` changes, but rendering of the `View` is not
 /// required.
 @propertyWrapper
-public struct Insensitive<Value> {
+public struct Ignored<Value> {
     public var wrappedValue: Value
 
     public init(wrappedValue: Value) {
         self.wrappedValue = wrappedValue
     }
 }
 
-extension Insensitive: CustomStringConvertible {
+extension Ignored: CustomStringConvertible {
     public var description: String {
         String(describing: wrappedValue)
     }
 }
 
-extension Insensitive: Sendable where Value: Sendable { }
-extension Insensitive: Equatable {
-    public static func == (lhs: Insensitive, rhs: Insensitive) -> Bool {
+extension Ignored: Sendable where Value: Sendable { }
+extension Ignored: Equatable {
+    public static func == (lhs: Ignored, rhs: Ignored) -> Bool {
         true
     }
 }
-extension Insensitive: Hashable where Value: Hashable {
+extension Ignored: Hashable where Value: Hashable {
     public func hash(into hasher: inout Hasher) {
         hasher.combine(wrappedValue)
     }
 }
+
+@available(*, deprecated, renamed: "Ignored")
+public typealias Insensitive = Ignored
diff --git a/Sources/OneWay/PropertyWrappers/Triggered.swift b/Sources/OneWay/PropertyWrappers/Triggered.swift
@@ -12,7 +12,7 @@
 /// It is useful in cases where the value hasn't actually changed, but the `View` needs to be
 /// rendered again.
 @propertyWrapper
-public struct Sensitive<Value> where Value: Equatable {
+public struct Triggered<Value> where Value: Equatable {
     fileprivate struct Storage: Equatable {
         var value: Value
         var version: UInt8
@@ -44,24 +44,27 @@ public struct Sensitive<Value> where Value: Equatable {
     }
 }
 
-extension Sensitive: CustomStringConvertible {
+extension Triggered: CustomStringConvertible {
     public var description: String {
         String(describing: storage.value)
     }
 }
 
-extension Sensitive: Sendable where Value: Sendable { }
-extension Sensitive: Equatable { }
-extension Sensitive: Hashable where Value: Hashable {
+extension Triggered: Sendable where Value: Sendable { }
+extension Triggered: Equatable { }
+extension Triggered: Hashable where Value: Hashable {
     public func hash(into hasher: inout Hasher) {
         hasher.combine(storage)
     }
 }
 
-extension Sensitive.Storage: Sendable where Value: Sendable { }
-extension Sensitive.Storage: Hashable where Value: Hashable {
+extension Triggered.Storage: Sendable where Value: Sendable { }
+extension Triggered.Storage: Hashable where Value: Hashable {
     fileprivate func hash(into hasher: inout Hasher) {
         hasher.combine(value)
         hasher.combine(version)
     }
 }
+
+@available(*, deprecated, renamed: "Triggered")
+public typealias Sensitive = Triggered
diff --git a/Tests/OneWayTests/PropertyWrappersTests.swift b/Tests/OneWayTests/PropertyWrappersTests.swift
@@ -52,9 +52,9 @@ final class PropertyWrappersTests: XCTestCase {
         }
     }
 
-    func test_sensitive() {
+    func test_triggered() {
         struct Storage: Equatable {
-            @Sensitive var value: Int
+            @Triggered var value: Int
         }
 
         do {
@@ -83,9 +83,9 @@ final class PropertyWrappersTests: XCTestCase {
         }
     }
 
-    func test_insensitive() {
+    func test_ignored() {
         struct Storage: Equatable {
-            @Insensitive var value: Int
+            @Ignored var value: Int
         }
 
         do {
diff --git a/Tests/OneWayTests/ViewStoreTests.swift b/Tests/OneWayTests/ViewStoreTests.swift
@@ -45,15 +45,15 @@ final class ViewStoreTests: XCTestCase {
         await sendableExpect { await sut.state.count == 4 }
     }
 
-    func test_sensitiveState() async {
+    func test_triggeredState() async {
         actor Result {
             var counts: [Int] = []
-            var sensitiveCounts: [Int] = []
+            var triggeredCounts: [Int] = []
             func appendCount(_ count: Int) {
                 counts.append(count)
             }
-            func appendSensitiveCount(_ count: Int) {
-                sensitiveCounts.append(count)
+            func appendTriggeredCount(_ count: Int) {
+                triggeredCounts.append(count)
             }
         }
         let result = Result()
@@ -64,28 +64,28 @@ final class ViewStoreTests: XCTestCase {
             }
         }
         Task { @MainActor in
-            for await sensitiveCount in sut.states.sensitiveCount {
-                await result.appendSensitiveCount(sensitiveCount)
+            for await triggeredCount in sut.states.triggeredCount {
+                await result.appendTriggeredCount(triggeredCount)
             }
         }
 
-        sut.send(.setSensitiveCount(10))
-        sut.send(.setSensitiveCount(10))
-        sut.send(.setSensitiveCount(10))
+        sut.send(.setTriggeredCount(10))
+        sut.send(.setTriggeredCount(10))
+        sut.send(.setTriggeredCount(10))
 
         await sendableExpect { await result.counts == [0, 0, 0, 0] }
-        await sendableExpect { await result.sensitiveCounts == [0, 10, 10, 10] }
+        await sendableExpect { await result.triggeredCounts == [0, 10, 10, 10] }
     }
 
-    func test_insensitiveState() async {
+    func test_ignoredState() async {
         actor Result {
             var counts: [Int] = []
-            var insensitiveCounts: [Int] = []
+            var ignoredCounts: [Int] = []
             func appendCount(_ count: Int) {
                 counts.append(count)
             }
-            func appendInsensitiveCount(_ count: Int) {
-                insensitiveCounts.append(count)
+            func appendIgnoredCount(_ count: Int) {
+                ignoredCounts.append(count)
             }
         }
         let result = Result()
@@ -96,18 +96,18 @@ final class ViewStoreTests: XCTestCase {
             }
         }
         Task { @MainActor in
-            for await insensitiveCount in sut.states.insensitiveCount {
-                await result.appendInsensitiveCount(insensitiveCount)
+            for await ignoredCount in sut.states.ignoredCount {
+                await result.appendIgnoredCount(ignoredCount)
             }
         }
 
-        sut.send(.setInsensitiveCount(10))
-        sut.send(.setInsensitiveCount(20))
-        sut.send(.setInsensitiveCount(30))
+        sut.send(.setIgnoredCount(10))
+        sut.send(.setIgnoredCount(20))
+        sut.send(.setIgnoredCount(30))
 
         // only initial value
         await sendableExpect { await result.counts == [0] }
-        await sendableExpect { await result.insensitiveCounts == [0] }
+        await sendableExpect { await result.ignoredCounts == [0] }
     }
 
     func test_asyncViewStateSequence() async {
@@ -179,14 +179,14 @@ private struct TestReducer: Reducer {
         case twice
         case concat
         case setCount(Int)
-        case setSensitiveCount(Int)
-        case setInsensitiveCount(Int)
+        case setTriggeredCount(Int)
+        case setIgnoredCount(Int)
     }
 
     struct State: Equatable {
         var count: Int
-        @Sensitive var sensitiveCount: Int = 0
-        @Insensitive var insensitiveCount: Int = 0
+        @Triggered var triggeredCount: Int = 0
+        @Ignored var ignoredCount: Int = 0
     }
 
     func reduce(state: inout State, action: Action) -> AnyEffect<Action> {
@@ -213,12 +213,12 @@ private struct TestReducer: Reducer {
             state.count = count
             return .none
 
-        case .setSensitiveCount(let count):
-            state.sensitiveCount = count
+        case .setTriggeredCount(let count):
+            state.triggeredCount = count
             return .none
 
-        case .setInsensitiveCount(let count):
-            state.insensitiveCount = count
+        case .setIgnoredCount(let count):
+            state.ignoredCount = count
             return .none
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -11,28 +11,31 @@`
`11`	`11`	/// useful when the actual value of the `State` changes, but rendering of the `View` is not
`12`	`12`	`/// required.`
`13`	`13`	`@propertyWrapper`
`14`		`-public struct Insensitive<Value> {`
	`14`	`+public struct Ignored<Value> {`
`15`	`15`	`public var wrappedValue: Value`
`16`	`16`
`17`	`17`	`public init(wrappedValue: Value) {`
`18`	`18`	`self.wrappedValue = wrappedValue`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`-extension Insensitive: CustomStringConvertible {`
	`22`	`+extension Ignored: CustomStringConvertible {`
`23`	`23`	`public var description: String {`
`24`	`24`	`String(describing: wrappedValue)`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`-extension Insensitive: Sendable where Value: Sendable { }`
`29`		`-extension Insensitive: Equatable {`
`30`		`- public static func == (lhs: Insensitive, rhs: Insensitive) -> Bool {`
	`28`	`+extension Ignored: Sendable where Value: Sendable { }`
	`29`	`+extension Ignored: Equatable {`
	`30`	`+ public static func == (lhs: Ignored, rhs: Ignored) -> Bool {`
`31`	`31`	`true`
`32`	`32`	`}`
`33`	`33`	`}`
`34`		`-extension Insensitive: Hashable where Value: Hashable {`
	`34`	`+extension Ignored: Hashable where Value: Hashable {`
`35`	`35`	`public func hash(into hasher: inout Hasher) {`
`36`	`36`	`hasher.combine(wrappedValue)`
`37`	`37`	`}`
`38`	`38`	`}`
	`39`	`+`
	`40`	`+@available(*, deprecated, renamed: "Ignored")`
	`41`	`+public typealias Insensitive = Ignored`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	/// It is useful in cases where the value hasn't actually changed, but the `View` needs to be
`13`	`13`	`/// rendered again.`
`14`	`14`	`@propertyWrapper`
`15`		`-public struct Sensitive<Value> where Value: Equatable {`
	`15`	`+public struct Triggered<Value> where Value: Equatable {`
`16`	`16`	`fileprivate struct Storage: Equatable {`
`17`	`17`	`var value: Value`
`18`	`18`	`var version: UInt8`
`@@ -44,24 +44,27 @@ public struct Sensitive<Value> where Value: Equatable {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`-extension Sensitive: CustomStringConvertible {`
	`47`	`+extension Triggered: CustomStringConvertible {`
`48`	`48`	`public var description: String {`
`49`	`49`	`String(describing: storage.value)`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`		`-extension Sensitive: Sendable where Value: Sendable { }`
`54`		`-extension Sensitive: Equatable { }`
`55`		`-extension Sensitive: Hashable where Value: Hashable {`
	`53`	`+extension Triggered: Sendable where Value: Sendable { }`
	`54`	`+extension Triggered: Equatable { }`
	`55`	`+extension Triggered: Hashable where Value: Hashable {`
`56`	`56`	`public func hash(into hasher: inout Hasher) {`
`57`	`57`	`hasher.combine(storage)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`		`-extension Sensitive.Storage: Sendable where Value: Sendable { }`
`62`		`-extension Sensitive.Storage: Hashable where Value: Hashable {`
	`61`	`+extension Triggered.Storage: Sendable where Value: Sendable { }`
	`62`	`+extension Triggered.Storage: Hashable where Value: Hashable {`
`63`	`63`	`fileprivate func hash(into hasher: inout Hasher) {`
`64`	`64`	`hasher.combine(value)`
`65`	`65`	`hasher.combine(version)`
`66`	`66`	`}`
`67`	`67`	`}`
	`68`	`+`
	`69`	`+@available(*, deprecated, renamed: "Triggered")`
	`70`	`+public typealias Sensitive = Triggered`
Original file line number	Diff line number	Diff line change
`@@ -52,9 +52,9 @@ final class PropertyWrappersTests: XCTestCase {`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- func test_sensitive() {`
	`55`	`+ func test_triggered() {`
`56`	`56`	`struct Storage: Equatable {`
`57`		`- @Sensitive var value: Int`
	`57`	`+ @Triggered var value: Int`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`do {`
`@@ -83,9 +83,9 @@ final class PropertyWrappersTests: XCTestCase {`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`- func test_insensitive() {`
	`86`	`+ func test_ignored() {`
`87`	`87`	`struct Storage: Equatable {`
`88`		`- @Insensitive var value: Int`
	`88`	`+ @Ignored var value: Int`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`do {`
Original file line number	Diff line number	Diff line change
`@@ -45,15 +45,15 @@ final class ViewStoreTests: XCTestCase {`
`45`	`45`	`await sendableExpect { await sut.state.count == 4 }`
`46`	`46`	`}`
`47`	`47`
`48`		`- func test_sensitiveState() async {`
	`48`	`+ func test_triggeredState() async {`
`49`	`49`	`actor Result {`
`50`	`50`	`var counts: [Int] = []`
`51`		`- var sensitiveCounts: [Int] = []`
	`51`	`+ var triggeredCounts: [Int] = []`
`52`	`52`	`func appendCount(_ count: Int) {`
`53`	`53`	`counts.append(count)`
`54`	`54`	`}`
`55`		`- func appendSensitiveCount(_ count: Int) {`
`56`		`- sensitiveCounts.append(count)`
	`55`	`+ func appendTriggeredCount(_ count: Int) {`
	`56`	`+ triggeredCounts.append(count)`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`	`let result = Result()`
`@@ -64,28 +64,28 @@ final class ViewStoreTests: XCTestCase {`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`Task { @MainActor in`
`67`		`- for await sensitiveCount in sut.states.sensitiveCount {`
`68`		`- await result.appendSensitiveCount(sensitiveCount)`
	`67`	`+ for await triggeredCount in sut.states.triggeredCount {`
	`68`	`+ await result.appendTriggeredCount(triggeredCount)`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`- sut.send(.setSensitiveCount(10))`
`73`		`- sut.send(.setSensitiveCount(10))`
`74`		`- sut.send(.setSensitiveCount(10))`
	`72`	`+ sut.send(.setTriggeredCount(10))`
	`73`	`+ sut.send(.setTriggeredCount(10))`
	`74`	`+ sut.send(.setTriggeredCount(10))`
`75`	`75`
`76`	`76`	`await sendableExpect { await result.counts == [0, 0, 0, 0] }`
`77`		`- await sendableExpect { await result.sensitiveCounts == [0, 10, 10, 10] }`
	`77`	`+ await sendableExpect { await result.triggeredCounts == [0, 10, 10, 10] }`
`78`	`78`	`}`
`79`	`79`
`80`		`- func test_insensitiveState() async {`
	`80`	`+ func test_ignoredState() async {`
`81`	`81`	`actor Result {`
`82`	`82`	`var counts: [Int] = []`
`83`		`- var insensitiveCounts: [Int] = []`
	`83`	`+ var ignoredCounts: [Int] = []`
`84`	`84`	`func appendCount(_ count: Int) {`
`85`	`85`	`counts.append(count)`
`86`	`86`	`}`
`87`		`- func appendInsensitiveCount(_ count: Int) {`
`88`		`- insensitiveCounts.append(count)`
	`87`	`+ func appendIgnoredCount(_ count: Int) {`
	`88`	`+ ignoredCounts.append(count)`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`let result = Result()`
`@@ -96,18 +96,18 @@ final class ViewStoreTests: XCTestCase {`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`Task { @MainActor in`
`99`		`- for await insensitiveCount in sut.states.insensitiveCount {`
`100`		`- await result.appendInsensitiveCount(insensitiveCount)`
	`99`	`+ for await ignoredCount in sut.states.ignoredCount {`
	`100`	`+ await result.appendIgnoredCount(ignoredCount)`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`- sut.send(.setInsensitiveCount(10))`
`105`		`- sut.send(.setInsensitiveCount(20))`
`106`		`- sut.send(.setInsensitiveCount(30))`
	`104`	`+ sut.send(.setIgnoredCount(10))`
	`105`	`+ sut.send(.setIgnoredCount(20))`
	`106`	`+ sut.send(.setIgnoredCount(30))`
`107`	`107`
`108`	`108`	`// only initial value`
`109`	`109`	`await sendableExpect { await result.counts == [0] }`
`110`		`- await sendableExpect { await result.insensitiveCounts == [0] }`
	`110`	`+ await sendableExpect { await result.ignoredCounts == [0] }`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`func test_asyncViewStateSequence() async {`
`@@ -179,14 +179,14 @@ private struct TestReducer: Reducer {`
`179`	`179`	`case twice`
`180`	`180`	`case concat`
`181`	`181`	`case setCount(Int)`
`182`		`- case setSensitiveCount(Int)`
`183`		`- case setInsensitiveCount(Int)`
	`182`	`+ case setTriggeredCount(Int)`
	`183`	`+ case setIgnoredCount(Int)`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`struct State: Equatable {`
`187`	`187`	`var count: Int`
`188`		`- @Sensitive var sensitiveCount: Int = 0`
`189`		`- @Insensitive var insensitiveCount: Int = 0`
	`188`	`+ @Triggered var triggeredCount: Int = 0`
	`189`	`+ @Ignored var ignoredCount: Int = 0`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`func reduce(state: inout State, action: Action) -> AnyEffect<Action> {`
`@@ -213,12 +213,12 @@ private struct TestReducer: Reducer {`
`213`	`213`	`state.count = count`
`214`	`214`	`return .none`
`215`	`215`
`216`		`- case .setSensitiveCount(let count):`
`217`		`- state.sensitiveCount = count`
	`216`	`+ case .setTriggeredCount(let count):`
	`217`	`+ state.triggeredCount = count`
`218`	`218`	`return .none`
`219`	`219`
`220`		`- case .setInsensitiveCount(let count):`
`221`		`- state.insensitiveCount = count`
	`220`	`+ case .setIgnoredCount(let count):`
	`221`	`+ state.ignoredCount = count`
`222`	`222`	`return .none`
`223`	`223`	`}`
`224`	`224`	`}`