# EclipseClasspath

API Documentation: | `EclipseClasspath`

The build path settings for the generated Eclipse project. Used by the `GenerateEclipseClasspath` task to generate an Eclipse .classpath file.

The following example demonstrates the various configuration options. Keep in mind that all properties have sensible defaults; only configure them explicitly if the defaults don't match your needs.

    apply plugin: 'java'
    apply plugin: 'eclipse'

    configurations {
      provided
      someBoringConfig
    }

    eclipse {
      //if you want parts of paths in resulting file to be replaced by variables (files):
      pathVariables 'GRADLE_HOME': file('/best/software/gradle'), 'TOMCAT_HOME': file('../tomcat')

      classpath {
        //you can tweak the classpath of the Eclipse project by adding extra configurations:
        plusConfigurations += configurations.provided

        //you can also remove configurations from the classpath:
        minusConfigurations += configurations.someBoringConfig

        //if you don't want some classpath entries 'exported' in Eclipse
        noExportConfigurations += configurations.provided

        //if you want to append extra containers:
        containers 'someFriendlyContainer', 'andYetAnotherContainer'

        //customizing the classes output directory:
        defaultOutputDir = file('build-eclipse')

        //default settings for downloading sources and Javadoc:
        downloadSources = true
        downloadJavadoc = false
      }
    }

For tackling edge cases, users can perform advanced configuration on the resulting XML file. It is also possible to affect the way that the Eclipse plugin merges the existing configuration via beforeMerged and whenMerged closures.

The beforeMerged and whenMerged closures receive a `Classpath` object.

Examples of advanced configuration:

    apply plugin: 'java'
    apply plugin: 'eclipse'

    eclipse {
      classpath {
        file {
          //if you want to mess with the resulting XML in whatever way you fancy
          withXml {
            def node = it.asNode()
            node.appendNode('xml', 'is what I love')
          }

          //closure executed after .classpath content is loaded from existing file
          //but before gradle build information is merged
          beforeMerged { classpath ->
            //you can tinker with the Classpath here
          }

          //closure executed after .classpath content is loaded from existing file
          //and after gradle build information is merged
          whenMerged { classpath ->
            //you can tinker with the Classpath here
          }
        }
      }
    }

### Properties

Property | Description
`containers` | The classpath containers to be added.
`defaultOutputDir` | The default output directory where Eclipse puts compiled classes.
`downloadJavadoc` | Whether to download and associate Javadoc Jars with the dependency Jars. Defaults to false.
`downloadSources` | Whether to download and associate source Jars with the dependency Jars. Defaults to true.
`file` | See `EclipseClasspath.file{}`.
`minusConfigurations` | The configurations whose files are to be excluded from the classpath entries.
`plusConfigurations` | The configurations whose files are to be added as classpath entries.

### Property details

#### ``Set`<`String`>` `containers`

The classpath containers to be added.

See `EclipseClasspath` for an example.

Default with `eclipse` and `java` plugins:
  [JRE container]

#### `File` `defaultOutputDir`

The default output directory where Eclipse puts compiled classes.

See `EclipseClasspath` for an example.

Default with `eclipse` and `java` plugins:
  ``${project.projectDir}`/bin`

#### `boolean` `downloadJavadoc`

Whether to download and associate Javadoc Jars with the dependency Jars. Defaults to false.

See `EclipseClasspath` for an example.

Default with `eclipse` and `java` plugins:
  `false`

#### `boolean` `downloadSources`

Whether to download and associate source Jars with the dependency Jars. Defaults to true.

See `EclipseClasspath` for an example.

Default with `eclipse` and `java` plugins:
  `true`

#### `XmlFileContentMerger` `file`

See `EclipseClasspath.file{}`.

#### ``Collection`<`Configuration`>` `minusConfigurations`

The configurations whose files are to be excluded from the classpath entries.

See `EclipseClasspath` for an example.

Default with `eclipse` and `java` plugins:
  `[]`

#### ``Collection`<`Configuration`>` `plusConfigurations`

The configurations whose files are to be added as classpath entries.

See `EclipseClasspath` for an example.

Default with `eclipse` and `java` plugins:
  `project.configurations.testRuntime`

### Script blocks

Block | Description
`file` | Enables advanced configuration like tinkering with the output XML or affecting the way that the contents of an existing .classpath file is merged with Gradle build information. The object passed to the whenMerged{} and beforeMerged{} closures is of type `Classpath`.

### Script block details

#### `file` { }

Enables advanced configuration like tinkering with the output XML or affecting the way that the contents of an existing .classpath file is merged with Gradle build information. The object passed to the whenMerged{} and beforeMerged{} closures is of type `Classpath`.

See `EclipseProject` for an example.

Delegates to:
  `XmlFileContentMerger` from `file`

### Methods

Method | Description
`containers(containers)` | Further classpath containers to be added.

### Method details

#### `void` `containers`(``String`...` containers)

Further classpath containers to be added.

See `EclipseClasspath` for an example.