From 7c8335aff8e2595eed5bf10495bbd43ab4356da2 Mon Sep 17 00:00:00 2001 From: Marcin Iwanicki Date: Sun, 4 Aug 2024 10:53:19 +0100 Subject: [PATCH] Name is more commonly used --- Sources/SCInject/Container.swift | 58 +++++++++---------- .../{Identifier.swift => RegisterName.swift} | 4 +- Sources/SCInject/Registry.swift | 8 +-- Sources/SCInject/Resolver.swift | 4 +- Tests/SCInject/ContainerTests.swift | 38 ++++++------ 5 files changed, 56 insertions(+), 56 deletions(-) rename Sources/SCInject/{Identifier.swift => RegisterName.swift} (86%) diff --git a/Sources/SCInject/Container.swift b/Sources/SCInject/Container.swift index d69ba28..a50ede8 100644 --- a/Sources/SCInject/Container.swift +++ b/Sources/SCInject/Container.swift @@ -31,27 +31,27 @@ public final class DefaultContainer: Container { // MARK: - Registry public func register(_ type: T.Type, closure: @escaping (Resolver) -> T) { - register(type: type, id: nil, scope: nil, closure: closure) + register(type: type, name: nil, scope: nil, closure: closure) } public func register(_ type: T.Type, _ scope: Scope, closure: @escaping (Resolver) -> T) { - register(type: type, id: nil, scope: scope, closure: closure) + register(type: type, name: nil, scope: scope, closure: closure) } - public func register(_ type: T.Type, id: String, closure: @escaping (Resolver) -> T) { - register(type: type, id: .init(rawValue: id), scope: nil, closure: closure) + public func register(_ type: T.Type, name: String, closure: @escaping (Resolver) -> T) { + register(type: type, name: .init(rawValue: name), scope: nil, closure: closure) } - public func register(_ type: T.Type, id: String, _ scope: Scope, closure: @escaping (Resolver) -> T) { - register(type: type, id: .init(rawValue: id), scope: scope, closure: closure) + public func register(_ type: T.Type, name: String, _ scope: Scope, closure: @escaping (Resolver) -> T) { + register(type: type, name: .init(rawValue: name), scope: scope, closure: closure) } - public func register(_ type: T.Type, id: Identifier, closure: @escaping (Resolver) -> T) { - register(type: type, id: id, scope: nil, closure: closure) + public func register(_ type: T.Type, name: RegisterName, closure: @escaping (Resolver) -> T) { + register(type: type, name: name, scope: nil, closure: closure) } - public func register(_ type: T.Type, id: Identifier, _ scope: Scope, closure: @escaping (Resolver) -> T) { - register(type: type, id: id, scope: scope, closure: closure) + public func register(_ type: T.Type, name: RegisterName, _ scope: Scope, closure: @escaping (Resolver) -> T) { + register(type: type, name: name, scope: scope, closure: closure) } // MARK: - Resolver @@ -64,13 +64,13 @@ public final class DefaultContainer: Container { return instance } - public func resolve(_ type: T.Type, id: String) -> T { - resolve(type, id: .init(rawValue: id)) + public func resolve(_ type: T.Type, name: String) -> T { + resolve(type, name: .init(rawValue: name)) } - public func resolve(_ type: T.Type, id: Identifier) -> T { - guard let instance = tryResolve(type, id: id) else { - let message = errorMessage("Failed to resolve given type -- TYPE=\(type) ID=\(id.rawValue)") + public func resolve(_ type: T.Type, name: RegisterName) -> T { + guard let instance = tryResolve(type, name: name) else { + let message = errorMessage("Failed to resolve given type -- TYPE=\(type) NAME=\(name.rawValue)") fatalError(message) } return instance @@ -79,42 +79,42 @@ public final class DefaultContainer: Container { // MARK: - Public public func tryResolve(_ type: T.Type) -> T? { - tryResolve(type: type, id: nil, container: self) + tryResolve(type: type, name: nil, container: self) } - public func tryResolve(_ type: T.Type, id: String) -> T? { - tryResolve(type: type, id: .init(rawValue: id), container: self) + public func tryResolve(_ type: T.Type, name: String) -> T? { + tryResolve(type: type, name: .init(rawValue: name), container: self) } - public func tryResolve(_ type: T.Type, id: Identifier) -> T? { - tryResolve(type: type, id: id, container: self) + public func tryResolve(_ type: T.Type, name: RegisterName) -> T? { + tryResolve(type: type, name: name, container: self) } // MARK: - Private private func register( type: T.Type, - id: Identifier?, + name: RegisterName?, scope: Scope?, closure: @escaping (Resolver) -> T ) { lock.lock(); defer { lock.unlock() } - let identifier = identifier(of: type, id: id) + let identifier = identifier(of: type, name: name) if resolvers[identifier] != nil { let message = - errorMessage("Given type is already registered -- TYPE=\(type) ID=\(id?.rawValue ?? "nil")") + errorMessage("Given type is already registered -- TYPE=\(type) NAME=\(name?.rawValue ?? "nil")") fatalError(message) } resolvers[identifier] = makeResolver(scope ?? defaultScope, closure: closure) } - private func tryResolve(type: T.Type, id: Identifier? = nil, container: Container) -> T? { + private func tryResolve(type: T.Type, name: RegisterName? = nil, container: Container) -> T? { lock.lock(); defer { lock.unlock() } - if let resolver = resolvers[identifier(of: type, id: id)] { + if let resolver = resolvers[identifier(of: type, name: name)] { return resolver.resolve(with: container) as? T } if let parent { - return parent.tryResolve(type: type, id: id, container: container) + return parent.tryResolve(type: type, name: name, container: container) } return nil } @@ -128,16 +128,16 @@ public final class DefaultContainer: Container { } } - private func identifier(of type: (some Any).Type, id: Identifier?) -> ResolverIdentifier { + private func identifier(of type: (some Any).Type, name: RegisterName?) -> ResolverIdentifier { ResolverIdentifier( - id: id, + name: name, typeIdentifier: ObjectIdentifier(type), description: String(describing: type) ) } private struct ResolverIdentifier: Hashable { - let id: Identifier? + let name: RegisterName? let typeIdentifier: ObjectIdentifier let description: String } diff --git a/Sources/SCInject/Identifier.swift b/Sources/SCInject/RegisterName.swift similarity index 86% rename from Sources/SCInject/Identifier.swift rename to Sources/SCInject/RegisterName.swift index b0d9901..b355b04 100644 --- a/Sources/SCInject/Identifier.swift +++ b/Sources/SCInject/RegisterName.swift @@ -16,7 +16,7 @@ import Foundation -public struct Identifier: RawRepresentable, CustomStringConvertible, Hashable { +public struct RegisterName: RawRepresentable, CustomStringConvertible, Hashable { public let rawValue: String public init(rawValue string: String) { @@ -24,6 +24,6 @@ public struct Identifier: RawRepresentable, CustomStringConvertible, Hashable { } public var description: String { - "SCInject.Identifier(\(rawValue))" + "SCInject.RegisterName(\(rawValue))" } } diff --git a/Sources/SCInject/Registry.swift b/Sources/SCInject/Registry.swift index a0dec6f..e080e16 100644 --- a/Sources/SCInject/Registry.swift +++ b/Sources/SCInject/Registry.swift @@ -20,9 +20,9 @@ public protocol Registry { func register(_ type: T.Type, closure: @escaping (Resolver) -> T) func register(_ type: T.Type, _ scope: Scope, closure: @escaping (Resolver) -> T) - func register(_ type: T.Type, id: String, closure: @escaping (Resolver) -> T) - func register(_ type: T.Type, id: String, _ scope: Scope, closure: @escaping (Resolver) -> T) + func register(_ type: T.Type, name: String, closure: @escaping (Resolver) -> T) + func register(_ type: T.Type, name: String, _ scope: Scope, closure: @escaping (Resolver) -> T) - func register(_ type: T.Type, id: Identifier, closure: @escaping (Resolver) -> T) - func register(_ type: T.Type, id: Identifier, _ scope: Scope, closure: @escaping (Resolver) -> T) + func register(_ type: T.Type, name: RegisterName, closure: @escaping (Resolver) -> T) + func register(_ type: T.Type, name: RegisterName, _ scope: Scope, closure: @escaping (Resolver) -> T) } diff --git a/Sources/SCInject/Resolver.swift b/Sources/SCInject/Resolver.swift index 580348e..2f6cf2e 100644 --- a/Sources/SCInject/Resolver.swift +++ b/Sources/SCInject/Resolver.swift @@ -18,6 +18,6 @@ import Foundation public protocol Resolver: AnyObject { func resolve(_ type: T.Type) -> T - func resolve(_ type: T.Type, id: String) -> T - func resolve(_ type: T.Type, id: Identifier) -> T + func resolve(_ type: T.Type, name: String) -> T + func resolve(_ type: T.Type, name: RegisterName) -> T } diff --git a/Tests/SCInject/ContainerTests.swift b/Tests/SCInject/ContainerTests.swift index de4f0f8..b6d949b 100644 --- a/Tests/SCInject/ContainerTests.swift +++ b/Tests/SCInject/ContainerTests.swift @@ -33,10 +33,10 @@ final class ContainerTests: XCTestCase { // When let class1 = container.tryResolve(TestClass1.self) let class2 = container.tryResolve(TestClass2.self) - let class1_id = container.tryResolve(TestClass1.self, id: "Test") - let class2_id = container.tryResolve(TestClass2.self, id: "Test") - let class1_id_second = container.tryResolve(TestClass1.self, id: .init(rawValue: "Test")) - let class2_id_second = container.tryResolve(TestClass2.self, id: .init(rawValue: "Test")) + let class1_name = container.tryResolve(TestClass1.self, name: "Test") + let class2_name = container.tryResolve(TestClass2.self, name: "Test") + let class1_name_second = container.tryResolve(TestClass1.self, name: .init(rawValue: "Test")) + let class2_name_second = container.tryResolve(TestClass2.self, name: .init(rawValue: "Test")) let class1_second = container.tryResolve(TestClass1.self) let class2_second = container.tryResolve(TestClass2.self) @@ -45,43 +45,43 @@ final class ContainerTests: XCTestCase { XCTAssertNotNil(class2) XCTAssertNotNil(class1_second) XCTAssertNotNil(class2_second) - XCTAssertNil(class1_id) - XCTAssertNil(class2_id) - XCTAssertNil(class1_id_second) - XCTAssertNil(class2_id_second) + XCTAssertNil(class1_name) + XCTAssertNil(class2_name) + XCTAssertNil(class1_name_second) + XCTAssertNil(class2_name_second) XCTAssertTrue(class1 !== class1_second) XCTAssertTrue(class2 !== class2_second) XCTAssertTrue(class2?.value !== class1) } - func testRegister_transientClassWithId() { - let second: Identifier = .init(rawValue: "second") + func testRegister_transientClassWithName() { + let second: RegisterName = .init(rawValue: "second") let container = DefaultContainer() container.register(TestClass1.self) { _ in TestClass1(value: "TestClass1_Instance") } - container.register(TestClass1.self, id: second) { _ in + container.register(TestClass1.self, name: second) { _ in TestClass1(value: "TestClass1_Second_Instance") } container.register(TestClass2.self) { r in - TestClass2(value: r.resolve(TestClass1.self, id: second)) + TestClass2(value: r.resolve(TestClass1.self, name: second)) } // When let class1 = container.tryResolve(TestClass1.self) let class2 = container.tryResolve(TestClass2.self) - let class1_id = container.tryResolve(TestClass1.self, id: second) - let class2_id = container.tryResolve(TestClass2.self, id: second) + let class1_name = container.tryResolve(TestClass1.self, name: second) + let class2_name = container.tryResolve(TestClass2.self, name: second) // Then XCTAssertNotNil(class1) XCTAssertNotNil(class2) - XCTAssertNotNil(class1_id) - XCTAssertNil(class2_id) - XCTAssertEqual(class1_id?.rawValue, "TestClass1_Second_Instance") + XCTAssertNotNil(class1_name) + XCTAssertNil(class2_name) + XCTAssertEqual(class1_name?.rawValue, "TestClass1_Second_Instance") XCTAssertEqual(class2?.value.rawValue, "TestClass1_Second_Instance") - XCTAssertTrue(class1 !== class1_id) - XCTAssertTrue(class2?.value !== class1_id) + XCTAssertTrue(class1 !== class1_name) + XCTAssertTrue(class2?.value !== class1_name) } }