/*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 package org.apache.maven.plugin.eclipse;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Iterator;

 import java.util.LinkedHashSet;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.ListIterator;

 import java.util.Map;

 import java.util.Set;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.handler.ArtifactHandler;

 import org.apache.maven.artifact.manager.WagonManager;

 import org.apache.maven.model.Build;

 import org.apache.maven.model.Plugin;

 import org.apache.maven.model.Resource;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.eclipse.reader.ReadWorkspaceLocations;

 import org.apache.maven.plugin.eclipse.writers.EclipseAjdtWriter;

 import org.apache.maven.plugin.eclipse.writers.EclipseClasspathWriter;

 import org.apache.maven.plugin.eclipse.writers.EclipseManifestWriter;

 import org.apache.maven.plugin.eclipse.writers.EclipseOSGiManifestWriter;

 import org.apache.maven.plugin.eclipse.writers.EclipseProjectWriter;

 import org.apache.maven.plugin.eclipse.writers.EclipseWriterConfig;

 import org.apache.maven.plugin.eclipse.writers.workspace.EclipseSettingsWriter;

 import org.apache.maven.plugin.eclipse.writers.wtp.EclipseWtpApplicationXMLWriter;

 import org.apache.maven.plugin.eclipse.writers.wtp.EclipseWtpComponent15Writer;

 import org.apache.maven.plugin.eclipse.writers.wtp.EclipseWtpComponentWriter;

 import org.apache.maven.plugin.eclipse.writers.wtp.EclipseWtpFacetsWriter;

 import org.apache.maven.plugin.eclipse.writers.wtp.EclipseWtpmodulesWriter;

 import org.apache.maven.plugin.ide.AbstractIdeSupportMojo;

 import org.apache.maven.plugin.ide.IdeDependency;

 import org.apache.maven.plugin.ide.IdeUtils;

 import org.apache.maven.plugin.ide.JeeUtils;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.settings.MavenSettingsBuilder;

 import org.apache.maven.settings.Proxy;

 import org.apache.maven.settings.Settings;

 import org.apache.maven.wagon.Wagon;

 import org.apache.maven.wagon.WagonException;

 import org.apache.maven.wagon.observers.Debug;

 import org.apache.maven.wagon.proxy.ProxyInfo;

 import org.apache.maven.wagon.repository.Repository;

 import org.codehaus.plexus.resource.ResourceManager;

 import org.codehaus.plexus.resource.loader.FileResourceLoader;

 import org.codehaus.plexus.resource.loader.ResourceNotFoundException;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.StringUtils;

 import org.codehaus.plexus.util.xml.Xpp3Dom;

 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

 /**

  * Generates the following eclipse configuration files:

  * <ul>

  * <li><code>.project</code> and <code>.classpath</code> files</li>

  * <li><code>.setting/org.eclipse.jdt.core.prefs</code> with project specific compiler settings</li>

  * <li>various configuration files for WTP (Web Tools Project), if the parameter <code>wtpversion</code> is set to a

  * valid version (WTP configuration is not generated by default)</li>

  * </ul>

  * If this goal is run on a multiproject root, dependencies between modules will be configured as direct project

  * dependencies in Eclipse (unless <code>useProjectReferences</code> is set to <code>false</code>).

  * 

  * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>

  * @author <a href="mailto:fgiust@apache.org">Fabrizio Giustina</a>

  * @version $Id: EclipsePlugin.java 1213573 2011-12-13 06:22:43Z baerrach $

  * @goal eclipse

  * @execute phase="generate-resources"

  */

 public class EclipsePlugin

     extends AbstractIdeSupportMojo

 {

     private static final String WEAVE_DEPENDENCY = "weaveDependency";

     private static final String WEAVE_DEPENDENCIES = "weaveDependencies";

     private static final String ASPECT_LIBRARY = "aspectLibrary";

     private static final String ASPECT_LIBRARIES = "aspectLibraries";

     private static final String ASPECT_DIRECTORY = "aspectDirectory";

     private static final String TEST_ASPECT_DIRECTORY = "testAspectDirectory";

     private static final String ASPECTJ_MAVEN_PLUGIN = "aspectj-maven-plugin";

     private static final String ORG_CODEHAUS_MOJO = "org.codehaus.mojo";

     private static final String DEFAULT_TEST_ASPECT_DIRECTORY = "src/test/aspect";

     private static final String DEFAULT_ASPECT_DIRECTORY = "src/main/aspect";

     private static final String NATURE_WST_FACET_CORE_NATURE = "org.eclipse.wst.common.project.facet.core.nature"; //$NON-NLS-1$

     private static final String BUILDER_WST_COMPONENT_STRUCTURAL_DEPENDENCY_RESOLVER =

         "org.eclipse.wst.common.modulecore.ComponentStructuralBuilderDependencyResolver"; //$NON-NLS-1$

     protected static final String BUILDER_WST_VALIDATION = "org.eclipse.wst.validation.validationbuilder"; //$NON-NLS-1$

     private static final String BUILDER_JDT_CORE_JAVA = "org.eclipse.jdt.core.javabuilder"; //$NON-NLS-1$

     private static final String BUILDER_WST_COMPONENT_STRUCTURAL =

         "org.eclipse.wst.common.modulecore.ComponentStructuralBuilder"; //$NON-NLS-1$

     private static final String BUILDER_WST_FACET = "org.eclipse.wst.common.project.facet.core.builder"; //$NON-NLS-1$

     private static final String BUILDER_PDE_MANIFEST = "org.eclipse.pde.ManifestBuilder"; //$NON-NLS-1$

     private static final String BUILDER_PDE_SCHEMA = "org.eclipse.pde.SchemaBuilder"; //$NON-NLS-1$

     private static final String BUILDER_AJDT_CORE_JAVA = "org.eclipse.ajdt.core.ajbuilder"; //$NON-NLS-1$

     private static final String NATURE_WST_MODULE_CORE_NATURE = "org.eclipse.wst.common.modulecore.ModuleCoreNature"; //$NON-NLS-1$

     private static final String NATURE_JDT_CORE_JAVA = "org.eclipse.jdt.core.javanature"; //$NON-NLS-1$

     private static final String NATURE_JEM_WORKBENCH_JAVA_EMF = "org.eclipse.jem.workbench.JavaEMFNature"; //$NON-NLS-1$

     private static final String NATURE_PDE_PLUGIN = "org.eclipse.pde.PluginNature"; //$NON-NLS-1$

     private static final String NATURE_AJDT_CORE_JAVA = "org.eclipse.ajdt.ui.ajnature"; //$NON-NLS-1$

     protected static final String COMMON_PATH_JDT_LAUNCHING_JRE_CONTAINER = "org.eclipse.jdt.launching.JRE_CONTAINER"; //$NON-NLS-1$

     protected static final String ASPECTJ_RT_CONTAINER = "org.eclipse.ajdt.core.ASPECTJRT_CONTAINER"; //$NON-NLS-1$

     protected static final String REQUIRED_PLUGINS_CONTAINER = "org.eclipse.pde.core.requiredPlugins"; //$NON-NLS-1$

     // warning, order is important for binary search

     public static final String[] WTP_SUPPORTED_VERSIONS = new String[] { "1.0", "1.5", "2.0", "R7", "none" }; //$NON-NLS-1$ //$NON-NLS-2$  //$NON-NLS-3$

     public static final String ASPECTJ_FILE_PATTERN = "**/*.aj";

     public static final String JAVA_FILE_PATTERN = "**/*.java";

     /**

      * Constant for 'artifactId' element in POM.xml.

      */

     private static final String POM_ELT_ARTIFACT_ID = "artifactId"; //$NON-NLS-1$

     /**

      * Constant for 'groupId' element in POM.xml.

      */

     private static final String POM_ELT_GROUP_ID = "groupId"; //$NON-NLS-1$

     /**

      * List of eclipse project natures. By default the <code>org.eclipse.jdt.core.javanature</code> nature plus the

      * needed WTP natures are added. Natures added using this property <strong>replace</strong> the default list.

      * 

      * <pre>

      * <projectnatures>

      *    <projectnature>org.eclipse.jdt.core.javanature</projectnature>

      *    <projectnature>org.eclipse.wst.common.modulecore.ModuleCoreNature</projectnature>

      * </projectnatures>

      * </pre>

      * 

      * @parameter

      */

     private List projectnatures;

     /**

      * List of artifacts, represented as <code>groupId:artifactId</code>, to exclude from the eclipse classpath, 

      * being provided by some eclipse classPathContainer.

      *

      * @see http://jira.codehaus.org/browse/MECLIPSE-79

      * @since 2.5

      * @parameter

      */

     private List excludes;

     /**

      * List of eclipse project natures to be added to the default ones.

      * 

      * <pre>

      * <additionalProjectnatures>

      *    <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>

      * </additionalProjectnatures>

      * </pre>

      * 

      * @parameter

      */

     private List additionalProjectnatures;

     /**

      * List of eclipse project facets to be added to the default ones.

      * 

      * <pre>

      * <additionalProjectFacets>

      *    <jst.jsf>1.1<jst.jsf/>

      * </additionalProjectFacets>

      * </pre>

      * 

      * @parameter

      */

     private Map additionalProjectFacets;

     /**

      * List of eclipse build commands. By default the <code>org.eclipse.jdt.core.javabuilder</code> builder plus the

      * needed WTP builders are added. If you specify any configuration for this parameter, only those buildcommands

      * specified will be used; the defaults won't be added. Use the <code>additionalBuildCommands</code> parameter for

      * that. Configuration example: Old style:

      * 

      * <pre>

      * <buildcommands>

      *    <buildcommand>org.eclipse.wst.common.modulecore.ComponentStructuralBuilder</buildcommand>

      *    <buildcommand>org.eclipse.jdt.core.javabuilder</buildcommand>

      *    <buildcommand>org.eclipse.wst.common.modulecore.ComponentStructuralBuilderDependencyResolver</buildcommand>

      * </buildcommands>

      * </pre>

      * 

      * For new style, see <code>additionalBuildCommands</code>.

      * 

      * @parameter

      */

     private List buildcommands;

     /**

      * List of eclipse build commands to be added to the default ones. Old style:

      * 

      * <pre>

      * <additionalBuildcommands>

      *    <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>

      * </additionalBuildcommands>

      * </pre>

      * 

      * New style:

      * 

      * <pre>

      * <additionalBuildcommands>

      *    <buildCommand>

      *      <name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>

      *      <triggers>auto,full,incremental,</triggers>

      *      <arguments>

      *        <LaunchConfigHandle><project>./externalToolBuilders/MavenBuilder.launch</LaunchConfighandle>

      *      </arguments>

      *    </buildCommand>

      * </additionalBuildcommands>

      * </pre>

      * 

      * Note the difference between <code>build<strong>c</strong>ommand</code> and

      * <code>build<strong>C</strong>ommand</code>. You can mix and match old and new-style configuration entries.

      * 

      * @parameter

      */

     private List additionalBuildcommands;

     /**

      * List of container classpath entries. By default the <code>org.eclipse.jdt.launching.JRE_CONTAINER</code>

      * classpath container is added. Configuration example:

      * 

      * <pre>

      * <classpathContainers>

      *    <classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer>

      *    <classpathContainer>org.eclipse.jst.server.core.container/org.eclipse.jst.server.tomcat.runtimeTarget/Apache Tomcat v5.5</classpathContainer>

      *    <classpathContainer>org.eclipse.jst.j2ee.internal.web.container/artifact</classpathContainer>

      * </classpathContainers>

      * </pre>

      * 

      * @parameter

      */

     private List classpathContainers;

     /**

      * Enables/disables the downloading of source attachments. Defaults to false. DEPRECATED - use downloadSources

      * 

      * @parameter expression="${eclipse.downloadSources}"

      * @deprecated use downloadSources

      */

     private boolean eclipseDownloadSources;

     /**

      * Eclipse workspace directory.

      * 

      * @parameter expression="${eclipse.projectDir}" alias="outputDir"

      */

     private File eclipseProjectDir;

     /**

      * When set to false, the plugin will not create sub-projects and instead reference those sub-projects using the

      * installed package in the local repository

      * 

      * @parameter expression="${eclipse.useProjectReferences}" default-value="true"

      * @required

      */

     private boolean useProjectReferences;

     /**

      * The default output directory

      * 

      * @parameter expression="${outputDirectory}" alias="outputDirectory"

      *            default-value="${project.build.outputDirectory}"

      * @required

      */

     private File buildOutputDirectory;

     /**

      * The version of WTP for which configuration files will be generated. The default value is "none" (don't generate

      * WTP configuration), supported versions are "R7", "1.0", "1.5" and "2.0"

      * 

      * @parameter expression="${wtpversion}" default-value="none"

      */

     private String wtpversion;

     /**

      * JEE context name of the WTP module. ( ex. WEB context name ). You can use "ROOT" if you want to map the webapp

      * to the root context.

      * 

      * @parameter expression="${wtpContextName}"

      */

     private String wtpContextName;

     /**

      * Is it an PDE project? If yes, the plugin adds the necessary natures and build commands to the .project file.

      * Additionally it copies all libraries to a project local directory and references them instead of referencing the

      * files in the local Maven repository. It also ensured that the "Bundle-Classpath" in META-INF/MANIFEST.MF is

      * synchronized.

      * 

      * @parameter expression="${eclipse.pde}" default-value="false"

      */

     private boolean pde;

     /**

      * Is it an AJDT project? If yes, the plugin adds the necessary natures and build commands to the .project file.

      */

     private boolean ajdt;

     /**

      * The relative path of the manifest file

      * 

      * @parameter expression="${eclipse.manifest}" default-value="${basedir}/META-INF/MANIFEST.MF"

      */

     private File manifest;

     /**

      * Allow to configure additional generic configuration files for eclipse that will be written out to disk when

      * running eclipse:eclipse. FOr each file you can specify the name and the text content.

      * 

      * <pre>

      * <plugin>

      *  <groupId>org.apache.maven.plugins</groupId>

      *  <artifactId>maven-eclipse-plugin</artifactId>

      *  <configuration>

      *   <additionalConfig>

      *    <file>

      *      <name>.checkstyle</name>

      *      <content>

      *        <![CDATA[<fileset-config file-format-version="1.2.0" simple-config="true">

      *          <fileset name="all" enabled="true" check-config-name="acme corporate style" local="false">

      *              <file-match-pattern match-pattern="." include-pattern="true"/>

      *          </fileset>

      *          <filter name="NonSrcDirs" enabled="true"/>

      *        </fileset-config>]]>

      *      </content>

      *    </file>

      *   </additionalConfig>

      *  </configuration>

      * </plugin>

      * </pre>

      * 

      * Instead of the content you can also define (from version 2.5) an url to download the file :

      * 

      * <pre>

      * <plugin>

      *  <groupId>org.apache.maven.plugins</groupId>

      *  <artifactId>maven-eclipse-plugin</artifactId>

      *  <configuration>

      *   <additionalConfig>

      *    <file>

      *      <name>.checkstyle</name>

      *      <url>http://some.place.org/path/to/file</url>

      *    </file>

      *   </additionalConfig>

      *  </configuration>

      * </pre>

      * 

      * or a location :

      * 

      * <pre>

      * <plugin>

      *  <groupId>org.apache.maven.plugins</groupId>

      *  <artifactId>maven-eclipse-plugin</artifactId>

      *  <configuration>

      *   <additionalConfig>

      *    <file>

      *     <name>.checkstyle</name>

      *     <location>/checkstyle-config.xml</location>

      *    </file>

      *   </additionalConfig>

      *  </configuration>

      *  <dependencies>

      *   <!-- The file defined in the location is stored in this dependency -->

      *   <dependency>

      *    <groupId>eclipsetest</groupId>

      *    <artifactId>checkstyle-config</artifactId>

      *    <version>1.0</version>

      *   </dependency>

      *  </dependencies>

      * </plugin>

      * </pre>

      * 

      * @parameter

      */

     private EclipseConfigFile[] additionalConfig;

     /**

      * If set to <code>true</code>, the version number of the artifact is appended to the name of the generated Eclipse

      * project. See projectNameTemplate for other options.

      * 

      * @parameter expression="${eclipse.addVersionToProjectName}" default-value="false"

      */

     private boolean addVersionToProjectName;

     /**

      * If set to <code>true</code>, the groupId of the artifact is appended to the name of the generated Eclipse

      * project. See projectNameTemplate for other options.

      * 

      * @parameter expression="${eclipse.addGroupIdToProjectName}" default-value="false"

      */

     private boolean addGroupIdToProjectName;

     /**

      * Allows configuring the name of the eclipse projects. This property if set wins over addVersionToProjectName and

      * addGroupIdToProjectName You can use <code>[groupId]</code>, <code>[artifactId]</code> and <code>[version]</code>

      * variables. eg. <code>[groupId].[artifactId]-[version]</code>

      * 

      * @parameter expression="${eclipse.projectNameTemplate}"

      */

     private String projectNameTemplate;

     /**

      * Parsed wtp version.

      */

     private float wtpVersionFloat;

     /**

      * Not a plugin parameter. Is this a java project?

      */

     private boolean isJavaProject;

     /**

      * Must the manifest files be written for java projects so that that the jee classpath for wtp is correct.

      * 

      * @parameter expression="${eclipse.wtpmanifest}" default-value="false"

      */

     private boolean wtpmanifest;

     /**

      * Must the application files be written for ear projects in a separate directory.

      * 

      * @parameter expression="${eclipse.wtpapplicationxml}" default-value="false"

      */

     private boolean wtpapplicationxml;

     /**

      * What WTP defined server to use for deployment informations.

      * 

      * @parameter expression="${eclipse.wtpdefaultserver}"

      */

     private String wtpdefaultserver;

     private WorkspaceConfiguration workspaceConfiguration;

     /**

      * ResourceManager for getting additonalConfig files from resources

      * 

      * @component

      * @required

      * @readonly

      */

     private ResourceManager locator;

     /**

      * WagonManager for accessing internet resources.

      *  

      * @component

      * @required

      * @readonly

      */

     private WagonManager wagonManager;

     /**

      * MavenSettingsBuilder for accessing settings.xml.

      *  

      * @component

      * @required

      * @readonly

      */

     private MavenSettingsBuilder mavenSettingsBuilder;

     /**

      * This eclipse workspace is read and all artifacts detected there will be connected as eclipse projects and will

      * not be linked to the jars in the local repository. Requirement is that it was created with the similar wtp

      * settings as the reactor projects, but the project name template my differ. The pom's in the workspace projects

      * may not contain variables in the artefactId, groupId and version tags. If workspace is not defined, then an

      * attempt to locate it by checking up the directory hierarchy will be made.

      * 

      * @since 2.5

      * @parameter expression="${eclipse.workspace}"

      */

     protected File workspace;

     /**

      * Limit the use of project references to the current workspace. No project references will be created to projects

      * in the reactor when they are not available in the workspace.

      * 

      * @parameter expression="${eclipse.limitProjectReferencesToWorkspace}" default-value="false"

      */

     protected boolean limitProjectReferencesToWorkspace;

     /**

      * The version of AJDT for which configuration files will be generated. The default value is "1.5", supported

      * versions are "none" (AJDT support disabled), "1.4", and "1.5".

      * 

      * @parameter expression="${eclipse.ajdtVersion}" default-value="none"

      */

     private String ajdtVersion;

     /**

      * List of exclusions to add to the source directories on the classpath. Adds excluding="" to the classpathentry of

      * the eclipse .classpath file. [MECLIPSE-104]

      * 

      * @since 2.6.1

      * @parameter

      */

     private List sourceExcludes;

     /**

      * List of inclusions to add to the source directories on the classpath. Adds including="" to the classpathentry of

      * the eclipse .classpath file.

      * <p>

      * Java projects will always include "**/*.java"

      * <p>

      * Ajdt projects will always include "**/*.aj"

      * <p>

      * [MECLIPSE-104]

      * 

      * @since 2.6.1

      * @parameter

      */

     private List sourceIncludes;

     /**

      * A list of links to local files in the system. A configuration like this one in the pom : 

      * <pre>

      * <plugin>

      *   <groupId>org.apache.maven.plugins</groupId>

      *   <artifactId>maven-eclipse-plugin</artifactId>

      *   <configuration> 

      *     <linkedResources> 

      *       <linkedResource>

      *         <name>src/test/resources/oracle-ds.xml</name>

      *         <type>1</type>

      *         <location>C://jboss/server/default/deploy/oracle-ds.xml</location> 

      *       </linkedResource>

      *     </linkedResources> 

      *   </configuration> 

      * </plugin>

      * </pre>

      * will produce in the .project :

      * <pre>

      * <linkedResources>

      *   <link>

      *     <name>src/test/resources/oracle-ds.xml</name>

      *     <type>1</type> 

      *     <location>C://jboss/server/default/deploy/oracle-ds.xml</location>

      *   </link>

      * </linkedResources>

      * </pre>

      * 

      * @since 2.8

      * @parameter

      */

     private List linkedResources;

     /**

      * Put classpath container entries last in eclipse classpath configuration. Note that this behaviour, although

      * useful in situations were you want to override resources found in classpath containers, will made JRE classes

      * loaded after 3rd party jars, so enabling it is not suggested.

      * 

      * @since 2.9

      * @parameter expression="${eclipse.classpathContainersLast}" default-value="false"

      */

     protected boolean classpathContainersLast;

     /**

      * Whether to place test resources after main resources. Note that the default behavior of Maven version 2.0.8 or 

      * later is to have test dirs before main dirs in classpath so this is discouraged if you need to reproduce the

      * maven behavior during tests. The default behavior is also changed in eclipse plugin version 2.6 in order to

      * better match the maven one.

      * Switching to "test source last" can anyway be useful if you need to run your application in eclipse, since there

      * is no concept in eclipse of "phases" with different set of source dirs and dependencies like we have in maven.

      * 

      * @since 2.9

      * @parameter expression="${eclipse.testSourcesLast}" default-value="false"

      */

     protected boolean testSourcesLast;

     /**

      * The plugin is often capable in predicting the required jee version based on the dependencies of the project.

      * By setting this parameter to one of the {@code jeeversion} options the version will be locked. 

      *  

      * <table>

      *  <thead>

      *    <tr><th>jeeversion</th><th>EJB version</th><th>Servlet version</th><th>JSP version</th></tr>

      *  </thead>

      *  <tbody>

      *    <tr><td>6.0</td><td>3.1</td><td>3.0</td><td>2.2</td></tr>

      *    <tr><td>5.0</td><td>3.0</td><td>2.5</td><td>2.1</td></tr>

      *    <tr><td>1.4</td><td>2.1</td><td>2.4</td><td>2.0</td></tr>

      *    <tr><td>1.3</td><td>2.0</td><td>2.3</td><td>1.2</td></tr>

      *    <tr><td>1.2</td><td>1.1</td><td>2.2</td><td>1.1</td></tr>

      *  </tbody>

      * </table>

      * 

      * @since 2.9

      * @parameter expression="${eclipse.jeeversion}"

      */

     protected String jeeversion;

     protected final boolean isJavaProject()

     {

         return isJavaProject;

     }

     protected final boolean isPdeProject()

     {

         return pde;

     }

     /**

      * Getter for <code>buildcommands</code>.

      * 

      * @return Returns the buildcommands.

      */

     public final List getBuildcommands()

     {

         return buildcommands;

     }

     /**

      * Setter for <code>buildcommands</code>.

      * 

      * @param buildcommands The buildcommands to set.

      */

     public final void setBuildcommands( List buildcommands )

     {

         this.buildcommands = buildcommands;

     }

     /**

      * Getter for <code>buildOutputDirectory</code>.

      * 

      * @return Returns the buildOutputDirectory.

      */

     public final File getBuildOutputDirectory()

     {

         return buildOutputDirectory;

     }

     /**

      * Setter for <code>buildOutputDirectory</code>.

      * 

      * @param buildOutputDirectory The buildOutputDirectory to set.

      */

     public final void setBuildOutputDirectory( File buildOutputDirectory )

     {

         this.buildOutputDirectory = buildOutputDirectory;

     }

     /**

      * Getter for <code>classpathContainers</code>.

      * 

      * @return Returns the classpathContainers.

      */

     public final List getClasspathContainers()

     {

         return classpathContainers;

     }

     /**

      * Setter for <code>classpathContainers</code>.

      * 

      * @param classpathContainers The classpathContainers to set.

      */

     public final void setClasspathContainers( List classpathContainers )

     {

         this.classpathContainers = classpathContainers;

     }

     /**

      * Getter for <code>eclipseProjectDir</code>.

      * 

      * @return Returns the eclipseProjectDir.

      */

     public final File getEclipseProjectDir()

     {

         return eclipseProjectDir;

     }

     /**

      * Setter for <code>eclipseProjectDir</code>.

      * 

      * @param eclipseProjectDir The eclipseProjectDir to set.

      */

     public final void setEclipseProjectDir( File eclipseProjectDir )

     {

         this.eclipseProjectDir = eclipseProjectDir;

     }

     /**

      * Getter for <code>projectnatures</code>.

      * 

      * @return Returns the projectnatures.

      */

     public final List getProjectnatures()

     {

         return projectnatures;

     }

     /**

      * Setter for <code>projectnatures</code>.

      * 

      * @param projectnatures The projectnatures to set.

      */

     public final void setProjectnatures( List projectnatures )

     {

         this.projectnatures = projectnatures;

     }

     /**

      * Getter for <code>useProjectReferences</code>.

      * 

      * @return Returns the useProjectReferences.

      */

     public final boolean getUseProjectReferences()

     {

         return useProjectReferences;

     }

     /**

      * Setter for <code>useProjectReferences</code>.

      * 

      * @param useProjectReferences The useProjectReferences to set.

      */

     public final void setUseProjectReferences( boolean useProjectReferences )

     {

         this.useProjectReferences = useProjectReferences;

     }

     /**

      * Getter for <code>wtpversion</code>.

      * 

      * @return Returns the wtpversion.

      */

     public final String getWtpversion()

     {

         return wtpversion;

     }

     /**

      * Setter for <code>wtpversion</code>.

      * 

      * @param wtpversion The wtpversion to set.

      */

     public final void setWtpversion( String wtpversion )

     {

         this.wtpversion = wtpversion;

     }

     /**

      * Getter for <code>additionalBuildcommands</code>.

      * 

      * @return Returns the additionalBuildcommands.

      */

     public final List getAdditionalBuildcommands()

     {

         return additionalBuildcommands;

     }

     /**

      * Setter for <code>additionalBuildcommands</code>.

      * 

      * @param additionalBuildcommands The additionalBuildcommands to set.

      */

     public final void setAdditionalBuildcommands( List additionalBuildcommands )

     {

         this.additionalBuildcommands = additionalBuildcommands;

     }

     /**

      * Getter for <code>additionalProjectnatures</code>.

      * 

      * @return Returns the additionalProjectnatures.

      */

     public final List getAdditionalProjectnatures()

     {

         return additionalProjectnatures;

     }

     /**

      * Setter for <code>additionalProjectnatures</code>.

      * 

      * @param additionalProjectnatures The additionalProjectnatures to set.

      */

     public final void setAdditionalProjectnatures( List additionalProjectnatures )

     {

         this.additionalProjectnatures = additionalProjectnatures;

     }

     /**

      * Getter for <code>addVersionToProjectName</code>.

      */

     public final boolean isAddVersionToProjectName()

     {

         return addVersionToProjectName;

     }

     /**

      * Setter for <code>addVersionToProjectName</code>.

      */

     public final void setAddVersionToProjectName( boolean addVersionToProjectName )

     {

         this.addVersionToProjectName = addVersionToProjectName;

     }

     /**

      * Getter for <code>addGroupIdToProjectName</code>.

      */

     public final boolean isAddGroupIdToProjectName()

     {

         return addGroupIdToProjectName;

     }

     /**

      * Setter for <code>addGroupIdToProjectName</code>.

      */

     public final void setAddGroupIdToProjectName( boolean addGroupIdToProjectName )

     {

         this.addGroupIdToProjectName = addGroupIdToProjectName;

     }

     /**

      * Getter for <code>projectNameTemplate</code>

      * 

      * @return projectNameTemplate

      */

     public final String getProjectNameTemplate()

     {

         return projectNameTemplate;

     }

     /**

      * Setter for <code>projectNameTemplate</code>.

      * 

      * @param projectNameTemplate projectNameTemplate

      */

     public final void setProjectNameTemplate( String projectNameTemplate )

     {

         this.projectNameTemplate = projectNameTemplate;

     }

     /**

      * @return the linkedResources

      */

     public List getLinkedResources()

     {

         return linkedResources;

     }

     /**

      * @param linkedResources the linkedResources to set

      */

     public void setLinkedResources( List linkedResources )

     {

         this.linkedResources = linkedResources;

     }

     /**

      * @see org.apache.maven.plugin.Mojo#execute()

      */

     public final boolean setup()

         throws MojoExecutionException

     {

         boolean ready = true;

         checkDeprecations();

         setProjectNameTemplate( IdeUtils.calculateProjectNameTemplate( getProjectNameTemplate(),

                                                                        isAddVersionToProjectName(),

                                                                        isAddGroupIdToProjectName(), getLog() ) );

         ajdt = enableAjdt( executedProject ) && !ajdtVersion.equals( "none" );

         ready = validate();

         // TODO: Why are we using project in some places, and executedProject in others??

         ArtifactHandler artifactHandler = project.getArtifact().getArtifactHandler();

         // ear projects don't contain java sources

         // pde projects are always java projects

         isJavaProject =

             pde

                 || ( Constants.LANGUAGE_JAVA.equals( artifactHandler.getLanguage() ) && !Constants.PROJECT_PACKAGING_EAR.equals( packaging ) );

         if ( sourceIncludes == null )

         {

             sourceIncludes = new ArrayList();

         }

         if ( isJavaProject )

         {

             sourceIncludes.add( JAVA_FILE_PATTERN );

         }

         if ( ajdt )

         {

             sourceIncludes.add( ASPECTJ_FILE_PATTERN );

         }

         if ( sourceExcludes == null )

         {

             sourceExcludes = new ArrayList();

         }

         setupExtras();

         parseConfigurationOptions();

         // defaults

         if ( projectnatures == null )

         {

             fillDefaultNatures( packaging );

         }

         if ( additionalProjectnatures != null )

         {

             projectnatures.addAll( additionalProjectnatures );

         }

         if ( buildcommands == null )

         {

             fillDefaultBuilders( packaging );

         }

         else

         {

             convertBuildCommandList( buildcommands );

         }

         if ( additionalBuildcommands != null )

         {

             convertBuildCommandList( additionalBuildcommands );

             buildcommands.addAll( additionalBuildcommands );

         }

         if ( classpathContainers == null )

         {

             fillDefaultClasspathContainers( packaging );

         }

         else

         {

             verifyClasspathContainerListIsComplete();

         }

         if ( linkedResources == null )

         {

             linkedResources = new ArrayList();

         }

         locator.addSearchPath( FileResourceLoader.ID, project.getFile().getParentFile().getAbsolutePath() );

         locator.setOutputDirectory( new File( project.getBuild().getDirectory() ) );

         // ready to start

         return ready;

     }

     /**

      * Convert any Strings in the <code>commands</code> List to <code>BuildCommand</code>s. The conversion happens in

      * situ.

      * 

      * @param commands a list of commands to convert into <code>BuildCommand</code>

      */

     protected final void convertBuildCommandList( List commands )

     {

         if ( commands != null )

         {

             for ( ListIterator i = commands.listIterator(); i.hasNext(); )

             {

                 Object command = i.next();

                 if ( command instanceof String )

                 {

                     command = new BuildCommand( (String) command );

                     i.set( command );

                 }

             }

         }

     }

     private void parseConfigurationOptions()

     {

         if ( "R7".equalsIgnoreCase( wtpversion ) ) //$NON-NLS-1$

         {

             wtpVersionFloat = 0.7f;

         }

         else if ( "1.0".equalsIgnoreCase( wtpversion ) ) //$NON-NLS-1$

         {

             wtpVersionFloat = 1.0f;

         }

         else if ( "1.5".equalsIgnoreCase( wtpversion ) ) //$NON-NLS-1$

         {

             wtpVersionFloat = 1.5f;

         }

         else if ( "2.0".equalsIgnoreCase( wtpversion ) ) //$NON-NLS-1$

         {

             wtpVersionFloat = 2.0f;

         }

         if ( !"none".equalsIgnoreCase( wtpversion ) )

         {

             getLog().info( Messages.getString( "EclipsePlugin.wtpversion", wtpversion ) );

         }

     }

     /**

      * Extension point for subclasses.

      * <p>

      * Called during <code>setup</code>.

      * 

      * @throws MojoExecutionException mojo failures.

      */

     protected void setupExtras()

         throws MojoExecutionException

     {

         // extension point.

     }

     private void verifyClasspathContainerListIsComplete()

     {

         boolean containsJREContainer = false;

         // Check if classpathContainer contains a JRE (default, alternate or

         // Execution Environment)

         for ( Iterator iter = classpathContainers.iterator(); iter.hasNext(); )

         {

             Object classPathContainer = iter.next();

             if ( classPathContainer != null

                 && classPathContainer.toString().startsWith( COMMON_PATH_JDT_LAUNCHING_JRE_CONTAINER ) )

             {

                 containsJREContainer = true;

                 break;

             }

         }

         if ( !containsJREContainer )

         {

             getLog().warn( Messages.getString( "EclipsePlugin.missingjrecontainer" ) ); //$NON-NLS-1$

             classpathContainers.add( 0, COMMON_PATH_JDT_LAUNCHING_JRE_CONTAINER );

         }

     }

     private boolean validate()

         throws MojoExecutionException

     {

         // validate sanity of the current m2 project

         if ( Arrays.binarySearch( WTP_SUPPORTED_VERSIONS, wtpversion ) < 0 )

         {

             throw new MojoExecutionException(

                                               Messages.getString( "EclipsePlugin.unsupportedwtp", new Object[] { //$NON-NLS-1$

                                                                   wtpversion,

                                                                       StringUtils.join( WTP_SUPPORTED_VERSIONS, " " ) } ) ); //$NON-NLS-1$

         }

         assertNotEmpty( executedProject.getGroupId(), POM_ELT_GROUP_ID );

         assertNotEmpty( executedProject.getArtifactId(), POM_ELT_ARTIFACT_ID );

         if ( executedProject.getFile() == null || !executedProject.getFile().exists() )

         {

             throw new MojoExecutionException( Messages.getString( "EclipsePlugin.missingpom" ) ); //$NON-NLS-1$

         }

         if ( "pom".equals( packaging ) && eclipseProjectDir == null ) //$NON-NLS-1$

         {

             getLog().info( Messages.getString( "EclipsePlugin.pompackaging" ) ); //$NON-NLS-1$

             return false;

         }

         if ( "eclipse-plugin".equals( packaging ) )

         {

             pde = true;

         }

         if ( eclipseProjectDir == null )

         {

             eclipseProjectDir = executedProject.getFile().getParentFile();

         }

         if ( !eclipseProjectDir.exists() && !eclipseProjectDir.mkdirs() )

         {

             throw new MojoExecutionException( Messages.getString( "EclipsePlugin.cantcreatedir", eclipseProjectDir ) ); //$NON-NLS-1$

         }

         if ( !eclipseProjectDir.equals( executedProject.getFile().getParentFile() ) )

         {

             if ( !eclipseProjectDir.isDirectory() )

             {

                 throw new MojoExecutionException( Messages.getString( "EclipsePlugin.notadir", eclipseProjectDir ) ); //$NON-NLS-1$

             }

             eclipseProjectDir = new File( eclipseProjectDir, executedProject.getArtifactId() );

             if ( !eclipseProjectDir.isDirectory() && !eclipseProjectDir.mkdirs() )

             {

                 throw new MojoExecutionException( Messages.getString( "EclipsePlugin.cantcreatedir", eclipseProjectDir ) ); //$NON-NLS-1$

             }

         }

         validateExtras();

         return true;

     }

     /**

      * Extension point for subclasses.

      * <p>

      * Called during <code>setup</code> and used to validate that the configuration is sane.

      * 

      * @throws MojoExecutionException mojo failures.

      */

     protected void validateExtras()

         throws MojoExecutionException

     {

         // provided for extension.

     }

     private void checkDeprecations()

     {

         if ( eclipseDownloadSources )

         {

             // deprecated warning

             getLog().warn( Messages.getString( "EclipsePlugin.deprecatedpar", new Object[] { //$NON-NLS-1$

                                                "eclipse.downloadSources", //$NON-NLS-1$

                                                    "downloadSources" } ) ); //$NON-NLS-1$

             downloadSources = true;

         }

         checkDeprecationsExtras();

     }

     /**

      * Extension point for subclasses.

      * <p>

      * Check for any extra deprecations and log warnings. Called during <code>setup</code>

      */

     protected void checkDeprecationsExtras()

     {

         // provided for extension.

     }

     public final void writeConfiguration( IdeDependency[] deps )

         throws MojoExecutionException

     {

         EclipseWriterConfig config = createEclipseWriterConfig( deps );

         if ( wtpmanifest && isJavaProject() )

         {

             // NOTE: This could change the config!

             EclipseManifestWriter.addManifestResource( getLog(), config );

         }

         // NOTE: This could change the config!

         writeConfigurationExtras( config );

         if ( wtpVersionFloat == 0.7f )

         {

             new EclipseWtpmodulesWriter().init( getLog(), config ).write();

         }

         if ( wtpVersionFloat >= 1.0f )

         {

             new EclipseWtpFacetsWriter().init( getLog(), config ).write();

         }

         if ( wtpVersionFloat == 1.0f )

         {

             new EclipseWtpComponentWriter().init( getLog(), config ).write();

         }

         if ( wtpVersionFloat >= 1.5 )

         {

             new EclipseWtpComponent15Writer().init( getLog(), config ).write();

         }

         new EclipseSettingsWriter().init( getLog(), config ).write();

         if ( isJavaProject )

         {

             new EclipseClasspathWriter().init( getLog(), config ).write();

             if ( ajdt && ajdtVersion.equals( "1.4" ) )

             {

                 new EclipseAjdtWriter().init( getLog(), config ).write();

             }

         }

         if ( wtpapplicationxml )

         {

             new EclipseWtpApplicationXMLWriter().init( getLog(), config ).write();

         }

         if ( pde )

         {

             this.getLog().info( "The Maven Eclipse plugin runs in 'pde'-mode." );

             new EclipseOSGiManifestWriter().init( getLog(), config ).write();

         }

         // NOTE: This one MUST be after EclipseClasspathwriter, and possibly others,

         // since currently EclipseClasspathWriter does some magic to detect nested

         // output folders and modifies the configuration by adding new (Ant) builders.

         // So the .project file must be written AFTER those have run!

         new EclipseProjectWriter().init( getLog(), config ).write();

         writeAdditionalConfig();

         getLog().info( Messages.getString( "EclipsePlugin.wrote", new Object[] { //$NON-NLS-1$

                                            config.getEclipseProjectName(), eclipseProjectDir.getAbsolutePath() } ) );

     }

     private void writeAdditionalConfig()

         throws MojoExecutionException

     {

         if ( additionalConfig != null )

         {

             for ( int j = 0; j < additionalConfig.length; j++ )

             {

                 EclipseConfigFile file = additionalConfig[j];

                 File projectRelativeFile = new File( eclipseProjectDir, file.getName() );

                 if ( projectRelativeFile.isDirectory() )

                 {

                     // just ignore?

                     getLog().warn( Messages.getString( "EclipsePlugin.foundadir", //$NON-NLS-1$

                                                        projectRelativeFile.getAbsolutePath() ) );

                 }

                 try

                 {

                     projectRelativeFile.getParentFile().mkdirs();

                     if ( file.getContent() == null )

                     {

                         if ( file.getLocation() != null )

                         {

                             InputStream inStream = locator.getResourceAsInputStream( file.getLocation() );

                             OutputStream outStream = new FileOutputStream( projectRelativeFile );

                             try

                             {

                                 IOUtil.copy( inStream, outStream );

                             }

                             finally

                             {

                                 IOUtil.close(inStream);

                                 IOUtil.close(outStream);

                             }                            

                         }

                         else

                         {

                             URL url = file.getURL();

                             String endPointUrl = url.getProtocol() + "://" + url.getAuthority();

                             // Repository Id should be ignored by Wagon ...

                             Repository repository = new Repository( "additonal-configs", endPointUrl );

                             Wagon wagon = wagonManager.getWagon( repository );;

                             if ( logger.isDebugEnabled() )

                             {

                                 Debug debug = new Debug();

                                 wagon.addSessionListener( debug );

                                 wagon.addTransferListener( debug );

                             }

                             wagon.setTimeout( 1000 );

                             Settings settings = mavenSettingsBuilder.buildSettings();

                             ProxyInfo proxyInfo = null; 

                             if ( settings != null && settings.getActiveProxy() != null )

                             {

                                 Proxy settingsProxy = settings.getActiveProxy();

                                 proxyInfo = new ProxyInfo();

                                 proxyInfo.setHost( settingsProxy.getHost() );

                                 proxyInfo.setType( settingsProxy.getProtocol() );

                                 proxyInfo.setPort( settingsProxy.getPort() );