Coverage Report

Coverage Report - org.apache.maven.plugin.eclipse.MyEclipsePlugin

Classes in this File

0/85

0/60

 package org.apache.maven.plugin.eclipse;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.eclipse.writers.EclipseProjectWriter;
 import org.apache.maven.plugin.eclipse.writers.EclipseSettingsWriter;
 import org.apache.maven.plugin.eclipse.writers.EclipseWriterConfig;
 import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseClasspathWriter;
 import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseHibernateWriter;
 import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseMetadataWriter;
 import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseSpringBeansWriter;
 import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseStrutsDataWriter;
 import org.apache.maven.plugin.ide.IdeDependency;
 import org.apache.maven.plugin.ide.IdeUtils;
 import org.apache.maven.plugin.ide.JeeUtils;
 
 /**
  * Generates MyEclipse configuration files
  * 
  * @author <a href="mailto:olivier.jacob@gmail.com">Olivier Jacob</a>
  * @goal myeclipse
  * @since 2.5
  * @execute phase="generate-resources"
  */
 public class MyEclipsePlugin
     extends EclipsePlugin
 {
     /* MyEclipse project natures */
     private static final String MYECLIPSE_EAR_NATURE = "com.genuitec.eclipse.j2eedt.core.earnature";
 
     private static final String MYECLIPSE_WEB_NATURE = "com.genuitec.eclipse.j2eedt.core.webnature";
 
     private static final String MYECLISPE_SPRING_NATURE = "com.genuitec.eclipse.springframework.springnature";
 
     private static final String MYECLIPSE_STRUTS_NATURE =
         "com.genuitec.eclipse.cross.easystruts.eclipse.easystrutsnature";
 
     private static final String MYECLIPSE_HIBERNATE_NATURE = "com.genuitec.eclipse.hibernate.hibernatenature";
 
     /* MyEclipse builders */
     private static final String MYECLIPSE_DEPLOYMENT_DESCRIPTOR_VALIDATOR_BUILDER =
         "com.genuitec.eclipse.j2eedt.core.DeploymentDescriptorValidator";
 
     private static final String MYECLIPSE_WEB_CLASSPATH_BUILDER =
         "com.genuitec.eclipse.j2eedt.core.WebClasspathBuilder";
 
     private static final String MYECLIPSE_J2EE_PROJECT_VALIDATOR_BUILDER =
         "com.genuitec.eclipse.j2eedt.core.J2EEProjectValidator";
 
     private static final String MYECLIPSE_SPRING_BUILDER = "com.genuitec.eclipse.springframework.springbuilder";
 
     private static final String MYECLIPSE_HIBERNATE_BUILDER = "com.genuitec.eclipse.hibernate.HibernateBuilder";
 
     private static final String MYECLIPSE_J2EE_14_CLASSPATH_CONTAINER =
         "com.genuitec.eclipse.j2eedt.core.J2EE14_CONTAINER";
 
     private static final String MYECLIPSE_J2EE_13_CLASSPATH_CONTAINER =
         "com.genuitec.eclipse.j2eedt.core.J2EE13_CONTAINER";
 
     private static final String MYECLIPSE_DEFAULT_HIBERNATE_CFG_XML = "src/main/resources/applicationContext.xml";
 
     /**
      * Spring configuration placeholder <p/>
      * 
      * <pre>
      *   &lt;spring&gt;
      *     &lt;version&gt;1.0/2.0&lt;/version&gt;
      *     &lt;file-pattern&gt;applicationContext-*.xml&lt;/file-pattern&gt;
      *     &lt;basedir&gt;src/main/resources&lt;/basedir&gt;
      *   &lt;/spring&gt;
      * </pre>
      * 
      * @parameter
      */
     private Map spring;
 
     /**
      * Hibernate configuration placeholder <p/>
      * 
      * <pre>
      *   &lt;hibernate&gt;
      *     &lt;config-file&gt;src/main/resources/applicationContext-persistence.xml&lt;/config-file&gt;
      *     &lt;session-factory-id&gt;mySessionFactory&lt;/session-factory-id&gt;
      *   &lt;/hibernate&gt;
      * </pre>
      * 
      * @parameter
      */
     private Map hibernate;
 
     /**
      * Allow declaration of struts properties for MyEclipse <p/>
      * 
      * <pre>
      *   &lt;struts&gt;
      *     &lt;version&gt;1.2.9&lt;/version&gt;
      *     &lt;servlet-name&gt;action&lt;/servlet-name&gt;
      *     &lt;pattern&gt;*.do&lt;/pattern&gt;
      *     &lt;base-package&gt;1.2.9&lt;/base-package&gt;
      *   &lt;/struts&gt;
      * </pre>
      * 
      * @parameter
      */
     private Map struts;
 
     public void writeConfiguration( IdeDependency[] deps )
         throws MojoExecutionException
     {
         EclipseWriterConfig config = createEclipseWriterConfig( deps );
 
         new EclipseSettingsWriter().init( getLog(), config ).write();
 
         if ( isJavaProject() )
         {
             // If the project is a Web Project, make it compile in WEB-INF/classes
             if ( Constants.PROJECT_PACKAGING_WAR.equals( project.getPackaging() ) )
             {
                 String warSourceDirectory =
                     IdeUtils.getPluginSetting( config.getProject(), JeeUtils.ARTIFACT_MAVEN_WAR_PLUGIN,
                                                "warSourceDirectory",//$NON-NLS-1$
                                                "/src/main/webapp" ); //$NON-NLS-1$
 
                 EclipseSourceDir[] sourceDirs = config.getSourceDirs();
                 for ( int i = 0; i < sourceDirs.length; i++ )
                 {
                     if ( !sourceDirs[i].isTest() )
                     {
                         sourceDirs[i].setOutput( warSourceDirectory + "/WEB-INF/classes" );
                     }
                 }
             }
 
             new MyEclipseClasspathWriter().init( getLog(), config ).write();
         }
 
         new EclipseProjectWriter().init( getLog(), config ).write();
 
         writeAdditionalConfig();
 
         // the MyEclipse part ...
 
         new MyEclipseMetadataWriter().init( getLog(), config ).write();
 
         if ( getStruts() != null )
         {
             new MyEclipseStrutsDataWriter( getStruts() ).init( getLog(), config ).write();
         }
         if ( getSpring() != null )
         {
             new MyEclipseSpringBeansWriter( getSpring() ).init( getLog(), config ).write();
         }
         if ( getHibernate() != null )
         {
             // Only Spring configuration file is currently supported
             String hbmCfgFile = (String) getHibernate().get( "config-file" );
 
             if ( "".equals( hbmCfgFile ) )
             {
                 hbmCfgFile = MYECLIPSE_DEFAULT_HIBERNATE_CFG_XML;
             }
 
             new MyEclipseHibernateWriter( getHibernate() ).init( getLog(), config ).write();
         }
     }
 
     /**
      * Override the default builders with the builders used by MyEclipse
      * 
      * @param packaging packaging-type (jar,war,ejb,ear)
      */
     protected void fillDefaultBuilders( String packaging )
     {
         List commands = new ArrayList();
 
         super.fillDefaultBuilders( packaging );
 
         if ( Constants.PROJECT_PACKAGING_EAR.equals( packaging ) )
         {
             if ( getLog().isDebugEnabled() )
             {
                 getLog().debug( "EAR packaging does not need specific builders" );
             }
         }
         else if ( Constants.PROJECT_PACKAGING_WAR.equals( packaging ) )
         {
             commands.add( MYECLIPSE_DEPLOYMENT_DESCRIPTOR_VALIDATOR_BUILDER );
             commands.add( MYECLIPSE_J2EE_PROJECT_VALIDATOR_BUILDER );
             commands.add( MYECLIPSE_WEB_CLASSPATH_BUILDER );
 
             // WST Validation Builder : may be added by super.fillDefaultBuilders so check before adding it
             if ( !getBuildcommands().contains( new BuildCommand( BUILDER_WST_VALIDATION ) ) )
             {
                 commands.add( BUILDER_WST_VALIDATION );
             }
         }
         else if ( Constants.PROJECT_PACKAGING_EJB.equals( packaging ) )
         {
             if ( getLog().isInfoEnabled() )
             {
                 getLog().info( "EJB packaging is not implemented yet" );
             }
         }
         else if ( isJavaProject() )
         {
             if ( getLog().isDebugEnabled() )
             {
                 getLog().debug( "JAR packaging does not need specific builders" );
             }
         }
 
         if ( getSpring() != null )
         {
             commands.add( MYECLIPSE_SPRING_BUILDER );
         }
         if ( getHibernate() != null )
         {
             commands.add( MYECLIPSE_HIBERNATE_BUILDER );
         }
 
         convertBuildCommandList( commands );
         getBuildcommands().addAll( commands );
     }
 
     /**
      * Override the default natures with the natures used by MyEclipse
      * 
      * @param packaging packaging-type (jar,war,ejb,ear)
      */
     protected void fillDefaultNatures( String packaging )
     {
         List natures = new ArrayList();
 
         super.fillDefaultNatures( packaging );
 
         if ( Constants.PROJECT_PACKAGING_EAR.equals( packaging ) )
         {
             natures.add( MYECLIPSE_EAR_NATURE );
         }
         else if ( Constants.PROJECT_PACKAGING_WAR.equals( packaging ) )
         {
             natures.add( MYECLIPSE_WEB_NATURE );
         }
         else if ( Constants.PROJECT_PACKAGING_EJB.equals( packaging ) )
         {
             if ( getLog().isInfoEnabled() )
             {
                 getLog().info( "EJB packaging is not implemented yet" );
             }
         }
         else if ( isJavaProject() )
         {
             if ( getLog().isDebugEnabled() )
             {
                 getLog().debug( "JAR projects does not need specific natures" );
             }
         }
 
         // Spring
         if ( getSpring() != null )
         {
             natures.add( MYECLISPE_SPRING_NATURE );
         }
         // Struts
         if ( getStruts() != null )
         {
             natures.add( MYECLIPSE_STRUTS_NATURE );
         }
 
         // Hibernate
         if ( getHibernate() != null )
         {
             natures.add( MYECLIPSE_HIBERNATE_NATURE );
         }
 
         getProjectnatures().addAll( natures );
     }
 
     protected void fillDefaultClasspathContainers( String packaging )
     {
         super.fillDefaultClasspathContainers( packaging );
 
         if ( Constants.PROJECT_PACKAGING_WAR.equals( packaging ) )
         {
             String jeeVersion =
                 JeeUtils.getJeeDescriptorFromServletVersion( JeeUtils.resolveServletVersion( project ) ).getJeeVersion();
 
             if ( "1.3".equals( jeeVersion ) )
             {
                 getClasspathContainers().add( MYECLIPSE_J2EE_13_CLASSPATH_CONTAINER );
             }
             else if ( "1.4".equals( jeeVersion ) )
             {
                 getClasspathContainers().add( MYECLIPSE_J2EE_14_CLASSPATH_CONTAINER );
             }
         }
     }
 
     public Map getSpring()
     {
         return spring;
     }
 
     public void setSpring( Map spring )
     {
         this.spring = spring;
     }
 
     public Map getHibernate()
     {
         return hibernate;
     }
 
     public void setHibernate( Map hibernate )
     {
         this.hibernate = hibernate;
     }
 
     public Map getStruts()
     {
         return struts;
     }
 
     public void setStruts( Map struts )
     {
         this.struts = struts;
     }
 
 }

1		package org.apache.maven.plugin.eclipse;
2
3		import java.util.ArrayList;
4		import java.util.List;
5		import java.util.Map;
6
7		import org.apache.maven.plugin.MojoExecutionException;
8		import org.apache.maven.plugin.eclipse.writers.EclipseProjectWriter;
9		import org.apache.maven.plugin.eclipse.writers.EclipseSettingsWriter;
10		import org.apache.maven.plugin.eclipse.writers.EclipseWriterConfig;
11		import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseClasspathWriter;
12		import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseHibernateWriter;
13		import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseMetadataWriter;
14		import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseSpringBeansWriter;
15		import org.apache.maven.plugin.eclipse.writers.myeclipse.MyEclipseStrutsDataWriter;
16		import org.apache.maven.plugin.ide.IdeDependency;
17		import org.apache.maven.plugin.ide.IdeUtils;
18		import org.apache.maven.plugin.ide.JeeUtils;
19
20		/**
21		* Generates MyEclipse configuration files
22		*
23		* @author <a href="mailto:olivier.jacob@gmail.com">Olivier Jacob</a>
24		* @goal myeclipse
25		* @since 2.5
26		* @execute phase="generate-resources"
27		*/
28	0	public class MyEclipsePlugin
29		extends EclipsePlugin
30		{
31		/* MyEclipse project natures */
32		private static final String MYECLIPSE_EAR_NATURE = "com.genuitec.eclipse.j2eedt.core.earnature";
33
34		private static final String MYECLIPSE_WEB_NATURE = "com.genuitec.eclipse.j2eedt.core.webnature";
35
36		private static final String MYECLISPE_SPRING_NATURE = "com.genuitec.eclipse.springframework.springnature";
37
38		private static final String MYECLIPSE_STRUTS_NATURE =
39		"com.genuitec.eclipse.cross.easystruts.eclipse.easystrutsnature";
40
41		private static final String MYECLIPSE_HIBERNATE_NATURE = "com.genuitec.eclipse.hibernate.hibernatenature";
42
43		/* MyEclipse builders */
44		private static final String MYECLIPSE_DEPLOYMENT_DESCRIPTOR_VALIDATOR_BUILDER =
45		"com.genuitec.eclipse.j2eedt.core.DeploymentDescriptorValidator";
46
47		private static final String MYECLIPSE_WEB_CLASSPATH_BUILDER =
48		"com.genuitec.eclipse.j2eedt.core.WebClasspathBuilder";
49
50		private static final String MYECLIPSE_J2EE_PROJECT_VALIDATOR_BUILDER =
51		"com.genuitec.eclipse.j2eedt.core.J2EEProjectValidator";
52
53		private static final String MYECLIPSE_SPRING_BUILDER = "com.genuitec.eclipse.springframework.springbuilder";
54
55		private static final String MYECLIPSE_HIBERNATE_BUILDER = "com.genuitec.eclipse.hibernate.HibernateBuilder";
56
57		private static final String MYECLIPSE_J2EE_14_CLASSPATH_CONTAINER =
58		"com.genuitec.eclipse.j2eedt.core.J2EE14_CONTAINER";
59
60		private static final String MYECLIPSE_J2EE_13_CLASSPATH_CONTAINER =
61		"com.genuitec.eclipse.j2eedt.core.J2EE13_CONTAINER";
62
63		private static final String MYECLIPSE_DEFAULT_HIBERNATE_CFG_XML = "src/main/resources/applicationContext.xml";
64
65		/**
66		* Spring configuration placeholder <p/>
67		*
68		* <pre>
69		* <spring>
70		* <version>1.0/2.0</version>
71		* <file-pattern>applicationContext-*.xml</file-pattern>
72		* <basedir>src/main/resources</basedir>
73		* </spring>
74		* </pre>
75		*
76		* @parameter
77		*/
78		private Map spring;
79
80		/**
81		* Hibernate configuration placeholder <p/>
82		*
83		* <pre>
84		* <hibernate>
85		* <config-file>src/main/resources/applicationContext-persistence.xml</config-file>
86		* <session-factory-id>mySessionFactory</session-factory-id>
87		* </hibernate>
88		* </pre>
89		*
90		* @parameter
91		*/
92		private Map hibernate;
93
94		/**
95		* Allow declaration of struts properties for MyEclipse <p/>
96		*
97		* <pre>
98		* <struts>
99		* <version>1.2.9</version>
100		* <servlet-name>action</servlet-name>
101		* <pattern>*.do</pattern>
102		* <base-package>1.2.9</base-package>
103		* </struts>
104		* </pre>
105		*
106		* @parameter
107		*/
108		private Map struts;
109
110		public void writeConfiguration( IdeDependency[] deps )
111		throws MojoExecutionException
112		{
113	0	EclipseWriterConfig config = createEclipseWriterConfig( deps );
114
115	0	new EclipseSettingsWriter().init( getLog(), config ).write();
116
117	0	if ( isJavaProject() )
118		{
119		// If the project is a Web Project, make it compile in WEB-INF/classes
120	0	if ( Constants.PROJECT_PACKAGING_WAR.equals( project.getPackaging() ) )
121		{
122	0	String warSourceDirectory =
123		IdeUtils.getPluginSetting( config.getProject(), JeeUtils.ARTIFACT_MAVEN_WAR_PLUGIN,
124		"warSourceDirectory",//$NON-NLS-1$
125		"/src/main/webapp" ); //$NON-NLS-1$
126
127	0	EclipseSourceDir[] sourceDirs = config.getSourceDirs();
128	0	for ( int i = 0; i < sourceDirs.length; i++ )
129		{
130	0	if ( !sourceDirs[i].isTest() )
131		{
132	0	sourceDirs[i].setOutput( warSourceDirectory + "/WEB-INF/classes" );
133		}
134		}
135		}
136
137	0	new MyEclipseClasspathWriter().init( getLog(), config ).write();
138		}
139
140	0	new EclipseProjectWriter().init( getLog(), config ).write();
141
142	0	writeAdditionalConfig();
143
144		// the MyEclipse part ...
145
146	0	new MyEclipseMetadataWriter().init( getLog(), config ).write();
147
148	0	if ( getStruts() != null )
149		{
150	0	new MyEclipseStrutsDataWriter( getStruts() ).init( getLog(), config ).write();
151		}
152	0	if ( getSpring() != null )
153		{
154	0	new MyEclipseSpringBeansWriter( getSpring() ).init( getLog(), config ).write();
155		}
156	0	if ( getHibernate() != null )
157		{
158		// Only Spring configuration file is currently supported
159	0	String hbmCfgFile = (String) getHibernate().get( "config-file" );
160
161	0	if ( "".equals( hbmCfgFile ) )
162		{
163	0	hbmCfgFile = MYECLIPSE_DEFAULT_HIBERNATE_CFG_XML;
164		}
165
166	0	new MyEclipseHibernateWriter( getHibernate() ).init( getLog(), config ).write();
167		}
168	0	}
169
170		/**
171		* Override the default builders with the builders used by MyEclipse
172		*
173		* @param packaging packaging-type (jar,war,ejb,ear)
174		*/
175		protected void fillDefaultBuilders( String packaging )
176		{
177	0	List commands = new ArrayList();
178
179	0	super.fillDefaultBuilders( packaging );
180
181	0	if ( Constants.PROJECT_PACKAGING_EAR.equals( packaging ) )
182		{
183	0	if ( getLog().isDebugEnabled() )
184		{
185	0	getLog().debug( "EAR packaging does not need specific builders" );
186		}
187		}
188	0	else if ( Constants.PROJECT_PACKAGING_WAR.equals( packaging ) )
189		{
190	0	commands.add( MYECLIPSE_DEPLOYMENT_DESCRIPTOR_VALIDATOR_BUILDER );
191	0	commands.add( MYECLIPSE_J2EE_PROJECT_VALIDATOR_BUILDER );
192	0	commands.add( MYECLIPSE_WEB_CLASSPATH_BUILDER );
193
194		// WST Validation Builder : may be added by super.fillDefaultBuilders so check before adding it
195	0	if ( !getBuildcommands().contains( new BuildCommand( BUILDER_WST_VALIDATION ) ) )
196		{
197	0	commands.add( BUILDER_WST_VALIDATION );
198		}
199		}
200	0	else if ( Constants.PROJECT_PACKAGING_EJB.equals( packaging ) )
201		{
202	0	if ( getLog().isInfoEnabled() )
203		{
204	0	getLog().info( "EJB packaging is not implemented yet" );
205		}
206		}
207	0	else if ( isJavaProject() )
208		{
209	0	if ( getLog().isDebugEnabled() )
210		{
211	0	getLog().debug( "JAR packaging does not need specific builders" );
212		}
213		}
214
215	0	if ( getSpring() != null )
216		{
217	0	commands.add( MYECLIPSE_SPRING_BUILDER );
218		}
219	0	if ( getHibernate() != null )
220		{
221	0	commands.add( MYECLIPSE_HIBERNATE_BUILDER );
222		}
223
224	0	convertBuildCommandList( commands );
225	0	getBuildcommands().addAll( commands );
226	0	}
227
228		/**
229		* Override the default natures with the natures used by MyEclipse
230		*
231		* @param packaging packaging-type (jar,war,ejb,ear)
232		*/
233		protected void fillDefaultNatures( String packaging )
234		{
235	0	List natures = new ArrayList();
236
237	0	super.fillDefaultNatures( packaging );
238
239	0	if ( Constants.PROJECT_PACKAGING_EAR.equals( packaging ) )
240		{
241	0	natures.add( MYECLIPSE_EAR_NATURE );
242		}
243	0	else if ( Constants.PROJECT_PACKAGING_WAR.equals( packaging ) )
244		{
245	0	natures.add( MYECLIPSE_WEB_NATURE );
246		}
247	0	else if ( Constants.PROJECT_PACKAGING_EJB.equals( packaging ) )
248		{
249	0	if ( getLog().isInfoEnabled() )
250		{
251	0	getLog().info( "EJB packaging is not implemented yet" );
252		}
253		}
254	0	else if ( isJavaProject() )
255		{
256	0	if ( getLog().isDebugEnabled() )
257		{
258	0	getLog().debug( "JAR projects does not need specific natures" );
259		}
260		}
261
262		// Spring
263	0	if ( getSpring() != null )
264		{
265	0	natures.add( MYECLISPE_SPRING_NATURE );
266		}
267		// Struts
268	0	if ( getStruts() != null )
269		{
270	0	natures.add( MYECLIPSE_STRUTS_NATURE );
271		}
272
273		// Hibernate
274	0	if ( getHibernate() != null )
275		{
276	0	natures.add( MYECLIPSE_HIBERNATE_NATURE );
277		}
278
279	0	getProjectnatures().addAll( natures );
280	0	}
281
282		protected void fillDefaultClasspathContainers( String packaging )
283		{
284	0	super.fillDefaultClasspathContainers( packaging );
285
286	0	if ( Constants.PROJECT_PACKAGING_WAR.equals( packaging ) )
287		{
288	0	String jeeVersion =
289		JeeUtils.getJeeDescriptorFromServletVersion( JeeUtils.resolveServletVersion( project ) ).getJeeVersion();
290
291	0	if ( "1.3".equals( jeeVersion ) )
292		{
293	0	getClasspathContainers().add( MYECLIPSE_J2EE_13_CLASSPATH_CONTAINER );
294		}
295	0	else if ( "1.4".equals( jeeVersion ) )
296		{
297	0	getClasspathContainers().add( MYECLIPSE_J2EE_14_CLASSPATH_CONTAINER );
298		}
299		}
300	0	}
301
302		public Map getSpring()
303		{
304	0	return spring;
305		}
306
307		public void setSpring( Map spring )
308		{
309	0	this.spring = spring;
310	0	}
311
312		public Map getHibernate()
313		{
314	0	return hibernate;
315		}
316
317		public void setHibernate( Map hibernate )
318		{
319	0	this.hibernate = hibernate;
320	0	}
321
322		public Map getStruts()
323		{
324	0	return struts;
325		}
326
327		public void setStruts( Map struts )
328		{
329	0	this.struts = struts;
330	0	}
331
332		}