Coverage Report

Coverage Report - org.apache.maven.plugin.eclipse.writers.EclipseClasspathWriter

Classes in this File

Line Coverage

Branch Coverage

Complexity

EclipseClasspathWriter

68%

127/188

38%

51/134

14,25

 /*
  * 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.writers;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.eclipse.BuildCommand;
 import org.apache.maven.plugin.eclipse.Constants;
 import org.apache.maven.plugin.eclipse.EclipseSourceDir;
 import org.apache.maven.plugin.eclipse.Messages;
 import org.apache.maven.plugin.ide.IdeDependency;
 import org.apache.maven.plugin.ide.IdeUtils;
 import org.codehaus.plexus.util.IOUtil;
 import org.codehaus.plexus.util.StringUtils;
 import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
 import org.codehaus.plexus.util.xml.XMLWriter;
 
 /**
  * Writes eclipse .classpath file.
  *
  * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>
  * @author <a href="mailto:kenney@neonics.com">Kenney Westerhof</a>
  * @author <a href="mailto:fgiust@apache.org">Fabrizio Giustina</a>
  * @version $Id: EclipseClasspathWriter.java 826604 2009-10-19 08:24:35Z nicolas $
  */
 public class EclipseClasspathWriter
     extends AbstractEclipseWriter
 {
 
     /**
      *
      */
     private static final String ORG_ECLIPSE_AJDT_INPATH = "org.eclipse.ajdt.inpath";
 
     /**
      *
      */
     private static final String ORG_ECLIPSE_AJDT_ASPECTPATH = "org.eclipse.ajdt.aspectpath";
 
     private static final String ASPECTJRT_CONTAINER = "org.eclipse.ajdt.core.ASPECTJRT_CONTAINER";
 
     /**
      *
      */
     private static final String NAME = "name";
 
     /**
      *
      */
     private static final String VALUE = "value";
 
     /**
      *
      */
     private static final String ATTRIBUTE = "attribute";
 
     /**
      *
      */
     private static final String ATTRIBUTES = "attributes";
 
     /**
      * Eclipse build path variable M2_REPO
      */
     protected static final String M2_REPO = "M2_REPO"; //$NON-NLS-1$
 
     /**
      * Attribute for sourcepath.
      */
     private static final String ATTR_SOURCEPATH = "sourcepath"; //$NON-NLS-1$
 
     /**
      * Attribute for output.
      */
     private static final String ATTR_OUTPUT = "output"; //$NON-NLS-1$
 
     /**
      * Attribute for path.
      */
     private static final String ATTR_PATH = "path"; //$NON-NLS-1$
 
     /**
      * Attribute for kind - Container (con), Variable (var)..etc.
      */
     private static final String ATTR_KIND = "kind"; //$NON-NLS-1$
 
     /**
      * Attribute value for kind: var
      */
     private static final String ATTR_VAR = "var"; //$NON-NLS-1$
 
     /**
      * Attribute value for kind: lib
      */
     private static final String ATTR_LIB = "lib"; //$NON-NLS-1$
 
     /**
      * Attribute value for kind: src
      */
     private static final String ATTR_SRC = "src"; //$NON-NLS-1$
 
     /**
      * Attribute name for source file includes in a path.
      */
     private static final String ATTR_INCLUDING = "including";
 
     /**
      * Attribute name for source file excludes in a path.
      */
     private static final String ATTR_EXCLUDING = "excluding";
 
     /**
      * Element for classpathentry.
      */
     private static final String ELT_CLASSPATHENTRY = "classpathentry"; //$NON-NLS-1$
 
     /**
      * Element for classpath.
      */
     private static final String ELT_CLASSPATH = "classpath"; //$NON-NLS-1$
 
     /**
      * File name that stores project classpath settings.
      */
     private static final String FILE_DOT_CLASSPATH = ".classpath"; //$NON-NLS-1$
 
     /**
      * @see org.apache.maven.plugin.eclipse.writers.EclipseWriter#write()
      */
     public void write()
         throws MojoExecutionException
     {
 
         Writer w;
 
         try
         {
             w =
                 new OutputStreamWriter( new FileOutputStream( new File( config.getEclipseProjectDirectory(),
                                                                         FILE_DOT_CLASSPATH ) ), "UTF-8" );
         }
         catch ( IOException ex )
         {
             throw new MojoExecutionException( Messages.getString( "EclipsePlugin.erroropeningfile" ), ex ); //$NON-NLS-1$
         }
 
         XMLWriter writer = new PrettyPrintXMLWriter( w );
 
         writer.startElement( ELT_CLASSPATH );
 
         String defaultOutput =
             IdeUtils.toRelativeAndFixSeparator( config.getProjectBaseDir(), config.getBuildOutputDirectory(), false );
 
         // ----------------------------------------------------------------------
         // Source roots and resources
         // ----------------------------------------------------------------------
 
         // List<EclipseSourceDir>
         List specialSources = new ArrayList();
 
         // Map<String,List<EclipseSourceDir>>
         Map byOutputDir = new HashMap();
 
         for ( int j = 0; j < config.getSourceDirs().length; j++ )
         {
             EclipseSourceDir dir = config.getSourceDirs()[j];
 
             // List<EclipseSourceDir>
             List byOutputDirs = (List) byOutputDir.get( dir.getOutput() );
             if ( byOutputDirs == null )
             {
                 // ArrayList<EclipseSourceDir>
                 byOutputDir.put( dir.getOutput() == null ? defaultOutput : dir.getOutput(), byOutputDirs =
                     new ArrayList() );
             }
             byOutputDirs.add( dir );
         }
 
         for ( int j = 0; j < config.getSourceDirs().length; j++ )
         {
             EclipseSourceDir dir = config.getSourceDirs()[j];
 
             log.debug( "Processing classpath for: " + dir.toString() + "; default output=" + defaultOutput );
 
             boolean isSpecial = false;
 
             // handle resource with nested output folders
             if ( dir.isResource() )
             {
                 // Check if the output is a subdirectory of the default output,
                 // and if the default output has any sources that copy there.
 
                 if ( dir.getOutput() != null // resource output dir is set
                     && !dir.getOutput().equals( defaultOutput ) // output dir is not default target/classes
                     && dir.getOutput().startsWith( defaultOutput ) // ... but is nested
                     && byOutputDir.get( defaultOutput ) != null // ???
                     && !( (List) byOutputDir.get( defaultOutput ) ).isEmpty() // ???
                 )
                 {
                     // do not specify as source since the output will be nested. Instead, mark
                     // it as a todo, and handle it with a custom build.xml file later.
 
                     log.debug( "Marking as special to prevent output folder nesting: " + dir.getPath() + " (output="
                         + dir.getOutput() + ")" );
 
                     isSpecial = true;
                     specialSources.add( dir );
                 }
             }
 
             writer.startElement( ELT_CLASSPATHENTRY );
 
             writer.addAttribute( ATTR_KIND, "src" ); //$NON-NLS-1$
             writer.addAttribute( ATTR_PATH, dir.getPath() );
 
             if ( !isSpecial && dir.getOutput() != null && !defaultOutput.equals( dir.getOutput() ) )
             {
                 writer.addAttribute( ATTR_OUTPUT, dir.getOutput() );
             }
 
             String includes = dir.getIncludeAsString();
             if ( StringUtils.isNotEmpty( includes ) )
             {
                 writer.addAttribute( ATTR_INCLUDING, includes );
             }
 
             String excludes = dir.getExcludeAsString();
             if ( StringUtils.isNotEmpty( excludes ) )
             {
                 writer.addAttribute( ATTR_EXCLUDING, excludes );
             }
 
             writer.endElement();
 
         }
 
         // handle the special sources.
         if ( !specialSources.isEmpty() )
         {
             log.info( "Creating maven-eclipse.xml Ant file to handle resources" );
 
             try
             {
                 Writer buildXmlWriter =
                     new OutputStreamWriter( new FileOutputStream( new File( config.getEclipseProjectDirectory(),
                                                                             "maven-eclipse.xml" ) ), "UTF-8" );
                 PrettyPrintXMLWriter buildXmlPrinter = new PrettyPrintXMLWriter( buildXmlWriter );
 
                 buildXmlPrinter.startElement( "project" );
                 buildXmlPrinter.addAttribute( "default", "copy-resources" );
 
                 buildXmlPrinter.startElement( "target" );
                 buildXmlPrinter.addAttribute( NAME, "init" );
                 // initialize filtering tokens here
                 buildXmlPrinter.endElement();
 
                 buildXmlPrinter.startElement( "target" );
                 buildXmlPrinter.addAttribute( NAME, "copy-resources" );
                 buildXmlPrinter.addAttribute( "depends", "init" );
 
                 for ( Iterator it = specialSources.iterator(); it.hasNext(); )
                 {
                     // TODO: merge source dirs on output path+filtering to reduce
                     // <copy> tags for speed.
                     EclipseSourceDir dir = (EclipseSourceDir) it.next();
                     buildXmlPrinter.startElement( "copy" );
                     buildXmlPrinter.addAttribute( "todir", dir.getOutput() );
                     buildXmlPrinter.addAttribute( "filtering", "" + dir.isFiltering() );
 
                     buildXmlPrinter.startElement( "fileset" );
                     buildXmlPrinter.addAttribute( "dir", dir.getPath() );
                     if ( dir.getIncludeAsString() != null )
                     {
                         buildXmlPrinter.addAttribute( "includes", dir.getIncludeAsString() );
                     }
                     if ( dir.getExcludeAsString() != null )
                     {
                         buildXmlPrinter.addAttribute( "excludes", dir.getExcludeAsString() );
                     }
                     buildXmlPrinter.endElement();
 
                     buildXmlPrinter.endElement();
                 }
 
                 buildXmlPrinter.endElement();
 
                 buildXmlPrinter.endElement();
 
                 IOUtil.close( buildXmlWriter );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Cannot create " + config.getEclipseProjectDirectory()
                     + "/maven-eclipse.xml", e );
             }
 
             log.info( "Creating external launcher file" );
             // now create the launcher
             new EclipseAntExternalLaunchConfigurationWriter().init( log, config, "Maven_Ant_Builder.launch",
                                                                     "maven-eclipse.xml" ).write();
 
             // finally add it to the project writer.
 
             config.getBuildCommands().add(
                                            new BuildCommand(
                                                              "org.eclipse.ui.externaltools.ExternalToolBuilder",
                                                              "LaunchConfigHandle",
                                                              "<project>/"
                                                                  + EclipseLaunchConfigurationWriter.FILE_DOT_EXTERNAL_TOOL_BUILDERS
                                                                  + "Maven_Ant_Builder.launch" ) );
         }
 
         // ----------------------------------------------------------------------
         // The default output
         // ----------------------------------------------------------------------
 
         writer.startElement( ELT_CLASSPATHENTRY );
         writer.addAttribute( ATTR_KIND, ATTR_OUTPUT );
         writer.addAttribute( ATTR_PATH, defaultOutput );
         writer.endElement();
 
         Set addedDependencies = new HashSet();
         // TODO if (..magic property equals orderDependencies..)
 
         // ----------------------------------------------------------------------
         // Java API dependencies that may complete the classpath container so must
         // be declared BEFORE so that container access rules don't fail
         // ----------------------------------------------------------------------
         IdeDependency[] depsToWrite = config.getDepsOrdered();
         for ( int j = 0; j < depsToWrite.length; j++ )
         {
             IdeDependency dep = depsToWrite[j];
             if ( dep.isJavaApi() )
             {
                 String depId = getDependencyId( dep );
                 if ( !addedDependencies.contains( depId ) )
                 {
                     addDependency( writer, dep );
                     addedDependencies.add( depId );
                 }
             }
         }
 
         // ----------------------------------------------------------------------
         // The dependencies
         // ----------------------------------------------------------------------
         for ( int j = 0; j < depsToWrite.length; j++ )
         {
             IdeDependency dep = depsToWrite[j];
 
             if ( dep.isAddedToClasspath() )
             {
                 String depId = getDependencyId( dep );
                 /* avoid duplicates in the classpath for artifacts with different types (like ejbs or test-jars) */
                 if ( !addedDependencies.contains( depId ) )
                 {
                     addDependency( writer, dep );
                     addedDependencies.add( depId );
                 }
             }
         }
 
         // ----------------------------------------------------------------------
         // Container classpath entries
         // ----------------------------------------------------------------------
 
         for ( Iterator it = config.getClasspathContainers().iterator(); it.hasNext(); )
         {
             writer.startElement( ELT_CLASSPATHENTRY );
             writer.addAttribute( ATTR_KIND, "con" ); //$NON-NLS-1$
             writer.addAttribute( ATTR_PATH, (String) it.next() );
             writer.endElement(); // name
         }
 
         writer.endElement();
 
         IOUtil.close( w );
 
     }
 
     private String getDependencyId( IdeDependency dep )
     {
         String depId =
             dep.getGroupId() + ":" + dep.getArtifactId() + ":" + dep.getClassifier() + ":" + dep.getVersion();
 
         if ( dep.isReferencedProject() )
         {
             // This dependency will be refered as an eclipse project
             depId = dep.getEclipseProjectName();
         }
         return depId;
     }
 
     protected void addDependency( XMLWriter writer, IdeDependency dep )
         throws MojoExecutionException
     {
 
         String path;
         String kind;
         String sourcepath = null;
         String javadocpath = null;
 
         if ( dep.isReferencedProject() && !config.isPde() )
         {
             path = "/" + dep.getEclipseProjectName(); //$NON-NLS-1$
             kind = ATTR_SRC;
         }
         else if ( dep.isReferencedProject() && config.isPde() )
         {
             // don't do anything, referenced projects are automatically handled by eclipse in PDE builds
             return;
         }
         else
         {
             File artifactPath = dep.getFile();
 
             if ( artifactPath == null )
             {
                 log.error( Messages.getString( "EclipsePlugin.artifactpathisnull", dep.getId() ) ); //$NON-NLS-1$
                 return;
             }
 
             if ( dep.isSystemScoped() )
             {
                 path = IdeUtils.toRelativeAndFixSeparator( config.getEclipseProjectDirectory(), artifactPath, false );
 
                 if ( log.isDebugEnabled() )
                 {
                     log.debug( Messages.getString( "EclipsePlugin.artifactissystemscoped", //$NON-NLS-1$
                                                    new Object[] { dep.getArtifactId(), path } ) );
                 }
 
                 kind = ATTR_LIB;
             }
             else
             {
                 File localRepositoryFile = new File( config.getLocalRepository().getBasedir() );
 
                 // if the dependency is not provided and the plugin runs in "pde mode", the dependency is
                 // added to the Bundle-Classpath:
                 if ( config.isPde() && ( dep.isProvided() || dep.isOsgiBundle() ) )
                 {
                     return;
                 }
                 else if ( config.isPde() && !dep.isProvided() && !dep.isTestDependency() )
                 {
                     // path for link created in .project, not to the actual file
                     path = dep.getFile().getName();
 
                     kind = ATTR_LIB;
                 }
                 // running in PDE mode and the dependency is provided means, that it is provided by
                 // the target platform. This case is covered by adding the plugin container
                 else
                 {
                     String fullPath = artifactPath.getPath();
                     String relativePath =
                         IdeUtils.toRelativeAndFixSeparator( localRepositoryFile, new File( fullPath ), false );
 
                     if ( !new File( relativePath ).isAbsolute() )
                     {
                         path = M2_REPO + "/" //$NON-NLS-1$
                             + relativePath;
                         kind = ATTR_VAR; //$NON-NLS-1$
                     }
                     else
                     {
                         path = relativePath;
                         kind = ATTR_LIB;
                     }
                 }
 
                 if ( dep.getSourceAttachment() != null )
                 {
                     if ( ATTR_VAR.equals( kind ) )
                     {
                         sourcepath =
                             M2_REPO
                                 + "/" //$NON-NLS-1$
                                 + IdeUtils.toRelativeAndFixSeparator( localRepositoryFile, dep.getSourceAttachment(),
                                                                       false );
                     }
                     else
                     {
                         // source archive must be referenced with the full path, we can't mix a lib with a variable
                         sourcepath = IdeUtils.getCanonicalPath( dep.getSourceAttachment() );
                     }
                 }
 
                 if ( dep.getJavadocAttachment() != null )
                 {
                     // NB eclipse (3.1) doesn't support variables in javadoc paths, so we need to add the
                     // full path for the maven repo
                     javadocpath =
                         StringUtils.replace( IdeUtils.getCanonicalPath( dep.getJavadocAttachment() ), "\\", "/" ); //$NON-NLS-1$ //$NON-NLS-2$
                 }
 
             }
 
         }
 
         // Replace aspectJ runtime library with ajdt ASPECTJRT_CONTAINER.
         if ( ( config.getAjdtVersion() != 0 ) && isAspectJRuntime( dep ) )
         {
             if ( ! config.getClasspathContainers().contains( ASPECTJRT_CONTAINER ) )
             {
                 config.getClasspathContainers().add( ASPECTJRT_CONTAINER );
             }
             return;
         }
 
         writer.startElement( ELT_CLASSPATHENTRY );
         writer.addAttribute( ATTR_KIND, kind );
         writer.addAttribute( ATTR_PATH, path );
 
         if ( sourcepath != null )
         {
             writer.addAttribute( ATTR_SOURCEPATH, sourcepath );
         }
 
         boolean attributeElemOpen = false;
 
         if ( javadocpath != null )
         {
             if ( !attributeElemOpen )
             {
                 writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
                 attributeElemOpen = true;
             }
 
             writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
             writer.addAttribute( VALUE, "jar:" + new File( javadocpath ).toURI() + "!/" ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
             writer.addAttribute( NAME, "javadoc_location" ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.endElement();
 
         }
 
         if ( Constants.PROJECT_PACKAGING_WAR.equals( this.config.getPackaging() ) && config.getWtpapplicationxml()
             && kind.equals( ATTR_VAR ) && !dep.isTestDependency() && !dep.isProvided()
             && !dep.isSystemScopedOutsideProject( this.config.getProject() ) )
         {
             if ( !attributeElemOpen )
             {
                 writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
                 attributeElemOpen = true;
             }
 
             writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
             writer.addAttribute( VALUE, "/WEB-INF/lib" ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.addAttribute( NAME, "org.eclipse.jst.component.dependency" ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.endElement();
 
         }
 
         if ( dep.isAjdtDependency() && ( config.getAjdtVersion() >= 1.5 ) )
         {
             if ( !attributeElemOpen )
             {
                 writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
                 attributeElemOpen = true;
             }
 
             writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
             writer.addAttribute( NAME, ORG_ECLIPSE_AJDT_ASPECTPATH ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.addAttribute( VALUE, Boolean.TRUE.toString() ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.endElement();
 
         }
 
         if ( dep.isAjdtWeaveDependency() && ( config.getAjdtVersion() >= 1.5 ) )
         {
             if ( !attributeElemOpen )
             {
                 writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
                 attributeElemOpen = true;
             }
 
             writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
             writer.addAttribute( NAME, ORG_ECLIPSE_AJDT_INPATH ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.addAttribute( VALUE, Boolean.TRUE.toString() ); //$NON-NLS-1$ //$NON-NLS-2$
             writer.endElement();
 
         }
 
         if ( attributeElemOpen )
         {
             writer.endElement();
         }
         writer.endElement();
 
     }
 
     /**
      * @return
      */
     private boolean isAspectJRuntime( IdeDependency dep )
     {
         if ( dep.getArtifactId().equals( "aspectjrt" ) )
         {
             return dep.getGroupId().equals( "org.aspectj" ) || dep.getGroupId().equals( "aspectj" );
         }
         return false;
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package org.apache.maven.plugin.eclipse.writers;
20
21		import java.io.File;
22		import java.io.FileOutputStream;
23		import java.io.IOException;
24		import java.io.OutputStreamWriter;
25		import java.io.Writer;
26		import java.util.ArrayList;
27		import java.util.HashMap;
28		import java.util.HashSet;
29		import java.util.Iterator;
30		import java.util.List;
31		import java.util.Map;
32		import java.util.Set;
33
34		import org.apache.maven.plugin.MojoExecutionException;
35		import org.apache.maven.plugin.eclipse.BuildCommand;
36		import org.apache.maven.plugin.eclipse.Constants;
37		import org.apache.maven.plugin.eclipse.EclipseSourceDir;
38		import org.apache.maven.plugin.eclipse.Messages;
39		import org.apache.maven.plugin.ide.IdeDependency;
40		import org.apache.maven.plugin.ide.IdeUtils;
41		import org.codehaus.plexus.util.IOUtil;
42		import org.codehaus.plexus.util.StringUtils;
43		import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
44		import org.codehaus.plexus.util.xml.XMLWriter;
45
46		/**
47		* Writes eclipse .classpath file.
48		*
49		* @author <a href="mailto:trygvis@inamo.no">Trygve Laugstøl</a>
50		* @author <a href="mailto:kenney@neonics.com">Kenney Westerhof</a>
51		* @author <a href="mailto:fgiust@apache.org">Fabrizio Giustina</a>
52		* @version $Id: EclipseClasspathWriter.java 826604 2009-10-19 08:24:35Z nicolas $
53		*/
54	12	public class EclipseClasspathWriter
55		extends AbstractEclipseWriter
56		{
57
58		/**
59		*
60		*/
61		private static final String ORG_ECLIPSE_AJDT_INPATH = "org.eclipse.ajdt.inpath";
62
63		/**
64		*
65		*/
66		private static final String ORG_ECLIPSE_AJDT_ASPECTPATH = "org.eclipse.ajdt.aspectpath";
67
68		private static final String ASPECTJRT_CONTAINER = "org.eclipse.ajdt.core.ASPECTJRT_CONTAINER";
69
70		/**
71		*
72		*/
73		private static final String NAME = "name";
74
75		/**
76		*
77		*/
78		private static final String VALUE = "value";
79
80		/**
81		*
82		*/
83		private static final String ATTRIBUTE = "attribute";
84
85		/**
86		*
87		*/
88		private static final String ATTRIBUTES = "attributes";
89
90		/**
91		* Eclipse build path variable M2_REPO
92		*/
93		protected static final String M2_REPO = "M2_REPO"; //$NON-NLS-1$
94
95		/**
96		* Attribute for sourcepath.
97		*/
98		private static final String ATTR_SOURCEPATH = "sourcepath"; //$NON-NLS-1$
99
100		/**
101		* Attribute for output.
102		*/
103		private static final String ATTR_OUTPUT = "output"; //$NON-NLS-1$
104
105		/**
106		* Attribute for path.
107		*/
108		private static final String ATTR_PATH = "path"; //$NON-NLS-1$
109
110		/**
111		* Attribute for kind - Container (con), Variable (var)..etc.
112		*/
113		private static final String ATTR_KIND = "kind"; //$NON-NLS-1$
114
115		/**
116		* Attribute value for kind: var
117		*/
118		private static final String ATTR_VAR = "var"; //$NON-NLS-1$
119
120		/**
121		* Attribute value for kind: lib
122		*/
123		private static final String ATTR_LIB = "lib"; //$NON-NLS-1$
124
125		/**
126		* Attribute value for kind: src
127		*/
128		private static final String ATTR_SRC = "src"; //$NON-NLS-1$
129
130		/**
131		* Attribute name for source file includes in a path.
132		*/
133		private static final String ATTR_INCLUDING = "including";
134
135		/**
136		* Attribute name for source file excludes in a path.
137		*/
138		private static final String ATTR_EXCLUDING = "excluding";
139
140		/**
141		* Element for classpathentry.
142		*/
143		private static final String ELT_CLASSPATHENTRY = "classpathentry"; //$NON-NLS-1$
144
145		/**
146		* Element for classpath.
147		*/
148		private static final String ELT_CLASSPATH = "classpath"; //$NON-NLS-1$
149
150		/**
151		* File name that stores project classpath settings.
152		*/
153		private static final String FILE_DOT_CLASSPATH = ".classpath"; //$NON-NLS-1$
154
155		/**
156		* @see org.apache.maven.plugin.eclipse.writers.EclipseWriter#write()
157		*/
158		public void write()
159		throws MojoExecutionException
160		{
161
162		Writer w;
163
164		try
165		{
166	12	w =
167		new OutputStreamWriter( new FileOutputStream( new File( config.getEclipseProjectDirectory(),
168		FILE_DOT_CLASSPATH ) ), "UTF-8" );
169		}
170	0	catch ( IOException ex )
171		{
172	0	throw new MojoExecutionException( Messages.getString( "EclipsePlugin.erroropeningfile" ), ex ); //$NON-NLS-1$
173	12	}
174
175	12	XMLWriter writer = new PrettyPrintXMLWriter( w );
176
177	12	writer.startElement( ELT_CLASSPATH );
178
179	12	String defaultOutput =
180		IdeUtils.toRelativeAndFixSeparator( config.getProjectBaseDir(), config.getBuildOutputDirectory(), false );
181
182		// ----------------------------------------------------------------------
183		// Source roots and resources
184		// ----------------------------------------------------------------------
185
186		// List<EclipseSourceDir>
187	12	List specialSources = new ArrayList();
188
189		// Map<String,List<EclipseSourceDir>>
190	12	Map byOutputDir = new HashMap();
191
192	24	for ( int j = 0; j < config.getSourceDirs().length; j++ )
193		{
194	12	EclipseSourceDir dir = config.getSourceDirs()[j];
195
196		// List<EclipseSourceDir>
197	12	List byOutputDirs = (List) byOutputDir.get( dir.getOutput() );
198	12	if ( byOutputDirs == null )
199		{
200		// ArrayList<EclipseSourceDir>
201	12	byOutputDir.put( dir.getOutput() == null ? defaultOutput : dir.getOutput(), byOutputDirs =
202		new ArrayList() );
203		}
204	12	byOutputDirs.add( dir );
205		}
206
207	24	for ( int j = 0; j < config.getSourceDirs().length; j++ )
208		{
209	12	EclipseSourceDir dir = config.getSourceDirs()[j];
210
211	12	log.debug( "Processing classpath for: " + dir.toString() + "; default output=" + defaultOutput );
212
213	12	boolean isSpecial = false;
214
215		// handle resource with nested output folders
216	12	if ( dir.isResource() )
217		{
218		// Check if the output is a subdirectory of the default output,
219		// and if the default output has any sources that copy there.
220
221	12	if ( dir.getOutput() != null // resource output dir is set
222		&& !dir.getOutput().equals( defaultOutput ) // output dir is not default target/classes
223		&& dir.getOutput().startsWith( defaultOutput ) // ... but is nested
224		&& byOutputDir.get( defaultOutput ) != null // ???
225		&& !( (List) byOutputDir.get( defaultOutput ) ).isEmpty() // ???
226		)
227		{
228		// do not specify as source since the output will be nested. Instead, mark
229		// it as a todo, and handle it with a custom build.xml file later.
230
231	6	log.debug( "Marking as special to prevent output folder nesting: " + dir.getPath() + " (output="
232		+ dir.getOutput() + ")" );
233
234	6	isSpecial = true;
235	6	specialSources.add( dir );
236		}
237		}
238
239	12	writer.startElement( ELT_CLASSPATHENTRY );
240
241	12	writer.addAttribute( ATTR_KIND, "src" ); //$NON-NLS-1$
242	12	writer.addAttribute( ATTR_PATH, dir.getPath() );
243
244	12	if ( !isSpecial && dir.getOutput() != null && !defaultOutput.equals( dir.getOutput() ) )
245		{
246	0	writer.addAttribute( ATTR_OUTPUT, dir.getOutput() );
247		}
248
249	12	String includes = dir.getIncludeAsString();
250	12	if ( StringUtils.isNotEmpty( includes ) )
251		{
252	0	writer.addAttribute( ATTR_INCLUDING, includes );
253		}
254
255	12	String excludes = dir.getExcludeAsString();
256	12	if ( StringUtils.isNotEmpty( excludes ) )
257		{
258	0	writer.addAttribute( ATTR_EXCLUDING, excludes );
259		}
260
261	12	writer.endElement();
262
263		}
264
265		// handle the special sources.
266	12	if ( !specialSources.isEmpty() )
267		{
268	6	log.info( "Creating maven-eclipse.xml Ant file to handle resources" );
269
270		try
271		{
272	6	Writer buildXmlWriter =
273		new OutputStreamWriter( new FileOutputStream( new File( config.getEclipseProjectDirectory(),
274		"maven-eclipse.xml" ) ), "UTF-8" );
275	6	PrettyPrintXMLWriter buildXmlPrinter = new PrettyPrintXMLWriter( buildXmlWriter );
276
277	6	buildXmlPrinter.startElement( "project" );
278	6	buildXmlPrinter.addAttribute( "default", "copy-resources" );
279
280	6	buildXmlPrinter.startElement( "target" );
281	6	buildXmlPrinter.addAttribute( NAME, "init" );
282		// initialize filtering tokens here
283	6	buildXmlPrinter.endElement();
284
285	6	buildXmlPrinter.startElement( "target" );
286	6	buildXmlPrinter.addAttribute( NAME, "copy-resources" );
287	6	buildXmlPrinter.addAttribute( "depends", "init" );
288
289	6	for ( Iterator it = specialSources.iterator(); it.hasNext(); )
290		{
291		// TODO: merge source dirs on output path+filtering to reduce
292		// <copy> tags for speed.
293	6	EclipseSourceDir dir = (EclipseSourceDir) it.next();
294	6	buildXmlPrinter.startElement( "copy" );
295	6	buildXmlPrinter.addAttribute( "todir", dir.getOutput() );
296	6	buildXmlPrinter.addAttribute( "filtering", "" + dir.isFiltering() );
297
298	6	buildXmlPrinter.startElement( "fileset" );
299	6	buildXmlPrinter.addAttribute( "dir", dir.getPath() );
300	6	if ( dir.getIncludeAsString() != null )
301		{
302	6	buildXmlPrinter.addAttribute( "includes", dir.getIncludeAsString() );
303		}
304	6	if ( dir.getExcludeAsString() != null )
305		{
306	6	buildXmlPrinter.addAttribute( "excludes", dir.getExcludeAsString() );
307		}
308	6	buildXmlPrinter.endElement();
309
310	6	buildXmlPrinter.endElement();
311	6	}
312
313	6	buildXmlPrinter.endElement();
314
315	6	buildXmlPrinter.endElement();
316
317	6	IOUtil.close( buildXmlWriter );
318		}
319	0	catch ( IOException e )
320		{
321	0	throw new MojoExecutionException( "Cannot create " + config.getEclipseProjectDirectory()
322		+ "/maven-eclipse.xml", e );
323	6	}
324
325	6	log.info( "Creating external launcher file" );
326		// now create the launcher
327	6	new EclipseAntExternalLaunchConfigurationWriter().init( log, config, "Maven_Ant_Builder.launch",
328		"maven-eclipse.xml" ).write();
329
330		// finally add it to the project writer.
331
332	6	config.getBuildCommands().add(
333		new BuildCommand(
334		"org.eclipse.ui.externaltools.ExternalToolBuilder",
335		"LaunchConfigHandle",
336		"<project>/"
337		+ EclipseLaunchConfigurationWriter.FILE_DOT_EXTERNAL_TOOL_BUILDERS
338		+ "Maven_Ant_Builder.launch" ) );
339		}
340
341		// ----------------------------------------------------------------------
342		// The default output
343		// ----------------------------------------------------------------------
344
345	12	writer.startElement( ELT_CLASSPATHENTRY );
346	12	writer.addAttribute( ATTR_KIND, ATTR_OUTPUT );
347	12	writer.addAttribute( ATTR_PATH, defaultOutput );
348	12	writer.endElement();
349
350	12	Set addedDependencies = new HashSet();
351		// TODO if (..magic property equals orderDependencies..)
352
353		// ----------------------------------------------------------------------
354		// Java API dependencies that may complete the classpath container so must
355		// be declared BEFORE so that container access rules don't fail
356		// ----------------------------------------------------------------------
357	12	IdeDependency[] depsToWrite = config.getDepsOrdered();
358	18	for ( int j = 0; j < depsToWrite.length; j++ )
359		{
360	6	IdeDependency dep = depsToWrite[j];
361	6	if ( dep.isJavaApi() )
362		{
363	0	String depId = getDependencyId( dep );
364	0	if ( !addedDependencies.contains( depId ) )
365		{
366	0	addDependency( writer, dep );
367	0	addedDependencies.add( depId );
368		}
369		}
370		}
371
372		// ----------------------------------------------------------------------
373		// The dependencies
374		// ----------------------------------------------------------------------
375	18	for ( int j = 0; j < depsToWrite.length; j++ )
376		{
377	6	IdeDependency dep = depsToWrite[j];
378
379	6	if ( dep.isAddedToClasspath() )
380		{
381	6	String depId = getDependencyId( dep );
382		/* avoid duplicates in the classpath for artifacts with different types (like ejbs or test-jars) */
383	6	if ( !addedDependencies.contains( depId ) )
384		{
385	6	addDependency( writer, dep );
386	6	addedDependencies.add( depId );
387		}
388		}
389		}
390
391		// ----------------------------------------------------------------------
392		// Container classpath entries
393		// ----------------------------------------------------------------------
394
395	12	for ( Iterator it = config.getClasspathContainers().iterator(); it.hasNext(); )
396		{
397	0	writer.startElement( ELT_CLASSPATHENTRY );
398	0	writer.addAttribute( ATTR_KIND, "con" ); //$NON-NLS-1$
399	0	writer.addAttribute( ATTR_PATH, (String) it.next() );
400	0	writer.endElement(); // name
401		}
402
403	12	writer.endElement();
404
405	12	IOUtil.close( w );
406
407	12	}
408
409		private String getDependencyId( IdeDependency dep )
410		{
411	6	String depId =
412		dep.getGroupId() + ":" + dep.getArtifactId() + ":" + dep.getClassifier() + ":" + dep.getVersion();
413
414	6	if ( dep.isReferencedProject() )
415		{
416		// This dependency will be refered as an eclipse project
417	0	depId = dep.getEclipseProjectName();
418		}
419	6	return depId;
420		}
421
422		protected void addDependency( XMLWriter writer, IdeDependency dep )
423		throws MojoExecutionException
424		{
425
426		String path;
427		String kind;
428	6	String sourcepath = null;
429	6	String javadocpath = null;
430
431	6	if ( dep.isReferencedProject() && !config.isPde() )
432		{
433	0	path = "/" + dep.getEclipseProjectName(); //$NON-NLS-1$
434	0	kind = ATTR_SRC;
435		}
436	6	else if ( dep.isReferencedProject() && config.isPde() )
437		{
438		// don't do anything, referenced projects are automatically handled by eclipse in PDE builds
439	0	return;
440		}
441		else
442		{
443	6	File artifactPath = dep.getFile();
444
445	6	if ( artifactPath == null )
446		{
447	0	log.error( Messages.getString( "EclipsePlugin.artifactpathisnull", dep.getId() ) ); //$NON-NLS-1$
448	0	return;
449		}
450
451	6	if ( dep.isSystemScoped() )
452		{
453	0	path = IdeUtils.toRelativeAndFixSeparator( config.getEclipseProjectDirectory(), artifactPath, false );
454
455	0	if ( log.isDebugEnabled() )
456		{
457	0	log.debug( Messages.getString( "EclipsePlugin.artifactissystemscoped", //$NON-NLS-1$
458		new Object[] { dep.getArtifactId(), path } ) );
459		}
460
461	0	kind = ATTR_LIB;
462		}
463		else
464		{
465	6	File localRepositoryFile = new File( config.getLocalRepository().getBasedir() );
466
467		// if the dependency is not provided and the plugin runs in "pde mode", the dependency is
468		// added to the Bundle-Classpath:
469	6	if ( config.isPde() && ( dep.isProvided() \|\| dep.isOsgiBundle() ) )
470		{
471	0	return;
472		}
473	6	else if ( config.isPde() && !dep.isProvided() && !dep.isTestDependency() )
474		{
475		// path for link created in .project, not to the actual file
476	0	path = dep.getFile().getName();
477
478	0	kind = ATTR_LIB;
479		}
480		// running in PDE mode and the dependency is provided means, that it is provided by
481		// the target platform. This case is covered by adding the plugin container
482		else
483		{
484	6	String fullPath = artifactPath.getPath();
485	6	String relativePath =
486		IdeUtils.toRelativeAndFixSeparator( localRepositoryFile, new File( fullPath ), false );
487
488	6	if ( !new File( relativePath ).isAbsolute() )
489		{
490	6	path = M2_REPO + "/" //$NON-NLS-1$
491		+ relativePath;
492	6	kind = ATTR_VAR; //$NON-NLS-1$
493		}
494		else
495		{
496	0	path = relativePath;
497	0	kind = ATTR_LIB;
498		}
499		}
500
501	6	if ( dep.getSourceAttachment() != null )
502		{
503	0	if ( ATTR_VAR.equals( kind ) )
504		{
505	0	sourcepath =
506		M2_REPO
507		+ "/" //$NON-NLS-1$
508		+ IdeUtils.toRelativeAndFixSeparator( localRepositoryFile, dep.getSourceAttachment(),
509		false );
510		}
511		else
512		{
513		// source archive must be referenced with the full path, we can't mix a lib with a variable
514	0	sourcepath = IdeUtils.getCanonicalPath( dep.getSourceAttachment() );
515		}
516		}
517
518	6	if ( dep.getJavadocAttachment() != null )
519		{
520		// NB eclipse (3.1) doesn't support variables in javadoc paths, so we need to add the
521		// full path for the maven repo
522	6	javadocpath =
523		StringUtils.replace( IdeUtils.getCanonicalPath( dep.getJavadocAttachment() ), "\\", "/" ); //$NON-NLS-1$ //$NON-NLS-2$
524		}
525
526		}
527
528		}
529
530		// Replace aspectJ runtime library with ajdt ASPECTJRT_CONTAINER.
531	6	if ( ( config.getAjdtVersion() != 0 ) && isAspectJRuntime( dep ) )
532		{
533	0	if ( ! config.getClasspathContainers().contains( ASPECTJRT_CONTAINER ) )
534		{
535	0	config.getClasspathContainers().add( ASPECTJRT_CONTAINER );
536		}
537	0	return;
538		}
539
540	6	writer.startElement( ELT_CLASSPATHENTRY );
541	6	writer.addAttribute( ATTR_KIND, kind );
542	6	writer.addAttribute( ATTR_PATH, path );
543
544	6	if ( sourcepath != null )
545		{
546	0	writer.addAttribute( ATTR_SOURCEPATH, sourcepath );
547		}
548
549	6	boolean attributeElemOpen = false;
550
551	6	if ( javadocpath != null )
552		{
553	6	if ( !attributeElemOpen )
554		{
555	6	writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
556	6	attributeElemOpen = true;
557		}
558
559	6	writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
560	6	writer.addAttribute( VALUE, "jar:" + new File( javadocpath ).toURI() + "!/" ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
561	6	writer.addAttribute( NAME, "javadoc_location" ); //$NON-NLS-1$ //$NON-NLS-2$
562	6	writer.endElement();
563
564		}
565
566	6	if ( Constants.PROJECT_PACKAGING_WAR.equals( this.config.getPackaging() ) && config.getWtpapplicationxml()
567		&& kind.equals( ATTR_VAR ) && !dep.isTestDependency() && !dep.isProvided()
568		&& !dep.isSystemScopedOutsideProject( this.config.getProject() ) )
569		{
570	0	if ( !attributeElemOpen )
571		{
572	0	writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
573	0	attributeElemOpen = true;
574		}
575
576	0	writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
577	0	writer.addAttribute( VALUE, "/WEB-INF/lib" ); //$NON-NLS-1$ //$NON-NLS-2$
578	0	writer.addAttribute( NAME, "org.eclipse.jst.component.dependency" ); //$NON-NLS-1$ //$NON-NLS-2$
579	0	writer.endElement();
580
581		}
582
583	6	if ( dep.isAjdtDependency() && ( config.getAjdtVersion() >= 1.5 ) )
584		{
585	0	if ( !attributeElemOpen )
586		{
587	0	writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
588	0	attributeElemOpen = true;
589		}
590
591	0	writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
592	0	writer.addAttribute( NAME, ORG_ECLIPSE_AJDT_ASPECTPATH ); //$NON-NLS-1$ //$NON-NLS-2$
593	0	writer.addAttribute( VALUE, Boolean.TRUE.toString() ); //$NON-NLS-1$ //$NON-NLS-2$
594	0	writer.endElement();
595
596		}
597
598	6	if ( dep.isAjdtWeaveDependency() && ( config.getAjdtVersion() >= 1.5 ) )
599		{
600	0	if ( !attributeElemOpen )
601		{
602	0	writer.startElement( ATTRIBUTES ); //$NON-NLS-1$
603	0	attributeElemOpen = true;
604		}
605
606	0	writer.startElement( ATTRIBUTE ); //$NON-NLS-1$
607	0	writer.addAttribute( NAME, ORG_ECLIPSE_AJDT_INPATH ); //$NON-NLS-1$ //$NON-NLS-2$
608	0	writer.addAttribute( VALUE, Boolean.TRUE.toString() ); //$NON-NLS-1$ //$NON-NLS-2$
609	0	writer.endElement();
610
611		}
612
613	6	if ( attributeElemOpen )
614		{
615	6	writer.endElement();
616		}
617	6	writer.endElement();
618
619	6	}
620
621		/**
622		* @return
623		*/
624		private boolean isAspectJRuntime( IdeDependency dep )
625		{
626	0	if ( dep.getArtifactId().equals( "aspectjrt" ) )
627		{
628	0	return dep.getGroupId().equals( "org.aspectj" ) \|\| dep.getGroupId().equals( "aspectj" );
629		}
630	0	return false;
631		}
632		}