View Javadoc

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 }