Moving files around

Author: goergisn

Package.swift

@@ -3,28 +3,136 @@
 
 import PackageDescription
 
+private extension String {
+    static var core: Self { "CoreModule" }
+    static var fileHandling: Self { "FileHandlingModule" }
+    static var shell: Self { "ShellModule" }
+    static var git: Self { "GitModule" }
+    static var logging: Self { "LoggingModule" }
+    static var outputGenerator: Self { "OutputGeneratorModule" }
+    static var swiftInterfaceAnalyzerModule: Self { "SwiftInterfaceAnalyzerModule" }
+    static var projectSetupModule: Self { "ProjectSetupModule" }
+    static var swiftInterfaceProducerModule: Self { "SwiftInterfaceProducerModule" }
+    static var swiftPackageFileHelperModule: Self { "SwiftPackageFileHelperModule" }
+    static var swiftPackageFileAnalyzerModule: Self { "SwiftPackageFileAnalyzerModule" }
+    
+}
+
+extension Target.Dependency {
+    static var core: Self { .byName(name: .core) }
+    static var fileHandling: Self { .byName(name: .fileHandling) }
+    static var shell: Self { .byName(name: .shell) }
+    static var git: Self { .byName(name: .git) }
+    static var logging: Self { .byName(name: .logging) }
+    static var outputGenerator: Self { .byName(name: .outputGenerator) }
+    static var swiftInterfaceAnalyzerModule: Self { .byName(name: .swiftInterfaceAnalyzerModule) }
+    static var projectSetupModule: Self { .byName(name: .projectSetupModule) }
+    static var swiftInterfaceProducerModule: Self { .byName(name: .swiftInterfaceProducerModule) }
+    static var swiftPackageFileHelperModule: Self { .byName(name: .swiftPackageFileHelperModule) }
+    static var swiftPackageFileAnalyzerModule: Self { .byName(name: .swiftPackageFileAnalyzerModule) }
+}
+
 let package = Package(
     name: "public-api-diff",
     platforms: [
         .macOS(.v13)
     ],
+    products: [
+        .executable(
+            name: "public-api-diff",
+            targets: ["public-api-diff"]
+        ),
+        .library(
+            name: "SwiftInterfaceDiff",
+            targets: [.swiftInterfaceAnalyzerModule]
+        )
+    ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.5.0"),
         .package(url: "https://github.com/swiftlang/swift-syntax", from: "600.0.0"),
         .package(url: "https://github.com/nicklockwood/SwiftFormat", from: "0.54.6")
     ],
     targets: [
-        // Targets are the basic building blocks of a package, defining a module or a test suite.
-        // Targets can depend on other targets in this package and products from dependencies.
         .executableTarget(
             name: "public-api-diff",
             dependencies: [
-                .product(name: "ArgumentParser", package: "swift-argument-parser"),
-                .product(name: "SwiftSyntax", package: "swift-syntax"),
-                .product(name: "SwiftParser", package: "swift-syntax"),
+                .core,
+                .logging,
+                .shell,
+                .git,
+                .outputGenerator,
+                .fileHandling,
+                .projectSetupModule,
+                .swiftInterfaceProducerModule,
+                .swiftInterfaceAnalyzerModule,
+                .swiftPackageFileHelperModule,
+                .swiftPackageFileAnalyzerModule,
+                "ProjectBuilderModule",
+                .product(name: "ArgumentParser", package: "swift-argument-parser")
             ],
-            path: "Sources"
+            path: "Sources/CommandLineTool"
         ),
+        
+        // MARK: - Modules
+        
+        .target(name: .core),
+        .target(name: .shell, dependencies: [
+            .core
+        ]),
+        .target(name: .logging, dependencies: [
+            .core,
+            .fileHandling
+        ]),
+        .target(name: .git, dependencies: [
+            .core,
+            .shell,
+            .fileHandling,
+            .logging
+        ]),
+        .target(name: .outputGenerator, dependencies: [
+            .core
+        ]),
+        .target(name: .fileHandling, dependencies: [
+            .core
+        ]),
+        .target(name: .swiftInterfaceAnalyzerModule, dependencies: [
+            .core,
+            .product(name: "SwiftSyntax", package: "swift-syntax"),
+            .product(name: "SwiftParser", package: "swift-syntax"),
+        ]),
+        .target(name: .swiftInterfaceProducerModule, dependencies: [
+            .core,
+            .fileHandling,
+            .logging,
+            .swiftPackageFileHelperModule
+        ]),
+        .target(name: .projectSetupModule, dependencies: [
+            .shell,
+            .fileHandling,
+            .logging,
+            .git
+        ]),
+        .target(name: .swiftPackageFileHelperModule, dependencies: [
+            .core,
+            .fileHandling,
+            .logging
+        ]),
+        .target(name: .swiftPackageFileAnalyzerModule, dependencies: [
+            .core,
+            .fileHandling,
+            .shell,
+            .logging,
+            .swiftPackageFileHelperModule
+        ]),
+        .target(name: "ProjectBuilderModule", dependencies: [
+            .swiftPackageFileAnalyzerModule,
+            .swiftPackageFileHelperModule,
+            .fileHandling,
+            .logging
+        ]),
+        
+        // MARK: - Test Targets
+        
         .testTarget(
             name: "UnitTests",
             dependencies: [

Sources/public-api-diff.swift renamed to Sources/CommandLineTool/public-api-diff.swift

@@ -7,6 +7,16 @@
 import ArgumentParser
 import Foundation
 
+import LoggingModule
+import FileHandlingModule
+import CoreModule
+import ProjectSetupModule
+import ShellModule
+import SwiftInterfaceProducerModule
+import SwiftInterfaceAnalyzerModule
+import OutputGeneratorModule
+import ProjectBuilderModule
+
 @main
 struct PublicApiDiff: AsyncParsableCommand {
 
@@ -42,80 +52,36 @@ struct PublicApiDiff: AsyncParsableCommand {
             var warnings = [String]()
             var changes = [String: [Change]]()
 
-            // MARK: START: BUILD PROJECT RELATED
-            
             let oldSource: ProjectSource = try ProjectSource.from(old, fileHandler: fileHandler)
             let newSource: ProjectSource = try ProjectSource.from(new, fileHandler: fileHandler)
 
             let oldVersionName = oldSource.description
-            let newVersionName = oldSource.description
-            
-            logger.log("Comparing `\(newVersionName)` to `\(oldVersionName)`", from: "Main")
+            let newVersionName = newSource.description
 
-            let currentDirectory = fileHandler.currentDirectoryPath
-            let workingDirectoryPath = currentDirectory.appending("/tmp-public-api-diff")
+            // MARK: - Producing .swiftinterface files
 
-            // MARK: - Setup projects
-            
-            let projectSetupHelper = ProjectSetupHelper(
-                workingDirectoryPath: workingDirectoryPath,
-                shell: shell,
-                fileHandler: fileHandler,
+            let projectBuilder = ProjectBuilder(
+                projectType: projectType,
+                swiftInterfaceType: swiftInterfaceType,
                 logger: logger
             )
 
-            let projectDirectories = try await projectSetupHelper.setupProjects(
+            let projectBuilderResult = try await projectBuilder.build(
                 oldSource: oldSource,
-                newSource: newSource,
-                projectType: projectType
+                newSource: newSource
             )
 
-            // MARK: - Analyze Package.swift (optional)
-            
-            switch projectType {
-            case .swiftPackage:
-                let swiftPackageFileAnalyzer = SwiftPackageFileAnalyzer(fileHandler: fileHandler, shell: shell, logger: logger)
-                let swiftPackageAnalysis = try swiftPackageFileAnalyzer.analyze(
-                    oldProjectUrl: projectDirectories.old,
-                    newProjectUrl: projectDirectories.new
-                )
-                
-                warnings = swiftPackageAnalysis.warnings
-                if !swiftPackageAnalysis.changes.isEmpty {
-                    changes["Package.swift"] = swiftPackageAnalysis.changes
-                }
-            case .xcodeProject:
-                warnings = []
-                break // Nothing to do
+            warnings += projectBuilderResult.warnings
+            if !projectBuilderResult.packageFileChanges.isEmpty {
+                changes["Package.swift"] = projectBuilderResult.packageFileChanges
             }
 
-            // MARK: - Produce .swiftinterface files
-            
-            let producer = SwiftInterfaceProducer(
-                workingDirectoryPath: workingDirectoryPath,
-                projectType: projectType,
-                swiftInterfaceType: swiftInterfaceType,
-                fileHandler: fileHandler,
-                shell: shell,
-                logger: logger
-            )
-            
-            let swiftInterfaceFiles = try await producer.produceInterfaceFiles(
-                oldProjectDirectory: projectDirectories.old,
-                newProjectDirectory: projectDirectories.new
-            )
-            
             // MARK: - Analyze .swiftinterface files
 
-            let pipeline = SwiftInterfacePipeline(
-                fileHandler: fileHandler,
-                swiftInterfaceParser: SwiftInterfaceParser(),
-                swiftInterfaceAnalyzer: SwiftInterfaceAnalyzer(),
-                logger: logger
-            )
+            let pipeline = SwiftInterfacePipeline(logger: logger)
 
             let pipelineOutput = try await pipeline.run(
-                with: swiftInterfaceFiles
+                with: projectBuilderResult.swiftInterfaceFiles
             )
 
             // Merging pipeline output into existing changes - making sure we're not overriding any keys
@@ -133,7 +99,7 @@ struct PublicApiDiff: AsyncParsableCommand {
 
             let generatedOutput = try outputGenerator.generate(
                 from: changes,
-                allTargets: swiftInterfaceFiles.map(\.name).sorted(),
+                allTargets: projectBuilderResult.swiftInterfaceFiles.map(\.name).sorted(),
                 oldVersionName: oldVersionName,
                 newVersionName: newVersionName,
                 warnings: warnings

Sources/Helpers/Models/Change.swift renamed to Sources/CoreModule/Change.swift

@@ -7,22 +7,32 @@
 import Foundation
 
 /// A change indicating an `addition`, `removal` or genuine `change` of an element
-struct Change: Equatable {
-    enum ChangeType: Equatable {
+public struct Change: Equatable {
+    public enum ChangeType: Equatable {
         case addition(description: String)
         case removal(description: String)
         case change(oldDescription: String, newDescription: String)
     }
 
-    var changeType: ChangeType
-    var parentPath: String?
+    public private(set) var changeType: ChangeType
+    public private(set) var parentPath: String?
 
-    var listOfChanges: [String] = []
+    public private(set) var listOfChanges: [String] = []
+    
+    public init(
+        changeType: ChangeType,
+        parentPath: String? = nil,
+        listOfChanges: [String] = []
+    ) {
+        self.changeType = changeType
+        self.parentPath = parentPath
+        self.listOfChanges = listOfChanges
+    }
 }
 
 extension Change.ChangeType {
 
-    var isAddition: Bool {
+    public var isAddition: Bool {
         switch self {
         case .addition:
             return true
@@ -33,7 +43,7 @@ extension Change.ChangeType {
         }
     }
 
-    var isRemoval: Bool {
+    public var isRemoval: Bool {
         switch self {
         case .addition:
             return false
@@ -44,7 +54,7 @@ extension Change.ChangeType {
         }
     }
 
-    var isChange: Bool {
+    public var isChange: Bool {
         switch self {
         case .addition:
             return false
@@ -56,7 +66,7 @@ extension Change.ChangeType {
     }
 }
 
-extension [String: [Change]] {
+public extension [String: [Change]] {
 
     var totalChangeCount: Int {
         var totalChangeCount = 0

Sources/CoreModule/ProjectType.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+public enum ProjectType {
+    case swiftPackage
+    case xcodeProject(scheme: String)
+}

Sources/Helpers/RandomStringGenerating.swift renamed to Sources/CoreModule/RandomStringGenerating.swift

@@ -6,14 +6,16 @@
 
 import Foundation
 
-protocol RandomStringGenerating {
+public protocol RandomStringGenerating {
 
     func generateRandomString() -> String
 }
 
-struct RandomStringGenerator: RandomStringGenerating {
+public struct RandomStringGenerator: RandomStringGenerating {
 
-    func generateRandomString() -> String {
+    public init() {}
+    
+    public func generateRandomString() -> String {
         UUID().uuidString
     }
 }

Sources/CoreModule/SwiftInterfaceFile.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+public struct SwiftInterfaceFile {
+    public let name: String
+    public let oldFilePath: String
+    public let newFilePath: String
+    
+    public init(name: String, oldFilePath: String, newFilePath: String) {
+        self.name = name
+        self.oldFilePath = oldFilePath
+        self.newFilePath = newFilePath
+    }
+}

Sources/Helpers/FileHandling/FileHandling+Convenience.swift renamed to Sources/FileHandlingModule/FileHandling+Convenience.swift

@@ -5,8 +5,9 @@
 //
 
 import Foundation
+import CoreModule
 
-enum FileHandlerError: LocalizedError, Equatable {
+public enum FileHandlerError: LocalizedError, Equatable {
     /// Could not encode the output string into data
     case couldNotEncodeOutput
     /// Could not persist output at the specified `outputFilePath`
@@ -16,7 +17,7 @@ enum FileHandlerError: LocalizedError, Equatable {
     /// File/Directory does not exist at `path`
     case pathDoesNotExist(path: String)
 
-    var errorDescription: String? {
+    public var errorDescription: String? {
         switch self {
         case .couldNotEncodeOutput:
             "Could not encode the output string into data"
@@ -32,7 +33,7 @@ enum FileHandlerError: LocalizedError, Equatable {
 
 // MARK: - Convenience
 
-extension FileHandling {
+public extension FileHandling {
 
     /// Creates a directory at the specified path and deletes any old directory if existing
     ///