Coverage Report

Coverage Report - org.apache.maven.shared.filtering.DefaultMavenResourcesFiltering

Classes in this File

Line Coverage

Branch Coverage

Complexity

DefaultMavenResourcesFiltering

81%

113/139

70%

64/92

4,9

 package org.apache.maven.shared.filtering;
 
 /*
  * 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.
  */
 
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.model.Resource;
 import org.apache.maven.project.MavenProject;
 import org.codehaus.plexus.logging.AbstractLogEnabled;
 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
 import org.codehaus.plexus.util.FileUtils;
 import org.codehaus.plexus.util.PathTool;
 import org.codehaus.plexus.util.ReaderFactory;
 import org.codehaus.plexus.util.Scanner;
 import org.codehaus.plexus.util.StringUtils;
 import org.sonatype.plexus.build.incremental.BuildContext;
 
 /**
  * @author <a href="mailto:olamy@apache.org">olamy</a>
  * @version $Id: DefaultMavenResourcesFiltering.java 1067324 2011-02-04 22:56:23Z dennisl $
  * 
  * @plexus.component role="org.apache.maven.shared.filtering.MavenResourcesFiltering"
  *                   role-hint="default"
  */
 public class DefaultMavenResourcesFiltering
     extends AbstractLogEnabled
     implements MavenResourcesFiltering, Initializable
 {
 
     private static final String[] EMPTY_STRING_ARRAY = {};
 
     private static final String[] DEFAULT_INCLUDES = {"**/**"};
     
     private List defaultNonFilteredFileExtensions;
 
     /** @plexus.requirement */
     private BuildContext buildContext;
 
     // ------------------------------------------------
     //  Plexus lifecycle
     // ------------------------------------------------
     public void initialize()
         throws InitializationException
     {
         // jpg,jpeg,gif,bmp,png
         this.defaultNonFilteredFileExtensions = new ArrayList( 5 );
         this.defaultNonFilteredFileExtensions.add( "jpg" );
         this.defaultNonFilteredFileExtensions.add( "jpeg" );
         this.defaultNonFilteredFileExtensions.add( "gif" );
         this.defaultNonFilteredFileExtensions.add( "bmp" );
         this.defaultNonFilteredFileExtensions.add( "png" );
     }    
     
     
     
     /**
      * @plexus.requirement
      *  role-hint="default"
      */
     private MavenFileFilter mavenFileFilter;
     
     public void filterResources( List resources, File outputDirectory, MavenProject mavenProject, String encoding,
                                  List fileFilters, List nonFilteredFileExtensions, MavenSession mavenSession )
         throws MavenFilteringException
     {
         MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution( resources, outputDirectory,
                                                                                        mavenProject, encoding,
                                                                                        fileFilters,
                                                                                        nonFilteredFileExtensions,
                                                                                        mavenSession );
         mavenResourcesExecution.setUseDefaultFilterWrappers( true );
 //        mavenResourcesExecution.setEscapeWindowsPaths( false );
         
         filterResources( mavenResourcesExecution );
     }
 
     public void filterResources( List resources, File outputDirectory, String encoding, List filterWrappers,
                                  File resourcesBaseDirectory, List nonFilteredFileExtensions )
         throws MavenFilteringException
     {
         MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution( resources, outputDirectory,
                                                                                        encoding, filterWrappers,
                                                                                        resourcesBaseDirectory,
                                                                                        nonFilteredFileExtensions );
         filterResources( mavenResourcesExecution );
     }
 
     
     public boolean filteredFileExtension( String fileName, List userNonFilteredFileExtensions )
     {
         List nonFilteredFileExtensions = new ArrayList( getDefaultNonFilteredFileExtensions() );
         if ( userNonFilteredFileExtensions != null )
         {
             nonFilteredFileExtensions.addAll( userNonFilteredFileExtensions );
         }
         boolean filteredFileExtension = !nonFilteredFileExtensions.contains( StringUtils.lowerCase( FileUtils
             .extension( fileName ) ) );
         if ( getLogger().isDebugEnabled() )
         {
             getLogger().debug(
                                "file " + fileName + " has a" + ( filteredFileExtension ? " " : " non " )
                                    + "filtered file extension" );
         }
         return filteredFileExtension;
     }
 
     public List getDefaultNonFilteredFileExtensions()
     {
         return this.defaultNonFilteredFileExtensions;
     }
 
     public void filterResources( MavenResourcesExecution mavenResourcesExecution )
         throws MavenFilteringException
     {
         if ( mavenResourcesExecution == null )
         {
             throw new MavenFilteringException( "mavenResourcesExecution cannot be null" );
         }
         
         if ( mavenResourcesExecution.getResources() == null )
         {
             getLogger().info( "No resources configured skip copying/filtering" );
             return;
         }
         
         if ( mavenResourcesExecution.getOutputDirectory() == null )
         {
             throw new MavenFilteringException( "outputDirectory cannot be null" );
         }
         
         if ( mavenResourcesExecution.isUseDefaultFilterWrappers() )
         {
             List filterWrappers = new ArrayList();
             if ( mavenResourcesExecution.getFilterWrappers() != null )
             {
                 filterWrappers.addAll( mavenResourcesExecution.getFilterWrappers() );
             }
             filterWrappers.addAll( mavenFileFilter.getDefaultFilterWrappers( mavenResourcesExecution ) );
             mavenResourcesExecution.setFilterWrappers( filterWrappers );
         }
 
         if ( mavenResourcesExecution.getEncoding() == null || mavenResourcesExecution.getEncoding().length() < 1 )
         {
             getLogger().warn(
                               "Using platform encoding (" + ReaderFactory.FILE_ENCODING
                                   + " actually) to copy filtered resources, i.e. build is platform dependent!" );
         }
         else
         {
             getLogger().info(
                               "Using '" + mavenResourcesExecution.getEncoding()
                                   + "' encoding to copy filtered resources." );
         }
         
         for ( Iterator i = mavenResourcesExecution.getResources().iterator(); i.hasNext(); )
         {
             Resource resource = (Resource) i.next();
             
             if ( getLogger().isDebugEnabled() )
             {
                 String ls = System.getProperty( "line.separator" );
                 StringBuffer debugMessage = new StringBuffer( "resource with targetPath " + resource.getTargetPath() )
                     .append( ls );
                 debugMessage.append( "directory " + resource.getDirectory() ).append( ls );
                 debugMessage.append(
                                      "excludes "
                                          + ( resource.getExcludes() == null ? " empty " : resource.getExcludes()
                                              .toString() ) ).append( ls );
                 debugMessage.append( "includes "
                     + ( resource.getIncludes() == null ? " empty " : resource.getIncludes().toString() ) );
                 getLogger().debug( debugMessage.toString() );
             }
 
             String targetPath = resource.getTargetPath();
 
             File resourceDirectory = new File( resource.getDirectory() );
 
             if ( !resourceDirectory.isAbsolute() )
             {
                 resourceDirectory = new File( mavenResourcesExecution.getResourcesBaseDirectory(), resourceDirectory
                     .getPath() );
             }
 
             if ( !resourceDirectory.exists() )
             {
                 getLogger().info( "skip non existing resourceDirectory " + resourceDirectory.getPath() );
                 continue;
             }
 
             // this part is required in case the user specified "../something" as destination
             // see MNG-1345
             File outputDirectory = mavenResourcesExecution.getOutputDirectory();
             boolean outputExists = outputDirectory.exists();
             if ( !outputExists && !outputDirectory.mkdirs() )
             {
                 throw new MavenFilteringException( "Cannot create resource output directory: " + outputDirectory );
             }
             
             boolean ignoreDelta =
                 !outputExists || buildContext.hasDelta( mavenResourcesExecution.getFileFilters() )
                     || buildContext.hasDelta( getRelativeOutputDirectory( mavenResourcesExecution ) );
             getLogger().debug( "ignoreDelta " + ignoreDelta );
             Scanner scanner = buildContext.newScanner( resourceDirectory, ignoreDelta );
 
             setupScanner( resource, scanner );
 
             scanner.scan();
 
             if ( mavenResourcesExecution.isIncludeEmptyDirs() )
             {
                 try
                 {
                     File targetDirectory = targetPath == null ? outputDirectory
                                                              : new File( outputDirectory, targetPath );
                     copyDirectoryLayout( resourceDirectory, targetDirectory, scanner );
                 }
                 catch ( IOException e )
                 {
                     throw new MavenFilteringException( "Cannot copy directory structure from "
                         + resourceDirectory.getPath() + " to " + outputDirectory.getPath() );
                 }
             }
 
             List includedFiles = Arrays.asList( scanner.getIncludedFiles() );
 
             getLogger().info(
                               "Copying " + includedFiles.size() + " resource" + ( includedFiles.size() > 1 ? "s" : "" )
                                   + ( targetPath == null ? "" : " to " + targetPath ) );
 
             for ( Iterator j = includedFiles.iterator(); j.hasNext(); )
             {
                 String name = (String) j.next();
 
                 File source = new File( resourceDirectory, name );
 
                 //File destinationFile = new File( outputDirectory, destination );
 
                 File destinationFile = getDestinationFile( outputDirectory, targetPath, name );
                 
                 boolean filteredExt = filteredFileExtension( source.getName(), mavenResourcesExecution
                     .getNonFilteredFileExtensions() );
                 
                 mavenFileFilter.copyFile( source, destinationFile, resource.isFiltering() && filteredExt,
                                           mavenResourcesExecution.getFilterWrappers(), mavenResourcesExecution
                                               .getEncoding(), mavenResourcesExecution.isOverwrite() );
             }
 
             // deal with deleted source files
 
             scanner = buildContext.newDeleteScanner( resourceDirectory );
             
             setupScanner( resource, scanner );
             
             scanner.scan();
 
             List deletedFiles = Arrays.asList( scanner.getIncludedFiles() );
 
             for ( Iterator j = deletedFiles.iterator(); j.hasNext(); )
             {
                 String name = (String) j.next();
 
                 File destinationFile = getDestinationFile( outputDirectory, targetPath, name );
                 
                 destinationFile.delete();
                 
                 buildContext.refresh( destinationFile );
             }
 
         }
 
     }
 
     private File getDestinationFile( File outputDirectory, String targetPath, String name )
     {
       String destination = name;
 
       if ( targetPath != null )
       {
           destination = targetPath + "/" + name;
       }
 
       File destinationFile = new File( destination );
       if ( !destinationFile.isAbsolute() )
       {
           destinationFile = new File( outputDirectory, destination );
       }                
       
       if ( !destinationFile.getParentFile().exists() )
       {
           destinationFile.getParentFile().mkdirs();
       }
       return destinationFile;
     }
 
     private String[] setupScanner( Resource resource, Scanner scanner )
     {
       String[] includes = null;
       if ( resource.getIncludes() != null && !resource.getIncludes().isEmpty() )
       {
           includes = (String[]) resource.getIncludes().toArray( EMPTY_STRING_ARRAY ) ;
       }
       else
       {
           includes = DEFAULT_INCLUDES;
       }
       scanner.setIncludes( includes );
       
       String[] excludes = null;
       if ( resource.getExcludes() != null && !resource.getExcludes().isEmpty() )
       {
           excludes = (String[]) resource.getExcludes().toArray( EMPTY_STRING_ARRAY );
           scanner.setExcludes( excludes );
       }
 
       scanner.addDefaultExcludes();
       return includes;
     }
     
     private void copyDirectoryLayout( File sourceDirectory, File destinationDirectory, Scanner scanner )
         throws IOException
     {
         if ( sourceDirectory == null )
         {
             throw new IOException( "source directory can't be null." );
         }
 
         if ( destinationDirectory == null )
         {
             throw new IOException( "destination directory can't be null." );
         }
 
         if ( sourceDirectory.equals( destinationDirectory ) )
         {
             throw new IOException( "source and destination are the same directory." );
         }
 
         if ( !sourceDirectory.exists() )
         {
             throw new IOException( "Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ")." );
         }
 
         List includedDirectories = Arrays.asList( scanner.getIncludedDirectories() );
 
         for ( Iterator i = includedDirectories.iterator(); i.hasNext(); )
         {
             String name = (String) i.next();
 
             File source = new File( sourceDirectory, name );
 
             if ( source.equals( sourceDirectory ) )
             {
                 continue;
             }
 
             File destination = new File( destinationDirectory, name );
             destination.mkdirs();
         }
     }
 
     private String getRelativeOutputDirectory( MavenResourcesExecution execution )
     {
         String relOutDir = execution.getOutputDirectory().getAbsolutePath();
 
         if ( execution.getMavenProject() != null && execution.getMavenProject().getBasedir() != null )
         {
             String basedir = execution.getMavenProject().getBasedir().getAbsolutePath();
             relOutDir = PathTool.getRelativeFilePath( basedir, relOutDir );
             if ( relOutDir == null )
             {
                 relOutDir = execution.getOutputDirectory().getPath();
             }
             else
             {
                 relOutDir = relOutDir.replace( '\\', '/' );
             }
         }
 
         return relOutDir;
     }
 
 }

1		package org.apache.maven.shared.filtering;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.File;
23		import java.io.IOException;
24		import java.util.ArrayList;
25		import java.util.Arrays;
26		import java.util.Iterator;
27		import java.util.List;
28
29		import org.apache.maven.execution.MavenSession;
30		import org.apache.maven.model.Resource;
31		import org.apache.maven.project.MavenProject;
32		import org.codehaus.plexus.logging.AbstractLogEnabled;
33		import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
34		import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
35		import org.codehaus.plexus.util.FileUtils;
36		import org.codehaus.plexus.util.PathTool;
37		import org.codehaus.plexus.util.ReaderFactory;
38		import org.codehaus.plexus.util.Scanner;
39		import org.codehaus.plexus.util.StringUtils;
40		import org.sonatype.plexus.build.incremental.BuildContext;
41
42		/**
43		* @author <a href="mailto:olamy@apache.org">olamy</a>
44		* @version $Id: DefaultMavenResourcesFiltering.java 1067324 2011-02-04 22:56:23Z dennisl $
45		*
46		* @plexus.component role="org.apache.maven.shared.filtering.MavenResourcesFiltering"
47		* role-hint="default"
48		*/
49	24	public class DefaultMavenResourcesFiltering
50		extends AbstractLogEnabled
51		implements MavenResourcesFiltering, Initializable
52		{
53
54	1	private static final String[] EMPTY_STRING_ARRAY = {};
55
56	1	private static final String[] DEFAULT_INCLUDES = {"/"};
57
58		private List defaultNonFilteredFileExtensions;
59
60		/** @plexus.requirement */
61		private BuildContext buildContext;
62
63		// ------------------------------------------------
64		// Plexus lifecycle
65		// ------------------------------------------------
66		public void initialize()
67		throws InitializationException
68		{
69		// jpg,jpeg,gif,bmp,png
70	24	this.defaultNonFilteredFileExtensions = new ArrayList( 5 );
71	24	this.defaultNonFilteredFileExtensions.add( "jpg" );
72	24	this.defaultNonFilteredFileExtensions.add( "jpeg" );
73	24	this.defaultNonFilteredFileExtensions.add( "gif" );
74	24	this.defaultNonFilteredFileExtensions.add( "bmp" );
75	24	this.defaultNonFilteredFileExtensions.add( "png" );
76	24	}
77
78
79
80		/**
81		* @plexus.requirement
82		* role-hint="default"
83		*/
84		private MavenFileFilter mavenFileFilter;
85
86		public void filterResources( List resources, File outputDirectory, MavenProject mavenProject, String encoding,
87		List fileFilters, List nonFilteredFileExtensions, MavenSession mavenSession )
88		throws MavenFilteringException
89		{
90	12	MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution( resources, outputDirectory,
91		mavenProject, encoding,
92		fileFilters,
93		nonFilteredFileExtensions,
94		mavenSession );
95	12	mavenResourcesExecution.setUseDefaultFilterWrappers( true );
96		// mavenResourcesExecution.setEscapeWindowsPaths( false );
97
98	12	filterResources( mavenResourcesExecution );
99	12	}
100
101		public void filterResources( List resources, File outputDirectory, String encoding, List filterWrappers,
102		File resourcesBaseDirectory, List nonFilteredFileExtensions )
103		throws MavenFilteringException
104		{
105	0	MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution( resources, outputDirectory,
106		encoding, filterWrappers,
107		resourcesBaseDirectory,
108		nonFilteredFileExtensions );
109	0	filterResources( mavenResourcesExecution );
110	0	}
111
112
113		public boolean filteredFileExtension( String fileName, List userNonFilteredFileExtensions )
114		{
115	69	List nonFilteredFileExtensions = new ArrayList( getDefaultNonFilteredFileExtensions() );
116	69	if ( userNonFilteredFileExtensions != null )
117		{
118	69	nonFilteredFileExtensions.addAll( userNonFilteredFileExtensions );
119		}
120	69	boolean filteredFileExtension = !nonFilteredFileExtensions.contains( StringUtils.lowerCase( FileUtils
121		.extension( fileName ) ) );
122	69	if ( getLogger().isDebugEnabled() )
123		{
124	0	getLogger().debug(
125		"file " + fileName + " has a" + ( filteredFileExtension ? " " : " non " )
126		+ "filtered file extension" );
127		}
128	69	return filteredFileExtension;
129		}
130
131		public List getDefaultNonFilteredFileExtensions()
132		{
133	69	return this.defaultNonFilteredFileExtensions;
134		}
135
136		public void filterResources( MavenResourcesExecution mavenResourcesExecution )
137		throws MavenFilteringException
138		{
139	24	if ( mavenResourcesExecution == null )
140		{
141	0	throw new MavenFilteringException( "mavenResourcesExecution cannot be null" );
142		}
143
144	24	if ( mavenResourcesExecution.getResources() == null )
145		{
146	0	getLogger().info( "No resources configured skip copying/filtering" );
147	0	return;
148		}
149
150	24	if ( mavenResourcesExecution.getOutputDirectory() == null )
151		{
152	0	throw new MavenFilteringException( "outputDirectory cannot be null" );
153		}
154
155	24	if ( mavenResourcesExecution.isUseDefaultFilterWrappers() )
156		{
157	24	List filterWrappers = new ArrayList();
158	24	if ( mavenResourcesExecution.getFilterWrappers() != null )
159		{
160	1	filterWrappers.addAll( mavenResourcesExecution.getFilterWrappers() );
161		}
162	24	filterWrappers.addAll( mavenFileFilter.getDefaultFilterWrappers( mavenResourcesExecution ) );
163	24	mavenResourcesExecution.setFilterWrappers( filterWrappers );
164		}
165
166	24	if ( mavenResourcesExecution.getEncoding() == null \|\| mavenResourcesExecution.getEncoding().length() < 1 )
167		{
168	0	getLogger().warn(
169		"Using platform encoding (" + ReaderFactory.FILE_ENCODING
170		+ " actually) to copy filtered resources, i.e. build is platform dependent!" );
171		}
172		else
173		{
174	24	getLogger().info(
175		"Using '" + mavenResourcesExecution.getEncoding()
176		+ "' encoding to copy filtered resources." );
177		}
178
179	24	for ( Iterator i = mavenResourcesExecution.getResources().iterator(); i.hasNext(); )
180		{
181	25	Resource resource = (Resource) i.next();
182
183	25	if ( getLogger().isDebugEnabled() )
184		{
185	0	String ls = System.getProperty( "line.separator" );
186	0	StringBuffer debugMessage = new StringBuffer( "resource with targetPath " + resource.getTargetPath() )
187		.append( ls );
188	0	debugMessage.append( "directory " + resource.getDirectory() ).append( ls );
189	0	debugMessage.append(
190		"excludes "
191		+ ( resource.getExcludes() == null ? " empty " : resource.getExcludes()
192		.toString() ) ).append( ls );
193	0	debugMessage.append( "includes "
194		+ ( resource.getIncludes() == null ? " empty " : resource.getIncludes().toString() ) );
195	0	getLogger().debug( debugMessage.toString() );
196		}
197
198	25	String targetPath = resource.getTargetPath();
199
200	25	File resourceDirectory = new File( resource.getDirectory() );
201
202	25	if ( !resourceDirectory.isAbsolute() )
203		{
204	0	resourceDirectory = new File( mavenResourcesExecution.getResourcesBaseDirectory(), resourceDirectory
205		.getPath() );
206		}
207
208	25	if ( !resourceDirectory.exists() )
209		{
210	0	getLogger().info( "skip non existing resourceDirectory " + resourceDirectory.getPath() );
211	0	continue;
212		}
213
214		// this part is required in case the user specified "../something" as destination
215		// see MNG-1345
216	25	File outputDirectory = mavenResourcesExecution.getOutputDirectory();
217	25	boolean outputExists = outputDirectory.exists();
218	25	if ( !outputExists && !outputDirectory.mkdirs() )
219		{
220	0	throw new MavenFilteringException( "Cannot create resource output directory: " + outputDirectory );
221		}
222
223	25	boolean ignoreDelta =
224		!outputExists \|\| buildContext.hasDelta( mavenResourcesExecution.getFileFilters() )
225		\|\| buildContext.hasDelta( getRelativeOutputDirectory( mavenResourcesExecution ) );
226	25	getLogger().debug( "ignoreDelta " + ignoreDelta );
227	25	Scanner scanner = buildContext.newScanner( resourceDirectory, ignoreDelta );
228
229	25	setupScanner( resource, scanner );
230
231	25	scanner.scan();
232
233	25	if ( mavenResourcesExecution.isIncludeEmptyDirs() )
234		{
235		try
236		{
237	3	File targetDirectory = targetPath == null ? outputDirectory
238		: new File( outputDirectory, targetPath );
239	3	copyDirectoryLayout( resourceDirectory, targetDirectory, scanner );
240		}
241	0	catch ( IOException e )
242		{
243	0	throw new MavenFilteringException( "Cannot copy directory structure from "
244		+ resourceDirectory.getPath() + " to " + outputDirectory.getPath() );
245	3	}
246		}
247
248	25	List includedFiles = Arrays.asList( scanner.getIncludedFiles() );
249
250	25	getLogger().info(
251		"Copying " + includedFiles.size() + " resource" + ( includedFiles.size() > 1 ? "s" : "" )
252		+ ( targetPath == null ? "" : " to " + targetPath ) );
253
254	25	for ( Iterator j = includedFiles.iterator(); j.hasNext(); )
255		{
256	69	String name = (String) j.next();
257
258	69	File source = new File( resourceDirectory, name );
259
260		//File destinationFile = new File( outputDirectory, destination );
261
262	69	File destinationFile = getDestinationFile( outputDirectory, targetPath, name );
263
264	69	boolean filteredExt = filteredFileExtension( source.getName(), mavenResourcesExecution
265		.getNonFilteredFileExtensions() );
266
267	69	mavenFileFilter.copyFile( source, destinationFile, resource.isFiltering() && filteredExt,
268		mavenResourcesExecution.getFilterWrappers(), mavenResourcesExecution
269		.getEncoding(), mavenResourcesExecution.isOverwrite() );
270	69	}
271
272		// deal with deleted source files
273
274	25	scanner = buildContext.newDeleteScanner( resourceDirectory );
275
276	25	setupScanner( resource, scanner );
277
278	25	scanner.scan();
279
280	25	List deletedFiles = Arrays.asList( scanner.getIncludedFiles() );
281
282	25	for ( Iterator j = deletedFiles.iterator(); j.hasNext(); )
283		{
284	3	String name = (String) j.next();
285
286	3	File destinationFile = getDestinationFile( outputDirectory, targetPath, name );
287
288	3	destinationFile.delete();
289
290	3	buildContext.refresh( destinationFile );
291	3	}
292
293	25	}
294
295	24	}
296
297		private File getDestinationFile( File outputDirectory, String targetPath, String name )
298		{
299	72	String destination = name;
300
301	72	if ( targetPath != null )
302		{
303	2	destination = targetPath + "/" + name;
304		}
305
306	72	File destinationFile = new File( destination );
307	72	if ( !destinationFile.isAbsolute() )
308		{
309	71	destinationFile = new File( outputDirectory, destination );
310		}
311
312	72	if ( !destinationFile.getParentFile().exists() )
313		{
314	13	destinationFile.getParentFile().mkdirs();
315		}
316	72	return destinationFile;
317		}
318
319		private String[] setupScanner( Resource resource, Scanner scanner )
320		{
321	50	String[] includes = null;
322	50	if ( resource.getIncludes() != null && !resource.getIncludes().isEmpty() )
323		{
324	8	includes = (String[]) resource.getIncludes().toArray( EMPTY_STRING_ARRAY ) ;
325		}
326		else
327		{
328	42	includes = DEFAULT_INCLUDES;
329		}
330	50	scanner.setIncludes( includes );
331
332	50	String[] excludes = null;
333	50	if ( resource.getExcludes() != null && !resource.getExcludes().isEmpty() )
334		{
335	2	excludes = (String[]) resource.getExcludes().toArray( EMPTY_STRING_ARRAY );
336	2	scanner.setExcludes( excludes );
337		}
338
339	50	scanner.addDefaultExcludes();
340	50	return includes;
341		}
342
343		private void copyDirectoryLayout( File sourceDirectory, File destinationDirectory, Scanner scanner )
344		throws IOException
345		{
346	3	if ( sourceDirectory == null )
347		{
348	0	throw new IOException( "source directory can't be null." );
349		}
350
351	3	if ( destinationDirectory == null )
352		{
353	0	throw new IOException( "destination directory can't be null." );
354		}
355
356	3	if ( sourceDirectory.equals( destinationDirectory ) )
357		{
358	0	throw new IOException( "source and destination are the same directory." );
359		}
360
361	3	if ( !sourceDirectory.exists() )
362		{
363	0	throw new IOException( "Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ")." );
364		}
365
366	3	List includedDirectories = Arrays.asList( scanner.getIncludedDirectories() );
367
368	3	for ( Iterator i = includedDirectories.iterator(); i.hasNext(); )
369		{
370	7	String name = (String) i.next();
371
372	7	File source = new File( sourceDirectory, name );
373
374	7	if ( source.equals( sourceDirectory ) )
375		{
376	3	continue;
377		}
378
379	4	File destination = new File( destinationDirectory, name );
380	4	destination.mkdirs();
381	4	}
382	3	}
383
384		private String getRelativeOutputDirectory( MavenResourcesExecution execution )
385		{
386	5	String relOutDir = execution.getOutputDirectory().getAbsolutePath();
387
388	5	if ( execution.getMavenProject() != null && execution.getMavenProject().getBasedir() != null )
389		{
390	5	String basedir = execution.getMavenProject().getBasedir().getAbsolutePath();
391	5	relOutDir = PathTool.getRelativeFilePath( basedir, relOutDir );
392	5	if ( relOutDir == null )
393		{
394	0	relOutDir = execution.getOutputDirectory().getPath();
395		}
396		else
397		{
398	5	relOutDir = relOutDir.replace( '\\', '/' );
399		}
400		}
401
402	5	return relOutDir;
403		}
404
405		}