Update README and remove compound module concept

I deemed the compound module concept as useless for now.
If we want to import protocol with an identical name from different targets, we should work on prefixing them with their target name in the generated mocks.

Author: SylvainRX

Generator/Plugin/Modular/CuckooPluginModular.swift

@@ -37,7 +37,6 @@ struct CuckooPluginModular: BuildToolPlugin {
         }
 
         return try commandsPerModule(
-            targetName: target.name,
             sourceModules: allSourceModules,
             executableFactory: context.tool(named:),
             projectDir: context.package.directoryURL,
@@ -86,7 +85,6 @@ extension CuckooPluginModular: XcodeBuildToolPlugin {
         allSourceModules.append(selfModule)
 
         return try commandsPerModule(
-            targetName: target.displayName,
             sourceModules: allSourceModules,
             executableFactory: context.tool(named:),
             projectDir: context.xcodeProject.directoryURL,
@@ -102,7 +100,6 @@ struct SourceModule {
 }
 
 private func commandsPerModule(
-    targetName: String,
     sourceModules: [SourceModule],
     executableFactory: (String) throws -> PluginContext.Tool,
     projectDir: URL,
@@ -123,7 +120,6 @@ private func commandsPerModule(
                 "DERIVED_SOURCES_DIR": derivedSourcesDir.path(),
                 "CUCKOO_OVERRIDE_OUTPUT": outputURL.path(),
                 "CUCKOO_MODULE_NAME": sourceModule.name,
-                "CUCKOO_COMPOUND_MODULE_NAME": "\(targetName)/\(sourceModule.name)",
             ],
             inputFiles: [configurationURL] + sourceModule.sources,
             outputFiles: [outputURL]

Generator/Sources/CLI/GenerateCommand.swift

@@ -56,11 +56,9 @@ struct GenerateCommand: AsyncParsableCommand {
         )
 
         if modules.isEmpty {
-            let compoundModuleName = ProcessInfo.processInfo.environment["CUCKOO_COMPOUND_MODULE_NAME"]
             let requestedModuleName = ProcessInfo.processInfo.environment["CUCKOO_MODULE_NAME"]
-            let effectiveName = compoundModuleName ?? requestedModuleName
-            if let effectiveName {
-                log(.info, message: "No module named '\(effectiveName)' found in Cuckoofile, skipping generation.")
+            if let requestedModuleName {
+                log(.info, message: "No module named '\(requestedModuleName)' found in Cuckoofile, skipping generation.")
             }
             if let outputPath = overriddenOutput {
                 let path = Path(outputPath, expandingTilde: true)
@@ -124,7 +122,6 @@ struct GenerateCommand: AsyncParsableCommand {
 
     func modules(configurationPath: Path, contents: String) throws -> [Module] {
         let requestedModuleName = ProcessInfo.processInfo.environment["CUCKOO_MODULE_NAME"]
-        let compoundModuleName = ProcessInfo.processInfo.environment["CUCKOO_COMPOUND_MODULE_NAME"]
 
         var errorMessages: [String] = []
         var globalOutput: String? = overriddenOutput
@@ -188,39 +185,9 @@ struct GenerateCommand: AsyncParsableCommand {
             throw GenerateError.configurationErrors(details: errorMessages)
         }
 
-        let filteredModules = filterModulesByEnvironment(
-            allModules: allModules,
-            compoundModuleName: compoundModuleName,
-            requestedModuleName: requestedModuleName
-        )
-
-        return filteredModules
-    }
-
-    /// Filter modules based on environment variables set by the plugin.
-    /// Priority: compound module name (TARGET/MODULE) > plain module name > all modules.
-    /// This allows test targets to override shared dependency mock generation.
-    private func filterModulesByEnvironment(
-        allModules: [Module],
-        compoundModuleName: String?,
-        requestedModuleName: String?
-    ) -> [Module] {
-        if let compoundModuleName {
-            let compoundMatches = allModules.filter { $0.name == compoundModuleName }
-            if !compoundMatches.isEmpty {
-                // Compound key (TARGET/MODULE) found – use it exclusively.
-                // An entry with empty sources acts as a suppressor, producing an empty output file.
-                return compoundMatches
-            } else if let requestedModuleName {
-                // No compound override – fall back to the plain module name.
-                return allModules.filter { $0.name == requestedModuleName }
-            } else {
-                return []
-            }
-        } else if let requestedModuleName {
+        if let requestedModuleName {
             return allModules.filter { $0.name == requestedModuleName }
         }
-
         return allModules
     }
 

README.md

@@ -133,63 +133,49 @@ target = "Cuckoonator"
 
 #### For CuckooPluginModular
 
-When using `CuckooPluginModular`, the plugin automatically detects source modules from your test target's dependencies and generates a dedicated mock file for each one (`GeneratedMocks_<ModuleName>.swift`). It supports compound module names (`TARGET/MODULE`) in `Cuckoofile.toml` so that different test targets can customize mock generation for shared dependencies.
+`CuckooPluginSingleFile` puts all mocks into a single `GeneratedMocks.swift` file in derived data. In a Swift Package with multiple targets this is problematic because each test target compiles independently and may not have visibility into types from unrelated modules. Use `CuckooPluginModular` instead: it inspects your test target's dependencies and runs the generator once per dependency module, producing a separate `GeneratedMocks_<ModuleName>.swift` for each.
+
+A `Cuckoofile.toml` entry is required for each module you want to generate mocks for. The plugin looks up the test target's own name (e.g. `[modules.TargetATests]`), letting you specify which source files to mock and which imports to add. Modules without a matching entry produce an empty file and no mocks.
 
 **Example `Cuckoofile.toml` for modular projects:**
 
 ```toml
-# CoreModule mocks
-[modules.CoreModuleTests]
-imports = ["Foundation"]
-testableImports = ["CoreModule"]
-sources = [
-    "Sources/CoreModule/ServiceProtocol.swift"
-]
-
-# NetworkAPI module mocks
-[modules.FirstNetworkAPITests]
+# TargetA mocks
+[modules.TargetATests]
 imports = ["Foundation"]
-testableImports = ["FirstNetworkAPI"]
+testableImports = ["TargetA"] #ProtocolA is internal to TargetA
 sources = [
-    "Sources/FirstNetworkAPI/Generated/Client.swift"
+    "Sources/TargetA/InternalProtocolA.swift"
 ]
 
-# SecondNetworkAPI module mocks
-[modules.SecondNetworkAPITests]
-imports = ["Foundation"]
-testableImports = ["SecondNetworkAPI"]
+# AggregationTarget mocks - demonstrates multiple testableImports
+[modules.AggregationTargetTests]
+imports = ["Foundation", "TargetA", "TargetB"]
 sources = [
-    "Sources/SecondNetworkAPI/Generated/Client.swift"
-]
-
-# FeatureModule mocks - demonstrates multiple testableImports
-[modules.FeatureModuleTests]
-imports = ["Foundation"]
-testableImports = ["FirstNetworkAPI", "SecondNetworkAPI"]
-sources = [
-    "Sources/FirstNetworkAPI/FirstNetworkAPI.swift",
-    "Sources/SecondNetworkAPI/SecondNetworkAPI.swift"
+    "Sources/TargetA/ProtocolA.swift",
+    "Sources/TargetB/ProtocolB.swift",
 ]
 ```
 
-**Note:** The modules specified in `testableImports` must be added as dependencies of your test target in `Package.swift`. For example:
+`Package.swift`:
 
 ```swift
 .testTarget(
-    name: "CoreModuleTests",
-    dependencies: ["CoreModule", "Cuckoo"]
+    name: "TargetATests",
+    dependencies: ["TargetA", "Cuckoo"],
+    plugins: [
+        .plugin(name: "CuckooPluginModular", package: "Cuckoo"),
+    ]
 ),
 .testTarget(
-    name: "FeatureModuleTests",
-    dependencies: ["FirstNetworkAPI", "SecondNetworkAPI", "Cuckoo"]
+    name: "AggregationTargetTests",
+    dependencies: ["AggregationTarget", "Cuckoo"],
+    plugins: [
+        .plugin(name: "CuckooPluginModular", package: "Cuckoo"),
+    ]
 )
 ```
 
-This approach is essential when:
-- **Multiple modules define protocols/types with identical names** (e.g., both `ModuleA` and `ModuleB` have a `ServiceProtocol`)
-- Different test targets need different subsets of mocks from the same module
-- You want to organize and namespace mocks by test target for clarity
-
 ### 3. Usage
 Usage of Cuckoo is similar to [Mockito](http://mockito.org/) and [Hamcrest](http://hamcrest.org/). However, there are some differences and limitations caused by generating the mocks and Swift language itself. List of all the supported features can be found below. You can find complete examples in [tests](Tests).