src/main/java/org/apache/maven/plugin/compiler/DiagnosticLogger.java

/*
 * 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.
 */
package org.apache.maven.plugin.compiler;

import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.JavaFileObject;

import java.nio.file.Path;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;

import org.apache.maven.api.plugin.Log;
import org.apache.maven.api.services.MessageBuilder;
import org.apache.maven.api.services.MessageBuilderFactory;

/**
 * A Java compiler diagnostic listener which send the messages to the Maven logger.
 *
 * @author Martin Desruisseaux
 */
final class DiagnosticLogger implements DiagnosticListener<JavaFileObject> {
    /**
     * The logger where to send diagnostics.
     */
    private final Log logger;

    /**
     * The factory for creating message builders.
     */
    private final MessageBuilderFactory messageBuilderFactory;

    /**
     * The locale for compiler message.
     */
    private final Locale locale;

    /**
     * The base directory with which to relativize the paths to source files.
     */
    private final Path directory;

    /**
     * Number of errors or warnings.
     */
    private int numErrors, numWarnings;

    /**
     * Number of messages received for each code.
     */
    private final Map<String, Integer> codeCount;

    /**
     * The first error, or {@code null} if none.
     */
    private String firstError;

    /**
     * Creates a listener which will send the diagnostics to the given logger.
     *
     * @param logger the logger where to send diagnostics
     * @param messageBuilderFactory the factory for creating message builders
     * @param locale the locale for compiler message
     * @param directory the base directory with which to relativize the paths to source files
     */
    DiagnosticLogger(Log logger, MessageBuilderFactory messageBuilderFactory, Locale locale, Path directory) {
        this.logger = logger;
        this.messageBuilderFactory = messageBuilderFactory;
        this.locale = locale;
        this.directory = directory;
        codeCount = new LinkedHashMap<>();
    }

    /**
     * Makes the given file relative to the base directory.
     *
     * @param  file  the path to make relative to the base directory
     * @return the given path, potentially relative to the base directory
     */
    private String relativize(String file) {
        try {
            return directory.relativize(Path.of(file)).toString();
        } catch (IllegalArgumentException e) {
            // Ignore, keep the absolute path.
            return file;
        }
    }

    /**
     * Invoked when the compiler emitted a warning.
     *
     * @param diagnostic the warning emitted by the Java compiler
     */
    @Override
    public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
        String message = diagnostic.getMessage(locale);
        if (message == null || message.isBlank()) {
            return;
        }
        MessageBuilder record = messageBuilderFactory.builder();
        record.a(message);
        JavaFileObject source = diagnostic.getSource();
        Diagnostic.Kind kind = diagnostic.getKind();
        String style;
        switch (kind) {
            case ERROR:
                style = ".error:-bold,f:red";
                break;
            case MANDATORY_WARNING:
            case WARNING:
                style = ".warning:-bold,f:yellow";
                break;
            default:
                style = ".info:-bold,f:blue";
                if (diagnostic.getLineNumber() == Diagnostic.NOPOS) {
                    source = null; // Some messages are generic, e.g. "Recompile with -Xlint:deprecation".
                }
                break;
        }
        if (source != null) {
            record.newline().a("    at ").a(relativize(source.getName()));
            long line = diagnostic.getLineNumber();
            long column = diagnostic.getColumnNumber();
            if (line != Diagnostic.NOPOS || column != Diagnostic.NOPOS) {
                record.style(style).a('[');
                if (line != Diagnostic.NOPOS) {
                    record.a(line);
                }
                if (column != Diagnostic.NOPOS) {
                    record.a(',').a(column);
                }
                record.a(']').resetStyle();
            }
        }
        String log = record.toString();
        switch (kind) {
            case ERROR:
                if (firstError == null) {
                    firstError = message;
                }
                logger.error(log);
                numErrors++;
                break;
            case MANDATORY_WARNING:
            case WARNING:
                logger.warn(log);
                numWarnings++;
                break;
            default:
                logger.info(log);
                break;
        }
        // Statistics
        String code = diagnostic.getCode();
        if (code != null) {
            codeCount.merge(code, 1, (old, initial) -> old + 1);
        }
    }

    /**
     * Returns the first error, if any.
     *
     * @param cause if compilation failed with an exception, the cause
     */
    Optional<String> firstError(Exception cause) {
        return Optional.ofNullable(cause != null && firstError == null ? cause.getMessage() : firstError);
    }

    /**
     * Reports summary after the compilation finished.
     */
    void logSummary() {
        MessageBuilder message = messageBuilderFactory.builder();
        final String patternForCount;
        if (!codeCount.isEmpty()) {
            @SuppressWarnings("unchecked")
            Map.Entry<String, Integer>[] entries = codeCount.entrySet().toArray(Map.Entry[]::new);
            Arrays.sort(entries, (a, b) -> Integer.compare(b.getValue(), a.getValue()));
            patternForCount = patternForCount(Math.max(entries[0].getValue(), Math.max(numWarnings, numErrors)));
            message.strong("Summary of compiler messages:").newline();
            for (Map.Entry<String, Integer> entry : entries) {
                int count = entry.getValue();
                message.format(patternForCount, count, entry.getKey()).newline();
            }
        } else {
            patternForCount = patternForCount(Math.max(numWarnings, numErrors));
        }
        if ((numWarnings | numErrors) != 0) {
            message.strong("Total:");
        }
        if (numWarnings != 0) {
            writeCount(message, patternForCount, numWarnings, "warning");
        }
        if (numErrors != 0) {
            writeCount(message, patternForCount, numErrors, "error");
        }
        logger.info(message.toString());
    }

    /**
     * {@return the pattern for formatting the specified number followed by a label}
     * The given number should be the widest number to format.
     * A margin of 4 spaces is added at the beginning of the line.
     */
    private static String patternForCount(int n) {
        return "    %" + Integer.toString(n).length() + "d %s";
    }

    /**
     * Appends the count of warnings or errors, making them plural if needed.
     */
    private static void writeCount(MessageBuilder message, String patternForCount, int count, String name) {
        message.newline();
        message.format(patternForCount, count, name);
        if (count > 1) {
            message.append('s');
        }
    }
}