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,47 @@ 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.
+When using `CuckooPluginModular`, the plugin collects every source module dependency of your test target (excluding Cuckoo) and runs the generator once per module, producing a separate `GeneratedMocks_<ModuleName>.swift` file for each one. It also runs the generator for the test target's own name, so you can add a `[modules.<TestTargetName>]` entry in `Cuckoofile.toml` to control exactly which files are mocked and which imports are added. If no matching entry exists in the configuration, that module is silently skipped.
 
 **Example `Cuckoofile.toml` for modular projects:**
 
 ```toml
-# CoreModule mocks
-[modules.CoreModuleTests]
+# TargetA mocks
+[modules.TargetATests]
 imports = ["Foundation"]
-testableImports = ["CoreModule"]
+testableImports = ["TargetA"] #ProtocolA is internal to TargetA
 sources = [
-    "Sources/CoreModule/ServiceProtocol.swift"
+    "Sources/TargetA/InternalProtocolA.swift"
 ]
 
-# NetworkAPI module mocks
-[modules.FirstNetworkAPITests]
-imports = ["Foundation"]
-testableImports = ["FirstNetworkAPI"]
-sources = [
-    "Sources/FirstNetworkAPI/Generated/Client.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).