#3999

Committed 04 Apr 2024 09:41PM UTC coverage: 48.726% (+0.004%) from 48.722%

Build # #3999

Build Type

push

github

Committed by Juan Martín Sotuyo Dodero

Commit Message

Checkstyle fixes

Run Details

32447 of 72903 branches covered (44.51%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 2 files covered. (100.0%)

72 existing lines in 4 files now uncovered.

68278 of 133815 relevant lines covered (51.02%)

0.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.52

/pmd-core/src/main/java/net/sourceforge/pmd/PMDConfiguration.java

/**
 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
 */

package net.sourceforge.pmd;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Properties;

import org.checkerframework.checker.nullness.qual.NonNull;
import org.slf4j.LoggerFactory;

import net.sourceforge.pmd.cache.internal.AnalysisCache;
import net.sourceforge.pmd.cache.internal.FileAnalysisCache;
import net.sourceforge.pmd.cache.internal.NoopAnalysisCache;
import net.sourceforge.pmd.internal.util.ClasspathClassLoader;
import net.sourceforge.pmd.lang.Language;
import net.sourceforge.pmd.lang.LanguageRegistry;
import net.sourceforge.pmd.lang.LanguageVersion;
import net.sourceforge.pmd.lang.PmdCapableLanguage;
import net.sourceforge.pmd.lang.rule.RulePriority;
import net.sourceforge.pmd.lang.rule.RuleSetLoader;
import net.sourceforge.pmd.renderers.Renderer;
import net.sourceforge.pmd.renderers.RendererFactory;
import net.sourceforge.pmd.util.AssertionUtil;
import net.sourceforge.pmd.util.log.internal.SimpleMessageReporter;

/**
 * This class contains the details for the runtime configuration of a
 * PMD run. Once configured, use {@link PmdAnalysis#create(PMDConfiguration)}
 * in a try-with-resources to execute the analysis (see {@link PmdAnalysis}).
 *
 * <h2>Rulesets</h2>
 *
 * <ul>
 * <li>You can configure paths to the rulesets to use with {@link #addRuleSet(String)}.
 * These can be file paths or classpath resources.</li>
 * <li>Use {@link #setMinimumPriority(RulePriority)} to control the minimum priority a
 * rule must have to be included. Defaults to the lowest priority, ie all rules are loaded.</li>
 * </ul>
 *
 * <h2>Source files</h2>
 *
 * <ul>
 * <li>The default encoding of source files is the system default as
 * returned by <code>System.getProperty("file.encoding")</code>.
 * You can set it with {@link #setSourceEncoding(Charset)}.</li>
 * <li>The source files to analyze can be given in many ways. See
 * {@link #addInputPath(Path)} {@link #setInputFilePath(Path)}, {@link #setInputUri(URI)}.
 * <li>Files are assigned a language based on their name. The language
 * version of languages can be given with
 * {@link #setDefaultLanguageVersion(LanguageVersion)}.
 * The default language assignment can be overridden with
 * {@link #setForceLanguageVersion(LanguageVersion)}.</li>
 * </ul>
 *
 * <h2>Rendering</h2>
 *
 * <ul>
 * <li>The renderer format to use for Reports. {@link #getReportFormat()}</li>
 * <li>The file to which the Report should render. {@link #getReportFilePath()}</li>
 * <li>Configure the root paths that are used to relativize file names in reports via {@link #addRelativizeRoot(Path)}.
 * This enables to get short names in reports.</li>
 * <li>The initialization properties to use when creating a Renderer instance.
 * {@link #getReportProperties()}</li>
 * <li>An indicator of whether to show suppressed Rule violations in Reports.
 * {@link #isShowSuppressedViolations()}</li>
 * </ul>
 *
 * <h2>Language configuration</h2>
 * <ul>
 * <li>Use {@link #setSuppressMarker(String)} to change the comment marker for suppression comments. Defaults to {@value #DEFAULT_SUPPRESS_MARKER}.</li>
 * <li>See {@link #setClassLoader(ClassLoader)} and {@link #prependAuxClasspath(String)} for
 *  information for how to configure classpath for Java analysis.</li>
 * <li>You can set additional language properties with {@link #getLanguageProperties(Language)}</li>
 * </ul>
 *
 * <h2>Miscellaneous</h2>
 * <ul>
 * <li>Use {@link #setThreads(int)} to control the parallelism of the analysis. Defaults
 * one thread per available processor. {@link #getThreads()}</li>
 * </ul>
 */
public class PMDConfiguration extends AbstractConfiguration {
    private static final LanguageRegistry DEFAULT_REGISTRY = LanguageRegistry.PMD;

    /** The default suppress marker string. */
    public static final String DEFAULT_SUPPRESS_MARKER = "NOPMD";
    private Path reportFile;

    // General behavior options
    private String suppressMarker = DEFAULT_SUPPRESS_MARKER;
    private int threads = Runtime.getRuntime().availableProcessors();
    private ClassLoader classLoader = getClass().getClassLoader();

    // Rule and source file options
    private List<String> ruleSets = new ArrayList<>();
    private RulePriority minimumPriority = RulePriority.LOW;

    // Reporting options
    private String reportFormat;
    private Properties reportProperties = new Properties();
    private boolean showSuppressedViolations = false;
    private boolean failOnViolation = true;

    private AnalysisCache analysisCache = new NoopAnalysisCache();
    private boolean ignoreIncrementalAnalysis;

    public PMDConfiguration() {
        this(DEFAULT_REGISTRY);
    }

    public PMDConfiguration(@NonNull LanguageRegistry languageRegistry) {
        super(languageRegistry, new SimpleMessageReporter(LoggerFactory.getLogger(PmdAnalysis.class)));
    }

    /**
     * Get the suppress marker. This is the source level marker used to indicate
     * a RuleViolation should be suppressed.
     *
     * @return The suppress marker.
     */
    public String getSuppressMarker() {
        return suppressMarker;
    }

    /**
     * Set the suppress marker.
     *
     * @param suppressMarker
     *            The suppress marker to use.
     */
    public void setSuppressMarker(String suppressMarker) {
        Objects.requireNonNull(suppressMarker, "Suppress marker was null");
        this.suppressMarker = suppressMarker;
    }

    /**
     * Get the number of threads to use when processing Rules.
     *
     * @return The number of threads.
     */
    public int getThreads() {
        return threads;
    }

    /**
     * Set the number of threads to use when processing Rules.
     *
     * @param threads
     *            The number of threads.
     */
    public void setThreads(int threads) {
        this.threads = threads;
    }

    /**
     * Get the ClassLoader being used by PMD when processing Rules.
     *
     * @return The ClassLoader being used
     */
    public ClassLoader getClassLoader() {
        return classLoader;
    }

    /**
     * Set the ClassLoader being used by PMD when processing Rules. Setting a
     * value of <code>null</code> will cause the default ClassLoader to be used.
     *
     * @param classLoader
     *            The ClassLoader to use
     */
    public void setClassLoader(ClassLoader classLoader) {
        if (classLoader == null) {
            this.classLoader = getClass().getClassLoader();
        } else {
            this.classLoader = classLoader;
        }
    }

    /**
     * Prepend the specified classpath like string to the current ClassLoader of
     * the configuration. If no ClassLoader is currently configured, the
     * ClassLoader used to load the {@link PMDConfiguration} class will be used
     * as the parent ClassLoader of the created ClassLoader.
     *
     * <p>If the classpath String looks like a URL to a file (i.e. starts with
     * <code>file://</code>) the file will be read with each line representing
     * an entry on the classpath.</p>
     *
     * <p>You can specify multiple class paths separated by `:` on Unix-systems or `;` under Windows.
     * See {@link File#pathSeparator}.
     *
     * @param classpath The prepended classpath.
     *
     * @throws IllegalArgumentException if the given classpath is invalid (e.g. does not exist)
     * @see PMDConfiguration#setClassLoader(ClassLoader)
     */
    public void prependAuxClasspath(String classpath) {
        try {
            if (classLoader == null) {
                classLoader = PMDConfiguration.class.getClassLoader();
            }
            if (classpath != null) {
                classLoader = new ClasspathClassLoader(classpath, classLoader);
            }
        } catch (IOException e) {
            // Note: IOExceptions shouldn't appear anymore, they should already be converted
            // to IllegalArgumentException in ClasspathClassLoader.
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * Returns the list of ruleset URIs.
     *
     * @see RuleSetLoader#loadFromResource(String)
     */
    public @NonNull List<@NonNull String> getRuleSetPaths() {
        return ruleSets;
    }

    /**
     * Sets the list of ruleset paths to load when starting the analysis.
     *
     * @param ruleSetPaths A list of ruleset paths, understandable by {@link RuleSetLoader#loadFromResource(String)}.
     *
     * @throws NullPointerException If the parameter is null
     */
    public void setRuleSets(@NonNull List<@NonNull String> ruleSetPaths) {
        AssertionUtil.requireParamNotNull("ruleSetPaths", ruleSetPaths);
        AssertionUtil.requireContainsNoNullValue("ruleSetPaths", ruleSetPaths);
        this.ruleSets = new ArrayList<>(ruleSetPaths);
    }

    /**
     * Add a new ruleset paths to load when starting the analysis.
     * This list is initially empty.
     *
     * @param rulesetPath A ruleset path, understandable by {@link RuleSetLoader#loadFromResource(String)}.
     *
     * @throws NullPointerException If the parameter is null
     */
    public void addRuleSet(@NonNull String rulesetPath) {
        AssertionUtil.requireParamNotNull("rulesetPath", rulesetPath);
        this.ruleSets.add(rulesetPath);
    }

    /**
     * Get the minimum priority threshold when loading Rules from RuleSets.
     *
     * @return The minimum priority threshold.
     */
    public RulePriority getMinimumPriority() {
        return minimumPriority;
    }

    /**
     * Set the minimum priority threshold when loading Rules from RuleSets.
     *
     * @param minimumPriority
     *            The minimum priority.
     */
    public void setMinimumPriority(RulePriority minimumPriority) {
        this.minimumPriority = minimumPriority;
    }


    /**
     * Create a Renderer instance based upon the configured reporting options.
     * No writer is created.
     *
     * @return renderer
     */
    public Renderer createRenderer() {
        return createRenderer(false);
    }

    /**
     * Create a Renderer instance based upon the configured reporting options.
     * If withReportWriter then we'll configure it with a writer for the
     * reportFile specified.
     *
     * @param withReportWriter
     *            whether to configure a writer or not
     * @return A Renderer instance.
     */
    public Renderer createRenderer(boolean withReportWriter) {
        Renderer renderer = RendererFactory.createRenderer(reportFormat, reportProperties);
        renderer.setShowSuppressedViolations(showSuppressedViolations);
        if (withReportWriter) {
            renderer.setReportFile(getReportFilePath() != null ? getReportFilePath().toString() : null);
        }
        return renderer;
    }

    /**
     * Get the report format.
     *
     * @return The report format.
     */
    public String getReportFormat() {
        return reportFormat;
    }

    /**
     * Set the report format. This should be a name of a Renderer.
     *
     * @param reportFormat
     *            The report format.
     *
     * @see Renderer
     */
    public void setReportFormat(String reportFormat) {
        this.reportFormat = reportFormat;
    }

    /**
     * Get whether the report should show suppressed violations.
     *
     * @return <code>true</code> if showing suppressed violations,
     *         <code>false</code> otherwise.
     */
    public boolean isShowSuppressedViolations() {
        return showSuppressedViolations;
    }

    /**
     * Set whether the report should show suppressed violations.
     *
     * @param showSuppressedViolations
     *            <code>true</code> if showing suppressed violations,
     *            <code>false</code> otherwise.
     */
    public void setShowSuppressedViolations(boolean showSuppressedViolations) {
        this.showSuppressedViolations = showSuppressedViolations;
    }

    /**
     * Get the Report properties. These are used to create the Renderer.
     *
     * @return The report properties.
     */
    public Properties getReportProperties() {
        return reportProperties;
    }

    /**
     * Set the Report properties. These are used to create the Renderer.
     *
     * @param reportProperties
     *            The Report properties to set.
     */
    public void setReportProperties(Properties reportProperties) {
        this.reportProperties = reportProperties;
    }

    /**
     * Whether PMD should exit with status 4 (the default behavior, true) if
     * violations are found or just with 0 (to not break the build, e.g.).
     *
     * @return failOnViolation
     */
    public boolean isFailOnViolation() {
        return failOnViolation;
    }

    /**
     * Sets whether PMD should exit with status 4 (the default behavior, true)
     * if violations are found or just with 0 (to not break the build, e.g.).
     *
     * @param failOnViolation
     *            failOnViolation
     */
    public void setFailOnViolation(boolean failOnViolation) {
        this.failOnViolation = failOnViolation;
    }

    /**
     * Retrieves the currently used analysis cache. Will never be null.
     *
     * @return The currently used analysis cache. Never null.
     *
     * @apiNote This is internal API.
     */
    AnalysisCache getAnalysisCache() {
        // Make sure we are not null
        if (analysisCache == null || isIgnoreIncrementalAnalysis() && !(analysisCache instanceof NoopAnalysisCache)) {
            // sets a noop cache
            setAnalysisCache(new NoopAnalysisCache());
        }

        return analysisCache;
    }

    /**
     * Sets the analysis cache to be used. Setting a
     * value of {@code null} will cause a Noop AnalysisCache to be used.
     * If incremental analysis was explicitly disabled ({@link #isIgnoreIncrementalAnalysis()}),
     * then this method is a noop.
     *
     * @param cache The analysis cache to be used.
     *
     * @apiNote This is internal API. Use {@link #setAnalysisCacheLocation(String)} to configure a cache.
     */
    void setAnalysisCache(final AnalysisCache cache) {
        // the doc says it's a noop if incremental analysis was disabled,
        // but it's actually the getter that enforces that
        this.analysisCache = cache == null ? new NoopAnalysisCache() : cache;
    }

    /**
     * Sets the location of the analysis cache to be used. This will automatically configure
     * and appropriate AnalysisCache implementation. Setting a
     * value of {@code null} will cause a Noop AnalysisCache to be used.
     * If incremental analysis was explicitly disabled ({@link #isIgnoreIncrementalAnalysis()}),
     * then this method is a noop.
     *
     * @param cacheLocation The location of the analysis cache to be used. Use {@code null}
     *                      to disable the cache.
     */
    public void setAnalysisCacheLocation(final String cacheLocation) {
        setAnalysisCache(cacheLocation == null
                         ? new NoopAnalysisCache()
                         : new FileAnalysisCache(new File(cacheLocation)));
    }


    /**
     * Sets whether the user has explicitly disabled incremental analysis or not.
     * If so, incremental analysis is not used, and all suggestions to use it are
     * disabled. The analysis cached location is ignored, even if it's specified.
     *
     * @param noCache Whether to ignore incremental analysis or not
     */
    public void setIgnoreIncrementalAnalysis(boolean noCache) {
        // see #getAnalysisCache for the implementation.
        this.ignoreIncrementalAnalysis = noCache;
    }


    /**
     * Returns whether incremental analysis was explicitly disabled by the user
     * or not.
     *
     * @return {@code true} if incremental analysis is explicitly disabled
     */
    public boolean isIgnoreIncrementalAnalysis() {
        return ignoreIncrementalAnalysis;
    }

    /**
     * Get the file to which the report should render.
     *
     * @return The file to which to render.
     */
    public Path getReportFilePath() {
        return reportFile;
    }

    /**
     * Set the file to which the report should render.
     *
     * @param reportFile the file to set
     */
    public void setReportFile(Path reportFile) {
        this.reportFile = reportFile;
    }

    @Override
    protected void checkLanguageIsAcceptable(Language lang) throws UnsupportedOperationException {
        if (!(lang instanceof PmdCapableLanguage)) {
            throw new UnsupportedOperationException("Language " + lang.getId() + " does not support analysis with PMD and cannot be used in a PMDConfiguration. "
                + "You may be able to use it with CPD though.");
        }
    }
}

1	/**
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd;
6
7	import java.io.File;
8	import java.io.IOException;
9	import java.net.URI;
10	import java.nio.charset.Charset;
11	import java.nio.file.Path;
12	import java.util.ArrayList;
13	import java.util.List;
14	import java.util.Objects;
15	import java.util.Properties;
16
17	import org.checkerframework.checker.nullness.qual.NonNull;
18	import org.slf4j.LoggerFactory;
19
20	import net.sourceforge.pmd.cache.internal.AnalysisCache;
21	import net.sourceforge.pmd.cache.internal.FileAnalysisCache;
22	import net.sourceforge.pmd.cache.internal.NoopAnalysisCache;
23	import net.sourceforge.pmd.internal.util.ClasspathClassLoader;
24	import net.sourceforge.pmd.lang.Language;
25	import net.sourceforge.pmd.lang.LanguageRegistry;
26	import net.sourceforge.pmd.lang.LanguageVersion;
27	import net.sourceforge.pmd.lang.PmdCapableLanguage;
28	import net.sourceforge.pmd.lang.rule.RulePriority;
29	import net.sourceforge.pmd.lang.rule.RuleSetLoader;
30	import net.sourceforge.pmd.renderers.Renderer;
31	import net.sourceforge.pmd.renderers.RendererFactory;
32	import net.sourceforge.pmd.util.AssertionUtil;
33	import net.sourceforge.pmd.util.log.internal.SimpleMessageReporter;
34
35	/**
36	* This class contains the details for the runtime configuration of a
37	* PMD run. Once configured, use {@link PmdAnalysis#create(PMDConfiguration)}
38	* in a try-with-resources to execute the analysis (see {@link PmdAnalysis}).
39	*
40	* <h2>Rulesets</h2>
41	*
42	* <ul>
43	* <li>You can configure paths to the rulesets to use with {@link #addRuleSet(String)}.
44	* These can be file paths or classpath resources.</li>
45	* <li>Use {@link #setMinimumPriority(RulePriority)} to control the minimum priority a
46	* rule must have to be included. Defaults to the lowest priority, ie all rules are loaded.</li>
47	* </ul>
48	*
49	* <h2>Source files</h2>
50	*
51	* <ul>
52	* <li>The default encoding of source files is the system default as
53	* returned by <code>System.getProperty("file.encoding")</code>.
54	* You can set it with {@link #setSourceEncoding(Charset)}.</li>
55	* <li>The source files to analyze can be given in many ways. See
56	* {@link #addInputPath(Path)} {@link #setInputFilePath(Path)}, {@link #setInputUri(URI)}.
57	* <li>Files are assigned a language based on their name. The language
58	* version of languages can be given with
59	* {@link #setDefaultLanguageVersion(LanguageVersion)}.
60	* The default language assignment can be overridden with
61	* {@link #setForceLanguageVersion(LanguageVersion)}.</li>
62	* </ul>
63	*
64	* <h2>Rendering</h2>
65	*
66	* <ul>
67	* <li>The renderer format to use for Reports. {@link #getReportFormat()}</li>
68	* <li>The file to which the Report should render. {@link #getReportFilePath()}</li>
69	* <li>Configure the root paths that are used to relativize file names in reports via {@link #addRelativizeRoot(Path)}.
70	* This enables to get short names in reports.</li>
71	* <li>The initialization properties to use when creating a Renderer instance.
72	* {@link #getReportProperties()}</li>
73	* <li>An indicator of whether to show suppressed Rule violations in Reports.
74	* {@link #isShowSuppressedViolations()}</li>
75	* </ul>
76	*
77	* <h2>Language configuration</h2>
78	* <ul>
79	* <li>Use {@link #setSuppressMarker(String)} to change the comment marker for suppression comments. Defaults to {@value #DEFAULT_SUPPRESS_MARKER}.</li>
80	* <li>See {@link #setClassLoader(ClassLoader)} and {@link #prependAuxClasspath(String)} for
81	* information for how to configure classpath for Java analysis.</li>
82	* <li>You can set additional language properties with {@link #getLanguageProperties(Language)}</li>
83	* </ul>
84	*
85	* <h2>Miscellaneous</h2>
86	* <ul>
87	* <li>Use {@link #setThreads(int)} to control the parallelism of the analysis. Defaults
88	* one thread per available processor. {@link #getThreads()}</li>
89	* </ul>
90	*/
91	public class PMDConfiguration extends AbstractConfiguration {
92	private static final LanguageRegistry DEFAULT_REGISTRY = LanguageRegistry.PMD;	1✔
93
94	/** The default suppress marker string. */
95	public static final String DEFAULT_SUPPRESS_MARKER = "NOPMD";
96	private Path reportFile;
97
98	// General behavior options
99	private String suppressMarker = DEFAULT_SUPPRESS_MARKER;	1✔
100	private int threads = Runtime.getRuntime().availableProcessors();	1✔
101	private ClassLoader classLoader = getClass().getClassLoader();	1✔
102
103	// Rule and source file options
104	private List<String> ruleSets = new ArrayList<>();	1✔
105	private RulePriority minimumPriority = RulePriority.LOW;	1✔
106
107	// Reporting options
108	private String reportFormat;
109	private Properties reportProperties = new Properties();	1✔
110	private boolean showSuppressedViolations = false;	1✔
111	private boolean failOnViolation = true;	1✔
112
113	private AnalysisCache analysisCache = new NoopAnalysisCache();	1✔
114	private boolean ignoreIncrementalAnalysis;
115
116	public PMDConfiguration() {
117	this(DEFAULT_REGISTRY);	1✔
118	}	1✔
119
120	public PMDConfiguration(@NonNull LanguageRegistry languageRegistry) {
121	super(languageRegistry, new SimpleMessageReporter(LoggerFactory.getLogger(PmdAnalysis.class)));	1✔
122	}	1✔
123
124	/**
125	* Get the suppress marker. This is the source level marker used to indicate
126	* a RuleViolation should be suppressed.
127	*
128	* @return The suppress marker.
129	*/
130	public String getSuppressMarker() {
131	return suppressMarker;	1✔
132	}
133
134	/**
135	* Set the suppress marker.
136	*
137	* @param suppressMarker
138	* The suppress marker to use.
139	*/
140	public void setSuppressMarker(String suppressMarker) {
141	Objects.requireNonNull(suppressMarker, "Suppress marker was null");	1✔
142	this.suppressMarker = suppressMarker;	1✔
143	}	1✔
144
145	/**
146	* Get the number of threads to use when processing Rules.
147	*
148	* @return The number of threads.
149	*/
150	public int getThreads() {
151	return threads;	1✔
152	}
153
154	/**
155	* Set the number of threads to use when processing Rules.
156	*
157	* @param threads
158	* The number of threads.
159	*/
160	public void setThreads(int threads) {
161	this.threads = threads;	1✔
162	}	1✔
163
164	/**
165	* Get the ClassLoader being used by PMD when processing Rules.
166	*
167	* @return The ClassLoader being used
168	*/
169	public ClassLoader getClassLoader() {
170	return classLoader;	1✔
171	}
172
173	/**
174	* Set the ClassLoader being used by PMD when processing Rules. Setting a
175	* value of <code>null</code> will cause the default ClassLoader to be used.
176	*
177	* @param classLoader
178	* The ClassLoader to use
179	*/
180	public void setClassLoader(ClassLoader classLoader) {
181	if (classLoader == null) {	1!
182	this.classLoader = getClass().getClassLoader();	1✔
183	} else {
UNCOV 184	this.classLoader = classLoader;	×
185	}
186	}	1✔
187
188	/**
189	* Prepend the specified classpath like string to the current ClassLoader of
190	* the configuration. If no ClassLoader is currently configured, the
191	* ClassLoader used to load the {@link PMDConfiguration} class will be used
192	* as the parent ClassLoader of the created ClassLoader.
193	*
194	* <p>If the classpath String looks like a URL to a file (i.e. starts with
195	* <code>file://</code>) the file will be read with each line representing
196	* an entry on the classpath.</p>
197	*
198	* <p>You can specify multiple class paths separated by `:` on Unix-systems or `;` under Windows.
199	* See {@link File#pathSeparator}.
200	*
201	* @param classpath The prepended classpath.
202	*
203	* @throws IllegalArgumentException if the given classpath is invalid (e.g. does not exist)
204	* @see PMDConfiguration#setClassLoader(ClassLoader)
205	*/
206	public void prependAuxClasspath(String classpath) {
207	try {
208	if (classLoader == null) {	1!
UNCOV 209	classLoader = PMDConfiguration.class.getClassLoader();	×
210	}
211	if (classpath != null) {	1!
212	classLoader = new ClasspathClassLoader(classpath, classLoader);	1✔
213	}
UNCOV 214	} catch (IOException e) {	×
215	// Note: IOExceptions shouldn't appear anymore, they should already be converted
216	// to IllegalArgumentException in ClasspathClassLoader.
UNCOV 217	throw new IllegalArgumentException(e);	×
218	}	1✔
219	}	1✔
220
221	/**
222	* Returns the list of ruleset URIs.
223	*
224	* @see RuleSetLoader#loadFromResource(String)
225	*/
226	public @NonNull List<@NonNull String> getRuleSetPaths() {
227	return ruleSets;	1✔
228	}
229
230	/**
231	* Sets the list of ruleset paths to load when starting the analysis.
232	*
233	* @param ruleSetPaths A list of ruleset paths, understandable by {@link RuleSetLoader#loadFromResource(String)}.
234	*
235	* @throws NullPointerException If the parameter is null
236	*/
237	public void setRuleSets(@NonNull List<@NonNull String> ruleSetPaths) {
238	AssertionUtil.requireParamNotNull("ruleSetPaths", ruleSetPaths);	1✔
239	AssertionUtil.requireContainsNoNullValue("ruleSetPaths", ruleSetPaths);	1✔
240	this.ruleSets = new ArrayList<>(ruleSetPaths);	1✔
241	}	1✔
242
243	/**
244	* Add a new ruleset paths to load when starting the analysis.
245	* This list is initially empty.
246	*
247	* @param rulesetPath A ruleset path, understandable by {@link RuleSetLoader#loadFromResource(String)}.
248	*
249	* @throws NullPointerException If the parameter is null
250	*/
251	public void addRuleSet(@NonNull String rulesetPath) {
252	AssertionUtil.requireParamNotNull("rulesetPath", rulesetPath);	1✔
253	this.ruleSets.add(rulesetPath);	1✔
254	}	1✔
255
256	/**
257	* Get the minimum priority threshold when loading Rules from RuleSets.
258	*
259	* @return The minimum priority threshold.
260	*/
261	public RulePriority getMinimumPriority() {
262	return minimumPriority;	1✔
263	}
264
265	/**
266	* Set the minimum priority threshold when loading Rules from RuleSets.
267	*
268	* @param minimumPriority
269	* The minimum priority.
270	*/
271	public void setMinimumPriority(RulePriority minimumPriority) {
272	this.minimumPriority = minimumPriority;	1✔
273	}	1✔
274
275
276	/**
277	* Create a Renderer instance based upon the configured reporting options.
278	* No writer is created.
279	*
280	* @return renderer
281	*/
282	public Renderer createRenderer() {
283	return createRenderer(false);	1✔
284	}
285
286	/**
287	* Create a Renderer instance based upon the configured reporting options.
288	* If withReportWriter then we'll configure it with a writer for the
289	* reportFile specified.
290	*
291	* @param withReportWriter
292	* whether to configure a writer or not
293	* @return A Renderer instance.
294	*/
295	public Renderer createRenderer(boolean withReportWriter) {
296	Renderer renderer = RendererFactory.createRenderer(reportFormat, reportProperties);	1✔
297	renderer.setShowSuppressedViolations(showSuppressedViolations);	1✔
298	if (withReportWriter) {	1!
UNCOV 299	renderer.setReportFile(getReportFilePath() != null ? getReportFilePath().toString() : null);	×
300	}
301	return renderer;	1✔
302	}
303
304	/**
305	* Get the report format.
306	*
307	* @return The report format.
308	*/
309	public String getReportFormat() {
310	return reportFormat;	1✔
311	}
312
313	/**
314	* Set the report format. This should be a name of a Renderer.
315	*
316	* @param reportFormat
317	* The report format.
318	*
319	* @see Renderer
320	*/
321	public void setReportFormat(String reportFormat) {
322	this.reportFormat = reportFormat;	1✔
323	}	1✔
324
325	/**
326	* Get whether the report should show suppressed violations.
327	*
328	* @return <code>true</code> if showing suppressed violations,
329	* <code>false</code> otherwise.
330	*/
331	public boolean isShowSuppressedViolations() {
332	return showSuppressedViolations;	1✔
333	}
334
335	/**
336	* Set whether the report should show suppressed violations.
337	*
338	* @param showSuppressedViolations
339	* <code>true</code> if showing suppressed violations,
340	* <code>false</code> otherwise.
341	*/
342	public void setShowSuppressedViolations(boolean showSuppressedViolations) {
343	this.showSuppressedViolations = showSuppressedViolations;	1✔
344	}	1✔
345
346	/**
347	* Get the Report properties. These are used to create the Renderer.
348	*
349	* @return The report properties.
350	*/
351	public Properties getReportProperties() {
352	return reportProperties;	1✔
353	}
354
355	/**
356	* Set the Report properties. These are used to create the Renderer.
357	*
358	* @param reportProperties
359	* The Report properties to set.
360	*/
361	public void setReportProperties(Properties reportProperties) {
362	this.reportProperties = reportProperties;	1✔
363	}	1✔
364
365	/**
366	* Whether PMD should exit with status 4 (the default behavior, true) if
367	* violations are found or just with 0 (to not break the build, e.g.).
368	*
369	* @return failOnViolation
370	*/
371	public boolean isFailOnViolation() {
UNCOV 372	return failOnViolation;	×
373	}
374
375	/**
376	* Sets whether PMD should exit with status 4 (the default behavior, true)
377	* if violations are found or just with 0 (to not break the build, e.g.).
378	*
379	* @param failOnViolation
380	* failOnViolation
381	*/
382	public void setFailOnViolation(boolean failOnViolation) {
383	this.failOnViolation = failOnViolation;	×
UNCOV 384	}	×
385
386	/**
387	* Retrieves the currently used analysis cache. Will never be null.
388	*
389	* @return The currently used analysis cache. Never null.
390	*
391	* @apiNote This is internal API.
392	*/
393	AnalysisCache getAnalysisCache() {
394	// Make sure we are not null
395	if (analysisCache == null \|\| isIgnoreIncrementalAnalysis() && !(analysisCache instanceof NoopAnalysisCache)) {	1!
396	// sets a noop cache
397	setAnalysisCache(new NoopAnalysisCache());	1✔
398	}
399
400	return analysisCache;	1✔
401	}
402
403	/**
404	* Sets the analysis cache to be used. Setting a
405	* value of {@code null} will cause a Noop AnalysisCache to be used.
406	* If incremental analysis was explicitly disabled ({@link #isIgnoreIncrementalAnalysis()}),
407	* then this method is a noop.
408	*
409	* @param cache The analysis cache to be used.
410	*
411	* @apiNote This is internal API. Use {@link #setAnalysisCacheLocation(String)} to configure a cache.
412	*/
413	void setAnalysisCache(final AnalysisCache cache) {
414	// the doc says it's a noop if incremental analysis was disabled,
415	// but it's actually the getter that enforces that
416	this.analysisCache = cache == null ? new NoopAnalysisCache() : cache;	1✔
417	}	1✔
418
419	/**
420	* Sets the location of the analysis cache to be used. This will automatically configure
421	* and appropriate AnalysisCache implementation. Setting a
422	* value of {@code null} will cause a Noop AnalysisCache to be used.
423	* If incremental analysis was explicitly disabled ({@link #isIgnoreIncrementalAnalysis()}),
424	* then this method is a noop.
425	*
426	* @param cacheLocation The location of the analysis cache to be used. Use {@code null}
427	* to disable the cache.
428	*/
429	public void setAnalysisCacheLocation(final String cacheLocation) {
430	setAnalysisCache(cacheLocation == null	1✔
431	? new NoopAnalysisCache()	1✔
432	: new FileAnalysisCache(new File(cacheLocation)));	1✔
433	}	1✔
434
435
436	/**
437	* Sets whether the user has explicitly disabled incremental analysis or not.
438	* If so, incremental analysis is not used, and all suggestions to use it are
439	* disabled. The analysis cached location is ignored, even if it's specified.
440	*
441	* @param noCache Whether to ignore incremental analysis or not
442	*/
443	public void setIgnoreIncrementalAnalysis(boolean noCache) {
444	// see #getAnalysisCache for the implementation.
445	this.ignoreIncrementalAnalysis = noCache;	1✔
446	}	1✔
447
448
449	/**
450	* Returns whether incremental analysis was explicitly disabled by the user
451	* or not.
452	*
453	* @return {@code true} if incremental analysis is explicitly disabled
454	*/
455	public boolean isIgnoreIncrementalAnalysis() {
456	return ignoreIncrementalAnalysis;	1✔
457	}
458
459	/**
460	* Get the file to which the report should render.
461	*
462	* @return The file to which to render.
463	*/
464	public Path getReportFilePath() {
UNCOV 465	return reportFile;	×
466	}
467
468	/**
469	* Set the file to which the report should render.
470	*
471	* @param reportFile the file to set
472	*/
473	public void setReportFile(Path reportFile) {
474	this.reportFile = reportFile;	×
UNCOV 475	}	×
476
477	@Override
478	protected void checkLanguageIsAcceptable(Language lang) throws UnsupportedOperationException {
479	if (!(lang instanceof PmdCapableLanguage)) {	1✔
480	throw new UnsupportedOperationException("Language " + lang.getId() + " does not support analysis with PMD and cannot be used in a PMDConfiguration. "	1✔
481	+ "You may be able to use it with CPD though.");
482	}
483	}	1✔
484	}

pmd / pmd / #3999

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous