Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

EclipseSourceDir

83%

55/66

55%

12/22

1.5

 /*
  * 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.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.List;
 
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.ide.IdeUtils;
 import org.codehaus.plexus.util.StringUtils;
 
 /**
  * Represent an eclipse source dir. Eclipse has no "main", "test" or "resource" concepts, so two source dirs with the
  * same path are equal.
  * <p>
  * source directories should always have a null output value.
  * 
  * @author <a href="mailto:fgiust@users.sourceforge.net">Fabrizio Giustina</a>
  * @version $Id: EclipseSourceDir.java 779831 2009-05-29 04:00:14Z baerrach $
  */
 public class EclipseSourceDir
     implements Comparable
 {
     private static final String PATTERN_SEPARATOR = "|";
 
     private String path;
 
     /**
      * source directories should always have a null output value.
      */
     private String output;
 
     /**
      * List<String>
      */
     private List include;
 
     /**
      * List<String>
      */
     private List exclude;
 
     private boolean isResource;
 
     private boolean test;
 
     private boolean filtering;
 
     /**
      * @param path the eclipse source directory
      * @param output path output directory
      * @param isResource true if the directory only contains resources, false if a compilation directory
      * @param test true if is a test directory, false otherwise
      * @param include a string in the eclipse pattern format for the include filter
      * @param exclude a string in the eclipse pattern format for the exclude filter
      * @param filtering true if filtering should be applied, false otherwise. Note: Filtering will only be applied if
      *            this become a "special directory" by being nested within the default output directory.
      */
     public EclipseSourceDir( String path, String output, boolean isResource, boolean test, List include, List exclude,
                              boolean filtering )
     {
         setPath( path );
         this.output = output;
         this.isResource = isResource;
         this.test = test;
         setInclude( include );
         setExclude( exclude );
         this.filtering = filtering;
     }
 
     /**
      * Getter for <code>exclude</code>.
      * 
      * @return Returns the exclude. Never null.
      */
     public List getExclude()
     {
         return this.exclude;
     }
 
     /**
      * Setter for <code>exclude</code>.
      * 
      * @param exclude The exclude to set.
      */
     public void setExclude( List exclude )
     {
         this.exclude = new ArrayList();
         if ( exclude != null )
         {
             this.exclude.addAll( exclude );
         }
     }
 
     /**
      * Getter for <code>include</code>.
      * 
      * @return Returns the include. Never null.
      */     
     public List getInclude()
     {
         return this.include;
     }
 
     /**
      * Setter for <code>include</code>.
      * 
      * @param include The include to set.
      */
     public void setInclude( List include )
     {
         this.include = new ArrayList();
         if ( include != null )
         {
             this.include.addAll( include );
         }
     }
 
     /**
      * @return Returns the exclude as a string pattern suitable for eclipse 
      */
     public String getExcludeAsString()
     {
         return StringUtils.join( exclude.iterator(), PATTERN_SEPARATOR );
     }
 
     /**
      * @return Returns the include as a string pattern suitable for eclipse 
      */
     public String getIncludeAsString()
     {
         return StringUtils.join( include.iterator(), PATTERN_SEPARATOR );
     }
 
     /**
      * Getter for <code>output</code>.
      * <p>
      * source directories should always have a null output value.
      * 
      * @return Returns the output.
      */
     public String getOutput()
     {
         return this.output;
     }
 
     /**
      * Setter for <code>output</code>.
      * 
      * @param output The output to set.
      */
     public void setOutput( String output )
     {
         this.output = output;
     }
 
     /**
      * Getter for <code>path</code>.
      * 
      * @return Returns the path.
      */
     public String getPath()
     {
         return this.path;
     }
 
     /**
      * Setter for <code>path</code>.
      * Converts \\ to / in path.
      * 
      * @param path The path to set.
      */
     public void setPath( String path )
     {
         this.path = IdeUtils.fixSeparator( path );
     }
 
     /**
      * Getter for <code>test</code>.
      * 
      * @return Returns the test.
      */
     public boolean isTest()
     {
         return this.test;
     }
 
     /**
      * Setter for <code>test</code>.
      * 
      * @param test The test to set.
      */
     public void setTest( boolean test )
     {
         this.test = test;
     }
 
     /**
      * Getter for <code>isResource</code>.
      * 
      * @return Returns the isResource.
      */
     public boolean isResource()
     {
         return this.isResource;
     }
 
     /**
      * Wheter this resource should be copied with filtering.
      */
     public boolean isFiltering()
     {
         return filtering;
     }
 
     /**
      * @see java.lang.Object#equals(java.lang.Object)
      */
     public boolean equals( Object obj )
     {
         return ( obj != null ) && ( obj instanceof EclipseSourceDir )
             && this.path.equals( ( (EclipseSourceDir) obj ).path );
     }
 
     /**
      * @see java.lang.Object#hashCode()
      */
     public int hashCode()
     {
         return this.path.hashCode();
     }
 
     /**
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     public int compareTo( Object obj )
     {
         return this.path.compareTo( ( (EclipseSourceDir) obj ).path );
     }
 
     /**
      * {@inheritDoc}
      */
     public String toString()
     {       
         StringBuffer buffer = new StringBuffer(); 
         buffer.append( ( isResource ? "re" : "" ) + "source " );
         buffer.append( path );
         buffer.append( ": " );
         buffer.append( "output=" ).append( output ).append( ", " );
         buffer.append( "include=[" ).append( getIncludeAsString() ).append( "], " );
         buffer.append( "exclude=[" ).append( getExcludeAsString() ).append( "], " );
         buffer.append( "test=" ).append( test ).append( ", " );
         buffer.append( "filtering=" ).append( filtering );
         return buffer.toString();        
     }
 
     /**
      * Merge with the provided directory.
      * <p>
      * If one directory is a source and the other is a resource directory then the result will be a source directory and
      * any includes or excludes will be removed since Eclipse has no "main", "test" or "resource" concepts. The output
      * directory will be the source directories value.
      * <p>
      * If the two directories are the same resources type (i.e isResource is equal) then the result will be the same
      * resource type with the includes from each merged together (duplicates will be removed), similarly for the
      * excludes. No effort is made to ensure that the includes and excludes are disjointed sets. Please fix your pom
      * instead.
      * <p>
      * No support for cases where the test, or filtering values are not identical.
      * 
      * @param mergeWith the directory to merge with
      * @throws MojoExecutionException test or filtering values are not identical, or isResource true and output are not identical
      */
     public void merge( EclipseSourceDir mergeWith )
         throws MojoExecutionException
     {
         if ( test != mergeWith.test )
         {
             throw new MojoExecutionException( "Request to merge when 'test' is not identical. Original=" + toString()
                 + ", merging with=" + mergeWith.toString() );
         }
         if ( filtering != mergeWith.filtering )
         {
             throw new MojoExecutionException( "Request to merge when 'filtering' is not identical. Original="
                 + toString() + ", merging with=" + mergeWith.toString() );
         }
 
         if ( isResource != mergeWith.isResource )
         {
             if ( isResource )
             {
                 // the output directory is set to the source directory's value
                 output = mergeWith.output;
             }
             isResource = false;
             setInclude( null );
             setExclude( null );
 
         }
         else
         {
             if ( !StringUtils.equals( output, mergeWith.output ) )
             {
                 throw new MojoExecutionException( "Request to merge when 'output' is not identical. Original="
                     + toString() + ", merging with=" + mergeWith.toString() );
             }
 
             LinkedHashSet includesAsSet = new LinkedHashSet();
             includesAsSet.addAll( include );
             includesAsSet.addAll( mergeWith.include );
             include = new ArrayList( includesAsSet );
 
             LinkedHashSet excludesAsSet = new LinkedHashSet();
             excludesAsSet.addAll( exclude );
             excludesAsSet.addAll( mergeWith.exclude );
             exclude = new ArrayList( excludesAsSet );
         }
     }
 }

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;
20
21		import java.util.ArrayList;
22		import java.util.LinkedHashSet;
23		import java.util.List;
24
25		import org.apache.maven.plugin.MojoExecutionException;
26		import org.apache.maven.plugin.ide.IdeUtils;
27		import org.codehaus.plexus.util.StringUtils;
28
29		/**
30		* Represent an eclipse source dir. Eclipse has no "main", "test" or "resource" concepts, so two source dirs with the
31		* same path are equal.
32		* <p>
33		* source directories should always have a null output value.
34		*
35		* @author <a href="mailto:fgiust@users.sourceforge.net">Fabrizio Giustina</a>
36		* @version $Id: EclipseSourceDir.java 779831 2009-05-29 04:00:14Z baerrach $
37		*/
38		public class EclipseSourceDir
39		implements Comparable
40		{
41		private static final String PATTERN_SEPARATOR = "\|";
42
43		private String path;
44
45		/**
46		* source directories should always have a null output value.
47		*/
48		private String output;
49
50		/**
51		* List<String>
52		*/
53		private List include;
54
55		/**
56		* List<String>
57		*/
58		private List exclude;
59
60		private boolean isResource;
61
62		private boolean test;
63
64		private boolean filtering;
65
66		/**
67		* @param path the eclipse source directory
68		* @param output path output directory
69		* @param isResource true if the directory only contains resources, false if a compilation directory
70		* @param test true if is a test directory, false otherwise
71		* @param include a string in the eclipse pattern format for the include filter
72		* @param exclude a string in the eclipse pattern format for the exclude filter
73		* @param filtering true if filtering should be applied, false otherwise. Note: Filtering will only be applied if
74		* this become a "special directory" by being nested within the default output directory.
75		*/
76		public EclipseSourceDir( String path, String output, boolean isResource, boolean test, List include, List exclude,
77		boolean filtering )
78	19	{
79	19	setPath( path );
80	19	this.output = output;
81	19	this.isResource = isResource;
82	19	this.test = test;
83	19	setInclude( include );
84	19	setExclude( exclude );
85	19	this.filtering = filtering;
86	19	}
87
88		/**
89		* Getter for <code>exclude</code>.
90		*
91		* @return Returns the exclude. Never null.
92		*/
93		public List getExclude()
94		{
95	6	return this.exclude;
96		}
97
98		/**
99		* Setter for <code>exclude</code>.
100		*
101		* @param exclude The exclude to set.
102		*/
103		public void setExclude( List exclude )
104		{
105	20	this.exclude = new ArrayList();
106	20	if ( exclude != null )
107		{
108	14	this.exclude.addAll( exclude );
109		}
110	20	}
111
112		/**
113		* Getter for <code>include</code>.
114		*
115		* @return Returns the include. Never null.
116		*/
117		public List getInclude()
118		{
119	6	return this.include;
120		}
121
122		/**
123		* Setter for <code>include</code>.
124		*
125		* @param include The include to set.
126		*/
127		public void setInclude( List include )
128		{
129	20	this.include = new ArrayList();
130	20	if ( include != null )
131		{
132	10	this.include.addAll( include );
133		}
134	20	}
135
136		/**
137		* @return Returns the exclude as a string pattern suitable for eclipse
138		*/
139		public String getExcludeAsString()
140		{
141	13	return StringUtils.join( exclude.iterator(), PATTERN_SEPARATOR );
142		}
143
144		/**
145		* @return Returns the include as a string pattern suitable for eclipse
146		*/
147		public String getIncludeAsString()
148		{
149	13	return StringUtils.join( include.iterator(), PATTERN_SEPARATOR );
150		}
151
152		/**
153		* Getter for <code>output</code>.
154		* <p>
155		* source directories should always have a null output value.
156		*
157		* @return Returns the output.
158		*/
159		public String getOutput()
160		{
161	18	return this.output;
162		}
163
164		/**
165		* Setter for <code>output</code>.
166		*
167		* @param output The output to set.
168		*/
169		public void setOutput( String output )
170		{
171	0	this.output = output;
172	0	}
173
174		/**
175		* Getter for <code>path</code>.
176		*
177		* @return Returns the path.
178		*/
179		public String getPath()
180		{
181	8	return this.path;
182		}
183
184		/**
185		* Setter for <code>path</code>.
186		* Converts \\ to / in path.
187		*
188		* @param path The path to set.
189		*/
190		public void setPath( String path )
191		{
192	19	this.path = IdeUtils.fixSeparator( path );
193	19	}
194
195		/**
196		* Getter for <code>test</code>.
197		*
198		* @return Returns the test.
199		*/
200		public boolean isTest()
201		{
202	0	return this.test;
203		}
204
205		/**
206		* Setter for <code>test</code>.
207		*
208		* @param test The test to set.
209		*/
210		public void setTest( boolean test )
211		{
212	0	this.test = test;
213	0	}
214
215		/**
216		* Getter for <code>isResource</code>.
217		*
218		* @return Returns the isResource.
219		*/
220		public boolean isResource()
221		{
222	2	return this.isResource;
223		}
224
225		/**
226		* Wheter this resource should be copied with filtering.
227		*/
228		public boolean isFiltering()
229		{
230	1	return filtering;
231		}
232
233		/**
234		* @see java.lang.Object#equals(java.lang.Object)
235		*/
236		public boolean equals( Object obj )
237		{
238	0	return ( obj != null ) && ( obj instanceof EclipseSourceDir )
239		&& this.path.equals( ( (EclipseSourceDir) obj ).path );
240		}
241
242		/**
243		* @see java.lang.Object#hashCode()
244		*/
245		public int hashCode()
246		{
247	8	return this.path.hashCode();
248		}
249
250		/**
251		* @see java.lang.Comparable#compareTo(java.lang.Object)
252		*/
253		public int compareTo( Object obj )
254		{
255	0	return this.path.compareTo( ( (EclipseSourceDir) obj ).path );
256		}
257
258		/**
259		* {@inheritDoc}
260		*/
261		public String toString()
262		{
263	9	StringBuffer buffer = new StringBuffer();
264	9	buffer.append( ( isResource ? "re" : "" ) + "source " );
265	9	buffer.append( path );
266	9	buffer.append( ": " );
267	9	buffer.append( "output=" ).append( output ).append( ", " );
268	9	buffer.append( "include=[" ).append( getIncludeAsString() ).append( "], " );
269	9	buffer.append( "exclude=[" ).append( getExcludeAsString() ).append( "], " );
270	9	buffer.append( "test=" ).append( test ).append( ", " );
271	9	buffer.append( "filtering=" ).append( filtering );
272	9	return buffer.toString();
273		}
274
275		/**
276		* Merge with the provided directory.
277		* <p>
278		* If one directory is a source and the other is a resource directory then the result will be a source directory and
279		* any includes or excludes will be removed since Eclipse has no "main", "test" or "resource" concepts. The output
280		* directory will be the source directories value.
281		* <p>
282		* If the two directories are the same resources type (i.e isResource is equal) then the result will be the same
283		* resource type with the includes from each merged together (duplicates will be removed), similarly for the
284		* excludes. No effort is made to ensure that the includes and excludes are disjointed sets. Please fix your pom
285		* instead.
286		* <p>
287		* No support for cases where the test, or filtering values are not identical.
288		*
289		* @param mergeWith the directory to merge with
290		* @throws MojoExecutionException test or filtering values are not identical, or isResource true and output are not identical
291		*/
292		public void merge( EclipseSourceDir mergeWith )
293		throws MojoExecutionException
294		{
295	3	if ( test != mergeWith.test )
296		{
297	0	throw new MojoExecutionException( "Request to merge when 'test' is not identical. Original=" + toString()
298		+ ", merging with=" + mergeWith.toString() );
299		}
300	3	if ( filtering != mergeWith.filtering )
301		{
302	0	throw new MojoExecutionException( "Request to merge when 'filtering' is not identical. Original="
303		+ toString() + ", merging with=" + mergeWith.toString() );
304		}
305
306	3	if ( isResource != mergeWith.isResource )
307		{
308	1	if ( isResource )
309		{
310		// the output directory is set to the source directory's value
311	0	output = mergeWith.output;
312		}
313	1	isResource = false;
314	1	setInclude( null );
315	1	setExclude( null );
316
317		}
318		else
319		{
320	2	if ( !StringUtils.equals( output, mergeWith.output ) )
321		{
322	0	throw new MojoExecutionException( "Request to merge when 'output' is not identical. Original="
323		+ toString() + ", merging with=" + mergeWith.toString() );
324		}
325
326	2	LinkedHashSet includesAsSet = new LinkedHashSet();
327	2	includesAsSet.addAll( include );
328	2	includesAsSet.addAll( mergeWith.include );
329	2	include = new ArrayList( includesAsSet );
330
331	2	LinkedHashSet excludesAsSet = new LinkedHashSet();
332	2	excludesAsSet.addAll( exclude );
333	2	excludesAsSet.addAll( mergeWith.exclude );
334	2	exclude = new ArrayList( excludesAsSet );
335		}
336	3	}
337		}