Support Many<Lazy<Type>>. But Lazy<Many<Type>> unsupport. Up version …

…3.8.1
ivlevAstef · Sep 10, 2019 · c6be0bb · c6be0bb
1 parent b93bd6a
commit c6be0bb
Show file tree

Hide file tree

Showing 5 changed files with 96 additions and 33 deletions.
diff --git a/DITranquillity.podspec b/DITranquillity.podspec
@@ -1,7 +1,7 @@
 Pod::Spec.new do |s|
 
   s.name         = 'DITranquillity'
-  s.version      = '3.8.0'
+  s.version      = '3.8.1'
   s.summary      = 'DITranquillity - Dependency injection for iOS/macOS/tvOS (Swift) '
 
   s.description  = <<-DESC

diff --git a/Sources/DITranquillity/Private/ParsedType.swift b/Sources/DITranquillity/Private/ParsedType.swift
@@ -66,6 +66,26 @@ final class ParsedType {
     self.init(type: Swift.type(of: (obj as Any)))
   }
 
+  func nextParsedTypeAfterManyOrBreakIfDelayed() -> ParsedType? {
+    var pType: ParsedType = self
+    repeat {
+      if pType.delayed {
+        return nil
+      }
+      if pType.many {
+        return pType.parent
+      }
+
+      if let parentType = pType.parent {
+        pType = parentType
+        continue
+      }
+      break
+    } while true
+
+    return nil
+  }
+
   @inline(__always)
   private func oGet(_ value1: Bool?, _ value2: @autoclosure () -> Bool?) -> Bool
   {

diff --git a/Sources/DITranquillity/Private/Resolver.swift b/Sources/DITranquillity/Private/Resolver.swift
@@ -172,12 +172,23 @@ class Resolver {
       if let delayMaker = parsedType.delayMaker {
         let saveGraph = cache.graph
 
-        return delayMaker.init(container, { () -> Any? in
-          return self.mutex.sync {
-            self.cache.graph = saveGraph
-            return self.make(by: parsedType, components: components, use: object)
+        func makeDelayMaker(by parsedType: ParsedType, components: Components) -> Any? {
+          return delayMaker.init(container, { () -> Any? in
+            return self.mutex.sync {
+              self.cache.graph = saveGraph
+              return self.make(by: parsedType, components: components, use: object)
+            }
+          })
+        }
+
+        if parsedType.hasMany, let subPType = parsedType.nextParsedTypeAfterManyOrBreakIfDelayed() {
+          // hard logic for support Many<Lazy<Type>> and Many<Provider<Type>> but Many<Many<Lazy<Type>>> not supported
+          return components.sorted{ $0.order < $1.order }.compactMap {
+            return makeDelayMaker(by: subPType, components: Components([$0]))
           }
-        })
+        } else {
+          return makeDelayMaker(by: parsedType, components: components)
+        }
       }
 
       return make(by: parsedType, components: components, use: object)

diff --git a/Sources/Info.plist b/Sources/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>3.8.0</string>
+	<string>3.8.1</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>

diff --git a/Tests/DITranquillityTest/DITranquillityTests_Resolve.swift b/Tests/DITranquillityTest/DITranquillityTests_Resolve.swift
@@ -8,6 +8,7 @@
 
 import XCTest
 import DITranquillity
+import SwiftLazy
 
 private class ManyTest {
   var services: [ServiceProtocol] = []
@@ -228,41 +229,72 @@ class DITranquillityTests_Resolve: XCTestCase {
 
   func test12_ResolveMultiplyMany() {
     let container = DIContainer()
-    
+
     container.register(FooService.init)
       .as(check: ServiceProtocol.self){$0}
-    
+
     container.register(BarService.init)
       .as(check: ServiceProtocol.self){$0}
-    
+
     let services: [ServiceProtocol] = container.resolveMany()
+
     XCTAssertEqual(services.count, 2)
     XCTAssertNotEqual(services[0].foo(), services[1].foo())
   }
 
-    func test12_ResolveMultiplyManyOrder() {
-        let container = DIContainer()
-
-        container.register(FooService.init)
-            .as(ServiceProtocol.self)
-        container.register(BarService.init)
-            .as(ServiceProtocol.self)
-        container.register(FooService.init)
-            .as(ServiceProtocol.self)
-        container.register(FooService.init)
-            .as(ServiceProtocol.self)
-        container.register(BarService.init)
-            .as(ServiceProtocol.self)
-
-        let services: [ServiceProtocol] = container.resolveMany()
-        XCTAssertEqual(services.count, 5)
-
-        XCTAssert(services[0] is FooService)
-        XCTAssert(services[1] is BarService)
-        XCTAssert(services[2] is FooService)
-        XCTAssert(services[3] is FooService)
-        XCTAssert(services[4] is BarService)
-    }
+  func test12_ResolveMultiplyLazyMany() {
+    let container = DIContainer()
+
+    container.register(FooService.init)
+      .as(check: ServiceProtocol.self){$0}
+
+    container.register(BarService.init)
+      .as(check: ServiceProtocol.self){$0}
+
+    let services: [Lazy<ServiceProtocol>] = many(*container)
+
+    XCTAssertEqual(services.count, 2)
+    XCTAssertNotEqual(services[0].value.foo(), services[1].value.foo())
+  }
+
+  func test12_ResolveMultiplyProviderMany() {
+    let container = DIContainer()
+
+    container.register(FooService.init)
+      .as(check: ServiceProtocol.self){$0}
+
+    container.register(BarService.init)
+      .as(check: ServiceProtocol.self){$0}
+
+    let services: [Provider<ServiceProtocol>] = many(*container)
+
+    XCTAssertEqual(services.count, 2)
+    XCTAssertNotEqual(services[0].value.foo(), services[1].value.foo())
+  }
+
+  func test12_ResolveMultiplyManyOrder() {
+    let container = DIContainer()
+
+    container.register(FooService.init)
+        .as(ServiceProtocol.self)
+    container.register(BarService.init)
+        .as(ServiceProtocol.self)
+    container.register(FooService.init)
+        .as(ServiceProtocol.self)
+    container.register(FooService.init)
+        .as(ServiceProtocol.self)
+    container.register(BarService.init)
+        .as(ServiceProtocol.self)
+
+    let services: [ServiceProtocol] = container.resolveMany()
+    XCTAssertEqual(services.count, 5)
+
+    XCTAssert(services[0] is FooService)
+    XCTAssert(services[1] is BarService)
+    XCTAssert(services[2] is FooService)
+    XCTAssert(services[3] is FooService)
+    XCTAssert(services[4] is BarService)
+  }
 
   func test13_ResolveCircular2() {
     let container = DIContainer()