#4067

Committed 27 Jun 2024 12:49PM UTC coverage: 48.909% (+0.01%) from 48.897%

Build # #4067

Build Type

push

github

Committed by

adangel

Commit Message

[java] Make impl of ASTLiteral#getLiteralText() public (#5078)

Merge pull request #5078 from adangel:issue-4885-method-should-be-accessible

Run Details

31782 of 71137 branches covered (44.68%)

Branch coverage included in aggregate %.

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

121 existing lines in 10 files now uncovered.

67828 of 132528 relevant lines covered (51.18%)

0.52 hits per line

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

97.03

/pmd-core/src/main/java/net/sourceforge/pmd/reporting/Report.java

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

package net.sourceforge.pmd.reporting;

import static java.util.Collections.synchronizedList;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

import net.sourceforge.pmd.PmdAnalysis;
import net.sourceforge.pmd.lang.document.FileId;
import net.sourceforge.pmd.lang.document.TextFile;
import net.sourceforge.pmd.lang.rule.Rule;
import net.sourceforge.pmd.util.BaseResultProducingCloseable;

/**
 * A {@link Report} collects all information during a PMD execution. This includes violations,
 * suppressed violations, metrics, recoverable errors (that occurred during processing)
 * and configuration errors.
 *
 * <p>A report may be created by a {@link GlobalReportBuilderListener} that you
 * use as the {@linkplain GlobalAnalysisListener} in {@link PmdAnalysis#performAnalysisAndCollectReport() PMD's entry point}.
 * You can also create one manually with {@link #buildReport(Consumer)}.
 *
 * <p>For special use cases, like filtering the report after PMD analysis and
 * before rendering the report, some transformation operations are provided:
 * <ul>
 *     <li>{@link #filterViolations(Predicate)}</li>
 *     <li>{@link #union(Report)}</li>
 * </ul>
 * These methods create a new {@link Report} rather than modifying their receiver.
 *
 */
public final class Report {
    private final List<RuleViolation> violations = synchronizedList(new ArrayList<>());
    private final List<SuppressedViolation> suppressedRuleViolations = synchronizedList(new ArrayList<>());
    private final List<ProcessingError> errors = synchronizedList(new ArrayList<>());
    private final List<ConfigurationError> configErrors = synchronizedList(new ArrayList<>());

    private Report() {
        // constructor is private
    }

    /**
     * Represents a configuration error for a specific rule.
     *
     * <p>This might be a missing rule property
     * or rule property with pointless values.
     */
    public static class ConfigurationError {

        private final Rule rule;
        private final String issue;

        /**
         * Creates a new configuration error for a specific rule.
         *
         * @param theRule
         *            the rule which is configured wrongly
         * @param theIssue
         *            the reason, why the configuration is wrong
         */
        public ConfigurationError(Rule theRule, String theIssue) {
            rule = theRule;
            issue = theIssue;
        }

        /**
         * Gets the wrongly configured rule.
         *
         * @return the wrongly configured rule
         */
        public Rule rule() {
            return rule;
        }

        /**
         * Gets the reason for the configuration error.
         *
         * @return the issue
         */
        public String issue() {
            return issue;
        }
    }

    /**
     * Represents a recovered error that occurred during analysis.
     *
     * <p>This might be a parse error or an unexpected error originating from a rule.
     * Such errors are called recoverable, because PMD can just skip
     * the problematic file, continue the analysis with the other files and still create a report.
     * However, due to these errors, the report might be incomplete.
     *
     * <p>Some report formats, such as {@link net.sourceforge.pmd.renderers.XMLRenderer}, include these
     * errors for further investigation.
     */
    public static class ProcessingError {

        private final Throwable error;
        private final FileId file;

        /**
         * Creates a new processing error.
         *
         * @param error
         *            the error
         * @param file
         *            the file during which the error occurred
         */
        public ProcessingError(Throwable error, FileId file) {
            this.error = error;
            this.file = file;
        }

        public String getMsg() {
            return error.getClass().getSimpleName() + ": " + error.getMessage();
        }

        public String getDetail() {
            try (StringWriter stringWriter = new StringWriter();
                 PrintWriter writer = new PrintWriter(stringWriter)) {
                error.printStackTrace(writer);
                return stringWriter.toString();
            } catch (IOException e) {
                // IOException on close - should never happen when using StringWriter
                throw new RuntimeException(e);
            }
        }

        public FileId getFileId() {
            return file;
        }

        public Throwable getError() {
            return error;
        }
    }

    /**
     * Represents a violation, that has been suppressed.
     */
    public static class SuppressedViolation {

        private final RuleViolation rv;
        private final String userMessage;
        private final ViolationSuppressor suppressor;

        /**
         * Creates a suppressed violation.
         *
         * @param rv          The violation, that has been suppressed
         * @param suppressor  The suppressor which suppressed the violation
         * @param userMessage Any relevant info given by the suppressor
         */
        public SuppressedViolation(RuleViolation rv, ViolationSuppressor suppressor, String userMessage) {
            this.suppressor = suppressor;
            this.rv = rv;
            this.userMessage = userMessage;
        }

        public ViolationSuppressor getSuppressor() {
            return suppressor;
        }

        public RuleViolation getRuleViolation() {
            return this.rv;
        }

        public String getUserMessage() {
            return userMessage;
        }
    }

    /**
     * Adds a new rule violation to the report and notify the listeners.
     *
     * @param violation the violation to add
     */
    private void addRuleViolation(RuleViolation violation) {
        synchronized (violations) {
            // note that this binary search is inefficient as we usually
            // report violations file by file.
            int index = Collections.binarySearch(violations, violation, RuleViolation.DEFAULT_COMPARATOR);
            violations.add(index < 0 ? -index - 1 : index, violation);
        }
    }

    /**
     * Adds a new suppressed violation.
     */
    private void addSuppressedViolation(SuppressedViolation sv) {
        suppressedRuleViolations.add(sv);
    }

    /**
     * Adds a new configuration error to the report.
     *
     * @param error the error to add
     */
    private void addConfigError(ConfigurationError error) {
        configErrors.add(error);
    }

    /**
     * Adds a new processing error to the report.
     *
     * @param error the error to add
     */
    private void addError(ProcessingError error) {
        errors.add(error);
    }

    /**
     * Returns an unmodifiable list of violations that were suppressed.
     */
    public List<SuppressedViolation> getSuppressedViolations() {
        return Collections.unmodifiableList(suppressedRuleViolations);
    }

    /**
     * Returns an unmodifiable list of violations that have been
     * recorded until now. None of those violations were suppressed.
     *
     * <p>The violations list is sorted with {@link RuleViolation#DEFAULT_COMPARATOR}.
     */
    public List<RuleViolation> getViolations() {
        return Collections.unmodifiableList(violations);
    }


    /**
     * Returns an unmodifiable list of processing errors that have been
     * recorded until now.
     */
    public List<ProcessingError> getProcessingErrors() {
        return Collections.unmodifiableList(errors);
    }


    /**
     * Returns an unmodifiable list of configuration errors that have
     * been recorded until now.
     */
    public List<ConfigurationError> getConfigurationErrors() {
        return Collections.unmodifiableList(configErrors);
    }

    /**
     * Create a report by making side effects on a {@link FileAnalysisListener}.
     * This wraps a {@link ReportBuilderListener}.
     */
    public static Report buildReport(Consumer<? super FileAnalysisListener> lambda) {
        return BaseResultProducingCloseable.using(new ReportBuilderListener(), lambda);
    }

    /**
     * A {@link FileAnalysisListener} that accumulates events into a
     * {@link Report}.
     */
    public static final class ReportBuilderListener extends BaseResultProducingCloseable<Report> implements FileAnalysisListener {

        private final Report report;

        public ReportBuilderListener() {
            this(new Report());
        }

        ReportBuilderListener(Report report) {
            this.report = report;
        }

        @Override
        protected Report getResultImpl() {
            return report;
        }

        @Override
        public void onRuleViolation(RuleViolation violation) {
            report.addRuleViolation(violation);
        }

        @Override
        public void onSuppressedRuleViolation(SuppressedViolation violation) {
            report.addSuppressedViolation(violation);
        }

        @Override
        public void onError(ProcessingError error) {
            report.addError(error);
        }

        @Override
        public String toString() {
            return "ReportBuilderListener";
        }
    }

    /**
     * A {@link GlobalAnalysisListener} that accumulates the events of
     * all files into a {@link Report}.
     */
    public static final class GlobalReportBuilderListener extends BaseResultProducingCloseable<Report> implements GlobalAnalysisListener {

        private final Report report = new Report();

        @Override
        public FileAnalysisListener startFileAnalysis(TextFile file) {
            // note that the report is shared, but Report is now thread-safe
            return new ReportBuilderListener(this.report);
        }

        @Override
        public void onConfigError(ConfigurationError error) {
            report.addConfigError(error);
        }

        @Override
        public Report getResultImpl() {
            return report;
        }
    }

    /**
     * Creates a new report taking all the information from this report,
     * but filtering the violations.
     *
     * @param filter when true, the violation will be kept.
     * @return copy of this report
     */
    public Report filterViolations(Predicate<RuleViolation> filter) {
        Report copy = new Report();

        for (RuleViolation violation : violations) {
            if (filter.test(violation)) {
                copy.addRuleViolation(violation);
            }
        }

        copy.suppressedRuleViolations.addAll(suppressedRuleViolations);
        copy.errors.addAll(errors);
        copy.configErrors.addAll(configErrors);
        return copy;
    }

    /**
     * Creates a new report by combining this report with another report.
     * The lowest start time and greatest end time are kept in the copy.
     *
     * @param other the other report to combine
     * @return a new report which is the combination of this and the other report.
     */
    public Report union(Report other) {
        Report copy = new Report();

        for (RuleViolation violation : violations) {
            copy.addRuleViolation(violation);
        }
        for (RuleViolation violation : other.violations) {
            copy.addRuleViolation(violation);
        }

        copy.suppressedRuleViolations.addAll(suppressedRuleViolations);
        copy.suppressedRuleViolations.addAll(other.suppressedRuleViolations);

        copy.errors.addAll(errors);
        copy.errors.addAll(other.errors);
        copy.configErrors.addAll(configErrors);
        copy.configErrors.addAll(other.configErrors);

        return copy;
    }
}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.reporting;
6
7	import static java.util.Collections.synchronizedList;
8
9	import java.io.IOException;
10	import java.io.PrintWriter;
11	import java.io.StringWriter;
12	import java.util.ArrayList;
13	import java.util.Collections;
14	import java.util.List;
15	import java.util.function.Consumer;
16	import java.util.function.Predicate;
17
18	import net.sourceforge.pmd.PmdAnalysis;
19	import net.sourceforge.pmd.lang.document.FileId;
20	import net.sourceforge.pmd.lang.document.TextFile;
21	import net.sourceforge.pmd.lang.rule.Rule;
22	import net.sourceforge.pmd.util.BaseResultProducingCloseable;
23
24	/**
25	* A {@link Report} collects all information during a PMD execution. This includes violations,
26	* suppressed violations, metrics, recoverable errors (that occurred during processing)
27	* and configuration errors.
28	*
29	* <p>A report may be created by a {@link GlobalReportBuilderListener} that you
30	* use as the {@linkplain GlobalAnalysisListener} in {@link PmdAnalysis#performAnalysisAndCollectReport() PMD's entry point}.
31	* You can also create one manually with {@link #buildReport(Consumer)}.
32	*
33	* <p>For special use cases, like filtering the report after PMD analysis and
34	* before rendering the report, some transformation operations are provided:
35	* <ul>
36	* <li>{@link #filterViolations(Predicate)}</li>
37	* <li>{@link #union(Report)}</li>
38	* </ul>
39	* These methods create a new {@link Report} rather than modifying their receiver.
40	*
41	*/
42	public final class Report {
43	private final List<RuleViolation> violations = synchronizedList(new ArrayList<>());	1✔
44	private final List<SuppressedViolation> suppressedRuleViolations = synchronizedList(new ArrayList<>());	1✔
45	private final List<ProcessingError> errors = synchronizedList(new ArrayList<>());	1✔
46	private final List<ConfigurationError> configErrors = synchronizedList(new ArrayList<>());	1✔
47
48	private Report() {	1✔
49	// constructor is private
50	}	1✔
51
52	/**
53	* Represents a configuration error for a specific rule.
54	*
55	* <p>This might be a missing rule property
56	* or rule property with pointless values.
57	*/
58	public static class ConfigurationError {
59
60	private final Rule rule;
61	private final String issue;
62
63	/**
64	* Creates a new configuration error for a specific rule.
65	*
66	* @param theRule
67	* the rule which is configured wrongly
68	* @param theIssue
69	* the reason, why the configuration is wrong
70	*/
71	public ConfigurationError(Rule theRule, String theIssue) {	1✔
72	rule = theRule;	1✔
73	issue = theIssue;	1✔
74	}	1✔
75
76	/**
77	* Gets the wrongly configured rule.
78	*
79	* @return the wrongly configured rule
80	*/
81	public Rule rule() {
82	return rule;	1✔
83	}
84
85	/**
86	* Gets the reason for the configuration error.
87	*
88	* @return the issue
89	*/
90	public String issue() {
91	return issue;	1✔
92	}
93	}
94
95	/**
96	* Represents a recovered error that occurred during analysis.
97	*
98	* <p>This might be a parse error or an unexpected error originating from a rule.
99	* Such errors are called recoverable, because PMD can just skip
100	* the problematic file, continue the analysis with the other files and still create a report.
101	* However, due to these errors, the report might be incomplete.
102	*
103	* <p>Some report formats, such as {@link net.sourceforge.pmd.renderers.XMLRenderer}, include these
104	* errors for further investigation.
105	*/
106	public static class ProcessingError {
107
108	private final Throwable error;
109	private final FileId file;
110
111	/**
112	* Creates a new processing error.
113	*
114	* @param error
115	* the error
116	* @param file
117	* the file during which the error occurred
118	*/
119	public ProcessingError(Throwable error, FileId file) {	1✔
120	this.error = error;	1✔
121	this.file = file;	1✔
122	}	1✔
123
124	public String getMsg() {
125	return error.getClass().getSimpleName() + ": " + error.getMessage();	1✔
126	}
127
128	public String getDetail() {
129	try (StringWriter stringWriter = new StringWriter();	1✔
130	PrintWriter writer = new PrintWriter(stringWriter)) {	1✔
131	error.printStackTrace(writer);	1✔
132	return stringWriter.toString();	1✔
UNCOV 133	} catch (IOException e) {	×
134	// IOException on close - should never happen when using StringWriter
UNCOV 135	throw new RuntimeException(e);	×
136	}
137	}
138
139	public FileId getFileId() {
140	return file;	1✔
141	}
142
143	public Throwable getError() {
144	return error;	1✔
145	}
146	}
147
148	/**
149	* Represents a violation, that has been suppressed.
150	*/
151	public static class SuppressedViolation {
152
153	private final RuleViolation rv;
154	private final String userMessage;
155	private final ViolationSuppressor suppressor;
156
157	/**
158	* Creates a suppressed violation.
159	*
160	* @param rv The violation, that has been suppressed
161	* @param suppressor The suppressor which suppressed the violation
162	* @param userMessage Any relevant info given by the suppressor
163	*/
164	public SuppressedViolation(RuleViolation rv, ViolationSuppressor suppressor, String userMessage) {	1✔
165	this.suppressor = suppressor;	1✔
166	this.rv = rv;	1✔
167	this.userMessage = userMessage;	1✔
168	}	1✔
169
170	public ViolationSuppressor getSuppressor() {
171	return suppressor;	1✔
172	}
173
174	public RuleViolation getRuleViolation() {
175	return this.rv;	1✔
176	}
177
178	public String getUserMessage() {
179	return userMessage;	1✔
180	}
181	}
182
183	/**
184	* Adds a new rule violation to the report and notify the listeners.
185	*
186	* @param violation the violation to add
187	*/
188	private void addRuleViolation(RuleViolation violation) {
189	synchronized (violations) {	1✔
190	// note that this binary search is inefficient as we usually
191	// report violations file by file.
192	int index = Collections.binarySearch(violations, violation, RuleViolation.DEFAULT_COMPARATOR);	1✔
193	violations.add(index < 0 ? -index - 1 : index, violation);	1✔
194	}	1✔
195	}	1✔
196
197	/**
198	* Adds a new suppressed violation.
199	*/
200	private void addSuppressedViolation(SuppressedViolation sv) {
201	suppressedRuleViolations.add(sv);	1✔
202	}	1✔
203
204	/**
205	* Adds a new configuration error to the report.
206	*
207	* @param error the error to add
208	*/
209	private void addConfigError(ConfigurationError error) {
210	configErrors.add(error);	1✔
211	}	1✔
212
213	/**
214	* Adds a new processing error to the report.
215	*
216	* @param error the error to add
217	*/
218	private void addError(ProcessingError error) {
219	errors.add(error);	1✔
220	}	1✔
221
222	/**
223	* Returns an unmodifiable list of violations that were suppressed.
224	*/
225	public List<SuppressedViolation> getSuppressedViolations() {
226	return Collections.unmodifiableList(suppressedRuleViolations);	1✔
227	}
228
229	/**
230	* Returns an unmodifiable list of violations that have been
231	* recorded until now. None of those violations were suppressed.
232	*
233	* <p>The violations list is sorted with {@link RuleViolation#DEFAULT_COMPARATOR}.
234	*/
235	public List<RuleViolation> getViolations() {
236	return Collections.unmodifiableList(violations);	1✔
237	}
238
239
240	/**
241	* Returns an unmodifiable list of processing errors that have been
242	* recorded until now.
243	*/
244	public List<ProcessingError> getProcessingErrors() {
245	return Collections.unmodifiableList(errors);	1✔
246	}
247
248
249	/**
250	* Returns an unmodifiable list of configuration errors that have
251	* been recorded until now.
252	*/
253	public List<ConfigurationError> getConfigurationErrors() {
254	return Collections.unmodifiableList(configErrors);	1✔
255	}
256
257	/**
258	* Create a report by making side effects on a {@link FileAnalysisListener}.
259	* This wraps a {@link ReportBuilderListener}.
260	*/
261	public static Report buildReport(Consumer<? super FileAnalysisListener> lambda) {
262	return BaseResultProducingCloseable.using(new ReportBuilderListener(), lambda);	1✔
263	}
264
265	/**
266	* A {@link FileAnalysisListener} that accumulates events into a
267	* {@link Report}.
268	*/
269	public static final class ReportBuilderListener extends BaseResultProducingCloseable<Report> implements FileAnalysisListener {
270
271	private final Report report;
272
273	public ReportBuilderListener() {
274	this(new Report());	1✔
275	}	1✔
276
277	ReportBuilderListener(Report report) {	1✔
278	this.report = report;	1✔
279	}	1✔
280
281	@Override
282	protected Report getResultImpl() {
283	return report;	1✔
284	}
285
286	@Override
287	public void onRuleViolation(RuleViolation violation) {
288	report.addRuleViolation(violation);	1✔
289	}	1✔
290
291	@Override
292	public void onSuppressedRuleViolation(SuppressedViolation violation) {
293	report.addSuppressedViolation(violation);	1✔
294	}	1✔
295
296	@Override
297	public void onError(ProcessingError error) {
298	report.addError(error);	1✔
299	}	1✔
300
301	@Override
302	public String toString() {
UNCOV 303	return "ReportBuilderListener";	×
304	}
305	}
306
307	/**
308	* A {@link GlobalAnalysisListener} that accumulates the events of
309	* all files into a {@link Report}.
310	*/
311	public static final class GlobalReportBuilderListener extends BaseResultProducingCloseable<Report> implements GlobalAnalysisListener {	1✔
312
313	private final Report report = new Report();	1✔
314
315	@Override
316	public FileAnalysisListener startFileAnalysis(TextFile file) {
317	// note that the report is shared, but Report is now thread-safe
318	return new ReportBuilderListener(this.report);	1✔
319	}
320
321	@Override
322	public void onConfigError(ConfigurationError error) {
323	report.addConfigError(error);	1✔
324	}	1✔
325
326	@Override
327	public Report getResultImpl() {
328	return report;	1✔
329	}
330	}
331
332	/**
333	* Creates a new report taking all the information from this report,
334	* but filtering the violations.
335	*
336	* @param filter when true, the violation will be kept.
337	* @return copy of this report
338	*/
339	public Report filterViolations(Predicate<RuleViolation> filter) {
340	Report copy = new Report();	1✔
341
342	for (RuleViolation violation : violations) {	1✔
343	if (filter.test(violation)) {	1✔
344	copy.addRuleViolation(violation);	1✔
345	}
346	}	1✔
347
348	copy.suppressedRuleViolations.addAll(suppressedRuleViolations);	1✔
349	copy.errors.addAll(errors);	1✔
350	copy.configErrors.addAll(configErrors);	1✔
351	return copy;	1✔
352	}
353
354	/**
355	* Creates a new report by combining this report with another report.
356	* The lowest start time and greatest end time are kept in the copy.
357	*
358	* @param other the other report to combine
359	* @return a new report which is the combination of this and the other report.
360	*/
361	public Report union(Report other) {
362	Report copy = new Report();	1✔
363
364	for (RuleViolation violation : violations) {	1✔
365	copy.addRuleViolation(violation);	1✔
366	}	1✔
367	for (RuleViolation violation : other.violations) {	1✔
368	copy.addRuleViolation(violation);	1✔
369	}	1✔
370
371	copy.suppressedRuleViolations.addAll(suppressedRuleViolations);	1✔
372	copy.suppressedRuleViolations.addAll(other.suppressedRuleViolations);	1✔
373
374	copy.errors.addAll(errors);	1✔
375	copy.errors.addAll(other.errors);	1✔
376	copy.configErrors.addAll(configErrors);	1✔
377	copy.configErrors.addAll(other.configErrors);	1✔
378
379	return copy;	1✔
380	}
381	}

pmd / pmd / #4067

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