Code cleanup: coverage improvements and dead code removal

.periphery.yml

@@ -18,6 +18,7 @@ index_exclude:
   - "**/checkouts/**"
   - "**/.github/**"
   - "**/Docs/**"
+  - "**/Tests/**"
 
 # Exclude test files from reports
 report_exclude:

.swiftlint.yml

@@ -1,7 +1,6 @@
 # Project paths
 included:
   - Sources
-  - Tests
 
 # Analyzer exclusions
 excluded:

Sources/SwiftMutationTesting/Build/BuildError.swift

@@ -1,7 +1,21 @@
-enum BuildError: Error, Equatable {
+import Foundation
+
+enum BuildError: Error, Equatable, LocalizedError {
     case compilationFailed(output: String)
     case xctestrunNotFound
 
+    var errorDescription: String? {
+        switch self {
+        case .compilationFailed(let output):
+            var message = "Build failed. The schematized source could not be compiled."
+            if !output.isEmpty { message = output + "\n" + message }
+            return message
+
+        case .xctestrunNotFound:
+            return "xctestrun file not found after build."
+        }
+    }
+
     static func == (lhs: BuildError, rhs: BuildError) -> Bool {
         switch (lhs, rhs) {
         case (.compilationFailed, .compilationFailed): return true

Sources/SwiftMutationTesting/Build/BuildStage.swift

@@ -25,12 +25,14 @@ struct BuildStage: Sendable {
         }
 
         let (exitCode, buildOutput) = try await launcher.launchCapturing(
-            executableURL: URL(fileURLWithPath: "/usr/bin/xcodebuild"),
-            arguments: arguments,
-            environment: nil,
-            additionalEnvironment: [:],
-            workingDirectoryURL: sandbox.rootURL,
-            timeout: timeout
+            ProcessRequest(
+                executableURL: URL(fileURLWithPath: "/usr/bin/xcodebuild"),
+                arguments: arguments,
+                environment: nil,
+                additionalEnvironment: [:],
+                workingDirectoryURL: sandbox.rootURL,
+                timeout: timeout
+            )
         )
 
         guard exitCode == 0 else {
@@ -58,18 +60,19 @@ struct BuildStage: Sendable {
 
     func buildSPM(
         sandbox: Sandbox,
-        testTarget: String?,
         timeout: Double
     ) async throws -> BuildArtifact {
         let arguments = ["build", "--build-tests"]
 
         let (exitCode, buildOutput) = try await launcher.launchCapturing(
-            executableURL: URL(fileURLWithPath: "/usr/bin/swift"),
-            arguments: arguments,
-            environment: nil,
-            additionalEnvironment: [:],
-            workingDirectoryURL: sandbox.rootURL,
-            timeout: timeout
+            ProcessRequest(
+                executableURL: URL(fileURLWithPath: "/usr/bin/swift"),
+                arguments: arguments,
+                environment: nil,
+                additionalEnvironment: [:],
+                workingDirectoryURL: sandbox.rootURL,
+                timeout: timeout
+            )
         )
 
         guard exitCode == 0 else { throw BuildError.compilationFailed(output: buildOutput) }

Sources/SwiftMutationTesting/CLI/CommandLineParser.swift

@@ -97,6 +97,7 @@ struct CommandLineParser: Sendable {
         return values
     }
 
+    // swiftlint:disable:next cyclomatic_complexity
     private func applyFlag(
         _ flag: String,
         to values: inout FlagValues,

Sources/SwiftMutationTesting/Cache/CacheStore.swift

@@ -1,10 +1,6 @@
 import Foundation
 
 actor CacheStore {
-    private struct CacheEntry: Codable {
-        let key: MutantCacheKey
-        let status: ExecutionStatus
-    }
 
     init(storePath: String) {
         self.storePath = storePath
@@ -16,6 +12,11 @@ actor CacheStore {
     private let storePath: String
     private var entries: [MutantCacheKey: ExecutionStatus]
 
+    private struct CacheEntry: Codable {
+        let key: MutantCacheKey
+        let status: ExecutionStatus
+    }
+
     func result(for key: MutantCacheKey) -> ExecutionStatus? {
         entries[key]
     }

Sources/SwiftMutationTesting/Configuration/ConfigurationFileParser.swift

@@ -46,7 +46,7 @@ struct ConfigurationFileParser: Sendable {
         }
 
         if !disabledMutators.isEmpty {
-            result["disabledMutators"] = disabledMutators.joined(separator: ",")
+            result["disabled-mutators"] = disabledMutators.joined(separator: ",")
         }
 
         return result

Sources/SwiftMutationTesting/Configuration/ConfigurationFileWriter.swift

@@ -55,17 +55,24 @@ struct ConfigurationFileWriter: Sendable {
         lines.append("")
         lines.append("# Testing framework: xctest or swift-testing (default: swift-testing)")
         lines.append("# When xctest is selected, concurrency is forced to 1 for deterministic results")
-        lines.append("testingFramework: \(testingFramework.rawValue)")
+        lines.append("testing-framework: \(testingFramework.rawValue)")
         lines.append("")
 
         if let testTarget {
             lines.append("# Limit test execution to a specific target (recommended when the project has UI tests)")
-            lines.append("testTarget: \(testTarget)")
+            lines.append("test-target: \(testTarget)")
         } else {
             lines.append("# Limit test execution to a specific target (recommended when the project has UI tests)")
-            lines.append("# testTarget: MyAppTests")
+            lines.append("# test-target: MyAppTests")
         }
 
+        lines.append(contentsOf: xcodeRunSection(testingFramework: testingFramework, testTarget: testTarget))
+
+        return lines.joined(separator: "\n") + "\n"
+    }
+
+    private func xcodeRunSection(testingFramework: TestingFramework, testTarget: String?) -> [String] {
+        var lines: [String] = []
         lines.append("")
         lines.append("# Per-mutant test timeout in seconds (default: 120)")
         lines.append("timeout: 120")
@@ -76,28 +83,9 @@ struct ConfigurationFileWriter: Sendable {
         } else {
             lines.append("concurrency: 4")
         }
-        lines.append("")
-        lines.append("# Disable result cache (re-runs all mutants on every execution)")
-        lines.append("# noCache: true")
-        lines.append("")
-        lines.append("# Report output paths")
-        lines.append("# output: mutation-report.json")
-        lines.append("# htmlOutput: mutation-report.html")
-        lines.append("sonarOutput: sonar-mutation-report.json")
-        lines.append("")
-        lines.append("# Source file glob patterns to exclude from mutation")
-
-        if let testTarget {
-            lines.append("exclude:")
-            lines.append("  - \"/\(testTarget)/\"")
-        } else {
-            lines.append("# exclude:")
-            lines.append("#   - \"**/Generated/**\"")
-        }
-
+        lines.append(contentsOf: reportSection(testTarget: testTarget, excludeExample: "**/Generated/**"))
         lines.append(contentsOf: mutatorsSection())
-
-        return lines.joined(separator: "\n") + "\n"
+        return lines
     }
 
     private func generateSPMContent(testTargets: [String], testTarget: String?) -> String {
@@ -113,37 +101,41 @@ struct ConfigurationFileWriter: Sendable {
 
         if let testTarget {
             lines.append("# Limit test execution to a specific target")
-            lines.append("testTarget: \(testTarget)")
+            lines.append("test-target: \(testTarget)")
         } else {
             lines.append("# Limit test execution to a specific target")
-            lines.append("# testTarget: MyPackageTests")
+            lines.append("# test-target: MyPackageTests")
         }
 
         lines.append("")
         lines.append("# Per-mutant test timeout in seconds (default: 30 for SPM)")
         lines.append("timeout: 30")
+        lines.append(contentsOf: reportSection(testTarget: testTarget, excludeExample: "**/Tests/**"))
+        lines.append(contentsOf: mutatorsSection())
+
+        return lines.joined(separator: "\n") + "\n"
+    }
+
+    private func reportSection(testTarget: String?, excludeExample: String) -> [String] {
+        var lines: [String] = []
         lines.append("")
         lines.append("# Disable result cache (re-runs all mutants on every execution)")
-        lines.append("# noCache: true")
+        lines.append("# no-cache: true")
         lines.append("")
         lines.append("# Report output paths")
-        lines.append("# output: mutation-report.json")
-        lines.append("# htmlOutput: mutation-report.html")
-        lines.append("sonarOutput: sonar-mutation-report.json")
+        lines.append("output: mutation-report.json")
+        lines.append("# html-output: mutation-report.html")
+        lines.append("# sonar-output: sonar-mutation-report.json")
         lines.append("")
         lines.append("# Source file glob patterns to exclude from mutation")
-
         if let testTarget {
             lines.append("exclude:")
             lines.append("  - \"/\(testTarget)/\"")
         } else {
             lines.append("# exclude:")
-            lines.append("#   - \"**/Tests/**\"")
+            lines.append("#   - \"\(excludeExample)\"")
         }
-
-        lines.append(contentsOf: mutatorsSection())
-
-        return lines.joined(separator: "\n") + "\n"
+        return lines
     }
 
     private func mutatorsSection() -> [String] {

Sources/SwiftMutationTesting/Configuration/ConfigurationResolver.swift

@@ -32,23 +32,23 @@ struct ConfigurationResolver: Sendable {
             projectPath: projectPath,
             build: .init(
                 projectType: projectType,
-                testTarget: cliArguments.build.testTarget ?? fileValues["testTarget"],
+                testTarget: cliArguments.build.testTarget ?? fileValues["test-target"],
                 timeout: timeout,
                 concurrency: effectiveConcurrency,
-                noCache: cliArguments.build.noCache || fileValues["noCache"]?.lowercased() == "true",
+                noCache: cliArguments.build.noCache || fileValues["no-cache"]?.lowercased() == "true",
                 testingFramework: testingFramework
             ),
             reporting: .init(
                 output: cliArguments.reporting.output ?? fileValues["output"],
-                htmlOutput: cliArguments.reporting.htmlOutput ?? fileValues["htmlOutput"],
-                sonarOutput: cliArguments.reporting.sonarOutput ?? fileValues["sonarOutput"],
+                htmlOutput: cliArguments.reporting.htmlOutput ?? fileValues["html-output"],
+                sonarOutput: cliArguments.reporting.sonarOutput ?? fileValues["sonar-output"],
                 quiet: cliArguments.reporting.quiet || fileValues["quiet"]?.lowercased() == "true"
             ),
             filter: .init(
-                sourcesPath: cliArguments.filter.sourcesPath ?? fileValues["sourcesPath"],
+                sourcesPath: cliArguments.filter.sourcesPath ?? fileValues["sources-path"],
                 excludePatterns: resolveList(
                     cli: cliArguments.filter.excludePatterns,
-                    keys: ["exclude", "excludePatterns"],
+                    keys: ["exclude", "exclude-patterns"],
                     from: fileValues
                 ),
                 operators: resolveOperators(cli: cliArguments, fileValues: fileValues)
@@ -104,7 +104,7 @@ struct ConfigurationResolver: Sendable {
 
     private func resolvedTestingFramework(cli: ParsedArguments, fileValues: [String: String]) throws -> TestingFramework
     {
-        let raw = cli.build.testingFramework ?? fileValues["testingFramework"]
+        let raw = cli.build.testingFramework ?? fileValues["testing-framework"]
 
         guard let raw else {
             return .swiftTesting
@@ -127,7 +127,7 @@ struct ConfigurationResolver: Sendable {
             return DiscoveryPipeline.allOperatorNames.filter { !disabled.contains($0) }
         }
 
-        let fileDisabled = resolveList(cli: [], keys: ["disabledMutators"], from: fileValues)
+        let fileDisabled = resolveList(cli: [], keys: ["disabled-mutators"], from: fileValues)
         if !fileDisabled.isEmpty {
             let disabled = Set(fileDisabled)
             return DiscoveryPipeline.allOperatorNames.filter { !disabled.contains($0) }

Sources/SwiftMutationTesting/Configuration/DetectedProject.swift

@@ -1,8 +1,4 @@
 struct DetectedProject: Sendable {
-    enum Kind: Sendable {
-        case xcode(scheme: String?, allSchemes: [String], destination: String)
-        case spm(testTargets: [String])
-    }
 
     static let empty = DetectedProject(
         kind: .xcode(scheme: nil, allSchemes: [], destination: "platform=macOS"),
@@ -14,18 +10,26 @@ struct DetectedProject: Sendable {
     let testTarget: String?
     var testingFramework: TestingFramework = .swiftTesting
 
+    // periphery:ignore
     var scheme: String? {
         guard case .xcode(let xScheme, _, _) = kind else { return nil }
         return xScheme
     }
 
+    // periphery:ignore
     var allSchemes: [String] {
         guard case .xcode(_, let all, _) = kind else { return [] }
         return all
     }
 
+    // periphery:ignore
     var destination: String {
         guard case .xcode(_, _, let dest) = kind else { return "platform=macOS" }
         return dest
     }
+
+    enum Kind: Sendable {
+        case xcode(scheme: String?, allSchemes: [String], destination: String)
+        case spm(testTargets: [String])
+    }
 }