Coverage Report

 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 org.apache.maven.execution.MavenSession;
 import org.apache.maven.model.Resource;
 import org.apache.maven.project.MavenProject;
 import org.codehaus.plexus.interpolation.Interpolator;
 import org.codehaus.plexus.interpolation.RegexBasedInterpolator;
 import org.codehaus.plexus.interpolation.StringSearchInterpolator;
 import org.codehaus.plexus.interpolation.ValueSource;
 import org.codehaus.plexus.util.FileUtils;
 import org.codehaus.plexus.util.FileUtils.FilterWrapper;
 
 import java.io.File;
 import java.io.Reader;
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * A bean to configure a resources filtering execution.
  *
  * @author Olivier Lamy
  *
  */
 public class MavenResourcesExecution
     extends AbstractMavenFilteringRequest
 {
 
     private List<Resource> resources;
 
     private File outputDirectory;
 
     private List<String> nonFilteredFileExtensions;
 
     private List<FileUtils.FilterWrapper> filterWrappers;
 
     private File resourcesBaseDirectory;
 
     private boolean useDefaultFilterWrappers = false;
 
     /**
      * Overwrite existing files even if the destination files are newer.
      * <code>false</code> by default.
      *
      * @since 1.0-beta-2
      */
     private boolean overwrite = false;
 
     /**
      * Copy any empty directories included in the Resources.
      *
      * @since 1.0-beta-2
      */
     private boolean includeEmptyDirs = false;
 
     /**
      * Do not stop trying to filter tokens when reaching EOL.
      *
      * @since 1.0
      */
     private boolean supportMultiLineFiltering;
 
     public MavenResourcesExecution()
     {
         // no op
     }
 
     /**
      * As we use a Maven project <code>useDefaultFilterWrappers</code> will be set to <code>true</code>.
      *
      * @param resources
      * @param outputDirectory
      * @param mavenProject
      * @param encoding
      * @param fileFilters
      * @param nonFilteredFileExtensions
      * @param mavenSession
      */
     public MavenResourcesExecution( List<Resource> resources, File outputDirectory, MavenProject mavenProject,
                                     String encoding, List fileFilters, List<String> nonFilteredFileExtensions,
                                     MavenSession mavenSession )
     {
         super( mavenProject, fileFilters, encoding, mavenSession );
         this.resources = resources;
         this.outputDirectory = outputDirectory;
         this.nonFilteredFileExtensions = nonFilteredFileExtensions;
         this.useDefaultFilterWrappers = true;
         this.resourcesBaseDirectory = mavenProject.getBasedir();
     }
 
     public MavenResourcesExecution( List<Resource> resources, File outputDirectory, String encoding,
                                     List<FileUtils.FilterWrapper> filterWrappers, File resourcesBaseDirectory,
                                     List<String> nonFilteredFileExtensions )
     {
         this();
         this.resources = resources;
         this.outputDirectory = outputDirectory;
         this.filterWrappers = filterWrappers;
         this.nonFilteredFileExtensions = nonFilteredFileExtensions;
         this.resourcesBaseDirectory = resourcesBaseDirectory;
         this.useDefaultFilterWrappers = false;
         setEncoding( encoding );
     }
 
 
     /**
      * @return List of {@link org.apache.maven.model.Resource}
      */
     public List<Resource> getResources()
     {
         return resources;
     }
 
     /**
      * @param resources List of {@link org.apache.maven.model.Resource}
      */
     public void setResources( List<Resource> resources )
     {
         this.resources = resources;
     }
 
     public File getOutputDirectory()
     {
         return outputDirectory;
     }
 
     public void setOutputDirectory( File outputDirectory )
     {
         this.outputDirectory = outputDirectory;
     }
 
     /**
      * @return List of {@link String} file extensions to not filter
      */
     public List<String> getNonFilteredFileExtensions()
     {
         return nonFilteredFileExtensions;
     }
 
     /**
      * @param nonFilteredFileExtensions List of {@link String} file extensions to not filter
      */
     public void setNonFilteredFileExtensions( List<String> nonFilteredFileExtensions )
     {
         this.nonFilteredFileExtensions = nonFilteredFileExtensions;
     }
 
     /**
      * @return List of {@link FileUtils.FilterWrapper}
      */
     public List<FileUtils.FilterWrapper> getFilterWrappers()
     {
         return filterWrappers;
     }
 
     /**
      * @param filterWrappers List of {@link FileUtils.FilterWrapper}
      */
     public void setFilterWrappers( List<FileUtils.FilterWrapper> filterWrappers )
     {
         this.filterWrappers = filterWrappers;
     }
 
     public void addFilterWrapper( FilterWrapper filterWrapper )
     {
         if ( this.filterWrappers == null )
         {
             this.filterWrappers = new ArrayList<FilterWrapper>();
         }
         this.filterWrappers.add( filterWrapper );
     }
 
     /**
      * Helper to add {@link FileUtils.FilterWrapper}, will {@link RegexBasedInterpolator} with default regex Exp ${ }
      * and InterpolatorFilterReaderLineEnding with defaultTokens ${ }.
      *
      * @param valueSource
      * @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
      */
     public void addFilerWrapper( final ValueSource valueSource )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 Interpolator propertiesInterpolator = new RegexBasedInterpolator();
                 propertiesInterpolator.addValueSource( valueSource );
                 return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator,
                                                                InterpolatorFilterReaderLineEnding.DEFAULT_BEGIN_TOKEN,
                                                                InterpolatorFilterReaderLineEnding.DEFAULT_END_TOKEN,
                                                                false );
             }
         } );
     }
 
     /**
      * @param valueSource
      * @param startRegExp
      * @param endRegExp
      * @param startToken
      * @param endToken
      * @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
      */
     public void addFilerWrapper( final ValueSource valueSource, final String startRegExp, final String endRegExp,
                                  final String startToken, final String endToken )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 Interpolator propertiesInterpolator = new RegexBasedInterpolator( startRegExp, endRegExp );
                 propertiesInterpolator.addValueSource( valueSource );
                 return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startToken, endToken,
                                                                false );
             }
         } );
     }
 
     /**
      * @param valueSource
      * @param startExp     start token like ${
      * @param endExp       endToken }
      * @param escapeString
      * @since 1.0-beta-2
      * @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
      */
     public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
                                              final String escapeString )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
                 propertiesInterpolator.addValueSource( valueSource );
                 propertiesInterpolator.setEscapeString( escapeString );
                 InterpolatorFilterReaderLineEnding interpolatorFilterReader =
                     new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startExp, endExp, false );
                 interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
                 return interpolatorFilterReader;
             }
         } );
     }
 
     /**
      * @param valueSource
      * @param startExp                  start token like ${
      * @param endExp                    endToken }
      * @param escapeString
      * @param supportMultiLineFiltering do we support or use filtering on multi lines with start and endtoken on multi lines
      * @since 1.0
      */
     public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
                                              final String escapeString, final boolean supportMultiLineFiltering )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
                 propertiesInterpolator.addValueSource( valueSource );
                 propertiesInterpolator.setEscapeString( escapeString );
                 InterpolatorFilterReaderLineEnding interpolatorFilterReader =
                     new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startExp, endExp,
                                                             supportMultiLineFiltering );
                 interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
                 return interpolatorFilterReader;
             }
         } );
     }
 
 
     public File getResourcesBaseDirectory()
     {
         return resourcesBaseDirectory;
     }
 
     public void setResourcesBaseDirectory( File resourcesBaseDirectory )
     {
         this.resourcesBaseDirectory = resourcesBaseDirectory;
     }
 
     public boolean isUseDefaultFilterWrappers()
     {
         return useDefaultFilterWrappers;
     }
 
     public void setUseDefaultFilterWrappers( boolean useDefaultFilterWrappers )
     {
         this.useDefaultFilterWrappers = useDefaultFilterWrappers;
     }
 
     /**
      * Overwrite existing files even if the destination files are newer.
      *
      * @since 1.0-beta-2
      */
     public boolean isOverwrite()
     {
         return overwrite;
     }
 
     /**
      * Overwrite existing files even if the destination files are newer.
      *
      * @param overwrite
      * @since 1.0-beta-2
      */
     public void setOverwrite( boolean overwrite )
     {
         this.overwrite = overwrite;
     }
 
     /**
      * Copy any empty directories included in the Resources.
      *
      * @since 1.0-beta-2
      */
     public boolean isIncludeEmptyDirs()
     {
         return includeEmptyDirs;
     }
 
     /**
      * Copy any empty directories included in the Resources.
      *
      * @param includeEmptyDirs
      * @since 1.0-beta-2
      */
     public void setIncludeEmptyDirs( boolean includeEmptyDirs )
     {
         this.includeEmptyDirs = includeEmptyDirs;
     }
 
     public MavenResourcesExecution copyOf()
     {
         MavenResourcesExecution mre = new MavenResourcesExecution();
         mre.setAdditionalProperties( mre.getAdditionalProperties() );
         mre.setEncoding( mre.getEncoding() );
         mre.setEscapedBackslashesInFilePath( mre.isEscapedBackslashesInFilePath() );
         mre.setEscapeString( mre.getEscapeString() );
         mre.setFileFilters( copyList( mre.getFileFilters() ) );
         mre.setFilterWrappers( copyList( mre.getFilterWrappers() ) );
         mre.setIncludeEmptyDirs( mre.isIncludeEmptyDirs() );
         mre.setInjectProjectBuildFilters( mre.isInjectProjectBuildFilters() );
         mre.setMavenProject( mre.getMavenProject() );
         mre.setMavenSession( mre.getMavenSession() );
         mre.setNonFilteredFileExtensions( copyList( mre.getNonFilteredFileExtensions() ) );
         mre.setOutputDirectory( mre.getOutputDirectory() );
         mre.setOverwrite( mre.isOverwrite() );
         mre.setProjectStartExpressions( copyList( mre.getProjectStartExpressions() ) );
         mre.setResources( copyList( mre.getResources() ) );
         mre.setResourcesBaseDirectory( mre.getResourcesBaseDirectory() );
         mre.setUseDefaultFilterWrappers( mre.isUseDefaultFilterWrappers() );
         mre.setSupportMultiLineFiltering( mre.isSupportMultiLineFiltering() );
         return mre;
     }
 
     private List copyList( List lst )
     {
         if ( lst == null )
         {
             return null;
         }
         else if ( lst.isEmpty() )
         {
             return new ArrayList();
         }
         else
         {
             return new ArrayList( lst );
         }
     }
 
     public boolean isSupportMultiLineFiltering()
     {
         return supportMultiLineFiltering;
     }
 
     public void setSupportMultiLineFiltering( boolean supportMultiLineFiltering )
     {
         this.supportMultiLineFiltering = supportMultiLineFiltering;
     }
 }

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 org.apache.maven.execution.MavenSession;
23		import org.apache.maven.model.Resource;
24		import org.apache.maven.project.MavenProject;
25		import org.codehaus.plexus.interpolation.Interpolator;
26		import org.codehaus.plexus.interpolation.RegexBasedInterpolator;
27		import org.codehaus.plexus.interpolation.StringSearchInterpolator;
28		import org.codehaus.plexus.interpolation.ValueSource;
29		import org.codehaus.plexus.util.FileUtils;
30		import org.codehaus.plexus.util.FileUtils.FilterWrapper;
31
32		import java.io.File;
33		import java.io.Reader;
34		import java.util.ArrayList;
35		import java.util.List;
36
37		/**
38		* A bean to configure a resources filtering execution.
39		*
40		* @author Olivier Lamy
41		*
42		*/
43		public class MavenResourcesExecution
44		extends AbstractMavenFilteringRequest
45		{
46
47		private List<Resource> resources;
48
49		private File outputDirectory;
50
51		private List<String> nonFilteredFileExtensions;
52
53		private List<FileUtils.FilterWrapper> filterWrappers;
54
55		private File resourcesBaseDirectory;
56
57	28	private boolean useDefaultFilterWrappers = false;
58
59		/**
60		* Overwrite existing files even if the destination files are newer.
61		* <code>false</code> by default.
62		*
63		* @since 1.0-beta-2
64		*/
65	28	private boolean overwrite = false;
66
67		/**
68		* Copy any empty directories included in the Resources.
69		*
70		* @since 1.0-beta-2
71		*/
72	28	private boolean includeEmptyDirs = false;
73
74		/**
75		* Do not stop trying to filter tokens when reaching EOL.
76		*
77		* @since 1.0
78		*/
79		private boolean supportMultiLineFiltering;
80
81		public MavenResourcesExecution()
82	3	{
83		// no op
84	3	}
85
86		/**
87		* As we use a Maven project <code>useDefaultFilterWrappers</code> will be set to <code>true</code>.
88		*
89		* @param resources
90		* @param outputDirectory
91		* @param mavenProject
92		* @param encoding
93		* @param fileFilters
94		* @param nonFilteredFileExtensions
95		* @param mavenSession
96		*/
97		public MavenResourcesExecution( List<Resource> resources, File outputDirectory, MavenProject mavenProject,
98		String encoding, List fileFilters, List<String> nonFilteredFileExtensions,
99		MavenSession mavenSession )
100		{
101	25	super( mavenProject, fileFilters, encoding, mavenSession );
102	25	this.resources = resources;
103	25	this.outputDirectory = outputDirectory;
104	25	this.nonFilteredFileExtensions = nonFilteredFileExtensions;
105	25	this.useDefaultFilterWrappers = true;
106	25	this.resourcesBaseDirectory = mavenProject.getBasedir();
107	25	}
108
109		public MavenResourcesExecution( List<Resource> resources, File outputDirectory, String encoding,
110		List<FileUtils.FilterWrapper> filterWrappers, File resourcesBaseDirectory,
111		List<String> nonFilteredFileExtensions )
112		{
113	0	this();
114	0	this.resources = resources;
115	0	this.outputDirectory = outputDirectory;
116	0	this.filterWrappers = filterWrappers;
117	0	this.nonFilteredFileExtensions = nonFilteredFileExtensions;
118	0	this.resourcesBaseDirectory = resourcesBaseDirectory;
119	0	this.useDefaultFilterWrappers = false;
120	0	setEncoding( encoding );
121	0	}
122
123
124		/**
125		* @return List of {@link org.apache.maven.model.Resource}
126		*/
127		public List<Resource> getResources()
128		{
129	50	return resources;
130		}
131
132		/**
133		* @param resources List of {@link org.apache.maven.model.Resource}
134		*/
135		public void setResources( List<Resource> resources )
136		{
137	0	this.resources = resources;
138	0	}
139
140		public File getOutputDirectory()
141		{
142	57	return outputDirectory;
143		}
144
145		public void setOutputDirectory( File outputDirectory )
146		{
147	0	this.outputDirectory = outputDirectory;
148	0	}
149
150		/**
151		* @return List of {@link String} file extensions to not filter
152		*/
153		public List<String> getNonFilteredFileExtensions()
154		{
155	71	return nonFilteredFileExtensions;
156		}
157
158		/**
159		* @param nonFilteredFileExtensions List of {@link String} file extensions to not filter
160		*/
161		public void setNonFilteredFileExtensions( List<String> nonFilteredFileExtensions )
162		{
163	0	this.nonFilteredFileExtensions = nonFilteredFileExtensions;
164	0	}
165
166		/**
167		* @return List of {@link FileUtils.FilterWrapper}
168		*/
169		public List<FileUtils.FilterWrapper> getFilterWrappers()
170		{
171	97	return filterWrappers;
172		}
173
174		/**
175		* @param filterWrappers List of {@link FileUtils.FilterWrapper}
176		*/
177		public void setFilterWrappers( List<FileUtils.FilterWrapper> filterWrappers )
178		{
179	25	this.filterWrappers = filterWrappers;
180	25	}
181
182		public void addFilterWrapper( FilterWrapper filterWrapper )
183		{
184	1	if ( this.filterWrappers == null )
185		{
186	1	this.filterWrappers = new ArrayList<FilterWrapper>();
187		}
188	1	this.filterWrappers.add( filterWrapper );
189	1	}
190
191		/**
192		* Helper to add {@link FileUtils.FilterWrapper}, will {@link RegexBasedInterpolator} with default regex Exp ${ }
193		* and InterpolatorFilterReaderLineEnding with defaultTokens ${ }.
194		*
195		* @param valueSource
196		* @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
197		*/
198		public void addFilerWrapper( final ValueSource valueSource )
199		{
200	0	addFilterWrapper( new FileUtils.FilterWrapper()
201	0	{
202		public Reader getReader( Reader reader )
203		{
204	0	Interpolator propertiesInterpolator = new RegexBasedInterpolator();
205	0	propertiesInterpolator.addValueSource( valueSource );
206	0	return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator,
207		InterpolatorFilterReaderLineEnding.DEFAULT_BEGIN_TOKEN,
208		InterpolatorFilterReaderLineEnding.DEFAULT_END_TOKEN,
209		false );
210		}
211		} );
212	0	}
213
214		/**
215		* @param valueSource
216		* @param startRegExp
217		* @param endRegExp
218		* @param startToken
219		* @param endToken
220		* @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
221		*/
222		public void addFilerWrapper( final ValueSource valueSource, final String startRegExp, final String endRegExp,
223		final String startToken, final String endToken )
224		{
225	0	addFilterWrapper( new FileUtils.FilterWrapper()
226	0	{
227		public Reader getReader( Reader reader )
228		{
229	0	Interpolator propertiesInterpolator = new RegexBasedInterpolator( startRegExp, endRegExp );
230	0	propertiesInterpolator.addValueSource( valueSource );
231	0	return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startToken, endToken,
232		false );
233		}
234		} );
235	0	}
236
237		/**
238		* @param valueSource
239		* @param startExp start token like ${
240		* @param endExp endToken }
241		* @param escapeString
242		* @since 1.0-beta-2
243		* @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
244		*/
245		public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
246		final String escapeString )
247		{
248	1	addFilterWrapper( new FileUtils.FilterWrapper()
249	1	{
250		public Reader getReader( Reader reader )
251		{
252	7	StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
253	7	propertiesInterpolator.addValueSource( valueSource );
254	7	propertiesInterpolator.setEscapeString( escapeString );
255	7	InterpolatorFilterReaderLineEnding interpolatorFilterReader =
256		new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startExp, endExp, false );
257	7	interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
258	7	return interpolatorFilterReader;
259		}
260		} );
261	1	}
262
263		/**
264		* @param valueSource
265		* @param startExp start token like ${
266		* @param endExp endToken }
267		* @param escapeString
268		* @param supportMultiLineFiltering do we support or use filtering on multi lines with start and endtoken on multi lines
269		* @since 1.0
270		*/
271		public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
272		final String escapeString, final boolean supportMultiLineFiltering )
273		{
274	0	addFilterWrapper( new FileUtils.FilterWrapper()
275	0	{
276		public Reader getReader( Reader reader )
277		{
278	0	StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
279	0	propertiesInterpolator.addValueSource( valueSource );
280	0	propertiesInterpolator.setEscapeString( escapeString );
281	0	InterpolatorFilterReaderLineEnding interpolatorFilterReader =
282		new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startExp, endExp,
283		supportMultiLineFiltering );
284	0	interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
285	0	return interpolatorFilterReader;
286		}
287		} );
288	0	}
289
290
291		public File getResourcesBaseDirectory()
292		{
293	0	return resourcesBaseDirectory;
294		}
295
296		public void setResourcesBaseDirectory( File resourcesBaseDirectory )
297		{
298	0	this.resourcesBaseDirectory = resourcesBaseDirectory;
299	0	}
300
301		public boolean isUseDefaultFilterWrappers()
302		{
303	25	return useDefaultFilterWrappers;
304		}
305
306		public void setUseDefaultFilterWrappers( boolean useDefaultFilterWrappers )
307		{
308	14	this.useDefaultFilterWrappers = useDefaultFilterWrappers;
309	14	}
310
311		/**
312		* Overwrite existing files even if the destination files are newer.
313		*
314		* @since 1.0-beta-2
315		*/
316		public boolean isOverwrite()
317		{
318	71	return overwrite;
319		}
320
321		/**
322		* Overwrite existing files even if the destination files are newer.
323		*
324		* @param overwrite
325		* @since 1.0-beta-2
326		*/
327		public void setOverwrite( boolean overwrite )
328		{
329	0	this.overwrite = overwrite;
330	0	}
331
332		/**
333		* Copy any empty directories included in the Resources.
334		*
335		* @since 1.0-beta-2
336		*/
337		public boolean isIncludeEmptyDirs()
338		{
339	27	return includeEmptyDirs;
340		}
341
342		/**
343		* Copy any empty directories included in the Resources.
344		*
345		* @param includeEmptyDirs
346		* @since 1.0-beta-2
347		*/
348		public void setIncludeEmptyDirs( boolean includeEmptyDirs )
349		{
350	3	this.includeEmptyDirs = includeEmptyDirs;
351	3	}
352
353		public MavenResourcesExecution copyOf()
354		{
355	0	MavenResourcesExecution mre = new MavenResourcesExecution();
356	0	mre.setAdditionalProperties( mre.getAdditionalProperties() );
357	0	mre.setEncoding( mre.getEncoding() );
358	0	mre.setEscapedBackslashesInFilePath( mre.isEscapedBackslashesInFilePath() );
359	0	mre.setEscapeString( mre.getEscapeString() );
360	0	mre.setFileFilters( copyList( mre.getFileFilters() ) );
361	0	mre.setFilterWrappers( copyList( mre.getFilterWrappers() ) );
362	0	mre.setIncludeEmptyDirs( mre.isIncludeEmptyDirs() );
363	0	mre.setInjectProjectBuildFilters( mre.isInjectProjectBuildFilters() );
364	0	mre.setMavenProject( mre.getMavenProject() );
365	0	mre.setMavenSession( mre.getMavenSession() );
366	0	mre.setNonFilteredFileExtensions( copyList( mre.getNonFilteredFileExtensions() ) );
367	0	mre.setOutputDirectory( mre.getOutputDirectory() );
368	0	mre.setOverwrite( mre.isOverwrite() );
369	0	mre.setProjectStartExpressions( copyList( mre.getProjectStartExpressions() ) );
370	0	mre.setResources( copyList( mre.getResources() ) );
371	0	mre.setResourcesBaseDirectory( mre.getResourcesBaseDirectory() );
372	0	mre.setUseDefaultFilterWrappers( mre.isUseDefaultFilterWrappers() );
373	0	mre.setSupportMultiLineFiltering( mre.isSupportMultiLineFiltering() );
374	0	return mre;
375		}
376
377		private List copyList( List lst )
378		{
379	0	if ( lst == null )
380		{
381	0	return null;
382		}
383	0	else if ( lst.isEmpty() )
384		{
385	0	return new ArrayList();
386		}
387		else
388		{
389	0	return new ArrayList( lst );
390		}
391		}
392
393		public boolean isSupportMultiLineFiltering()
394		{
395	56	return supportMultiLineFiltering;
396		}
397
398		public void setSupportMultiLineFiltering( boolean supportMultiLineFiltering )
399		{
400	28	this.supportMultiLineFiltering = supportMultiLineFiltering;
401	28	}
402		}