AnsiMessagePrinter.java

  1. package ship.util;

  3. import static hera.util.StringUtils.removeSuffix;
  4. import static hera.util.ValidationUtils.assertEquals;
  5. import static hera.util.ValidationUtils.assertNotNull;
  6. import static hera.util.ValidationUtils.assertTrue;
  7. import static org.slf4j.LoggerFactory.getLogger;

  9. import java.io.IOException;
  10. import java.io.PrintStream;
  11. import java.io.StringReader;
  12. import java.io.StringWriter;
  13. import java.util.HashMap;
  14. import java.util.Map;
  15. import java.util.Stack;
  16. import lombok.Getter;
  17. import lombok.RequiredArgsConstructor;
  18. import lombok.Setter;
  19. import org.slf4j.Logger;

  21. public class AnsiMessagePrinter implements MessagePrinter {

  23.   public static final String COLOR_RESET   = "\u001B[0m";

  25.   public static final String COLOR_BLACK   = "\u001B[30m";
  26.   public static final String COLOR_RED     = "\u001B[31m";
  27.   public static final String COLOR_GREEN   = "\u001B[32m";
  28.   public static final String COLOR_YELLOW  = "\u001B[33m";
  29.   public static final String COLOR_BLUE    = "\u001B[34m";
  30.   public static final String COLOR_MAGENTA = "\u001B[35m";
  31.   public static final String COLOR_CYAN    = "\u001B[36m";
  32.   public static final String COLOR_WHITE   = "\u001B[37m";

  34.   public static final String COLOR_BRIGHT_BLACK    = removeSuffix(COLOR_BLACK, "m") + ";1m";
  35.   public static final String COLOR_BRIGHT_RED      = removeSuffix(COLOR_RED, "m") + ";1m";
  36.   public static final String COLOR_BRIGHT_GREEN    = removeSuffix(COLOR_GREEN, "m") + ";1m";
  37.   public static final String COLOR_BRIGHT_YELLOW   = removeSuffix(COLOR_YELLOW, "m") + ";1m";
  38.   public static final String COLOR_BRIGHT_BLUE     = removeSuffix(COLOR_BLUE, "m") + ";1m";
  39.   public static final String COLOR_BRIGHT_MAGENTA  = removeSuffix(COLOR_MAGENTA, "m") + ";1m";
  40.   public static final String COLOR_BRIGHT_CYAN     = removeSuffix(COLOR_CYAN, "m") + ";1m";
  41.   public static final String COLOR_BRIGHT_WHITE    = removeSuffix(COLOR_WHITE, "m") + ";1m";

  43.   public static final String BG_BLACK = "\u001B[40m";
  44.   public static final String BG_RED = "\u001B[41m";
  45.   public static final String BG_GREEN = "\u001B[42m";
  46.   public static final String BG_YELLOW = "\u001B[43m";
  47.   public static final String BG_BLUE = "\u001B[44m";
  48.   public static final String BG_MAGENTA = "\u001B[45m";
  49.   public static final String BG_CYAN = "\u001B[46m";
  50.   public static final String BG_WHITE = "\u001B[47m";

  52.   public static final String BG_BRIGHT_BLACK = removeSuffix(BG_BLACK, "m") + ";1m";
  53.   public static final String BG_BRIGHT_RED = removeSuffix(BG_RED, "m") + ";1m";
  54.   public static final String BG_BRIGHT_GREEN = removeSuffix(BG_GREEN, "m") + ";1m";
  55.   public static final String BG_BRIGHT_YELLOW = removeSuffix(BG_YELLOW, "m") + ";1m";
  56.   public static final String BG_BRIGHT_BLUE = removeSuffix(BG_BLUE, "m") + ";1m";
  57.   public static final String BG_BRIGHT_MAGENTA = removeSuffix(BG_MAGENTA, "m") + ";1m";
  58.   public static final String BG_BRIGHT_CYAN = removeSuffix(BG_CYAN, "m") + ";1m";
  59.   public static final String BG_BRIGHT_WHITE = removeSuffix(BG_WHITE, "m") + ";1m";

  61.   protected final transient Logger logger = getLogger(getClass());

  63.   @Getter
  64.   @Setter
  65.   protected String resetCode = COLOR_RESET;

  67.   @Getter
  68.   @Setter
  69.   protected Map<String, String> colors = new HashMap<>();

  71.   protected final PrintStream out;

  73.   /**
  74.    * Constructor with stream.
  75.    *
  76.    * @param out stream to print out
  77.    */
  78.   public AnsiMessagePrinter(final PrintStream out) {
  79.     this.out = out;
  80.     colors.put("black", COLOR_BLACK);
  81.     colors.put("red", COLOR_RED);
  82.     colors.put("green", COLOR_GREEN);
  83.     colors.put("yellow", COLOR_YELLOW);
  84.     colors.put("blue", COLOR_BLUE);
  85.     colors.put("magenta", COLOR_MAGENTA);
  86.     colors.put("cyan", COLOR_CYAN);
  87.     colors.put("white", COLOR_WHITE);

  89.     colors.put("bright_black", COLOR_BRIGHT_BLACK);
  90.     colors.put("bright_red", COLOR_BRIGHT_RED);
  91.     colors.put("bright_green", COLOR_BRIGHT_GREEN);
  92.     colors.put("bright_yellow", COLOR_BRIGHT_YELLOW);
  93.     colors.put("bright_blue", COLOR_BRIGHT_BLUE);
  94.     colors.put("bright_magenta", COLOR_BRIGHT_MAGENTA);
  95.     colors.put("bright_cyan", COLOR_BRIGHT_CYAN);
  96.     colors.put("bright_white", COLOR_BRIGHT_WHITE);

  98.     colors.put("bg_black", BG_BLACK);
  99.     colors.put("bg_red", BG_RED);
  100.     colors.put("bg_green", BG_GREEN);
  101.     colors.put("bg_yellow", BG_YELLOW);
  102.     colors.put("bg_blue", BG_BLUE);
  103.     colors.put("bg_magenta", BG_MAGENTA);
  104.     colors.put("bg_cyan", BG_CYAN);
  105.     colors.put("bg_white", BG_WHITE);

  107.     colors.put("bg_bright_black", BG_BRIGHT_BLACK);
  108.     colors.put("bg_bright_red", BG_BRIGHT_RED);
  109.     colors.put("bg_bright_green", BG_BRIGHT_GREEN);
  110.     colors.put("bg_bright_yellow", BG_BRIGHT_YELLOW);
  111.     colors.put("bg_bright_blue", BG_BRIGHT_BLUE);
  112.     colors.put("bg_bright_magenta", BG_BRIGHT_MAGENTA);
  113.     colors.put("bg_bright_cyan", BG_BRIGHT_CYAN);
  114.     colors.put("bg_bright_white", BG_BRIGHT_WHITE);
  115.   }

  117.   @RequiredArgsConstructor
  118.   abstract class State {
  119.     @Getter
  120.     protected final Stack<String> tags;

  122.     @Getter
  123.     protected final StringWriter writer;

  125.     abstract State next(int ch);
  126.   }

  128.   class Normal extends State {

  130.     protected static final int CH_TAG_START = '<';
  131.     protected static final int CH_ESCAPE = '!';

  133.     public Normal(final Stack<String> tags, final StringWriter writer) {
  134.       super(tags, writer);
  135.     }

  137.     @Override
  138.     public State next(int ch) {
  139.       if (CH_ESCAPE == ch) {
  140.         return new Escape(tags, writer);
  141.       } else if (CH_TAG_START == ch) {
  142.         return new TagOpen(tags, writer);
  143.       } else {
  144.         writer.write((char) ch);
  145.         return this;
  146.       }
  147.     }
  148.   }

  150.   class Escape extends State {

  152.     public Escape(final Stack<String> tags, final StringWriter writer) {
  153.       super(tags, writer);
  154.     }

  156.     @Override
  157.     public State next(int ch) {
  158.       writer.write((char) ch);
  159.       return new Normal(tags, writer);
  160.     }
  161.   }

  163.   class TagOpen extends State {
  164.     protected static final int CH_TAG_CLOSE = '/';

  166.     public TagOpen(final Stack<String> tags, final StringWriter writer) {
  167.       super(tags, writer);
  168.     }

  170.     @Override
  171.     public State next(int ch) {
  172.       if (ch == CH_TAG_CLOSE) {
  173.         return new CloseColor(tags, writer);
  174.       } else {
  175.         return new OpenColor(tags, writer).next(ch);
  176.       }
  177.     }
  178.   }

  180.   class OpenColor extends State {
  181.     protected static final int CH_TAG_END = '>';

  183.     protected final StringBuilder color = new StringBuilder();

  185.     public OpenColor(final Stack<String> tags, final StringWriter writer) {
  186.       super(tags, writer);
  187.     }

  189.     @Override
  190.     public State next(int ch) {
  191.       if (ch == CH_TAG_END) {
  192.         final String colorName = color.toString();
  193.         // check valid
  194.         tags.push(colorName);
  195.         logger.debug("Tags: {}", tags);
  196.         final String colorCode = colors.get(colorName);
  197.         assertNotNull(colorCode, "Unknown color: " + colorName);
  198.         writer.write(colorCode);
  199.         return new Normal(tags, writer);
  200.       } else {
  201.         color.append((char) ch);
  202.         return this;
  203.       }

  205.     }
  206.   }

  208.   class CloseColor extends State {

  210.     protected static final int CH_TAG_END = '>';

  212.     protected final StringBuilder color = new StringBuilder();

  214.     public CloseColor(final Stack<String> tags, final StringWriter writer) {
  215.       super(tags, writer);
  216.     }

  218.     @Override
  219.     public State next(int ch) {
  220.       if (ch == CH_TAG_END) {
  221.         final String colorName = color.toString();
  222.         // check valid
  223.         final String openColorName = tags.pop();
  224.         logger.debug("Tags: {}", tags);
  225.         assertEquals(openColorName, colorName,
  226.             "The closing tag not matched: " + openColorName + ", " + colorName);
  227.         color.delete(0, color.length());
  228.         if (tags.isEmpty()) {
  229.           writer.write(resetCode);
  230.         } else {
  231.           writer.write(colors.get(tags.peek()));
  232.         }
  233.         return new Normal(tags, writer);
  234.       } else {
  235.         color.append((char) ch);
  236.         return this;
  237.       }
  238.     }
  239.   }

  241.   /**
  242.    * Format tagged message with ansi color.
  243.    *
  244.    * @param message message to format
  245.    *
  246.    * @return text with ansi code
  247.    */
  248.   public String format(final String message) {
  249.     if (null == message) {
  250.       return null;
  251.     }
  252.     final StringReader reader = new StringReader(message);

  254.     int ch = 0;
  255.     State state = new Normal(new Stack<>(), new StringWriter());
  256.     try {
  257.       while (0 <= (ch = reader.read())) {
  258.         logger.trace("Char: {}", (char) ch);
  259.         final State old = state;
  260.         state = state.next(ch);
  261.         if (old != state) {
  262.           logger.debug("{} -> {}", old, state);
  263.         }
  264.       }
  265.     } catch (final IOException ex) {
  266.       throw new IllegalStateException();
  267.     }
  268.     logger.debug("State: {}", state);
  269.     logger.debug("Tags: {}", state.getTags());
  270.     assertTrue(state instanceof Normal, "Expression is invalid: " + state);
  271.     assertTrue(state.getTags().isEmpty(), "The closing tag missed: " + state.getTags());
  272.     return state.getWriter().toString();
  273.   }

  275.   public void print(final String format, Object...args) {
  276.     out.print(this.format(String.format(format, args)));
  277.   }

  279.   public void println() {
  280.     out.println();
  281.   }

  283.   public void println(final String format, Object... args) {
  284.     out.println(this.format(String.format(format, args)));
  285.   }

  287.   @Override
  288.   public void flush() {
  289.     out.flush();
  290.   }
  291. }
Created with JaCoCo 0.8.2.201808211720