src/vogar/Console.java

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed 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 vogar;

import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import vogar.util.MarkResetConsole;

/**
 * Controls, formats and emits output to the command line. This class emits
 * output in two modes:
 * <ul>
 *   <li><strong>Streaming</strong> output prints as it is received, but cannot
 *       support multiple concurrent output streams.
 *   <li><strong>Multiplexing</strong> buffers output until it is complete and
 *       then prints it completely.
 * </ul>
 */
public abstract class Console implements Log {
    static final long DAY_MILLIS = 1000 * 60 * 60 * 24;
    static final long HOUR_MILLIS = 1000 * 60 * 60;
    static final long WARNING_HOURS = 12;
    static final long FAILURE_HOURS = 48;

    private boolean useColor;
    private boolean ansi;
    private boolean verbose;
    protected String indent;
    protected CurrentLine currentLine = CurrentLine.NEW;
    protected final MarkResetConsole out = new MarkResetConsole(System.out);
    protected MarkResetConsole.Mark currentVerboseMark;
    protected MarkResetConsole.Mark currentStreamMark;

    private Console() {}

    public void setIndent(String indent) {
        this.indent = indent;
    }

    public void setUseColor(
      boolean useColor, int passColor, int skipColor, int failColor, int warnColor) {
        this.useColor = useColor;
        Color.PASS.setCode(passColor);
        Color.SKIP.setCode(skipColor);
        Color.FAIL.setCode(failColor);
        Color.WARN.setCode(warnColor);
        Color.COMMENT.setCode(34);
    }

    public void setAnsi(boolean ansi) {
        this.ansi = ansi;
    }

    public void setVerbose(boolean verbose) {
        this.verbose = verbose;
    }

    public boolean isVerbose() {
        return verbose;
    }

    public synchronized void verbose(String s) {
        /*
         * terminal does't support overwriting output, so don't print
         * verbose message unless requested.
         */
        if (!verbose && !ansi) {
            return;
        }
        /*
         * When writing verbose output in the middle of streamed output, keep
         * the streamed mark location. That way we can remove the verbose output
         * later without losing our position mid-line in the streamed output.
         */
        MarkResetConsole.Mark savedStreamMark = currentLine == CurrentLine.STREAMED_OUTPUT
                ? out.mark()
                : currentStreamMark;
        newLine();
        currentStreamMark = savedStreamMark;

        currentVerboseMark = out.mark();
        out.print(s);
        currentLine = CurrentLine.VERBOSE;
    }

    public synchronized void warn(String message) {
        warn(message, Collections.<String>emptyList());
    }

    /**
     * Warns, and also puts a list of strings afterwards.
     */
    public synchronized void warn(String message, List<String> list) {
        newLine();
        out.println(colorString("Warning: " + message, Color.WARN));
        for (String item : list) {
            out.println(colorString(indent + item, Color.WARN));
        }
    }

    public synchronized void info(String s) {
        newLine();
        out.println(s);
    }

    public synchronized void info(String message, Throwable throwable) {
        newLine();
        out.println(message);
        throwable.printStackTrace(System.out);
    }

    /**
     * Begins streaming output for the named action.
     */
    public void action(String name) {}

    /**
     * Begins streaming output for the named outcome.
     */
    public void outcome(String name) {}

    /**
     * Appends the action output immediately to the stream when streaming is on,
     * or to a buffer when streaming is off. Buffered output will be held and
     * printed only if the outcome is unsuccessful.
     */
    public abstract void streamOutput(String outcomeName, String output);

    /**
     * Hook to flush anything streamed via {@link #streamOutput}.
     */
    protected void flushBufferedOutput(String outcomeName) {}

    /**
     * Writes the action's outcome.
     */
    public synchronized void printResult(
            String outcomeName, Result result, ResultValue resultValue, Expectation expectation) {
        // when the result is interesting, include the description and bug number
        if (result != Result.SUCCESS || resultValue != ResultValue.OK) {
            if (!expectation.getDescription().isEmpty()) {
                streamOutput(outcomeName, "\n" + colorString(expectation.getDescription(), Color.COMMENT));
            }
            if (expectation.getBug() != -1) {
                streamOutput(outcomeName, "\n" + colorString("http://b/" + expectation.getBug(), Color.COMMENT));
            }
        }

        flushBufferedOutput(outcomeName);

        if (currentLine == CurrentLine.NAME) {
            out.print(" ");
        } else {
            newLine(); // TODO: backup the cursor up to the name if there's no streaming output
            out.print(indent + outcomeName + " ");
        }

        if (resultValue == ResultValue.OK) {
            out.println(colorString("OK (" + result + ")", Color.PASS));
        } else if (resultValue == ResultValue.FAIL) {
            out.println(colorString("FAIL (" + result + ")", Color.FAIL));
        } else if (resultValue == ResultValue.IGNORE) {
            out.println(colorString("SKIP (" + result + ")", Color.WARN));
        }

        currentLine = CurrentLine.NEW;
    }

    public synchronized void summarizeOutcomes(Collection<AnnotatedOutcome> annotatedOutcomes) {
        List<AnnotatedOutcome> annotatedOutcomesSorted =
                AnnotatedOutcome.ORDER_BY_NAME.sortedCopy(annotatedOutcomes);

        List<String> failures = Lists.newArrayList();
        List<String> skips = Lists.newArrayList();
        List<String> successes = Lists.newArrayList();
        List<String> warnings = Lists.newArrayList();

        // figure out whether each outcome is noteworthy, and add a message to the appropriate list
        for (AnnotatedOutcome annotatedOutcome : annotatedOutcomesSorted) {
            if (!annotatedOutcome.isNoteworthy()) {
                continue;
            }

            Color color;
            List<String> list;
            ResultValue resultValue = annotatedOutcome.getResultValue();
            if (resultValue == ResultValue.OK) {
                color = Color.PASS;
                list = successes;
            } else if (resultValue == ResultValue.FAIL) {
                color = Color.FAIL;
                list = failures;
            } else if (resultValue == ResultValue.WARNING) {
                color = Color.WARN;
                list = warnings;
            } else {
                color = Color.SKIP;
                list = skips;
            }

            Long lastRun = annotatedOutcome.lastRun(null);
            String timestamp;
            if (lastRun == null) {
                timestamp = colorString("unknown", Color.WARN);
            } else {
                timestamp = formatElapsedTime(new Date().getTime() - lastRun);
            }

            String brokeThisMessage = "";
            ResultValue mostRecentResultValue = annotatedOutcome.getMostRecentResultValue(null);
            if (mostRecentResultValue != null && resultValue != mostRecentResultValue) {
                if (resultValue == ResultValue.OK) {
                    brokeThisMessage = colorString(" (you might have fixed this)", Color.WARN);
                } else {
                    brokeThisMessage = colorString(" (you might have broken this)", Color.WARN);
                }
            } else if (mostRecentResultValue == null) {
                brokeThisMessage = colorString(" (no test history available)", Color.WARN);
            }

            List<ResultValue> previousResultValues = annotatedOutcome.getPreviousResultValues();
            int numPreviousResultValues = previousResultValues.size();
            int numResultValuesToShow = Math.min(10, numPreviousResultValues);
            List<ResultValue> previousResultValuesToShow = previousResultValues.subList(
                    numPreviousResultValues - numResultValuesToShow, numPreviousResultValues);

            StringBuilder sb = new StringBuilder();
            sb.append(indent);
            sb.append(colorString(annotatedOutcome.getOutcome().getName(), color));
            if (!previousResultValuesToShow.isEmpty()) {
                sb.append(String.format(" [last %d: %s] [last run: %s]",
                        previousResultValuesToShow.size(),
                        generateSparkLine(previousResultValuesToShow),
                        timestamp));
            }
            sb.append(brokeThisMessage);
            list.add(sb.toString());
        }

        newLine();
        if (!successes.isEmpty()) {
            out.println("Success summary:");
            for (String success : successes) {
                out.println(success);
            }
        }
        if (!failures.isEmpty()) {
            out.println("Failure summary:");
            for (String failure : failures) {
                out.println(failure);
            }
        }
        if (!skips.isEmpty()) {
            out.println("Skips summary:");
            for (String skip : skips) {
                out.println(skip);
            }
        }
        if (!warnings.isEmpty()) {
            out.println("Warnings summary:");
            for (String warning : warnings) {
                out.println(warning);
            }
        }
    }

    private String formatElapsedTime(long elapsedTime) {
        if (elapsedTime < 0) {
            throw new IllegalArgumentException("non-negative elapsed times only");
        }

        String formatted;
        if (elapsedTime >= DAY_MILLIS) {
            long days = elapsedTime / DAY_MILLIS;
            formatted = String.format("%d days ago", days);
        } else if (elapsedTime >= HOUR_MILLIS) {
            long hours = elapsedTime / HOUR_MILLIS;
            formatted = String.format("%d hours ago", hours);
        } else {
            formatted = "less than an hour ago";
        }

        Color color = elapsedTimeWarningColor(elapsedTime);
        return colorString(formatted, color);
    }

    private Color elapsedTimeWarningColor(long elapsedTime) {
        if (elapsedTime < WARNING_HOURS * HOUR_MILLIS) {
            return Color.PASS;
        } else if (elapsedTime < FAILURE_HOURS * HOUR_MILLIS) {
            return Color.WARN;
        } else {
            return Color.FAIL;
        }
    }

    private String generateSparkLine(List<ResultValue> resultValues) {
        StringBuilder sb = new StringBuilder();
        for (ResultValue resultValue : resultValues) {
            if (resultValue == ResultValue.OK) {
                sb.append(colorString("\u2713", Color.PASS));
            } else if (resultValue == ResultValue.FAIL) {
                sb.append(colorString("X", Color.FAIL));
            } else {
                sb.append(colorString("-", Color.WARN));
            }
        }
        return sb.toString();
    }

    /**
     * Prints the action output with appropriate indentation.
     */
    public synchronized void streamOutput(CharSequence streamedOutput) {
        if (streamedOutput.length() == 0) {
            return;
        }

        String[] lines = messageToLines(streamedOutput.toString());

        if (currentLine == CurrentLine.VERBOSE && currentStreamMark != null && ansi) {
            currentStreamMark.reset();
            currentStreamMark = null;
        } else if (currentLine != CurrentLine.STREAMED_OUTPUT) {
            newLine();
            out.print(indent);
            out.print(indent);
        }
        out.print(lines[0]);
        currentLine = CurrentLine.STREAMED_OUTPUT;

        for (int i = 1; i < lines.length; i++) {
            newLine();

            if (lines[i].length() > 0) {
                out.print(indent);
                out.print(indent);
                out.print(lines[i]);
                currentLine = CurrentLine.STREAMED_OUTPUT;
            }
        }
    }

    /**
     * Inserts a linebreak if necessary.
     */
    protected void newLine() {
        currentStreamMark = null;

        if (currentLine == CurrentLine.VERBOSE && !verbose && ansi) {
            /*
             * Verbose means we leave all verbose output on the screen.
             * Otherwise we overwrite verbose output when new output arrives.
             */
            currentVerboseMark.reset();
        } else if (currentLine != CurrentLine.NEW) {
            out.print("\n");
        }

        currentLine = CurrentLine.NEW;
    }

    /**
     * Status of a currently-in-progress line of output.
     */
    enum CurrentLine {

        /**
         * The line is blank.
         */
        NEW,

        /**
         * The line contains streamed application output. Additional streamed
         * output may be appended without additional line separators or
         * indentation.
         */
        STREAMED_OUTPUT,

        /**
         * The line contains the name of an action or outcome. The outcome's
         * result (such as "OK") can be appended without additional line
         * separators or indentation.
         */
        NAME,

        /**
         * The line contains verbose output, and may be overwritten.
         */
        VERBOSE,
    }

    /**
     * Returns an array containing the lines of the given text.
     */
    private String[] messageToLines(String message) {
        // pass Integer.MAX_VALUE so split doesn't trim trailing empty strings.
        return message.split("\r\n|\r|\n", Integer.MAX_VALUE);
    }

    private enum Color {
        PASS, FAIL, SKIP, WARN, COMMENT;

        int code = 0;

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }
    }

    protected String colorString(String message, Color color) {
        return useColor ? ("\u001b[" + color.getCode() + ";1m" + message + "\u001b[0m") : message;
    }

    /**
     * This console prints output as it's emitted. It supports at most one
     * action at a time.
     */
    static class StreamingConsole extends Console {
        private String currentName;

        @Override public synchronized void action(String name) {
            newLine();
            out.print("Action " + name);
            currentName = name;
            currentLine = CurrentLine.NAME;
        }

        /**
         * Prints the beginning of the named outcome.
         */
        @Override public synchronized void outcome(String name) {
            // if the outcome and action names are the same, omit the outcome name
            if (name.equals(currentName)) {
                return;
            }

            currentName = name;
            newLine();
            out.print(indent + name);
            currentLine = CurrentLine.NAME;
        }

        @Override public synchronized void streamOutput(String outcomeName, String output) {
            streamOutput(output);
        }
    }

    /**
     * This console buffers output, only printing when a result is found. It
     * supports multiple concurrent actions.
     */
    static class MultiplexingConsole extends Console {
        private final Map<String, StringBuilder> bufferedOutputByOutcome = new HashMap<String, StringBuilder>();

        @Override public synchronized void streamOutput(String outcomeName, String output) {
            StringBuilder buffer = bufferedOutputByOutcome.get(outcomeName);
            if (buffer == null) {
                buffer = new StringBuilder();
                bufferedOutputByOutcome.put(outcomeName, buffer);
            }

            buffer.append(output);
        }

        @Override protected synchronized void flushBufferedOutput(String outcomeName) {
            newLine();
            out.print(indent + outcomeName);
            currentLine = CurrentLine.NAME;

            StringBuilder buffer = bufferedOutputByOutcome.remove(outcomeName);
            if (buffer != null) {
                streamOutput(buffer);
            }
        }
    }
}