Implemented factories with a custom argument

DIKit/Sources/Component/Component.swift

@@ -7,26 +7,26 @@
 //
 // Copyright © 2018 Ben John. All rights reserved.
 
-public typealias ComponentFactory = () -> Any
+public typealias ComponentFactory = (Any?) -> Any
 
-class Component<T>: ComponentProtocol {
+class Component<A, T>: ComponentProtocol {
     let lifetime: Lifetime
     let identifier: AnyHashable
     let type: Any.Type
     let componentFactory: ComponentFactory
 
-    init(lifetime: Lifetime, factory: @escaping () -> T) {
+    init(lifetime: Lifetime, factory: @escaping (_ argument: A) -> T) {
         self.lifetime = lifetime
         self.identifier = ComponentIdentifier(type: T.self)
         self.type = T.self
-        self.componentFactory = { factory() }
+        self.componentFactory = { factory($0 as! A) } // swiftlint:disable:this force_cast
     }
 
-    init(lifetime: Lifetime, tag: AnyHashable, factory: @escaping () -> T) {
+    init(lifetime: Lifetime, tag: AnyHashable, factory: @escaping (_ argument: A) -> T) {
         self.lifetime = lifetime
         self.identifier = ComponentIdentifier(tag: tag, type: T.self)
         self.type = T.self
-        self.componentFactory = { factory() }
+        self.componentFactory = { factory($0 as! A) } // swiftlint:disable:this force_cast
     }
 }
 

DIKit/Sources/Container/DependencyContainer+Register.swift

@@ -13,7 +13,7 @@ extension DependencyContainer {
     /// - Parameters:
     ///     - lifetime: The *scope* of the `Component`, defaults to `Lifetime.singleton`.
     ///     - factory: The *factory* for the initialization of the `Component`.
-    public func register<T>(lifetime: Lifetime = .singleton, _ factory: @escaping () -> T) {
+    public func register<A, T>(lifetime: Lifetime = .singleton, _ factory: @escaping (A) -> T) {
         let component = Component(lifetime: lifetime, factory: factory)
         register(component)
     }
@@ -38,4 +38,10 @@ extension DependencyContainer {
             self.componentStack[component.identifier] = component
         }
     }
+
+    /// Convenience function without any arguments
+    public func register<T>(lifetime: Lifetime = .singleton, _ factory: @escaping () -> T) {
+        let newFactory: (Any) -> T = { _ in factory() }
+        register(lifetime: lifetime, newFactory)
+    }
 }

DIKit/Sources/Container/DependencyContainer+Resolve.swift

@@ -12,18 +12,18 @@ extension DependencyContainer {
     ///
     /// - Parameter tag: An optional *tag* to identify the Component. `nil` per default.
     /// - Returns: The resolved `Optional<Component<T>>`.
-    func _resolve<T>(tag: AnyHashable? = nil) -> T? {
+    func _resolve<A, T>(_ argument: A, tag: AnyHashable? = nil) -> T? {
         let identifier = ComponentIdentifier(tag: tag, type: T.self)
         guard let foundComponent = self.componentStack[identifier] else {
             return nil
         }
         if foundComponent.lifetime == .factory {
-            return foundComponent.componentFactory() as? T
+            return foundComponent.componentFactory(argument) as? T
         }
         if let instanceOfComponent = self.instanceStack[identifier] as? T {
             return instanceOfComponent
         }
-        let instance = foundComponent.componentFactory() as! T
+        let instance = foundComponent.componentFactory(argument) as! T
         self.instanceStack[identifier] = instance
         return instance
     }
@@ -48,10 +48,21 @@ extension DependencyContainer {
     /// - Parameter tag: An optional *tag* to identify the Component. `nil` per default.
     ///
     /// - Returns: The resolved `Component<T>`.
+    public func resolve<A, T>(_ argument: A, tag: AnyHashable? = nil) -> T {
+        if let t: T = _resolve(argument, tag: tag) {
+            return t
+        }
+        fatalError("Component `\(String(describing: T.self))` could not be resolved.")
+    }
+
+    /// Convenience function without any arguments
     public func resolve<T>(tag: AnyHashable? = nil) -> T {
         if let t: T = _resolve(tag: tag) {
             return t
         }
         fatalError("Component `\(String(describing: T.self))` could not be resolved.")
     }
+    func _resolve<T>(tag: AnyHashable? = nil) -> T? {
+        _resolve((), tag: tag)
+    }
 }

DIKit/Sources/DIKit+Inject.swift

@@ -49,6 +49,10 @@ public struct Inject<Component> {
     public init(tag: AnyHashable? = nil) {
         self.wrappedValue = resolve(tag: tag)
     }
+
+    public init<A>(_ argument: A) {
+        self.wrappedValue = resolve(argument)
+    }
 }
 
 /// A property wrapper (SE-0258) to make a `Optional<Component>` injectable

DIKit/Sources/DIKit.swift

@@ -13,6 +13,8 @@
 /// - Returns: The resolved `Component<T>`.
 public func resolve<T>(tag: AnyHashable? = nil) -> T { DependencyContainer.shared.resolve(tag: tag) }
 
+public func resolve<A, T>(_ argument: A, tag: AnyHashable? = nil) -> T { DependencyContainer.shared.resolve(argument, tag: tag) }
+
 /// Resolves nil safe given `Component<T>`.
 ///
 /// - Parameter tag: An optional *tag* to identify the Component. `nil` per default.
@@ -21,3 +23,8 @@ public func resolveOptional<T>(tag: AnyHashable? = nil) -> T? {
     guard DependencyContainer.shared.resolvable(type: T.self, tag: tag) else { return nil }
     return DependencyContainer.shared._resolve(tag: tag)
 }
+
+public func resolveOptional<A, T>(_ argument: A, tag: AnyHashable? = nil) -> T? {
+    guard DependencyContainer.shared.resolvable(type: T.self, tag: tag) else { return nil }
+    return DependencyContainer.shared._resolve(argument, tag: tag)
+}

DIKit/Sources/DIKitDSL.swift

@@ -41,6 +41,10 @@ public func resolvable<T>(lifetime: Lifetime = .singleton, _ factory: @escaping
     Component(lifetime: lifetime, factory: factory) as ComponentProtocol
 }
 
+public func resolvable<A, T>(lifetime: Lifetime = .singleton, _ factory: @escaping (_ argument: A) -> T) -> ComponentProtocol {
+    Component(lifetime: lifetime, factory: factory) as ComponentProtocol
+}
+
 public func resolvable<T>(
     lifetime: Lifetime = .singleton,
     tag: AnyHashable,
@@ -53,6 +57,10 @@ public func factory<T>(factory: @escaping () -> T) -> [ComponentProtocol] {
     [resolvable(lifetime: .factory, factory)]
 }
 
+public func factory<A, T>(factory: @escaping (_ argument: A) -> T) -> [ComponentProtocol] {
+    [resolvable(lifetime: .factory, factory)]
+}
+
 public func factory<T>(tag: AnyHashable, factory: @escaping () -> T) -> [ComponentProtocol] {
     [resolvable(lifetime: .factory, tag: tag, factory)]
 }

DIKitExample/Sources/DependencyContainer+App.swift

@@ -13,7 +13,9 @@ import DIKit
 public extension DependencyContainer {
     static var app = module {
         // We create two different kind of storages. One for both kind of contexts.
-        factory(tag: StorageContext.systemdata) { LocalStorage() as LocalStorageProtocol }
-        factory(tag: StorageContext.userdata) { LocalStorage() as LocalStorageProtocol }
+        factory(tag: StorageContext.systemdata) { LocalStorage(name: "system") as LocalStorageProtocol }
+        factory(tag: StorageContext.userdata) { LocalStorage(name: "userdata") as LocalStorageProtocol }
+
+        factory { name in LocalStorage(name: name ?? "default") as LocalStorageProtocol }
     }
 }

DIKitExample/Sources/LocalStorageLayer/LocalStorage.swift

@@ -12,8 +12,10 @@ class LocalStorage: LocalStorageProtocol {
     var id: ObjectIdentifier {
         return ObjectIdentifier.init(self)
     }
+    let name: String
 
-    init() {
+    init(name: String) {
+        self.name = name
         print("LocalStorage init")
         print("LocalStorage instance \(ObjectIdentifier.init(self))")
     }

DIKitExample/Sources/LocalStorageLayer/LocalStorageProtocol.swift

@@ -10,4 +10,5 @@
 
 protocol LocalStorageProtocol {
     var id: ObjectIdentifier { get }
+    var name: String { get }
 }

DIKitExample/Sources/Views/FirstViewController.swift

@@ -15,10 +15,13 @@ import DIKitExampleBackend
 class FirstViewController: UIViewController {
     // MARK: - DIKit
     @Inject var backend: BackendProtocol
+    @Inject("Local Storage with a custom name") var localStorage: LocalStorageProtocol
 
     // MARK: - View lifecycle
     override func viewWillAppear(_ animated: Bool) {
         let result = backend.fetch()
         print(result)
+
+        print(localStorage.name)
     }
 }