Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

EclipseSourceDir

86%

60/69

65%

17/26

1.714

 /*
  * 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 1154368 2011-08-05 20:13:42Z rfscholte $
  */
 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;
     }
 
     /**
      * Wheter this resource should be copied with filtering.
      * @param filtering filter resources
      */
     public void setFiltering(boolean filtering)
     {
         this.filtering = 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 ? "resource " : "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 boolean merge( EclipseSourceDir mergeWith )
         throws MojoExecutionException
     {
 
         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
         {
 
             LinkedHashSet includesAsSet = new LinkedHashSet();
 
             // if the orginal or merged dir have an empty "include" this means all is included,
             // so merge includes only if both are not empty
             if (!include.isEmpty() && !mergeWith.include.isEmpty())
             {
                 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 );
         }
 
         if (!StringUtils.equals(output, mergeWith.output))
         {
             // Request to merge when 'output' is not identical
             return false;
         }
 
         if (test != mergeWith.test)
         {
             // Request to merge when 'test' is not identical
             return false;
         }
 
         if (filtering != mergeWith.filtering)
         {
             // Request to merge when 'filtering' is not identical
             return false;
         }
         return true;
     }
 }

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 1154368 2011-08-05 20:13:42Z rfscholte $
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	23	{
79	23	setPath( path );
80	23	this.output = output;
81	23	this.isResource = isResource;
82	23	this.test = test;
83	23	setInclude( include );
84	23	setExclude( exclude );
85	23	this.filtering = filtering;
86	23	}
87
88		/**
89		* Getter for <code>exclude</code>.
90		*
91		* @return Returns the exclude. Never null.
92		*/
93		public List getExclude()
94		{
95	10	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	24	this.exclude = new ArrayList();
106	24	if ( exclude != null )
107		{
108	18	this.exclude.addAll( exclude );
109		}
110	24	}
111
112		/**
113		* Getter for <code>include</code>.
114		*
115		* @return Returns the include. Never null.
116		*/
117		public List getInclude()
118		{
119	11	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	24	this.include = new ArrayList();
130	24	if ( include != null )
131		{
132	10	this.include.addAll( include );
133		}
134	24	}
135
136		/**
137		* @return Returns the exclude as a string pattern suitable for eclipse
138		*/
139		public String getExcludeAsString()
140		{
141	15	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	15	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>. Converts \\ to / in path.
186		*
187		* @param path The path to set.
188		*/
189		public void setPath( String path )
190		{
191	23	this.path = IdeUtils.fixSeparator( path );
192	23	}
193
194		/**
195		* Getter for <code>test</code>.
196		*
197		* @return Returns the test.
198		*/
199		public boolean isTest()
200		{
201	0	return this.test;
202		}
203
204		/**
205		* Setter for <code>test</code>.
206		*
207		* @param test The test to set.
208		*/
209		public void setTest( boolean test )
210		{
211	0	this.test = test;
212	0	}
213
214		/**
215		* Getter for <code>isResource</code>.
216		*
217		* @return Returns the isResource.
218		*/
219		public boolean isResource()
220		{
221	2	return this.isResource;
222		}
223
224		/**
225		* Wheter this resource should be copied with filtering.
226		*/
227		public boolean isFiltering()
228		{
229	1	return filtering;
230		}
231
232		/**
233		* Wheter this resource should be copied with filtering.
234		* @param filtering filter resources
235		*/
236		public void setFiltering(boolean filtering)
237		{
238	2	this.filtering = filtering;
239	2	}
240
241		/**
242		* @see java.lang.Object#equals(java.lang.Object)
243		*/
244		public boolean equals( Object obj )
245		{
246	0	return ( obj != null ) && ( obj instanceof EclipseSourceDir )
247		&& this.path.equals( ( (EclipseSourceDir) obj ).path );
248		}
249
250		/**
251		* @see java.lang.Object#hashCode()
252		*/
253		public int hashCode()
254		{
255	8	return this.path.hashCode();
256		}
257
258		/**
259		* @see java.lang.Comparable#compareTo(java.lang.Object)
260		*/
261		public int compareTo( Object obj )
262		{
263	0	return this.path.compareTo( ( (EclipseSourceDir) obj ).path );
264		}
265
266		/**
267		* {@inheritDoc}
268		*/
269		public String toString()
270		{
271	11	StringBuffer buffer = new StringBuffer();
272	11	buffer.append( isResource ? "resource " : "source " );
273	11	buffer.append( path );
274	11	buffer.append( ": " );
275	11	buffer.append( "output=" ).append( output ).append( ", " );
276	11	buffer.append( "include=[" ).append( getIncludeAsString() ).append( "], " );
277	11	buffer.append( "exclude=[" ).append( getExcludeAsString() ).append( "], " );
278	11	buffer.append( "test=" ).append( test ).append( ", " );
279	11	buffer.append( "filtering=" ).append( filtering );
280	11	return buffer.toString();
281		}
282
283		/**
284		* Merge with the provided directory.
285		* <p>
286		* If one directory is a source and the other is a resource directory then the result will be a source directory and
287		* any includes or excludes will be removed since Eclipse has no "main", "test" or "resource" concepts. The output
288		* directory will be the source directories value.
289		* <p>
290		* If the two directories are the same resources type (i.e isResource is equal) then the result will be the same
291		* resource type with the includes from each merged together (duplicates will be removed), similarly for the
292		* excludes. No effort is made to ensure that the includes and excludes are disjointed sets. Please fix your pom
293		* instead.
294		* <p>
295		* No support for cases where the test, or filtering values are not identical.
296		*
297		* @param mergeWith the directory to merge with
298		* @throws MojoExecutionException test or filtering values are not identical, or isResource true and output are not
299		* identical
300		*/
301		public boolean merge( EclipseSourceDir mergeWith )
302		throws MojoExecutionException
303		{
304
305	5	if ( isResource != mergeWith.isResource )
306		{
307	1	if ( isResource )
308		{
309		// the output directory is set to the source directory's value
310	0	output = mergeWith.output;
311		}
312	1	isResource = false;
313	1	setInclude( null );
314	1	setExclude( null );
315
316		}
317		else
318		{
319
320	4	LinkedHashSet includesAsSet = new LinkedHashSet();
321
322		// if the orginal or merged dir have an empty "include" this means all is included,
323		// so merge includes only if both are not empty
324	4	if (!include.isEmpty() && !mergeWith.include.isEmpty())
325		{
326	3	includesAsSet.addAll(include);
327	3	includesAsSet.addAll(mergeWith.include);
328		}
329
330	4	include = new ArrayList( includesAsSet );
331
332	4	LinkedHashSet excludesAsSet = new LinkedHashSet();
333	4	excludesAsSet.addAll( exclude );
334	4	excludesAsSet.addAll( mergeWith.exclude );
335	4	exclude = new ArrayList( excludesAsSet );
336		}
337
338	5	if (!StringUtils.equals(output, mergeWith.output))
339		{
340		// Request to merge when 'output' is not identical
341	1	return false;
342		}
343
344	4	if (test != mergeWith.test)
345		{
346		// Request to merge when 'test' is not identical
347	0	return false;
348		}
349
350	4	if (filtering != mergeWith.filtering)
351		{
352		// Request to merge when 'filtering' is not identical
353	2	return false;
354		}
355	2	return true;
356		}
357		}