org.gradle.plugins.ide.eclipse.model

## Class EclipseWtpComponent

- java.lang.Object
- - groovy.lang.GroovyObjectSupport
  - - org.gradle.plugins.ide.eclipse.model.EclipseWtpComponent

- All Implemented Interfaces:
    GroovyObject

      public class EclipseWtpComponent
      extends GroovyObjectSupport

  Enables fine-tuning wtp component details of the Eclipse plugin

  Example of use with a blend of all possible properties. Bear in mind that usually you don't have configure them directly because Gradle configures it for free!

       apply plugin: 'java'
       apply plugin: 'war'
       apply plugin: 'eclipse-wtp'

       configurations {
         someInterestingConfiguration
         anotherConfiguration
       }

       eclipse {

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

         wtp {
           component {
             //you can configure the context path:
             contextPath = 'someContextPath'

             //you can configure the deployName:
             deployName = 'killerApp'

             //you can alter the wb-resource elements. sourceDirs is a ConventionProperty.
             //non-existing source dirs won't be added to the component file.
             sourceDirs += file('someExtraFolder')

             //you can alter the files are to be transformed into dependent-module elements:
             plusConfigurations += [ configurations.someInterestingConfiguration ]

             //or whose files are to be excluded from dependent-module elements:
             minusConfigurations << configurations.anotherConfiguration

             //you can add a wb-resource elements; mandatory keys: 'sourcePath', 'deployPath':
             //if sourcePath points to non-existing folder it will *not* be added.
             resource sourcePath: 'extra/resource', deployPath: 'deployment/resource'

             //you can add a wb-property elements; mandatory keys: 'name', 'value':
             property name: 'moodOfTheDay', value: ':-D'
           }
         }
       }

  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.

  beforeMerged and whenMerged closures receive `WtpComponent` object

  Examples of advanced configuration:

       apply plugin: 'java'
       apply plugin: 'war'
       apply plugin: 'eclipse-wtp'

       eclipse {

         wtp {
           component {
             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 wtp component file content is loaded from existing file
               //but before gradle build information is merged
               beforeMerged { wtpComponent ->
                 //tinker with WtpComponent here
               }

               //closure executed after wtp component file content is loaded from existing file
               //and after gradle build information is merged
               whenMerged { wtpComponent ->
                 //you can tinker with the WtpComponent here
               }
             }
           }
         }
       }

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `EclipseWtpComponent(Project project, XmlFileContentMerger file)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `file(Closure closure)` Enables advanced configuration like tinkering with the output XML or affecting the way existing wtp component file content is merged with gradle build information
    `String` | `getClassesDeployPath()` The deploy path for classes.
    `String` | `getContextPath()` The context path for the web application
    `String` | `getDeployName()` The deploy name to be used.
    `XmlFileContentMerger` | `getFile()` See `file(Closure)`
    `org.gradle.plugins.ide.eclipse.model.internal.FileReferenceFactory` | `getFileReferenceFactory()`
    `Set<Configuration>` | `getLibConfigurations()` The configurations whose files are to be transformed into dependent-module elements with a deploy path of `getLibDeployPath()`.
    `String` | `getLibDeployPath()` The deploy path for libraries.
    `Set<Configuration>` | `getMinusConfigurations()` The configurations whose files are to be excluded from dependent-module elements.
    `Map<String,File>` | `getPathVariables()` The variables to be used for replacing absolute path in dependent-module elements.
    `Set<Configuration>` | `getPlusConfigurations()` Synonym for `getLibConfigurations()`.
    `Project` | `getProject()`
    `List<WbProperty>` | `getProperties()` Additional property elements.
    `List<WbResource>` | `getResources()` `ConventionProperty` for additional wb-resource elements.
    `Set<Configuration>` | `getRootConfigurations()` The configurations whose files are to be transformed into dependent-module elements with a deploy path of '/'.
    `Set<File>` | `getSourceDirs()` `ConventionProperty` for the source directories to be transformed into wb-resource elements.
    `void` | `mergeXmlComponent(WtpComponent xmlComponent)`
    `void` | `property(Map<String,String> args)` Adds a property.
    `void` | `resource(Map<String,String> args)` Adds a wb-resource.
    `void` | `setClassesDeployPath(String classesDeployPath)`
    `void` | `setContextPath(String contextPath)`
    `void` | `setDeployName(String deployName)`
    `void` | `setLibConfigurations(Set<Configuration> libConfigurations)`
    `void` | `setLibDeployPath(String libDeployPath)`
    `void` | `setMinusConfigurations(Set<Configuration> minusConfigurations)`
    `void` | `setPathVariables(Map<String,File> pathVariables)`
    `void` | `setPlusConfigurations(Set<Configuration> plusConfigurations)` Synonym for `setLibConfigurations(Set)`.
    `void` | `setProperties(List<WbProperty> properties)`
    `void` | `setResources(List<WbResource> resources)`
    `void` | `setRootConfigurations(Set<Configuration> rootConfigurations)`
    `void` | `setSourceDirs(Set<File> sourceDirs)`

    - ### Methods inherited from class groovy.lang.GroovyObjectSupport

      `getMetaClass, getProperty, invokeMethod, setMetaClass, setProperty`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### EclipseWtpComponent

          public EclipseWtpComponent(Project project,
                             XmlFileContentMerger file)

  - ### Method Detail

    - #### getProject

          public Project getProject()

    - #### getFile

          public XmlFileContentMerger getFile()

      See `file(Closure)`

    - #### file

          public void file(Closure closure)

      Enables advanced configuration like tinkering with the output XML or affecting the way existing wtp component file content is merged with gradle build information

      The object passed to whenMerged{} and beforeMerged{} closures is of type `WtpComponent`

      For example see docs for `EclipseWtpComponent`

    - #### getSourceDirs

          public Set<File> getSourceDirs()

      `ConventionProperty` for the source directories to be transformed into wb-resource elements.

      For examples see docs for `EclipseWtp`

      Only source dirs that exist will be added to the wtp component file. Non-existing resource directory declarations lead to errors when project is imported into Eclipse.

    - #### setSourceDirs

          public void setSourceDirs(Set<File> sourceDirs)

    - #### getRootConfigurations

          public Set<Configuration> getRootConfigurations()

      The configurations whose files are to be transformed into dependent-module elements with a deploy path of '/'.

      For examples see docs for `EclipseWtp`

    - #### setRootConfigurations

          public void setRootConfigurations(Set<Configuration> rootConfigurations)

    - #### getLibConfigurations

          public Set<Configuration> getLibConfigurations()

      The configurations whose files are to be transformed into dependent-module elements with a deploy path of `getLibDeployPath()`.

      For examples see docs for `EclipseWtp`

    - #### setLibConfigurations

          public void setLibConfigurations(Set<Configuration> libConfigurations)

    - #### getPlusConfigurations

          public Set<Configuration> getPlusConfigurations()

      Synonym for `getLibConfigurations()`.

    - #### setPlusConfigurations

          public void setPlusConfigurations(Set<Configuration> plusConfigurations)

      Synonym for `setLibConfigurations(Set)`.

    - #### getMinusConfigurations

          public Set<Configuration> getMinusConfigurations()

      The configurations whose files are to be excluded from dependent-module elements.

      For examples see docs for `EclipseWtp`

    - #### setMinusConfigurations

          public void setMinusConfigurations(Set<Configuration> minusConfigurations)

    - #### getDeployName

          public String getDeployName()

      The deploy name to be used.

      For examples see docs for `EclipseWtp`

    - #### setDeployName

          public void setDeployName(String deployName)

    - #### getResources

          public List<WbResource> getResources()

      `ConventionProperty` for additional wb-resource elements.

      For examples see docs for `EclipseWtp`

      Only resources that link to an existing directory (`WbResource.getSourcePath()`) will be added to the wtp component file. The reason is that non-existing resource directory declarations lead to errors when project is imported into Eclipse.

    - #### setResources

          public void setResources(List<WbResource> resources)

    - #### resource

          public void resource(Map<String,String> args)

      Adds a wb-resource.

      For examples see docs for `EclipseWtp`

      Parameters:
        `args` - A map that must contain a deployPath and sourcePath key with corresponding values.

    - #### getProperties

          public List<WbProperty> getProperties()

      Additional property elements.

      For examples see docs for `EclipseWtp`

    - #### setProperties

          public void setProperties(List<WbProperty> properties)

    - #### property

          public void property(Map<String,String> args)

      Adds a property.

      For examples see docs for `EclipseWtp`

      Parameters:
        `args` - A map that must contain a 'name' and 'value' key with corresponding values.

    - #### getContextPath

          public String getContextPath()

      The context path for the web application

      For examples see docs for `EclipseWtp`

    - #### setContextPath

          public void setContextPath(String contextPath)

    - #### getClassesDeployPath

          public String getClassesDeployPath()

      The deploy path for classes.

      For examples see docs for `EclipseWtp`

    - #### setClassesDeployPath

          public void setClassesDeployPath(String classesDeployPath)

    - #### getLibDeployPath

          public String getLibDeployPath()

      The deploy path for libraries.

      For examples see docs for `EclipseWtp`

    - #### setLibDeployPath

          public void setLibDeployPath(String libDeployPath)

    - #### getPathVariables

          public Map<String,File> getPathVariables()

      The variables to be used for replacing absolute path in dependent-module elements.

      For examples see docs for `EclipseModel`

    - #### setPathVariables

          public void setPathVariables(Map<String,File> pathVariables)

    - #### getFileReferenceFactory

          public org.gradle.plugins.ide.eclipse.model.internal.FileReferenceFactory getFileReferenceFactory()

    - #### mergeXmlComponent

          public void mergeXmlComponent(WtpComponent xmlComponent)