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 {
79 setPath( path );
80 this.output = output;
81 this.isResource = isResource;
82 this.test = test;
83 setInclude( include );
84 setExclude( exclude );
85 this.filtering = filtering;
86 }
87
88 /**
89 * Getter for <code>exclude</code>.
90 *
91 * @return Returns the exclude. Never null.
92 */
93 public List getExclude()
94 {
95 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 this.exclude = new ArrayList();
106 if ( exclude != null )
107 {
108 this.exclude.addAll( exclude );
109 }
110 }
111
112 /**
113 * Getter for <code>include</code>.
114 *
115 * @return Returns the include. Never null.
116 */
117 public List getInclude()
118 {
119 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 this.include = new ArrayList();
130 if ( include != null )
131 {
132 this.include.addAll( include );
133 }
134 }
135
136 /**
137 * @return Returns the exclude as a string pattern suitable for eclipse
138 */
139 public String getExcludeAsString()
140 {
141 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 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 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 this.output = output;
172 }
173
174 /**
175 * Getter for <code>path</code>.
176 *
177 * @return Returns the path.
178 */
179 public String getPath()
180 {
181 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 this.path = IdeUtils.fixSeparator( path );
193 }
194
195 /**
196 * Getter for <code>test</code>.
197 *
198 * @return Returns the test.
199 */
200 public boolean isTest()
201 {
202 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 this.test = test;
213 }
214
215 /**
216 * Getter for <code>isResource</code>.
217 *
218 * @return Returns the isResource.
219 */
220 public boolean isResource()
221 {
222 return this.isResource;
223 }
224
225 /**
226 * Wheter this resource should be copied with filtering.
227 */
228 public boolean isFiltering()
229 {
230 return filtering;
231 }
232
233 /**
234 * @see java.lang.Object#equals(java.lang.Object)
235 */
236 public boolean equals( Object obj )
237 {
238 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 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 return this.path.compareTo( ( (EclipseSourceDir) obj ).path );
256 }
257
258 /**
259 * {@inheritDoc}
260 */
261 public String toString()
262 {
263 StringBuffer buffer = new StringBuffer();
264 buffer.append( ( isResource ? "re" : "" ) + "source " );
265 buffer.append( path );
266 buffer.append( ": " );
267 buffer.append( "output=" ).append( output ).append( ", " );
268 buffer.append( "include=[" ).append( getIncludeAsString() ).append( "], " );
269 buffer.append( "exclude=[" ).append( getExcludeAsString() ).append( "], " );
270 buffer.append( "test=" ).append( test ).append( ", " );
271 buffer.append( "filtering=" ).append( filtering );
272 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 if ( test != mergeWith.test )
296 {
297 throw new MojoExecutionException( "Request to merge when 'test' is not identical. Original=" + toString()
298 + ", merging with=" + mergeWith.toString() );
299 }
300 if ( filtering != mergeWith.filtering )
301 {
302 throw new MojoExecutionException( "Request to merge when 'filtering' is not identical. Original="
303 + toString() + ", merging with=" + mergeWith.toString() );
304 }
305
306 if ( isResource != mergeWith.isResource )
307 {
308 if ( isResource )
309 {
310 // the output directory is set to the source directory's value
311 output = mergeWith.output;
312 }
313 isResource = false;
314 setInclude( null );
315 setExclude( null );
316
317 }
318 else
319 {
320 if ( !StringUtils.equals( output, mergeWith.output ) )
321 {
322 throw new MojoExecutionException( "Request to merge when 'output' is not identical. Original="
323 + toString() + ", merging with=" + mergeWith.toString() );
324 }
325
326 LinkedHashSet includesAsSet = new LinkedHashSet();
327 includesAsSet.addAll( include );
328 includesAsSet.addAll( mergeWith.include );
329 include = new ArrayList( includesAsSet );
330
331 LinkedHashSet excludesAsSet = new LinkedHashSet();
332 excludesAsSet.addAll( exclude );
333 excludesAsSet.addAll( mergeWith.exclude );
334 exclude = new ArrayList( excludesAsSet );
335 }
336 }
337 }