apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   containers 'classpathContainerPath'
                   file {
                       whenMerged { classpath ->
                           def container = classpath.entries.find { it.kind == 'con' && it.path == 'classpathContainerPath' }

           apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->
                           def sourceDir = classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }
                           sourceDir.accessRules.add(new AccessRule('0', 'accessibleFilesPattern'))

// end::module-when-merged[]
    beforeMerged(Action<Classpath> {
        entries.removeAll { entry -> entry.kind == "lib" || entry.kind == "var" }
    })
// end::module-before-merged[]
// tag::module-when-merged[]
    whenMerged(Action<Classpath> { ->
        entries.filter { entry -> entry.kind == "lib" }
            .forEach { (it as AbstractClasspathEntry).isExported = false }
    })
// tag::module-before-merged[]
}

        ipr {
            beforeMerged {
                assert it.wildcards.contains('!?*.fooBar')
                it.wildcards << '!?*.fooBarTwo'
                hooks << 'before'
            }
            whenMerged {
                assert it.wildcards.contains('!?*.fooBarTwo')
                hooks << 'when'
            }
        }
    }
}

ideaProject.doLast {
    assert hooks == ['before', 'when']
}

        super(null);
        this.delegate = delegate;
    }

    @Override
    public void setName(String name) {
        throw new InvalidUserDataException("Configuring eclipse project name in 'beforeMerged' or 'whenMerged' hook is not allowed.");
    }

    @Override
    public String getDefaultResourceName() {
        return delegate.getDefaultResourceName();
    }

    @Override
    public String getName() {

        """import org.gradle.plugins.ide.eclipse.model.AccessRule
           eclipse {
               classpath {
                   containers 'classpathContainerPath'
                   file {
                       whenMerged { classpath ->
                           def projectDependency = classpath.entries.find { it.path == '/sub' }
                           projectDependency.accessRules.add(new AccessRule('0', 'sub-accessibleFilesPattern'))

 * It is also possible to affect the way the IDEA plugin merges the existing configuration
 * via beforeMerged and whenMerged closures.
 * <p>
 * beforeMerged and whenMerged closures receive a {@link Module} parameter
 * <p>
 * Examples of advanced configuration:
 *
 * <pre class='autoTested'>
 * plugins {
 *     id 'java'
 *     id 'idea'
 * }

            testImplementation child2.dependencies.project(path: ":child1", configuration: "testArtifacts")
        }
        child3.eclipse {
            (classpath as EclipseClasspath).file.whenMerged {
                def customDependency = new ProjectDependency("/child1")
                customDependency.buildDependencies(":child1:jar")
                customDependency.publication = fileReference("customJar.jar")

        assert it.entries.any { it.path.contains('someVarDependency.jar') }
        assert !it.entries.any { it.path.contains('newDependency.jar') }
      }
      whenMerged {
        hooks << 'whenMerged'
        assert it.entries.size() == 3
        assert it.entries.any { it.path.contains('newDependency.jar') }
        assert !it.entries.any { it.path.contains('someDependency.jar') }

            }
            project(":child2") {
                dependencies {
                    implementation project(":child1");
                }
                eclipse {
                    classpath.file.whenMerged { cp ->
                        def dep = entries.find { it.path.endsWith('child1') }
                        def sourceJar = this.project(":child1").tasks.getByName("sourceJar")