Coverage Report

Coverage Report - org.apache.maven.plugin.pmd.AbstractPmdReport

Classes in this File

Line Coverage

Branch Coverage

Complexity

AbstractPmdReport

67%

70/103

50%

38/76

5,083

 package org.apache.maven.plugin.pmd;
 
 /*
  * 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.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
 import net.sourceforge.pmd.PMD;
 
 import org.apache.maven.doxia.siterenderer.Renderer;
 import org.apache.maven.model.ReportPlugin;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.reporting.AbstractMavenReport;
 import org.codehaus.plexus.util.FileUtils;
 import org.codehaus.plexus.util.PathTool;
 import org.codehaus.plexus.util.ReaderFactory;
 import org.codehaus.plexus.util.StringUtils;
 
 /**
  * Base class for the PMD reports.
  *
  * @author <a href="mailto:brett@apache.org">Brett Porter</a>
  * @version $Id: AbstractPmdReport.java 1231523 2012-01-14 16:36:56Z rfscholte $
  */
 public abstract class AbstractPmdReport
     extends AbstractMavenReport
 {
     /**
      * The output directory for the intermediate XML report.
      *
      * @parameter expression="${project.build.directory}"
      * @required
      */
     protected File targetDirectory;
 
     /**
      * The output directory for the final HTML report. Note that this parameter is only evaluated if the goal is run
      * directly from the command line or during the default lifecycle. If the goal is run indirectly as part of a site
      * generation, the output directory configured in the Maven Site Plugin is used instead.
      *
      * @parameter expression="${project.reporting.outputDirectory}"
      * @required
      */
     protected File outputDirectory;
 
     /**
      * Site rendering component for generating the HTML report.
      *
      * @component
      */
     private Renderer siteRenderer;
 
     /**
      * The project to analyse.
      *
      * @parameter expression="${project}"
      * @required
      * @readonly
      */
     protected MavenProject project;
 
     /**
      * Set the output format type, in addition to the HTML report.  Must be one of: "none",
      * "csv", "xml", "txt" or the full class name of the PMD renderer to use.
      * See the net.sourceforge.pmd.renderers package javadoc for available renderers.
      * XML is required if the pmd:check goal is being used.
      *
      * @parameter expression="${format}" default-value="xml"
      */
     protected String format = "xml";
 
     /**
      * Link the violation line numbers to the source xref. Links will be created
      * automatically if the jxr plugin is being used.
      *
      * @parameter expression="${linkXRef}" default-value="true"
      */
     private boolean linkXRef;
 
     /**
      * Location of the Xrefs to link to.
      *
      * @parameter default-value="${project.reporting.outputDirectory}/xref"
      */
     private File xrefLocation;
 
     /**
      * Location of the Test Xrefs to link to.
      *
      * @parameter default-value="${project.reporting.outputDirectory}/xref-test"
      */
     private File xrefTestLocation;
 
     /**
      * A list of files to exclude from checking. Can contain Ant-style wildcards and double wildcards. Note that these
      * exclusion patterns only operate on the path of a source file relative to its source root directory. In other
      * words, files are excluded based on their package and/or class name. If you want to exclude entire source root
      * directories, use the parameter <code>excludeRoots</code> instead.
      *
      * @parameter
      * @since 2.2
      */
     private List<String> excludes;
 
     /**
      * A list of files to include from checking. Can contain Ant-style wildcards and double wildcards.
      * Defaults to **\/*.java.
      *
      * @parameter
      * @since 2.2
      */
     private List<String> includes;
 
     /**
      * The directories containing the sources to be compiled.
      *
      * @parameter expression="${project.compileSourceRoots}"
      * @required
      * @readonly
      */
     private List<String> compileSourceRoots;
 
     /**
      * The directories containing the test-sources to be compiled.
      *
      * @parameter expression="${project.testCompileSourceRoots}"
      * @required
      * @readonly
      */
     private List<String> testSourceRoots;
 
     /**
      * The project source directories that should be excluded.
      *
      * @parameter
      * @since 2.2
      */
     private List<File> excludeRoots;
 
     /**
      * Run PMD on the tests.
      *
      * @parameter default-value="false"
      * @since 2.2
      */
     protected boolean includeTests;
 
     /**
      * Whether to build an aggregated report at the root, or build individual reports.
      *
      * @parameter expression="${aggregate}" default-value="false"
      * @since 2.2
      */
     protected boolean aggregate;
 
     /**
      * The file encoding to use when reading the Java sources.
      *
      * @parameter expression="${encoding}" default-value="${project.build.sourceEncoding}"
      * @since 2.3
      */
     private String sourceEncoding;
 
     /**
      * The file encoding when writing non-HTML reports.
      *
      * @parameter expression="${outputEncoding}" default-value="${project.reporting.outputEncoding}"
      * @since 2.5
      */
     private String outputEncoding;
 
     /**
      * The projects in the reactor for aggregation report.
      *
      * @parameter expression="${reactorProjects}"
      * @readonly
      */
     protected List<MavenProject> reactorProjects;
 
     /** {@inheritDoc} */
     protected MavenProject getProject()
     {
         return project;
     }
 
     /** {@inheritDoc} */
     protected Renderer getSiteRenderer()
     {
         return siteRenderer;
     }
 
     protected String constructXRefLocation( boolean test )
     {
         String location = null;
         if ( linkXRef )
         {
             File xrefLoc = test ? xrefTestLocation : xrefLocation;
 
             String relativePath = PathTool.getRelativePath( outputDirectory.getAbsolutePath(),
                                                             xrefLoc.getAbsolutePath() );
             if ( StringUtils.isEmpty( relativePath ) )
             {
                 relativePath = ".";
             }
             relativePath = relativePath + "/" + xrefLoc.getName();
             if ( xrefLoc.exists() )
             {
                 // XRef was already generated by manual execution of a lifecycle binding
                 location = relativePath;
             }
             else
             {
                 // Not yet generated - check if the report is on its way
                 @SuppressWarnings( "unchecked" )
                 List<ReportPlugin> reportPlugins = project.getReportPlugins();
                 for ( ReportPlugin plugin  : reportPlugins )
                 {
                     String artifactId = plugin.getArtifactId();
                     if ( "maven-jxr-plugin".equals( artifactId ) || "jxr-maven-plugin".equals( artifactId ) )
                     {
                         location = relativePath;
                     }
                 }
             }
 
             if ( location == null )
             {
                 getLog().warn( "Unable to locate Source XRef to link to - DISABLED" );
             }
         }
         return location;
     }
 
     /**
      * Convenience method to get the list of files where the PMD tool will be executed
      *
      * @return a List of the files where the PMD tool will be executed
      * @throws java.io.IOException
      */
     protected Map<File, PmdFileInfo> getFilesToProcess()
         throws IOException
     {
         String sourceXref = constructXRefLocation( false );
         String testXref = includeTests ? constructXRefLocation( true ) : "";
 
         if ( aggregate && !project.isExecutionRoot() )
         {
             return Collections.emptyMap();
         }
 
         if ( excludeRoots == null )
         {
             excludeRoots = Collections.emptyList();
         }
         
         Collection<File> excludeRootFiles = new HashSet<File>( excludeRoots.size() );
 
         for ( File file : excludeRoots )
         {
             if ( file.isDirectory() )
             {
                 excludeRootFiles.add( file );
             }
         }
 
         List<PmdFileInfo> directories = new ArrayList<PmdFileInfo>();
 
         if ( compileSourceRoots != null )
         {
 
             for ( String root : compileSourceRoots )
             {
                 File sroot = new File( root );
                 directories.add( new PmdFileInfo( project, sroot, sourceXref ) );
             }
 
         }
         if ( includeTests )
         {
             if ( testSourceRoots != null )
             {
                 for ( String root : testSourceRoots )
                 {
                     File sroot = new File( root );
                     directories.add( new PmdFileInfo( project, sroot, testXref ) );
                 }
             }
         }
         if ( aggregate )
         {
             for ( MavenProject localProject : reactorProjects )
             {
                 @SuppressWarnings( "unchecked" )
                 List<String> localCompileSourceRoots = localProject.getCompileSourceRoots(); 
                 for ( String root : localCompileSourceRoots )
                 {
                     File sroot = new File( root );
                     directories.add( new PmdFileInfo( localProject, sroot, sourceXref ) );
                 }
                 if ( includeTests )
                 {
                     @SuppressWarnings( "unchecked" )
                     List<String> localTestCompileSourceRoots = localProject.getTestCompileSourceRoots(); 
                     for ( String root : localTestCompileSourceRoots )
                     {
                         File sroot = new File( root );
                         directories.add( new PmdFileInfo( localProject, sroot, testXref ) );
                     }
                 }
             }
 
         }
 
         String excluding = getExcludes();
         getLog().debug( "Exclusions: " + excluding );
         String including = getIncludes();
         getLog().debug( "Inclusions: " + including );
 
         Map<File, PmdFileInfo> files = new TreeMap<File, PmdFileInfo>();
 
         for ( PmdFileInfo finfo : directories )
         {
             File sourceDirectory = finfo.getSourceDirectory();
             if ( sourceDirectory.isDirectory() && !excludeRootFiles.contains( sourceDirectory ) )
             {
                 @SuppressWarnings( "unchecked" )
                 List<File> newfiles = FileUtils.getFiles( sourceDirectory, including, excluding );
                 for ( Iterator<File> it2 = newfiles.iterator(); it2.hasNext(); )
                 {
                     files.put( it2.next(), finfo );
                 }
             }
         }
 
         return files;
     }
 
     /**
      * Gets the comma separated list of effective include patterns.
      *
      * @return The comma separated list of effective include patterns, never <code>null</code>.
      */
     private String getIncludes()
     {
         Collection<String> patterns = new LinkedHashSet<String>();
         if ( includes != null )
         {
             patterns.addAll( includes );
         }
         if ( patterns.isEmpty() )
         {
             patterns.add( "**/*.java" );
         }
         return StringUtils.join( patterns.iterator(), "," );
     }
 
     /**
      * Gets the comma separated list of effective exclude patterns.
      *
      * @return The comma separated list of effective exclude patterns, never <code>null</code>.
      */
     private String getExcludes()
     {
         @SuppressWarnings( "unchecked" )
         Collection<String> patterns = new LinkedHashSet<String>( FileUtils.getDefaultExcludesAsList() );
         if ( excludes != null )
         {
             patterns.addAll( excludes );
         }
         return StringUtils.join( patterns.iterator(), "," );
     }
 
     protected boolean isHtml()
     {
         return "html".equals( format );
     }
 
     /** {@inheritDoc} */
     public boolean canGenerateReport()
     {
         if ( aggregate && !project.isExecutionRoot() )
         {
             return false;
         }
 
         if ( "pom".equals( project.getPackaging() ) && !aggregate )
         {
             return false;
         }
 
         // if format is XML, we need to output it even if the file list is empty
         // so the "check" goals can check for failures
         if ( "xml".equals( format ) )
         {
             return true;
         }
         try
         {
             Map<File, PmdFileInfo> filesToProcess = getFilesToProcess();
             if ( filesToProcess.isEmpty() )
             {
                 return false;
             }
         }
         catch ( IOException e )
         {
             getLog().error( e );
         }
         return true;
     }
 
     /** {@inheritDoc} */
     protected String getOutputDirectory()
     {
         return outputDirectory.getAbsolutePath();
     }
 
     protected String getSourceEncoding()
     {
         return sourceEncoding;
     }
 
     /**
      * Gets the effective reporting output files encoding.
      *
      * @return The effective reporting output file encoding, never <code>null</code>.
      * @since 2.5
      */
     protected String getOutputEncoding()
     {
         return ( outputEncoding != null ) ? outputEncoding : ReaderFactory.UTF_8;
     }
 
     static String getPmdVersion()
     {
         try
         {
             return (String) PMD.class.getField( "VERSION" ).get( null );
         }
         catch ( IllegalAccessException e )
         {
             throw new RuntimeException( "PMD VERSION field not accessible", e );
         }
         catch ( NoSuchFieldException e )
         {
             throw new RuntimeException( "PMD VERSION field not found", e );
         }
     }
 }

1		package org.apache.maven.plugin.pmd;
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.Collection;
26		import java.util.Collections;
27		import java.util.HashSet;
28		import java.util.Iterator;
29		import java.util.LinkedHashSet;
30		import java.util.List;
31		import java.util.Map;
32		import java.util.TreeMap;
33
34		import net.sourceforge.pmd.PMD;
35
36		import org.apache.maven.doxia.siterenderer.Renderer;
37		import org.apache.maven.model.ReportPlugin;
38		import org.apache.maven.project.MavenProject;
39		import org.apache.maven.reporting.AbstractMavenReport;
40		import org.codehaus.plexus.util.FileUtils;
41		import org.codehaus.plexus.util.PathTool;
42		import org.codehaus.plexus.util.ReaderFactory;
43		import org.codehaus.plexus.util.StringUtils;
44
45		/**
46		* Base class for the PMD reports.
47		*
48		* @author <a href="mailto:brett@apache.org">Brett Porter</a>
49		* @version $Id: AbstractPmdReport.java 1231523 2012-01-14 16:36:56Z rfscholte $
50		*/
51	52	public abstract class AbstractPmdReport
52		extends AbstractMavenReport
53		{
54		/**
55		* The output directory for the intermediate XML report.
56		*
57		* @parameter expression="${project.build.directory}"
58		* @required
59		*/
60		protected File targetDirectory;
61
62		/**
63		* The output directory for the final HTML report. Note that this parameter is only evaluated if the goal is run
64		* directly from the command line or during the default lifecycle. If the goal is run indirectly as part of a site
65		* generation, the output directory configured in the Maven Site Plugin is used instead.
66		*
67		* @parameter expression="${project.reporting.outputDirectory}"
68		* @required
69		*/
70		protected File outputDirectory;
71
72		/**
73		* Site rendering component for generating the HTML report.
74		*
75		* @component
76		*/
77		private Renderer siteRenderer;
78
79		/**
80		* The project to analyse.
81		*
82		* @parameter expression="${project}"
83		* @required
84		* @readonly
85		*/
86		protected MavenProject project;
87
88		/**
89		* Set the output format type, in addition to the HTML report. Must be one of: "none",
90		* "csv", "xml", "txt" or the full class name of the PMD renderer to use.
91		* See the net.sourceforge.pmd.renderers package javadoc for available renderers.
92		* XML is required if the pmd:check goal is being used.
93		*
94		* @parameter expression="${format}" default-value="xml"
95		*/
96	52	protected String format = "xml";
97
98		/**
99		* Link the violation line numbers to the source xref. Links will be created
100		* automatically if the jxr plugin is being used.
101		*
102		* @parameter expression="${linkXRef}" default-value="true"
103		*/
104		private boolean linkXRef;
105
106		/**
107		* Location of the Xrefs to link to.
108		*
109		* @parameter default-value="${project.reporting.outputDirectory}/xref"
110		*/
111		private File xrefLocation;
112
113		/**
114		* Location of the Test Xrefs to link to.
115		*
116		* @parameter default-value="${project.reporting.outputDirectory}/xref-test"
117		*/
118		private File xrefTestLocation;
119
120		/**
121		* A list of files to exclude from checking. Can contain Ant-style wildcards and double wildcards. Note that these
122		* exclusion patterns only operate on the path of a source file relative to its source root directory. In other
123		* words, files are excluded based on their package and/or class name. If you want to exclude entire source root
124		* directories, use the parameter <code>excludeRoots</code> instead.
125		*
126		* @parameter
127		* @since 2.2
128		*/
129		private List<String> excludes;
130
131		/**
132		* A list of files to include from checking. Can contain Ant-style wildcards and double wildcards.
133		* Defaults to *\/.java.
134		*
135		* @parameter
136		* @since 2.2
137		*/
138		private List<String> includes;
139
140		/**
141		* The directories containing the sources to be compiled.
142		*
143		* @parameter expression="${project.compileSourceRoots}"
144		* @required
145		* @readonly
146		*/
147		private List<String> compileSourceRoots;
148
149		/**
150		* The directories containing the test-sources to be compiled.
151		*
152		* @parameter expression="${project.testCompileSourceRoots}"
153		* @required
154		* @readonly
155		*/
156		private List<String> testSourceRoots;
157
158		/**
159		* The project source directories that should be excluded.
160		*
161		* @parameter
162		* @since 2.2
163		*/
164		private List<File> excludeRoots;
165
166		/**
167		* Run PMD on the tests.
168		*
169		* @parameter default-value="false"
170		* @since 2.2
171		*/
172		protected boolean includeTests;
173
174		/**
175		* Whether to build an aggregated report at the root, or build individual reports.
176		*
177		* @parameter expression="${aggregate}" default-value="false"
178		* @since 2.2
179		*/
180		protected boolean aggregate;
181
182		/**
183		* The file encoding to use when reading the Java sources.
184		*
185		* @parameter expression="${encoding}" default-value="${project.build.sourceEncoding}"
186		* @since 2.3
187		*/
188		private String sourceEncoding;
189
190		/**
191		* The file encoding when writing non-HTML reports.
192		*
193		* @parameter expression="${outputEncoding}" default-value="${project.reporting.outputEncoding}"
194		* @since 2.5
195		*/
196		private String outputEncoding;
197
198		/**
199		* The projects in the reactor for aggregation report.
200		*
201		* @parameter expression="${reactorProjects}"
202		* @readonly
203		*/
204		protected List<MavenProject> reactorProjects;
205
206		/** {@inheritDoc} */
207		protected MavenProject getProject()
208		{
209	0	return project;
210		}
211
212		/** {@inheritDoc} */
213		protected Renderer getSiteRenderer()
214		{
215	52	return siteRenderer;
216		}
217
218		protected String constructXRefLocation( boolean test )
219		{
220	76	String location = null;
221	76	if ( linkXRef )
222		{
223	32	File xrefLoc = test ? xrefTestLocation : xrefLocation;
224
225	32	String relativePath = PathTool.getRelativePath( outputDirectory.getAbsolutePath(),
226		xrefLoc.getAbsolutePath() );
227	32	if ( StringUtils.isEmpty( relativePath ) )
228		{
229	0	relativePath = ".";
230		}
231	32	relativePath = relativePath + "/" + xrefLoc.getName();
232	32	if ( xrefLoc.exists() )
233		{
234		// XRef was already generated by manual execution of a lifecycle binding
235	8	location = relativePath;
236		}
237		else
238		{
239		// Not yet generated - check if the report is on its way
240		@SuppressWarnings( "unchecked" )
241	24	List<ReportPlugin> reportPlugins = project.getReportPlugins();
242	24	for ( ReportPlugin plugin : reportPlugins )
243		{
244	24	String artifactId = plugin.getArtifactId();
245	24	if ( "maven-jxr-plugin".equals( artifactId ) \|\| "jxr-maven-plugin".equals( artifactId ) )
246		{
247	24	location = relativePath;
248		}
249	24	}
250		}
251
252	32	if ( location == null )
253		{
254	0	getLog().warn( "Unable to locate Source XRef to link to - DISABLED" );
255		}
256		}
257	76	return location;
258		}
259
260		/**
261		* Convenience method to get the list of files where the PMD tool will be executed
262		*
263		* @return a List of the files where the PMD tool will be executed
264		* @throws java.io.IOException
265		*/
266		protected Map<File, PmdFileInfo> getFilesToProcess()
267		throws IOException
268		{
269	76	String sourceXref = constructXRefLocation( false );
270	76	String testXref = includeTests ? constructXRefLocation( true ) : "";
271
272	76	if ( aggregate && !project.isExecutionRoot() )
273		{
274	0	return Collections.emptyMap();
275		}
276
277	76	if ( excludeRoots == null )
278		{
279	40	excludeRoots = Collections.emptyList();
280		}
281
282	76	Collection<File> excludeRootFiles = new HashSet<File>( excludeRoots.size() );
283
284	76	for ( File file : excludeRoots )
285		{
286	0	if ( file.isDirectory() )
287		{
288	0	excludeRootFiles.add( file );
289		}
290		}
291
292	76	List<PmdFileInfo> directories = new ArrayList<PmdFileInfo>();
293
294	76	if ( compileSourceRoots != null )
295		{
296
297	72	for ( String root : compileSourceRoots )
298		{
299	72	File sroot = new File( root );
300	72	directories.add( new PmdFileInfo( project, sroot, sourceXref ) );
301	72	}
302
303		}
304	76	if ( includeTests )
305		{
306	0	if ( testSourceRoots != null )
307		{
308	0	for ( String root : testSourceRoots )
309		{
310	0	File sroot = new File( root );
311	0	directories.add( new PmdFileInfo( project, sroot, testXref ) );
312	0	}
313		}
314		}
315	76	if ( aggregate )
316		{
317	0	for ( MavenProject localProject : reactorProjects )
318		{
319		@SuppressWarnings( "unchecked" )
320	0	List<String> localCompileSourceRoots = localProject.getCompileSourceRoots();
321	0	for ( String root : localCompileSourceRoots )
322		{
323	0	File sroot = new File( root );
324	0	directories.add( new PmdFileInfo( localProject, sroot, sourceXref ) );
325	0	}
326	0	if ( includeTests )
327		{
328		@SuppressWarnings( "unchecked" )
329	0	List<String> localTestCompileSourceRoots = localProject.getTestCompileSourceRoots();
330	0	for ( String root : localTestCompileSourceRoots )
331		{
332	0	File sroot = new File( root );
333	0	directories.add( new PmdFileInfo( localProject, sroot, testXref ) );
334	0	}
335		}
336	0	}
337
338		}
339
340	76	String excluding = getExcludes();
341	76	getLog().debug( "Exclusions: " + excluding );
342	76	String including = getIncludes();
343	76	getLog().debug( "Inclusions: " + including );
344
345	76	Map<File, PmdFileInfo> files = new TreeMap<File, PmdFileInfo>();
346
347	76	for ( PmdFileInfo finfo : directories )
348		{
349	72	File sourceDirectory = finfo.getSourceDirectory();
350	72	if ( sourceDirectory.isDirectory() && !excludeRootFiles.contains( sourceDirectory ) )
351		{
352		@SuppressWarnings( "unchecked" )
353	72	List<File> newfiles = FileUtils.getFiles( sourceDirectory, including, excluding );
354	72	for ( Iterator<File> it2 = newfiles.iterator(); it2.hasNext(); )
355		{
356	180	files.put( it2.next(), finfo );
357		}
358		}
359	72	}
360
361	76	return files;
362		}
363
364		/**
365		* Gets the comma separated list of effective include patterns.
366		*
367		* @return The comma separated list of effective include patterns, never <code>null</code>.
368		*/
369		private String getIncludes()
370		{
371	76	Collection<String> patterns = new LinkedHashSet<String>();
372	76	if ( includes != null )
373		{
374	0	patterns.addAll( includes );
375		}
376	76	if ( patterns.isEmpty() )
377		{
378	76	patterns.add( "*/.java" );
379		}
380	76	return StringUtils.join( patterns.iterator(), "," );
381		}
382
383		/**
384		* Gets the comma separated list of effective exclude patterns.
385		*
386		* @return The comma separated list of effective exclude patterns, never <code>null</code>.
387		*/
388		private String getExcludes()
389		{
390		@SuppressWarnings( "unchecked" )
391	76	Collection<String> patterns = new LinkedHashSet<String>( FileUtils.getDefaultExcludesAsList() );
392	76	if ( excludes != null )
393		{
394	32	patterns.addAll( excludes );
395		}
396	76	return StringUtils.join( patterns.iterator(), "," );
397		}
398
399		protected boolean isHtml()
400		{
401	32	return "html".equals( format );
402		}
403
404		/** {@inheritDoc} */
405		public boolean canGenerateReport()
406		{
407	116	if ( aggregate && !project.isExecutionRoot() )
408		{
409	0	return false;
410		}
411
412	116	if ( "pom".equals( project.getPackaging() ) && !aggregate )
413		{
414	0	return false;
415		}
416
417		// if format is XML, we need to output it even if the file list is empty
418		// so the "check" goals can check for failures
419	116	if ( "xml".equals( format ) )
420		{
421	72	return true;
422		}
423		try
424		{
425	44	Map<File, PmdFileInfo> filesToProcess = getFilesToProcess();
426	44	if ( filesToProcess.isEmpty() )
427		{
428	4	return false;
429		}
430		}
431	0	catch ( IOException e )
432		{
433	0	getLog().error( e );
434	40	}
435	40	return true;
436		}
437
438		/** {@inheritDoc} */
439		protected String getOutputDirectory()
440		{
441	68	return outputDirectory.getAbsolutePath();
442		}
443
444		protected String getSourceEncoding()
445		{
446	336	return sourceEncoding;
447		}
448
449		/**
450		* Gets the effective reporting output files encoding.
451		*
452		* @return The effective reporting output file encoding, never <code>null</code>.
453		* @since 2.5
454		*/
455		protected String getOutputEncoding()
456		{
457	56	return ( outputEncoding != null ) ? outputEncoding : ReaderFactory.UTF_8;
458		}
459
460		static String getPmdVersion()
461		{
462		try
463		{
464	32	return (String) PMD.class.getField( "VERSION" ).get( null );
465		}
466	0	catch ( IllegalAccessException e )
467		{
468	0	throw new RuntimeException( "PMD VERSION field not accessible", e );
469		}
470	0	catch ( NoSuchFieldException e )
471		{
472	0	throw new RuntimeException( "PMD VERSION field not found", e );
473		}
474		}
475		}