#4158

Committed 27 Oct 2024 06:40PM UTC coverage: 61.191% (-0.008%) from 61.199%

Build # #4158

Build Type

push

github

Committed by

web-flow

Commit Message

[ant] Formatter: avoid reflective access to determine console encoding (#5286)

Run Details

17435 of 28013 branches covered (62.24%)

Branch coverage included in aggregate %.

0 of 22 new or added lines in 1 file covered. (0.0%)

2 existing lines in 1 file now uncovered.

39195 of 64534 relevant lines covered (60.74%)

0.61 hits per line

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

56.05

/pmd-ant/src/main/java/net/sourceforge/pmd/ant/Formatter.java

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

package net.sourceforge.pmd.ant;

import java.io.BufferedWriter;
import java.io.Console;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.apache.commons.lang3.StringUtils;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.Parameter;

import net.sourceforge.pmd.internal.util.IOUtil;
import net.sourceforge.pmd.lang.document.TextFile;
import net.sourceforge.pmd.renderers.Renderer;
import net.sourceforge.pmd.renderers.RendererFactory;
import net.sourceforge.pmd.reporting.FileAnalysisListener;
import net.sourceforge.pmd.reporting.FileNameRenderer;
import net.sourceforge.pmd.reporting.GlobalAnalysisListener;
import net.sourceforge.pmd.reporting.ListenerInitializer;

/**
 * Part of PMD Ant task configuration. Setters of this class are interpreted by Ant as properties
 * settable in the XML. This is therefore published API.
 *
 * <p>This class is used to configure a specific {@link Renderer} for outputting the violations. This is called
 * a formatter in PMD Ant task configuration and might look like this:
 *
 * <pre>{@code
 * <pmd>
 *   <formatter type="html" toFile="${build}/pmd_report.html"/>
 * </pmd>
 * }</pre>
 *
 * @see PMDTask#addFormatter(Formatter)
 */
public class Formatter {

    private File toFile;
    private String type;
    private boolean toConsole;
    private boolean showSuppressed;
    private final List<Parameter> parameters = new ArrayList<>();
    private Writer writer;
    private Renderer renderer;

    public void setShowSuppressed(boolean value) {
        this.showSuppressed = value;
    }

    public void setType(String type) {
        this.type = type;
    }

    public void setToFile(File toFile) {
        this.toFile = toFile;
    }

    public void setToConsole(boolean toConsole) {
        this.toConsole = toConsole;
    }

    public void addConfiguredParam(Parameter parameter) {
        this.parameters.add(parameter);
    }

    private void start(String baseDir) {

        Properties properties = createProperties();

        Charset charset;
        {
            String s = (String) properties.get("encoding");
            if (null == s) {

                if (toConsole) {
                    s = getConsoleEncoding();
                    if (null == s) {
                        s = System.getProperty("file.encoding");
                    }
                }

                if (null == s) {
                    charset = StandardCharsets.UTF_8;
                } else {
                    charset = Charset.forName(s);
                }

                // Configures the encoding for the renderer.
                final Parameter parameter = new Parameter();
                parameter.setName("encoding");
                parameter.setValue(charset.name());
                parameters.add(parameter);
            } else {
                charset = Charset.forName(s);
            }
        }

        try {
            if (toConsole) {
                writer = new BufferedWriter(new OutputStreamWriter(System.out, charset));
            }
            if (toFile != null) {
                writer = getToFileWriter(baseDir, toFile, charset);
            }
            renderer = createRenderer();
            renderer.setWriter(writer);
        } catch (IOException ioe) {
            throw new BuildException(ioe.getMessage(), ioe);
        }
    }

    boolean isNoOutputSupplied() {
        return toFile == null && !toConsole;
    }

    @Override
    public String toString() {
        return "file = " + toFile + "; renderer = " + type;
    }

    private static String[] validRendererCodes() {
        return RendererFactory.supportedRenderers().toArray(new String[0]);
    }

    private static String unknownRendererMessage(String userSpecifiedType) {
        String[] typeCodes = validRendererCodes();
        StringBuilder sb = new StringBuilder(100);
        sb.append("Formatter type must be one of: '").append(typeCodes[0]);
        for (int i = 1; i < typeCodes.length; i++) {
            sb.append("', '").append(typeCodes[i]);
        }
        sb.append("', or a class name; you specified: ").append(userSpecifiedType);
        return sb.toString();
    }

    Renderer createRenderer() {
        if (StringUtils.isBlank(type)) {
            throw new BuildException(unknownRendererMessage("<unspecified>"));
        }

        Properties properties = createProperties();
        Renderer renderer = RendererFactory.createRenderer(type, properties);
        renderer.setShowSuppressedViolations(showSuppressed);
        return renderer;
    }

    private Properties createProperties() {
        Properties properties = new Properties();
        for (Parameter parameter : parameters) {
            properties.put(parameter.getName(), parameter.getValue());
        }
        return properties;
    }

    private static Writer getToFileWriter(String baseDir, File toFile, Charset charset) throws IOException {
        final File file;
        if (toFile.isAbsolute()) {
            file = toFile;
        } else {
            file = new File(baseDir + System.getProperty("file.separator") + toFile.getPath());
        }

        OutputStream output = null;
        Writer writer = null;
        boolean isOnError = true;
        try {
            output = Files.newOutputStream(file.toPath());
            writer = new BufferedWriter(new OutputStreamWriter(output, charset));
            isOnError = false;
        } finally {
            if (isOnError) {
                IOUtil.closeQuietly(output);
                IOUtil.closeQuietly(writer);
            }
        }
        return writer;
    }

    private static String getConsoleEncoding() {
        Console console = System.console();
        // in case of pipe or redirect, no interactive console, we get null
        if (console != null) {
            // Since Java 22, this returns a console even for redirected streams.
            // In that case, we need to check Console.isTerminal()
            // https://docs.oracle.com/en/java/javase/22/docs/api/java.base/java/io/Console.html#isTerminal()
            // See: JLine As The Default Console Provider (JDK-8308591)
            try {
                Method method = Console.class.getMethod("isTerminal");
                Object isTerminal = method.invoke(console);
                if (isTerminal instanceof Boolean && !(Boolean) isTerminal) {
                    // stop here, we don't have an interactive console.
                    return null;
                }
            } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException ignored) {
                // fall-through - we use a Java Runtime < 22.
            }

            // Maybe this is Java17+? Then there will be a public method charset()
            // https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/Console.html#charset()
            try {
                Method method = Console.class.getMethod("charset");
                Object charset = method.invoke(console);
                if (charset instanceof Charset) {
                    return ((Charset) charset).name();
                }
            } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException ignored) {
                // fall-through
            }

            {
                // try to use the system property "sun.jnu.encoding", which is the platform encoding.
                // this property is not specified and might not always be available, but it is for
                // openjdk 11: https://github.com/openjdk/jdk11u/blob/cee8535a9d3de8558b4b5028d68e397e508bef71/src/java.base/share/native/libjava/System.c#L384
                // if it exists, we use it - this avoids illegal reflective access below.
                String jnuEncoding = System.getProperty("sun.jnu.encoding");
                if (jnuEncoding != null) {
                    return jnuEncoding;
                }
            }

            // the following parts are accessing private/protected fields via reflection
            // this should work with Java 8 and 11. With Java 11, you'll see warnings abouts
            // illegal reflective access, see #1860. However, the access still works.

            // Fall-Back 1: private field "cs" in java.io.Console
            try {
                Field field = Console.class.getDeclaredField("cs");
                field.setAccessible(true);
                Object csField = field.get(console);
                if (csField instanceof Charset) {
                    return ((Charset) csField).name();
                }
            } catch (IllegalArgumentException | ReflectiveOperationException ignored) {
                // fall-through
            }

            // Fall-Back 2: private native method "encoding()" in java.io.Console
            try {
                Method method = Console.class.getDeclaredMethod("encoding");
                method.setAccessible(true);
                Object encoding = method.invoke(console);
                if (encoding instanceof String) {
                    return (String) encoding;
                }
            } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException ignored) {
                // fall-through
            }
        }
        // we couldn't determine the correct platform console encoding
        return null;
    }

    GlobalAnalysisListener newListener(Project project) throws IOException {
        start(project.getBaseDir().toString());
        return new GlobalAnalysisListener() {
            final GlobalAnalysisListener listener = renderer.newListener();

            @Override
            public ListenerInitializer initializer() {
                return new ListenerInitializer() {
                    @Override
                    public void setFileNameRenderer(FileNameRenderer fileNameRenderer) {
                        renderer.setFileNameRenderer(fileNameRenderer);
                    }
                };
            }

            @Override
            public FileAnalysisListener startFileAnalysis(TextFile file) {
                return listener.startFileAnalysis(file);
            }

            @Override
            public void close() throws Exception {
                listener.close();
                if (!toConsole) {
                    writer.close();
                }
            }
        };
    }
}

1	/**
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.ant;
6
7	import java.io.BufferedWriter;
8	import java.io.Console;
9	import java.io.File;
10	import java.io.IOException;
11	import java.io.OutputStream;
12	import java.io.OutputStreamWriter;
13	import java.io.Writer;
14	import java.lang.reflect.Field;
15	import java.lang.reflect.InvocationTargetException;
16	import java.lang.reflect.Method;
17	import java.nio.charset.Charset;
18	import java.nio.charset.StandardCharsets;
19	import java.nio.file.Files;
20	import java.util.ArrayList;
21	import java.util.List;
22	import java.util.Properties;
23
24	import org.apache.commons.lang3.StringUtils;
25	import org.apache.tools.ant.BuildException;
26	import org.apache.tools.ant.Project;
27	import org.apache.tools.ant.types.Parameter;
28
29	import net.sourceforge.pmd.internal.util.IOUtil;
30	import net.sourceforge.pmd.lang.document.TextFile;
31	import net.sourceforge.pmd.renderers.Renderer;
32	import net.sourceforge.pmd.renderers.RendererFactory;
33	import net.sourceforge.pmd.reporting.FileAnalysisListener;
34	import net.sourceforge.pmd.reporting.FileNameRenderer;
35	import net.sourceforge.pmd.reporting.GlobalAnalysisListener;
36	import net.sourceforge.pmd.reporting.ListenerInitializer;
37
38	/**
39	* Part of PMD Ant task configuration. Setters of this class are interpreted by Ant as properties
40	* settable in the XML. This is therefore published API.
41	*
42	* <p>This class is used to configure a specific {@link Renderer} for outputting the violations. This is called
43	* a formatter in PMD Ant task configuration and might look like this:
44	*
45	* <pre>{@code
46	* <pmd>
47	* <formatter type="html" toFile="${build}/pmd_report.html"/>
48	* </pmd>
49	* }</pre>
50	*
51	* @see PMDTask#addFormatter(Formatter)
52	*/
53	public class Formatter {	1✔
54
55	private File toFile;
56	private String type;
57	private boolean toConsole;
58	private boolean showSuppressed;
59	private final List<Parameter> parameters = new ArrayList<>();	1✔
60	private Writer writer;
61	private Renderer renderer;
62
63	public void setShowSuppressed(boolean value) {
64	this.showSuppressed = value;	×
65	}	×
66
67	public void setType(String type) {
68	this.type = type;	1✔
69	}	1✔
70
71	public void setToFile(File toFile) {
72	this.toFile = toFile;	1✔
73	}	1✔
74
75	public void setToConsole(boolean toConsole) {
76	this.toConsole = toConsole;	1✔
77	}	1✔
78
79	public void addConfiguredParam(Parameter parameter) {
80	this.parameters.add(parameter);	×
81	}	×
82
83	private void start(String baseDir) {
84
85	Properties properties = createProperties();	1✔
86
87	Charset charset;
88	{
89	String s = (String) properties.get("encoding");	1✔
90	if (null == s) {	1!
91
92	if (toConsole) {	1✔
93	s = getConsoleEncoding();	1✔
94	if (null == s) {	1!
95	s = System.getProperty("file.encoding");	1✔
96	}
97	}
98
99	if (null == s) {	1✔
100	charset = StandardCharsets.UTF_8;	1✔
101	} else {
102	charset = Charset.forName(s);	1✔
103	}
104
105	// Configures the encoding for the renderer.
106	final Parameter parameter = new Parameter();	1✔
107	parameter.setName("encoding");	1✔
108	parameter.setValue(charset.name());	1✔
109	parameters.add(parameter);	1✔
110	} else {	1✔
111	charset = Charset.forName(s);	×
112	}
113	}
114
115	try {
116	if (toConsole) {	1✔
117	writer = new BufferedWriter(new OutputStreamWriter(System.out, charset));	1✔
118	}
119	if (toFile != null) {	1✔
120	writer = getToFileWriter(baseDir, toFile, charset);	1✔
121	}
122	renderer = createRenderer();	1✔
123	renderer.setWriter(writer);	1✔
124	} catch (IOException ioe) {	×
125	throw new BuildException(ioe.getMessage(), ioe);	×
126	}	1✔
127	}	1✔
128
129	boolean isNoOutputSupplied() {
130	return toFile == null && !toConsole;	1!
131	}
132
133	@Override
134	public String toString() {
135	return "file = " + toFile + "; renderer = " + type;	1✔
136	}
137
138	private static String[] validRendererCodes() {
139	return RendererFactory.supportedRenderers().toArray(new String[0]);	×
140	}
141
142	private static String unknownRendererMessage(String userSpecifiedType) {
143	String[] typeCodes = validRendererCodes();	×
144	StringBuilder sb = new StringBuilder(100);	×
145	sb.append("Formatter type must be one of: '").append(typeCodes[0]);	×
146	for (int i = 1; i < typeCodes.length; i++) {	×
147	sb.append("', '").append(typeCodes[i]);	×
148	}
149	sb.append("', or a class name; you specified: ").append(userSpecifiedType);	×
150	return sb.toString();	×
151	}
152
153	Renderer createRenderer() {
154	if (StringUtils.isBlank(type)) {	1!
155	throw new BuildException(unknownRendererMessage("<unspecified>"));	×
156	}
157
158	Properties properties = createProperties();	1✔
159	Renderer renderer = RendererFactory.createRenderer(type, properties);	1✔
160	renderer.setShowSuppressedViolations(showSuppressed);	1✔
161	return renderer;	1✔
162	}
163
164	private Properties createProperties() {
165	Properties properties = new Properties();	1✔
166	for (Parameter parameter : parameters) {	1✔
167	properties.put(parameter.getName(), parameter.getValue());	1✔
168	}	1✔
169	return properties;	1✔
170	}
171
172	private static Writer getToFileWriter(String baseDir, File toFile, Charset charset) throws IOException {
173	final File file;
174	if (toFile.isAbsolute()) {	1!
175	file = toFile;	1✔
176	} else {
177	file = new File(baseDir + System.getProperty("file.separator") + toFile.getPath());	×
178	}
179
180	OutputStream output = null;	1✔
181	Writer writer = null;	1✔
182	boolean isOnError = true;	1✔
183	try {
184	output = Files.newOutputStream(file.toPath());	1✔
185	writer = new BufferedWriter(new OutputStreamWriter(output, charset));	1✔
186	isOnError = false;	1✔
187	} finally {
188	if (isOnError) {	1!
189	IOUtil.closeQuietly(output);	×
190	IOUtil.closeQuietly(writer);	×
191	}
192	}
193	return writer;	1✔
194	}
195
196	private static String getConsoleEncoding() {
197	Console console = System.console();	1✔
198	// in case of pipe or redirect, no interactive console, we get null
199	if (console != null) {	1!
200	// Since Java 22, this returns a console even for redirected streams.
201	// In that case, we need to check Console.isTerminal()
202	// https://docs.oracle.com/en/java/javase/22/docs/api/java.base/java/io/Console.html#isTerminal()
203	// See: JLine As The Default Console Provider (JDK-8308591)
204	try {
NEW 205	Method method = Console.class.getMethod("isTerminal");	×
NEW 206	Object isTerminal = method.invoke(console);	×
NEW 207	if (isTerminal instanceof Boolean && !(Boolean) isTerminal) {	×
208	// stop here, we don't have an interactive console.
209	return null;	×
210	}
211	} catch (InvocationTargetException \| NoSuchMethodException \| IllegalAccessException ignored) {	×
212	// fall-through - we use a Java Runtime < 22.
213	}	×
214
215	// Maybe this is Java17+? Then there will be a public method charset()
216	// https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/Console.html#charset()
217	try {
NEW 218	Method method = Console.class.getMethod("charset");	×
NEW 219	Object charset = method.invoke(console);	×
NEW 220	if (charset instanceof Charset) {	×
NEW 221	return ((Charset) charset).name();	×
222	}
NEW 223	} catch (InvocationTargetException \| NoSuchMethodException \| IllegalAccessException ignored) {	×
224	// fall-through
225	}	×
226
227	{
228	// try to use the system property "sun.jnu.encoding", which is the platform encoding.
229	// this property is not specified and might not always be available, but it is for
230	// openjdk 11: https://github.com/openjdk/jdk11u/blob/cee8535a9d3de8558b4b5028d68e397e508bef71/src/java.base/share/native/libjava/System.c#L384
231	// if it exists, we use it - this avoids illegal reflective access below.
NEW 232	String jnuEncoding = System.getProperty("sun.jnu.encoding");	×
NEW 233	if (jnuEncoding != null) {	×
NEW 234	return jnuEncoding;	×
235	}
236	}
237
238	// the following parts are accessing private/protected fields via reflection
239	// this should work with Java 8 and 11. With Java 11, you'll see warnings abouts
240	// illegal reflective access, see #1860. However, the access still works.
241
242	// Fall-Back 1: private field "cs" in java.io.Console
243	try {
NEW 244	Field field = Console.class.getDeclaredField("cs");	×
NEW 245	field.setAccessible(true);	×
NEW 246	Object csField = field.get(console);	×
NEW 247	if (csField instanceof Charset) {	×
NEW 248	return ((Charset) csField).name();	×
249	}
UNCOV 250	} catch (IllegalArgumentException \| ReflectiveOperationException ignored) {	×
251	// fall-through
UNCOV 252	}	×
253
254	// Fall-Back 2: private native method "encoding()" in java.io.Console
255	try {
NEW 256	Method method = Console.class.getDeclaredMethod("encoding");	×
NEW 257	method.setAccessible(true);	×
NEW 258	Object encoding = method.invoke(console);	×
NEW 259	if (encoding instanceof String) {	×
NEW 260	return (String) encoding;	×
261	}
NEW 262	} catch (InvocationTargetException \| NoSuchMethodException \| IllegalAccessException ignored) {	×
263	// fall-through
264	}	×
265	}
266	// we couldn't determine the correct platform console encoding
267	return null;	1✔
268	}
269
270	GlobalAnalysisListener newListener(Project project) throws IOException {
271	start(project.getBaseDir().toString());	1✔
272	return new GlobalAnalysisListener() {	1✔
273	final GlobalAnalysisListener listener = renderer.newListener();	1✔
274
275	@Override
276	public ListenerInitializer initializer() {
277	return new ListenerInitializer() {	1✔
278	@Override
279	public void setFileNameRenderer(FileNameRenderer fileNameRenderer) {
280	renderer.setFileNameRenderer(fileNameRenderer);	1✔
281	}	1✔
282	};
283	}
284
285	@Override
286	public FileAnalysisListener startFileAnalysis(TextFile file) {
287	return listener.startFileAnalysis(file);	1✔
288	}
289
290	@Override
291	public void close() throws Exception {
292	listener.close();	1✔
293	if (!toConsole) {	1✔
294	writer.close();	1✔
295	}
296	}	1✔
297	};
298	}
299	}

pmd / pmd / #4158

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