feat(Builder): Scope support for immutable values of classes

Author: maximkrouk

Sources/FunctionalBuilder/Builder.swift

@@ -234,6 +234,19 @@ extension Builder {
         var builder: Builder
         var keyPath: FunctionalKeyPath<Base, Value>
 
+        public func scope(
+            _ builder: @escaping (Builder<Value>) -> Builder<Value>
+        ) -> Builder where Value: AnyObject {
+            Builder(
+                self.builder._initialValue,
+                self.builder._configurator.appendingConfiguration { base in
+                    keyPath.embed(
+                        builder(.init(keyPath.extract(from: base))).build(),
+                        in: base)
+                }
+            )
+        }
+        
         public subscript<LocalValue>(
             dynamicMember keyPath: WritableKeyPath<Value, LocalValue>
         ) -> CallableBlock<LocalValue> where Value: AnyObject {

Tests/DeclarativeConfigurationTests/BuilderTests.swift

@@ -58,25 +58,38 @@ final class BuilderTests: XCTestCase {
     }
 
     func testScope() {
-        struct Container: BuilderProvider, Equatable {
-            struct Content: Equatable {
+        struct Container: BuilderProvider {
+            class Content {
                 var a: Int = 0
                 var b: Int = 0
                 var c: Int = 0
+                
+                init() {}
             }
-            var content: Content = .init()
+            
+            let content: Content = .init()
         }
 
-        let expected = Container(content: .init(a: 1, b: 2, c: 3))
+        let expected = Container().builder
+            .content.a(1)
+            .content.b(2)
+            .content.c(3)
+            .build()
         let initial = Container()
-        let actual = initial.builder
+        let actual = Container().builder
             .content.scope { $0
                 .a(1)
                 .b(2)
                 .c(3)
             }.build()
 
-        XCTAssertNotEqual(initial, expected)
-        XCTAssertEqual(actual, expected)
+        
+        XCTAssertNotEqual(actual.content.a, initial.content.a)
+        XCTAssertNotEqual(actual.content.b, initial.content.b)
+        XCTAssertNotEqual(actual.content.c, initial.content.c)
+        
+        XCTAssertEqual(actual.content.a, expected.content.a)
+        XCTAssertEqual(actual.content.b, expected.content.b)
+        XCTAssertEqual(actual.content.c, expected.content.c)
     }
 }