Merge pull request #5 from baekteun/3-internal-dependency-append-method-change

🔀 :: 내부 의존성 연결 방식 개편

Author: baekteun

Plugin/DependencyPlugin/ProjectDescriptionHelpers/Dependency+Target.swift

@@ -9,58 +9,63 @@ public enum ModulePaths {
     case userInterface(UserInterface)
 }
 
+extension ModulePaths: MicroTargetPathConvertable {
+    public func targetName(type: MicroTargetType) -> String {
+        switch self {
+        case let .feature(module as any MicroTargetPathConvertable),
+            let .domain(module as any MicroTargetPathConvertable),
+            let .core(module as any MicroTargetPathConvertable),
+            let .shared(module as any MicroTargetPathConvertable),
+            let .userInterface(module as any MicroTargetPathConvertable):
+            return module.targetName(type: type)
+        }
+    }
+}
+
 public extension ModulePaths {
-    enum Feature: String {
+    enum Feature: String, MicroTargetPathConvertable {
         case BaseFeature
-
-        func targetName(type: MicroTargetType) -> String {
-            "\(self.rawValue)\(type.rawValue)"
-        }
     }
 }
 
 public extension ModulePaths {
-    enum Domain: String {
+    enum Domain: String, MicroTargetPathConvertable {
         case BaseDomain
-
-        func targetName(type: MicroTargetType) -> String {
-            "\(self.rawValue)\(type.rawValue)"
-        }
     }
 }
 
 public extension ModulePaths {
-    enum Core: String {
+    enum Core: String, MicroTargetPathConvertable {
         case CoreKit
-
-        func targetName(type: MicroTargetType) -> String {
-            "\(self.rawValue)\(type.rawValue)"
-        }
     }
 }
 
 public extension ModulePaths {
-    enum Shared: String {
+    enum Shared: String, MicroTargetPathConvertable {
         case GlobalThirdPartyLibrary
-
-        func targetName(type: MicroTargetType) -> String {
-            "\(self.rawValue)\(type.rawValue)"
-        }
     }
 }
 
 public extension ModulePaths {
-    enum UserInterface: String {
+    enum UserInterface: String, MicroTargetPathConvertable {
         case DesignSystem
-
-        func targetName(type: MicroTargetType) -> String {
-            "\(self.rawValue)\(type.rawValue)"
-        }
     }
 }
 
 public enum MicroTargetType: String {
     case interface = "Interface"
     case sources = ""
     case testing = "Testing"
+    case unitTest = "Tests"
+    case demo = "Demo"
+}
+
+public protocol MicroTargetPathConvertable {
+    func targetName(type: MicroTargetType) -> String
+}
+
+public extension MicroTargetPathConvertable where Self: RawRepresentable {
+    func targetName(type: MicroTargetType) -> String {
+        "\(self.rawValue)\(type.rawValue)"
+    }
 }

Plugin/DependencyPlugin/ProjectDescriptionHelpers/ModulePaths.swift

@@ -0,0 +1,54 @@
+import Foundation
+import ProjectDescription
+
+public extension TargetDependency {
+    static func feature(
+        target: ModulePaths.Feature,
+        type: MicroTargetType = .sources
+    ) -> TargetDependency {
+        .project(
+            target: target.targetName(type: type),
+            path: .relativeToFeature(target.rawValue)
+        )
+    }
+
+    static func domain(
+        target: ModulePaths.Domain,
+        type: MicroTargetType = .sources
+    ) -> TargetDependency {
+        .project(
+            target: target.targetName(type: type),
+            path: .relativeToDomain(target.rawValue)
+        )
+    }
+
+    static func core(
+        target: ModulePaths.Core,
+        type: MicroTargetType = .sources
+    ) -> TargetDependency {
+        .project(
+            target: target.targetName(type: type),
+            path: .relativeToCore(target.rawValue)
+        )
+    }
+
+    static func shared(
+        target: ModulePaths.Shared,
+        type: MicroTargetType = .sources
+    ) -> TargetDependency {
+        .project(
+            target: target.targetName(type: type),
+            path: .relativeToShared(target.rawValue)
+        )
+    }
+
+    static func userInterface(
+        target: ModulePaths.UserInterface,
+        type: MicroTargetType = .sources
+    ) -> TargetDependency {
+        .project(
+            target: target.targetName(type: type),
+            path: .relativeToUserInterface(target.rawValue)
+        )
+    }
+}

Plugin/DependencyPlugin/ProjectDescriptionHelpers/TargetDependency+MicroFeatureTarget.swift

@@ -7,7 +7,6 @@ let project = Project.makeModule(
     product: .framework,
     targets: [.unitTest],
     internalDependencies: [
-        .Shared.GlobalThirdPartyLibrary,
-        .Shared.UtilityModule
+        .shared(target: .GlobalThirdPartyLibrary)
     ]
 )

Projects/Domain/BaseDomain/Project.swift

@@ -7,8 +7,7 @@ let project = Project.makeModule(
     product: .framework,
     targets: [.unitTest],
     internalDependencies: [
-        .Core.DesignSystem,
-        .Shared.GlobalThirdPartyLibrary,
-        .Shared.UtilityModule
+        .userInterface(target: .DesignSystem),
+        .shared(target: .GlobalThirdPartyLibrary)
     ]
 )

Projects/Feature/BaseFeature/Project.swift

@@ -26,15 +26,12 @@ func registerModuleDependency() {
     registerModulePaths()
     makeProjectDirectory()
     registerXCConfig()
-    registerMicroTarget(target: .sources)
     var targetString = "["
     if hasInterface {
-        registerMicroTarget(target: .interface)
         makeScaffold(target: .interface)
         targetString += ".\(MicroTargetType.interface), "
     }
     if hasTesting {
-        registerMicroTarget(target: .testing)
         makeScaffold(target: .testing)
         targetString += ".\(MicroTargetType.testing), "
     }
@@ -61,27 +58,12 @@ func registerModuleDependency() {
 func registerModulePaths() {
     updateFileContent(
         filePath: currentPath + "Plugin/DependencyPlugin/ProjectDescriptionHelpers/ModulePaths.swift",
-        finding: "enum \(layer.rawValue): String {\n",
+        finding: "enum \(layer.rawValue): String, MicroTargetPathConvertable {\n",
         inserting: "        case \(moduleName)\n"
     )
     print("Register \(moduleName) to ModulePaths.swift")
 }
 
-func registerMicroTarget(target: MicroTargetType) {
-    let targetString = """
-    static let \(moduleName)\(target.rawValue) = TargetDependency.project(
-        target: ModulePaths.\(layer.rawValue).\(moduleName).targetName(type: .\(target)),
-        path: .relativeTo\(layer.rawValue)(ModulePaths.\(layer.rawValue).\(moduleName).rawValue)
-    )\n
-"""
-    updateFileContent(
-        filePath: currentPath + "Plugin/DependencyPlugin/ProjectDescriptionHelpers/Dependency+Target.swift",
-        finding: "public extension TargetDependency.\(layer.rawValue) {\n",
-        inserting: targetString
-    )
-    print("Register \(moduleName) \(target.rawValue) target to Dependency+Target.swift")
-}
-
 func registerXCConfig() {
     makeDirectory(path: currentPath + "XCConfig/\(moduleName)")
     let xcconfigContent = "#include \"../Shared.xcconfig\""
@@ -220,18 +202,19 @@ print("This module has a 'Demo' Target? (y\\n, default = n)", terminator: " : ")
 let hasDemo = readLine()?.lowercased() == "y"
 
 print("")
+print("""
+------------------------------------------------------------------------------------------------------------------------
+Layer: \(layer.rawValue)
+Module name: \(moduleName)
+interface: \(hasInterface), testing: \(hasTesting), unitTests: \(hasUnitTests), uiTests: \(hasUITests), demo: \(hasDemo)
+------------------------------------------------------------------------------------------------------------------------
+""")
+print("🔄 Module is creating ...")
 
 registerModuleDependency()
 
-print("")
-print("------------------------------------------------------------------------------------------------------------------------")
-print("Layer: \(layer.rawValue)")
-print("Module name: \(moduleName)")
-print("interface: \(hasInterface), testing: \(hasTesting), unitTests: \(hasUnitTests), uiTests: \(hasUITests), demo: \(hasDemo)")
-print("------------------------------------------------------------------------------------------------------------------------")
 print("✅ Module is created successfully!")
 
-
 // MARK: - Bash
 protocol CommandExecuting {
     func run(commandName: String, arguments: [String]) throws -> String