Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

AbstractPmdReport

66 %

70/106

50 %

37/74

4,25

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