added auto injection with tags

Author: ilyapuchka

Dip/Dip/AutoInjection.swift

@@ -46,10 +46,6 @@ class ClientImp: Client {
 */
 public final class Injected<T>: _InjectedPropertyBox {
 
-  static var tag: DependencyContainer.Tag {
-    return .String("\(Injected<T>.self)")
-  }
-
   var _value: Any?
 
   public var value: T? {
@@ -61,7 +57,11 @@ public final class Injected<T>: _InjectedPropertyBox {
     }
   }
 
-  public init() {}
+  var tag: DependencyContainer.Tag?
+  
+  public init(tag: DependencyContainer.Tag? = nil) {
+    self.tag = tag
+  }
 
 }
 
@@ -101,10 +101,6 @@ public final class InjectedWeak<T>: _InjectedWeakPropertyBox {
   //so we just rely on user reading documentation and passing AnyObject in runtime
   //also we will throw fatal error if type can not be casted to AnyObject during resolution
 
-  static var tag: DependencyContainer.Tag {
-    return .String("\(InjectedWeak<T>.self)")
-  }
-
   weak var _value: AnyObject?
 
   public var value: T? {
@@ -116,7 +112,11 @@ public final class InjectedWeak<T>: _InjectedWeakPropertyBox {
     }
   }
 
-  public init() {}
+  var tag: DependencyContainer.Tag?
+  
+  public init(tag: DependencyContainer.Tag? = nil) {
+    self.tag = tag
+  }
 
 }
 
@@ -166,60 +166,88 @@ typealias InjectedWeakFactory = ()->AnyObject
 
 extension DependencyContainer {
 
-  func registerInjected(definition: AutoInjectedDefinition) {
-    guard let key = definition.injectedKey,
-      definition = definition.injectedDefinition else { return }
-    definitions[key] = definition
+  func registerInjected(definition: AutoInjectedDefinition, tag: Tag?) {
+    guard let key = definition.injectedKey(tag),
+      definitionToInject = definition.injectedDefinition else { return }
+    definitions[key] = definitionToInject
   }
 
-  func registerInjectedWeak(definition: AutoInjectedDefinition) {
-    guard let key = definition.injectedWeakKey,
-      definition = definition.injectedWeakDefinition else { return }
-    definitions[key] = definition
+  func registerInjectedWeak(definition: AutoInjectedDefinition, tag: Tag?) {
+    guard let key = definition.injectedWeakKey(tag),
+      definitionToInject = definition.injectedWeakDefinition else { return }
+    definitions[key] = definitionToInject
   }
 
-  func removeInjected(definition: AutoInjectedDefinition) {
+  func removeInjected(definition: AutoInjectedDefinition, tag: Tag?) {
     guard definition.injectedDefinition != nil else { return }
-    definitions[definition.injectedKey] = nil
+    let key = definition.injectedKey(tag)
+    definitions[key] = nil
   }
 
-  func removeInjectedWeak(definition: AutoInjectedDefinition) {
+  func removeInjectedWeak(definition: AutoInjectedDefinition, tag: Tag?) {
     guard definition.injectedWeakDefinition != nil else { return }
-    definitions[definition.injectedWeakKey] = nil
+    let key = definition.injectedWeakKey(tag)
+    definitions[key] = nil
   }
 
 }
 
-protocol _AutoInjectedPropertyBox {
+protocol _AutoInjectedPropertyBox: class {
   func resolve(container: DependencyContainer) throws
-  static var tag: DependencyContainer.Tag { get }
+  var tag: DependencyContainer.Tag? { get }
+  static func tagForTag(tag: DependencyContainer.Tag?) -> DependencyContainer.Tag
+}
+
+extension _AutoInjectedPropertyBox {
+  
+  static func tagForTag(tag: DependencyContainer.Tag?) -> DependencyContainer.Tag {
+    return .String(String(self)) + tag
+  }
+
+  func _resolve<T>(container: DependencyContainer) throws -> T {
+    do {
+      return try container.resolve(tag: self.dynamicType.tagForTag(self.tag)) as T
+    }
+    catch {
+      //fallback to definition with nil tag if needed
+      if self.tag != nil {
+        return try container.resolve(tag: self.dynamicType.tagForTag(nil)) as T
+      }
+      else {
+        //rethrow error if instance tag is already nil
+        throw error
+      }
+    }
+
+  }
+  
 }
 
-protocol _InjectedPropertyBox: class, _AutoInjectedPropertyBox {
+protocol _InjectedPropertyBox: _AutoInjectedPropertyBox {
   var _value: Any? { get set }
 }
 
 extension _InjectedPropertyBox {
   func resolve(container: DependencyContainer) throws {
-    self._value = try container.resolve(tag: self.dynamicType.tag) as Any
+    self._value = try _resolve(container) as Any
   }
 }
 
-protocol _InjectedWeakPropertyBox: class, _AutoInjectedPropertyBox {
+protocol _InjectedWeakPropertyBox: _AutoInjectedPropertyBox {
   weak var _value: AnyObject? { get set }
 }
 
 extension _InjectedWeakPropertyBox {
   func resolve(container: DependencyContainer) throws {
-    self._value = try container.resolve(tag: self.dynamicType.tag) as AnyObject
+    self._value = try _resolve(container) as AnyObject
   }
 }
 
 func isInjectedTag(tag: DependencyContainer.Tag?) -> String? {
   guard let tag = tag else { return nil }
   guard case let .String(stringTag) = tag else { return nil }
 
-  return try! stringTag.match("^Injected(?:Weak){0,1}<\\((.+)\\)>$")?.first
+  return try! stringTag.match("^Injected(?:Weak){0,1}<\\((.+)\\)>.*$")?.first
 }
 
 extension String {
@@ -238,4 +266,30 @@ extension String {
   }
 }
 
+func +(lhs: DependencyContainer.Tag, rhs: DependencyContainer.Tag?) -> DependencyContainer.Tag {
+  guard let rhs = rhs else { return lhs }
+  return lhs + rhs
+}
+
+func +(lhs: DependencyContainer.Tag?, rhs: DependencyContainer.Tag) -> DependencyContainer.Tag {
+  guard let lhs = lhs else { return rhs }
+  return lhs + rhs
+}
+
+func +(lhs: DependencyContainer.Tag, rhs: DependencyContainer.Tag) -> DependencyContainer.Tag {
+  let lhsValue: String
+  switch lhs {
+  case let .String(stringValue): lhsValue = stringValue
+  case let .Int(intValue): lhsValue = String(intValue)
+  }
+
+  let rhsValue: String
+  switch rhs {
+  case let .String(stringValue): rhsValue = stringValue
+  case let .Int(intValue): rhsValue = String(intValue)
+  }
+
+  return .String("\(lhsValue);\(rhsValue)")
+}
+
 

Dip/Dip/Definition.swift

@@ -118,7 +118,6 @@ public final class DefinitionOf<T, F>: Definition {
     if let factory = factory as? ()->T {
       injectedDefinition = DefinitionOf<Any, ()->Any>(factory: { factory() })
       injectedDefinition!.scope = scope
-      injectedKey = DefinitionKey(protocolType: Any.self, factoryType: InjectedFactory.self, associatedTag: Injected<T>.tag)
 
       injectedWeakDefinition = DefinitionOf<AnyObject, ()->AnyObject>(factory: {
         guard let result = factory() as? AnyObject else {
@@ -127,7 +126,6 @@ public final class DefinitionOf<T, F>: Definition {
         return result
         })
       injectedWeakDefinition!.scope = scope
-      injectedWeakKey = DefinitionKey(protocolType: AnyObject.self, factoryType: InjectedWeakFactory.self, associatedTag: InjectedWeak<T>.tag)
     }
   }
 
@@ -153,11 +151,20 @@ public final class DefinitionOf<T, F>: Definition {
 
   ///Accessory definition used to auto-inject strong properties
   private(set) var injectedDefinition: DefinitionOf<Any,()->Any>?
-  private(set) var injectedKey: DefinitionKey?
 
   ///Accessory definition used to auto-inject weak properties
   private(set) var injectedWeakDefinition: DefinitionOf<AnyObject,()->AnyObject>?
-  private(set) var injectedWeakKey: DefinitionKey?
+  
+  
+  func injectedKey(tag: DependencyContainer.Tag?) -> DefinitionKey? {
+    guard let _ = factory as? ()->T else { return nil }
+    return DefinitionKey(protocolType: Any.self, factoryType: InjectedFactory.self, associatedTag: Injected<T>.tagForTag(tag))
+  }
+  
+  func injectedWeakKey(tag: DependencyContainer.Tag?) -> DefinitionKey? {
+    guard let _ = factory as? ()->T else { return nil }
+    return DefinitionKey(protocolType: AnyObject.self, factoryType: InjectedWeakFactory.self, associatedTag: InjectedWeak<T>.tagForTag(tag))
+  }
 
 }
 
@@ -166,13 +173,17 @@ public protocol Definition: class { }
 
 protocol AutoInjectedDefinition: Definition {
   var injectedDefinition: DefinitionOf<Any,()->Any>? { get }
-  var injectedKey: DefinitionKey? { get }
+  
+  func injectedKey(tag: DependencyContainer.Tag?) -> DefinitionKey?
 
   var injectedWeakDefinition: DefinitionOf<AnyObject,()->AnyObject>? { get }
-  var injectedWeakKey: DefinitionKey? { get }
+  
+  func injectedWeakKey(tag: DependencyContainer.Tag?) -> DefinitionKey?
 }
 
-extension DefinitionOf: AutoInjectedDefinition {}
+extension DefinitionOf: AutoInjectedDefinition {
+
+}
 
 extension DefinitionOf: CustomStringConvertible {
   public var description: String {

Dip/Dip/Dip.swift

@@ -73,8 +73,8 @@ public final class DependencyContainer {
   public func remove(definition: Definition, forKey key: DefinitionKey) {
     definitions[key] = nil
     if let definition = definition as? AutoInjectedDefinition {
-      removeInjected(definition)
-      removeInjectedWeak(definition)
+      removeInjected(definition, tag: key.associatedTag)
+      removeInjectedWeak(definition, tag: key.associatedTag)
     }
   }
 
@@ -151,9 +151,9 @@ public final class DependencyContainer {
   public func register(definition: Definition, forKey key: DefinitionKey) {
     definitions[key] = definition
 
-    if let definition = definition as? AutoInjectedDefinition where key.associatedTag == nil {
-      registerInjected(definition)
-      registerInjectedWeak(definition)
+    if let definition = definition as? AutoInjectedDefinition {
+      registerInjected(definition, tag: key.associatedTag)
+      registerInjectedWeak(definition, tag: key.associatedTag)
     }
   }
 
@@ -256,9 +256,9 @@ public final class DependencyContainer {
 
     func storeResolvedInstance<T, F>(instance: T, forKey key: DefinitionKey?, definition: DefinitionOf<T, F>) {
       resolvedInstances[key] = instance
-      if key != nil {
-        resolvedInstances[definition.injectedKey] = instance
-        resolvedInstances[definition.injectedWeakKey] = instance
+      if let key = key {
+        resolvedInstances[definition.injectedKey(key.associatedTag)] = instance
+        resolvedInstances[definition.injectedWeakKey(key.associatedTag)] = instance
       }
     }
 

Dip/DipTests/AutoInjectionTests.swift

@@ -27,13 +27,15 @@ import XCTest
 
 private protocol Server: class {
   weak var client: Client? {get}
-  
   var anotherClient: Client? {get set}
+  
+  var name: String? { get }
 }
 
 private protocol Client: class {
   var server: Server? {get}
   var anotherServer: Server? {get set}
+  var taggedServer: Server? { get }
 }
 
 class AutoInjectionTests: XCTestCase {
@@ -54,6 +56,8 @@ class AutoInjectionTests: XCTestCase {
     }
 
     weak var anotherClient: Client?
+    
+    var name: String?
   }
 
   private class ClientImp: Client {
@@ -69,6 +73,11 @@ class AutoInjectionTests: XCTestCase {
       return _server.value
     }
 
+    var _taggedServer = Injected<Server>(tag: "tagged")
+    var taggedServer: Server? {
+      return _taggedServer.value
+    }
+    
   }
 
   let container = DependencyContainer()
@@ -82,6 +91,11 @@ class AutoInjectionTests: XCTestCase {
 
     container.register(.ObjectGraph) { ServerImp() as Server }
     container.register(.ObjectGraph) { ClientImp() as Client }
+    container.register(tag: "tagged", .ObjectGraph) { {
+      let server = ServerImp()
+      server.name = "tagged"
+      return server
+      }() as Server }
   }
 
   func testThatItResolvesInjectedDependencies() {
@@ -183,6 +197,15 @@ class AutoInjectionTests: XCTestCase {
 
     XCTAssertNil(weakClient)
     XCTAssertNil(server)
-
   }
+  
+  func testThatItInjectsTaggedDefinition() {
+    let client = try! container.resolve() as Client
+    let taggedServer = client.taggedServer
+    XCTAssertTrue(taggedServer?.name == "tagged")
+    
+    let server = client.server
+    XCTAssertNil(server?.name)
+  }
+  
 }