JLineLogHandler.java

package org.springframework.roo.shell.jline;

import static org.apache.commons.io.IOUtils.LINE_SEPARATOR;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import jline.ANSIBuffer;
import jline.ConsoleReader;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.apache.commons.lang3.Validate;
import org.springframework.roo.shell.ShellPromptAccessor;
import org.springframework.roo.support.util.AnsiEscapeCode;

/**
 * JDK logging {@link Handler} that emits log messages to a JLine
 * {@link ConsoleReader}.
 * 
 * @author Ben Alex
 * @since 1.0
 */
public class JLineLogHandler extends Handler {

  private static final boolean BRIGHT_COLORS = Boolean.getBoolean("roo.bright");
  private static boolean includeThreadName = false;
  private static String lastMessage;
  private static ThreadLocal<Boolean> redrawProhibit = new ThreadLocal<Boolean>();
  private static boolean suppressDuplicateMessages = true;

  public static void cancelRedrawProhibition() {
    redrawProhibit.remove();
  }

  /**
   * Makes text brighter if requested through system property 'roo.bright' and
   * works around issue on Windows in using reverse() in combination with the
   * Jansi lib, which leaves its 'negative' flag set unless reset explicitly.
   * 
   * @return new patched ANSIBuffer
   */
  static ANSIBuffer getANSIBuffer() {
    final char esc = (char) 27;
    return new ANSIBuffer() {
      @Override
      public ANSIBuffer attrib(final String str, final int code) {
        if (BRIGHT_COLORS && 30 <= code && code <= 37) {
          // This is a color code: add a 'bright' code
          return append(esc + "[" + code + ";1m").append(str).append(ANSICodes.attrib(0));
        }
        return super.attrib(str, code);
      };

      @Override
      public ANSIBuffer reverse(final String str) {
        if (SystemUtils.IS_OS_WINDOWS) {
          return super.reverse(str).append(ANSICodes.attrib(esc));
        }
        return super.reverse(str);
      }
    };
  }

  public static boolean isSuppressDuplicateMessages() {
    return suppressDuplicateMessages;
  }

  public static void prohibitRedraw() {
    redrawProhibit.set(true);
  }

  public static void resetMessageTracking() {
    lastMessage = null; // see ROO-251
  }

  public static void setIncludeThreadName(final boolean include) {
    includeThreadName = include;
  }

  public static void setSuppressDuplicateMessages(final boolean suppressDuplicateMessages) {
    JLineLogHandler.suppressDuplicateMessages = suppressDuplicateMessages;
  }

  private boolean ansiSupported;
  private ConsoleReader reader;
  private ShellPromptAccessor shellPromptAccessor;
  private String userInterfaceThreadName;

  public JLineLogHandler(final ConsoleReader reader, final ShellPromptAccessor shellPromptAccessor) {
    Validate.notNull(reader, "Console reader required");
    Validate.notNull(shellPromptAccessor, "Shell prompt accessor required");
    this.reader = reader;
    this.shellPromptAccessor = shellPromptAccessor;
    userInterfaceThreadName = Thread.currentThread().getName();
    ansiSupported = reader.getTerminal().isANSISupported() && AnsiEscapeCode.isAnsiEnabled();

    setFormatter(new Formatter() {
      @Override
      public String format(final LogRecord record) {
        final StringBuilder sb = new StringBuilder();
        String message = record.getMessage();
        if (message != null) {
          final Object[] parameters = record.getParameters();
          if (!ArrayUtils.isEmpty(parameters)) {
            final Pattern pattern = Pattern.compile("\\{.*?\\}");
            final Matcher matcher = pattern.matcher(message);
            int i = 0;
            while (matcher.find()) {
              message = StringUtils.replace(message, matcher.group(0), parameters[i].toString());
              i++;
            }
          }
          sb.append(message).append(LINE_SEPARATOR);
        }
        if (record.getThrown() != null) {
          PrintWriter pw = null;
          try {
            final StringWriter sw = new StringWriter();
            pw = new PrintWriter(sw);
            record.getThrown().printStackTrace(pw);
            sb.append(sw.toString());
          } catch (final Exception ex) {
          } finally {
            IOUtils.closeQuietly(pw);
          }
        }
        return sb.toString();
      }
    });
  }

  @Override
  public void close() throws SecurityException {}

  @Override
  public void flush() {}

  @Override
  public void publish(final LogRecord record) {
    try {
      // Avoid repeating the same message that displayed immediately
      // before the current message (ROO-30, ROO-1873)
      final String toDisplay = toDisplay(record);
      if (toDisplay.equals(lastMessage) && suppressDuplicateMessages) {
        return;
      }
      lastMessage = toDisplay;

      final StringBuffer buffer = reader.getCursorBuffer().getBuffer();
      final int cursor = reader.getCursorBuffer().cursor;
      if (reader.getCursorBuffer().length() > 0) {
        // The user has semi-typed something, so put a new line in so
        // the debug message is separated
        reader.printNewline();

        // We need to cancel whatever they typed (it's reset later on),
        // so the line appears empty
        reader.getCursorBuffer().setBuffer(new StringBuffer());
        reader.getCursorBuffer().cursor = 0;
      }

      // This ensures nothing is ever displayed when redrawing the line
      reader.setDefaultPrompt("");
      reader.redrawLine();

      // Now restore the line formatting settings back to their original
      reader.setDefaultPrompt(shellPromptAccessor.getShellPrompt());

      reader.getCursorBuffer().setBuffer(buffer);
      reader.getCursorBuffer().cursor = cursor;

      reader.printString(toDisplay);

      final Boolean prohibitingRedraw = redrawProhibit.get();
      if (prohibitingRedraw == null) {
        reader.redrawLine();
      }

      reader.flushConsole();
    } catch (final Exception e) {
      reportError("Could not publish log message", e, Level.SEVERE.intValue());
    }
  }

  private String toDisplay(final LogRecord event) {
    final StringBuilder sb = new StringBuilder();

    String threadName;
    String eventString;
    if (includeThreadName && !userInterfaceThreadName.equals(Thread.currentThread().getName())
        && !"".equals(Thread.currentThread().getName())) {
      threadName = "[" + Thread.currentThread().getName() + "]";

      // Build an event string that will indent nicely given the left hand
      // side now contains a thread name
      final StringBuilder lineSeparatorAndIndentingString = new StringBuilder();
      for (int i = 0; i <= threadName.length(); i++) {
        lineSeparatorAndIndentingString.append(" ");
      }

      eventString =
          " "
              + getFormatter().format(event).replace(LINE_SEPARATOR,
                  LINE_SEPARATOR + lineSeparatorAndIndentingString.toString());
      if (eventString.endsWith(lineSeparatorAndIndentingString.toString())) {
        eventString =
            eventString.substring(0,
                eventString.length() - lineSeparatorAndIndentingString.length());
      }
    } else {
      threadName = "";
      eventString = getFormatter().format(event);
    }

    if (ansiSupported) {
      if (event.getLevel().intValue() >= Level.SEVERE.intValue()) {
        sb.append(getANSIBuffer().reverse(threadName).red(eventString));
      } else if (event.getLevel().intValue() >= Level.WARNING.intValue()) {
        sb.append(getANSIBuffer().reverse(threadName).magenta(eventString));
      } else if (event.getLevel().intValue() >= Level.INFO.intValue()) {
        sb.append(getANSIBuffer().reverse(threadName).green(eventString));
      } else {
        sb.append(getANSIBuffer().reverse(threadName).append(eventString));
      }
    } else {
      sb.append(threadName).append(eventString);
    }

    return sb.toString();
  }
}