buildFile <<
            """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->
                           classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }.entryAttributes.customKey = 'customValue'
                       }
                   }
               }

          assert it.deployName == 'coolDeployName'
        }
        whenMerged {
          hooks << 'whenMerged'
          it.deployName = 'betterDeployName'
        }
        withXml { it.asNode().appendNode('be', 'cool') }
      }
    }
  }
}

eclipseWtpComponent.doLast() {
  assert hooks == ['beforeMerged', 'whenMerged']
}

        """

        //when

    }

    @Issue('eclipse/buildship#694')
    def "EclipseProject attributes modified via whenMerged"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           import org.gradle.plugins.ide.eclipse.model.BuildCommand

           eclipse.project.file.whenMerged {
               it.natures.clear()
               it.buildCommands.clear()
           }
        """

 * For tackling edge cases users can perform advanced configuration on resulting XML file.
 * It is also possible to affect the way eclipse plugin merges the existing configuration
 * via beforeMerged and whenMerged closures.
 * <p>
 * beforeMerged and whenMerged closures receive {@link Project} object
 * <p>
 * Examples of advanced configuration:
 *
 * <pre class='autoTested'>
 * plugins {
 *     id 'java'
 *     id 'eclipse'
 * }

        setup:
        buildFile << """
            import org.gradle.plugins.ide.eclipse.model.AccessRule
            eclipse.classpath.file.whenMerged {
                def dependency = entries.find { it.path.contains 'example-lib' }
                dependency.accessRules.add(new AccessRule('0', 'id-accessible'))

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

            whenMerged {whenConfiguredObjects++ }
        }
    }

    classpath {
        file {
            beforeMerged {beforeConfiguredObjects++ }
            whenMerged {whenConfiguredObjects++ }
        }
    }

    wtp.component {
        file {
            beforeMerged {beforeConfiguredObjects++ }
            whenMerged {whenConfiguredObjects++ }
        }
    }

idea.project.ipr {
    beforeMerged { project ->
        project.modulePaths.clear()
    }
}
// end::project-before-merged[]


// tag::module-when-merged[]
idea.module.iml {
    whenMerged { module ->
        module.dependencies*.exported = true
    }
}
// end::module-when-merged[]

// tag::project-with-xml[]
idea.project.ipr {
    withXml { provider ->
        provider.node.component

            dependencies {
                implementation 'com.google.guava:guava:18.0'
            }

            eclipse {
                classpath {
                    file {
                        whenMerged { classpath ->
                            def guava = classpath.entries.find { it.path.contains('guava-18') }
                            guava.javadocPath = classpath.fileReference('$customJavadocPath')

. The `beforeMerged` hook is executed with a domain object representing the existing file
. The existing content is merged with the configuration inferred from the Gradle build or defined explicitly in the eclipse DSL
. The `whenMerged` hook is executed with a domain object representing contents of the file to be persisted
. The `withXml` hook is executed with a raw representation of the XML that will be persisted
. The final XML is persisted