Merge pull request #93 from unsignedapps/feature/flagvaluedictionary-boxed

Changed `FlagValueDictionary` to use `[String: BoxedFlagValue]` as its internal storage

Author: bok-

Sources/Vexil/Sources/FlagValueDictionary+FlagValueSource.swift

@@ -16,12 +16,15 @@ extension FlagValueDictionary: FlagValueSource {
     }
 
     public func flagValue<Value>(key: String) -> Value? where Value: FlagValue {
-        return self.storage[key] as? Value
+        guard let value = self.storage[key] else {
+            return nil
+        }
+        return Value(boxedFlagValue: value)
     }
 
     public func setFlagValue<Value>(_ value: Value?, key: String) throws where Value: FlagValue {
         if let value = value {
-            self.storage.updateValue(value, forKey: key)
+            self.storage.updateValue(value.boxedFlagValue, forKey: key)
         } else {
             self.storage.removeValue(forKey: key)
         }

Sources/Vexil/Sources/FlagValueDictionary.swift

@@ -22,7 +22,7 @@ open class FlagValueDictionary: Identifiable, ExpressibleByDictionaryLiteral {
     public let id = UUID()
 
     /// Our internal dictionary type
-    public typealias DictionaryType = [String: Any]
+    public typealias DictionaryType = [String: BoxedFlagValue]
 
     internal var storage: DictionaryType
 
@@ -41,7 +41,7 @@ open class FlagValueDictionary: Identifiable, ExpressibleByDictionaryLiteral {
 
     /// Initialises a `FlagValueDictionary` using a dictionary literal
     ///
-    public required init(dictionaryLiteral elements: (String, Any)...) {
+    public required init(dictionaryLiteral elements: (String, BoxedFlagValue)...) {
         self.storage = elements.reduce(into: [:]) { dict, pair in
             dict.updateValue(pair.1, forKey: pair.0)
         }

Tests/VexilTests/EquatableTests.swift

@@ -93,11 +93,11 @@ final class EquatableTests: XCTestCase {
             }
 
         // WHEN we emit, then change some values and emit more
-        dictionary["untracked-key"] = true                              // 1
-        dictionary["top-level-flag"] = true                             // 2
-        dictionary["second-test-flag"] = true                           // 3
-        dictionary["subgroup.second-level-flag"] = true                 // 4
-        dictionary["subgroup.double-subgroup.third-level-flag"] = true  // 5
+        dictionary["untracked-key"] = .bool(true)                              // 1
+        dictionary["top-level-flag"] = .bool(true)                             // 2
+        dictionary["second-test-flag"] = .bool(true)                           // 3
+        dictionary["subgroup.second-level-flag"] = .bool(true)                 // 4
+        dictionary["subgroup.double-subgroup.third-level-flag"] = .bool(true)  // 5
 
         // THEN we should have 6 snapshots of varying equatability
         wait(for: [ expectation ], timeout: 0.1)

Tests/VexilTests/FlagValueDictionaryTests.swift

@@ -14,7 +14,7 @@ final class FlagValueDictionaryTests: XCTestCase {
 
     func testReadsValues () {
         let source: FlagValueDictionary = [
-            "top-level-flag": true
+            "top-level-flag": .bool(true)
         ]
 
         let flagPole = FlagPole(hoist: TestFlags.self, sources: [ source ])
@@ -35,8 +35,8 @@ final class FlagValueDictionaryTests: XCTestCase {
             snapshot.oneFlagGroup.secondLevelFlag = false
             try flagPole.save(snapshot: snapshot, to: source)
 
-            XCTAssertEqual(source.storage["top-level-flag"] as? Bool, true)
-            XCTAssertEqual(source.storage["one-flag-group.second-level-flag"] as? Bool, false)
+            XCTAssertEqual(source.storage["top-level-flag"], .bool(true))
+            XCTAssertEqual(source.storage["one-flag-group.second-level-flag"], .bool(false))
         }
     }
 
@@ -59,8 +59,8 @@ final class FlagValueDictionaryTests: XCTestCase {
                 expectation.fulfill()
             }
 
-        source["top-level-flag"] = true
-        source["one-flag-group.second-level-flag"] = true
+        source["top-level-flag"] = .bool(true)
+        source["one-flag-group.second-level-flag"] = .bool(true)
 
         self.wait(for: [ expectation ], timeout: 1)
 

Tests/VexilTests/FlagValueSourceTests.swift

@@ -57,8 +57,8 @@ final class FlagValueSourceTests: XCTestCase {
 
         // GIVEN two dictionaries
         let source = FlagValueDictionary([
-            "test-flag": true,
-            "subgroup.test-flag": true
+            "test-flag": .bool(true),
+            "subgroup.test-flag": .bool(true)
         ])
         let destination = FlagValueDictionary()
 
@@ -68,17 +68,17 @@ final class FlagValueSourceTests: XCTestCase {
 
         // THEN we expect those two dictionaries to match
         XCTAssertEqual(destination.count, 2)
-        XCTAssertEqual(destination["test-flag"] as? Bool, true)
-        XCTAssertEqual(destination["subgroup.test-flag"] as? Bool, true)
+        XCTAssertEqual(destination["test-flag"], .bool(true))
+        XCTAssertEqual(destination["subgroup.test-flag"], .bool(true))
 
     }
 
     func testSourceRemovesAllVales () throws {
 
         // GIVEN a dictionary with some values
         let source = FlagValueDictionary([
-            "test-flag": true,
-            "subgroup.test-flag": true
+            "test-flag": .bool(true),
+            "subgroup.test-flag": .bool(true)
         ])
 
         // WHEN we remove all values from that source

Tests/VexilTests/SnapshotTests.swift

@@ -92,8 +92,8 @@ final class SnapshotTests: XCTestCase {
         // GIVEN a FlagPole and a dictionary that is not a part it
         let pole = FlagPole(hoist: TestFlags.self, sources: [])
         let dictionary = FlagValueDictionary([
-            "top-level-flag": true,
-            "subgroup.double-subgroup.third-level-flag": true
+            "top-level-flag": .bool(true),
+            "subgroup.double-subgroup.third-level-flag": .bool(true)
         ])
 
         // WHEN we take a snapshot of that source