Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
EclipseSourceDir |
|
| 1.7142857142857142;1.714 |
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 | 46 | { |
79 | 46 | setPath( path ); |
80 | 46 | this.output = output; |
81 | 46 | this.isResource = isResource; |
82 | 46 | this.test = test; |
83 | 46 | setInclude( include ); |
84 | 46 | setExclude( exclude ); |
85 | 46 | this.filtering = filtering; |
86 | 46 | } |
87 | ||
88 | /** | |
89 | * Getter for <code>exclude</code>. | |
90 | * | |
91 | * @return Returns the exclude. Never null. | |
92 | */ | |
93 | public List getExclude() | |
94 | { | |
95 | 20 | 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 | 48 | this.exclude = new ArrayList(); |
106 | 48 | if ( exclude != null ) |
107 | { | |
108 | 36 | this.exclude.addAll( exclude ); |
109 | } | |
110 | 48 | } |
111 | ||
112 | /** | |
113 | * Getter for <code>include</code>. | |
114 | * | |
115 | * @return Returns the include. Never null. | |
116 | */ | |
117 | public List getInclude() | |
118 | { | |
119 | 22 | 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 | 48 | this.include = new ArrayList(); |
130 | 48 | if ( include != null ) |
131 | { | |
132 | 20 | this.include.addAll( include ); |
133 | } | |
134 | 48 | } |
135 | ||
136 | /** | |
137 | * @return Returns the exclude as a string pattern suitable for eclipse | |
138 | */ | |
139 | public String getExcludeAsString() | |
140 | { | |
141 | 30 | 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 | 30 | 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 | 36 | 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 | 16 | 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 | 46 | this.path = IdeUtils.fixSeparator( path ); |
192 | 46 | } |
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 | 4 | return this.isResource; |
222 | } | |
223 | ||
224 | /** | |
225 | * Wheter this resource should be copied with filtering. | |
226 | */ | |
227 | public boolean isFiltering() | |
228 | { | |
229 | 2 | 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 | 4 | this.filtering = filtering; |
239 | 4 | } |
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 | 16 | 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 | 22 | StringBuffer buffer = new StringBuffer(); |
272 | 22 | buffer.append( isResource ? "resource " : "source " ); |
273 | 22 | buffer.append( path ); |
274 | 22 | buffer.append( ": " ); |
275 | 22 | buffer.append( "output=" ).append( output ).append( ", " ); |
276 | 22 | buffer.append( "include=[" ).append( getIncludeAsString() ).append( "], " ); |
277 | 22 | buffer.append( "exclude=[" ).append( getExcludeAsString() ).append( "], " ); |
278 | 22 | buffer.append( "test=" ).append( test ).append( ", " ); |
279 | 22 | buffer.append( "filtering=" ).append( filtering ); |
280 | 22 | 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 | 10 | if ( isResource != mergeWith.isResource ) |
306 | { | |
307 | 2 | if ( isResource ) |
308 | { | |
309 | // the output directory is set to the source directory's value | |
310 | 0 | output = mergeWith.output; |
311 | } | |
312 | 2 | isResource = false; |
313 | 2 | setInclude( null ); |
314 | 2 | setExclude( null ); |
315 | ||
316 | } | |
317 | else | |
318 | { | |
319 | ||
320 | 8 | 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 | 8 | if (!include.isEmpty() && !mergeWith.include.isEmpty()) |
325 | { | |
326 | 6 | includesAsSet.addAll(include); |
327 | 6 | includesAsSet.addAll(mergeWith.include); |
328 | } | |
329 | ||
330 | 8 | include = new ArrayList( includesAsSet ); |
331 | ||
332 | 8 | LinkedHashSet excludesAsSet = new LinkedHashSet(); |
333 | 8 | excludesAsSet.addAll( exclude ); |
334 | 8 | excludesAsSet.addAll( mergeWith.exclude ); |
335 | 8 | exclude = new ArrayList( excludesAsSet ); |
336 | } | |
337 | ||
338 | 10 | if (!StringUtils.equals(output, mergeWith.output)) |
339 | { | |
340 | // Request to merge when 'output' is not identical | |
341 | 2 | return false; |
342 | } | |
343 | ||
344 | 8 | if (test != mergeWith.test) |
345 | { | |
346 | // Request to merge when 'test' is not identical | |
347 | 0 | return false; |
348 | } | |
349 | ||
350 | 8 | if (filtering != mergeWith.filtering) |
351 | { | |
352 | // Request to merge when 'filtering' is not identical | |
353 | 4 | return false; |
354 | } | |
355 | 4 | return true; |
356 | } | |
357 | } |