mirror of
https://github.com/spring-projects/spring-boot.git
synced 2024-08-29 03:06:45 +08:00
Merge pull request #18264 from making
* pr/18264: Add ANSI 8-bit color image banner support Polish 'Add ANSI 8-bit color support' Add ANSI 8-bit color support Closes gh-18264
This commit is contained in:
Phillip Webb
commit
18396a3dc3
@ -37,6 +37,7 @@ import org.apache.commons.logging.LogFactory;
|
||||
import org.springframework.boot.ansi.AnsiBackground;
|
||||
import org.springframework.boot.ansi.AnsiColor;
|
||||
import org.springframework.boot.ansi.AnsiColors;
|
||||
import org.springframework.boot.ansi.AnsiColors.BitDepth;
|
||||
import org.springframework.boot.ansi.AnsiElement;
|
||||
import org.springframework.boot.ansi.AnsiOutput;
|
||||
import org.springframework.core.env.Environment;
|
||||
@ -102,16 +103,22 @@ public class ImageBanner implements Banner {
|
||||
int height = getProperty(environment, "height", Integer.class, 0);
|
||||
int margin = getProperty(environment, "margin", Integer.class, 2);
|
||||
boolean invert = getProperty(environment, "invert", Boolean.class, false);
|
||||
BitDepth bitDepth = getBitDepthProperty(environment);
|
||||
Frame[] frames = readFrames(width, height);
|
||||
for (int i = 0; i < frames.length; i++) {
|
||||
if (i > 0) {
|
||||
resetCursor(frames[i - 1].getImage(), out);
|
||||
}
|
||||
printBanner(frames[i].getImage(), margin, invert, out);
|
||||
printBanner(frames[i].getImage(), margin, invert, bitDepth, out);
|
||||
sleep(frames[i].getDelayTime());
|
||||
}
|
||||
}
|
||||
|
||||
private BitDepth getBitDepthProperty(Environment environment) {
|
||||
Integer bitDepth = getProperty(environment, "bitdepth", Integer.class, null);
|
||||
return (bitDepth != null) ? BitDepth.of(bitDepth) : BitDepth.FOUR;
|
||||
}
|
||||
|
||||
private <T> T getProperty(Environment environment, String name, Class<T> targetType, T defaultValue) {
|
||||
return environment.getProperty(PROPERTY_PREFIX + name, targetType, defaultValue);
|
||||
}
|
||||
@ -190,20 +197,21 @@ public class ImageBanner implements Banner {
|
||||
out.print("\033[" + lines + "A\r");
|
||||
}
|
||||
|
||||
private void printBanner(BufferedImage image, int margin, boolean invert, PrintStream out) {
|
||||
private void printBanner(BufferedImage image, int margin, boolean invert, BitDepth bitDepth, PrintStream out) {
|
||||
AnsiElement background = invert ? AnsiBackground.BLACK : AnsiBackground.DEFAULT;
|
||||
out.print(AnsiOutput.encode(AnsiColor.DEFAULT));
|
||||
out.print(AnsiOutput.encode(background));
|
||||
out.println();
|
||||
out.println();
|
||||
AnsiColor lastColor = AnsiColor.DEFAULT;
|
||||
AnsiElement lastColor = AnsiColor.DEFAULT;
|
||||
AnsiColors colors = new AnsiColors(bitDepth);
|
||||
for (int y = 0; y < image.getHeight(); y++) {
|
||||
for (int i = 0; i < margin; i++) {
|
||||
out.print(" ");
|
||||
}
|
||||
for (int x = 0; x < image.getWidth(); x++) {
|
||||
Color color = new Color(image.getRGB(x, y), false);
|
||||
AnsiColor ansiColor = AnsiColors.getClosest(color);
|
||||
AnsiElement ansiColor = colors.findClosest(color);
|
||||
if (ansiColor != lastColor) {
|
||||
out.print(AnsiOutput.encode(ansiColor));
|
||||
lastColor = ansiColor;
|
||||
|
||||
@ -43,6 +43,7 @@ import org.springframework.util.StreamUtils;
|
||||
*
|
||||
* @author Phillip Webb
|
||||
* @author Vedran Pavic
|
||||
* @author Toshiaki Maki
|
||||
* @since 1.2.0
|
||||
*/
|
||||
public class ResourceBanner implements Banner {
|
||||
|
||||
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright 2012-2019 the original author or authors.
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* https://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.springframework.boot.ansi;
|
||||
|
||||
import org.springframework.util.Assert;
|
||||
|
||||
/**
|
||||
* {@link AnsiElement} implementation for ANSI 8-bit foreground or background color codes.
|
||||
*
|
||||
* @author Toshiaki Maki
|
||||
* @author Phillip Webb
|
||||
* @since 2.2.0
|
||||
* @see #foreground(int)
|
||||
* @see #background(int)
|
||||
*/
|
||||
public final class Ansi8BitColor implements AnsiElement {
|
||||
|
||||
private final String prefix;
|
||||
|
||||
private final int code;
|
||||
|
||||
/**
|
||||
* Create a new {@link Ansi8BitColor} instance.
|
||||
* @param prefix the prefix escape chars
|
||||
* @param code color code (must be 0-255)
|
||||
* @throws IllegalArgumentException if color code is not between 0 and 255.
|
||||
*/
|
||||
private Ansi8BitColor(String prefix, int code) {
|
||||
Assert.isTrue(code >= 0 && code <= 255, "Code must be between 0 and 255");
|
||||
this.prefix = prefix;
|
||||
this.code = code;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
if (obj == null || getClass() != obj.getClass()) {
|
||||
return false;
|
||||
}
|
||||
Ansi8BitColor other = (Ansi8BitColor) obj;
|
||||
return this.prefix.equals(other.prefix) && this.code == other.code;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return this.prefix.hashCode() * 31 + this.code;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return this.prefix + this.code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a foreground ANSI color code instance for the given code.
|
||||
* @param code the color code
|
||||
* @return an ANSI color code instance
|
||||
*/
|
||||
public static Ansi8BitColor foreground(int code) {
|
||||
return new Ansi8BitColor("38;5;", code);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a background ANSI color code instance for the given code.
|
||||
* @param code the color code
|
||||
* @return an ANSI color code instance
|
||||
*/
|
||||
public static Ansi8BitColor background(int code) {
|
||||
return new Ansi8BitColor("48;5;", code);
|
||||
}
|
||||
|
||||
}
|
||||
@ -20,8 +20,8 @@ import java.awt.Color;
|
||||
import java.awt.color.ColorSpace;
|
||||
import java.util.Collections;
|
||||
import java.util.EnumMap;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import org.springframework.util.Assert;
|
||||
|
||||
@ -36,7 +36,7 @@ import org.springframework.util.Assert;
|
||||
*/
|
||||
public final class AnsiColors {
|
||||
|
||||
private static final Map<AnsiColor, LabColor> ANSI_COLOR_MAP;
|
||||
private static final Map<AnsiElement, LabColor> ANSI_COLOR_MAP;
|
||||
|
||||
static {
|
||||
Map<AnsiColor, LabColor> colorMap = new EnumMap<>(AnsiColor.class);
|
||||
@ -59,24 +59,86 @@ public final class AnsiColors {
|
||||
ANSI_COLOR_MAP = Collections.unmodifiableMap(colorMap);
|
||||
}
|
||||
|
||||
private AnsiColors() {
|
||||
private static final int[] ANSI_8BIT_COLOR_CODE_LOOKUP = new int[] { 0x000000, 0x800000, 0x008000, 0x808000,
|
||||
0x000080, 0x800080, 0x008080, 0xc0c0c0, 0x808080, 0xff0000, 0x00ff00, 0xffff00, 0x0000ff, 0xff00ff,
|
||||
0x00ffff, 0xffffff, 0x000000, 0x00005f, 0x000087, 0x0000af, 0x0000d7, 0x0000ff, 0x005f00, 0x005f5f,
|
||||
0x005f87, 0x005faf, 0x005fd7, 0x005fff, 0x008700, 0x00875f, 0x008787, 0x0087af, 0x0087d7, 0x0087ff,
|
||||
0x00af00, 0x00af5f, 0x00af87, 0x00afaf, 0x00afd7, 0x00afff, 0x00d700, 0x00d75f, 0x00d787, 0x00d7af,
|
||||
0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f, 0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff, 0x5f0000, 0x5f005f,
|
||||
0x5f0087, 0x5f00af, 0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f, 0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff,
|
||||
0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af, 0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f, 0x5faf87, 0x5fafaf,
|
||||
0x5fafd7, 0x5fafff, 0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af, 0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f,
|
||||
0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff, 0x870000, 0x87005f, 0x870087, 0x8700af, 0x8700d7, 0x8700ff,
|
||||
0x875f00, 0x875f5f, 0x875f87, 0x875faf, 0x875fd7, 0x875fff, 0x878700, 0x87875f, 0x878787, 0x8787af,
|
||||
0x8787d7, 0x8787ff, 0x87af00, 0x87af5f, 0x87af87, 0x87afaf, 0x87afd7, 0x87afff, 0x87d700, 0x87d75f,
|
||||
0x87d787, 0x87d7af, 0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f, 0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff,
|
||||
0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af, 0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f, 0xaf5f87, 0xaf5faf,
|
||||
0xaf5fd7, 0xaf5fff, 0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af, 0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f,
|
||||
0xafaf87, 0xafafaf, 0xafafd7, 0xafafff, 0xafd700, 0xafd75f, 0xafd787, 0xafd7af, 0xafd7d7, 0xafd7ff,
|
||||
0xafff00, 0xafff5f, 0xafff87, 0xafffaf, 0xafffd7, 0xafffff, 0xd70000, 0xd7005f, 0xd70087, 0xd700af,
|
||||
0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f, 0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff, 0xd78700, 0xd7875f,
|
||||
0xd78787, 0xd787af, 0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f, 0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff,
|
||||
0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af, 0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f, 0xd7ff87, 0xd7ffaf,
|
||||
0xd7ffd7, 0xd7ffff, 0xff0000, 0xff005f, 0xff0087, 0xff00af, 0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f,
|
||||
0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff, 0xff8700, 0xff875f, 0xff8787, 0xff87af, 0xff87d7, 0xff87ff,
|
||||
0xffaf00, 0xffaf5f, 0xffaf87, 0xffafaf, 0xffafd7, 0xffafff, 0xffd700, 0xffd75f, 0xffd787, 0xffd7af,
|
||||
0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f, 0xffff87, 0xffffaf, 0xffffd7, 0xffffff, 0x080808, 0x121212,
|
||||
0x1c1c1c, 0x262626, 0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e, 0x585858, 0x626262, 0x6c6c6c, 0x767676,
|
||||
0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e, 0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6, 0xd0d0d0, 0xdadada,
|
||||
0xe4e4e4, 0xeeeeee };
|
||||
|
||||
private final Map<AnsiElement, LabColor> lookup;
|
||||
|
||||
/**
|
||||
* Create a new {@link AnsiColors} instance with the specified bit depth.
|
||||
* @param bitDepth the required bit depth
|
||||
*/
|
||||
public AnsiColors(BitDepth bitDepth) {
|
||||
this.lookup = getLookup(bitDepth);
|
||||
}
|
||||
|
||||
public static AnsiColor getClosest(Color color) {
|
||||
return getClosest(new LabColor(color));
|
||||
private Map<AnsiElement, LabColor> getLookup(BitDepth bitDepth) {
|
||||
if (bitDepth == BitDepth.EIGHT) {
|
||||
Map<Ansi8BitColor, LabColor> lookup = new LinkedHashMap<>();
|
||||
for (int i = 0; i < ANSI_8BIT_COLOR_CODE_LOOKUP.length; i++) {
|
||||
lookup.put(Ansi8BitColor.foreground(i), new LabColor(ANSI_8BIT_COLOR_CODE_LOOKUP[i]));
|
||||
}
|
||||
return Collections.unmodifiableMap(lookup);
|
||||
}
|
||||
return ANSI_COLOR_MAP;
|
||||
}
|
||||
|
||||
private static AnsiColor getClosest(LabColor color) {
|
||||
AnsiColor result = null;
|
||||
double resultDistance = Float.MAX_VALUE;
|
||||
for (Entry<AnsiColor, LabColor> entry : ANSI_COLOR_MAP.entrySet()) {
|
||||
double distance = color.getDistance(entry.getValue());
|
||||
if (result == null || distance < resultDistance) {
|
||||
resultDistance = distance;
|
||||
result = entry.getKey();
|
||||
/**
|
||||
* Find the closest {@link AnsiElement ANSI color} to the given AWT {@link Color}.
|
||||
* @param color the AWT color
|
||||
* @return the closest ANSI color
|
||||
*/
|
||||
public AnsiElement findClosest(Color color) {
|
||||
return findClosest(new LabColor(color));
|
||||
}
|
||||
|
||||
private AnsiElement findClosest(LabColor color) {
|
||||
AnsiElement closest = null;
|
||||
double closestDistance = Float.MAX_VALUE;
|
||||
for (Map.Entry<AnsiElement, LabColor> entry : this.lookup.entrySet()) {
|
||||
double candidateDistance = color.getDistance(entry.getValue());
|
||||
if (closest == null || candidateDistance < closestDistance) {
|
||||
closestDistance = candidateDistance;
|
||||
closest = entry.getKey();
|
||||
}
|
||||
}
|
||||
return result;
|
||||
return closest;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the closest {@link AnsiColor ANSI color} to the given AWT {@link Color}.
|
||||
* @param color the color to find
|
||||
* @return the closest color
|
||||
* @deprecated since 2.2.0 in favor of {@link #findClosest(Color)}
|
||||
*/
|
||||
@Deprecated
|
||||
public static AnsiColor getClosest(Color color) {
|
||||
return (AnsiColor) new AnsiColors(BitDepth.FOUR).findClosest(color);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -132,4 +194,38 @@ public final class AnsiColors {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Bit depths supported by this class.
|
||||
*/
|
||||
public enum BitDepth {
|
||||
|
||||
/**
|
||||
* 4 bits (16 color).
|
||||
* @see AnsiColor
|
||||
*/
|
||||
FOUR(4),
|
||||
|
||||
/**
|
||||
* 8 bits (256 color).
|
||||
* @see Ansi8BitColor
|
||||
*/
|
||||
EIGHT(8);
|
||||
|
||||
private final int bits;
|
||||
|
||||
BitDepth(int bits) {
|
||||
this.bits = bits;
|
||||
}
|
||||
|
||||
public static BitDepth of(int bits) {
|
||||
for (BitDepth candidate : values()) {
|
||||
if (candidate.bits == bits) {
|
||||
return candidate;
|
||||
}
|
||||
}
|
||||
throw new IllegalArgumentException("Unsupported ANSI bit depth '" + bits + "'");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -21,34 +21,43 @@ import java.util.Collections;
|
||||
import java.util.EnumSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.function.IntFunction;
|
||||
|
||||
import org.springframework.core.env.PropertyResolver;
|
||||
import org.springframework.core.env.PropertySource;
|
||||
import org.springframework.util.StringUtils;
|
||||
|
||||
/**
|
||||
* {@link PropertyResolver} for {@link AnsiStyle}, {@link AnsiColor} and
|
||||
* {@link AnsiBackground} elements. Supports properties of the form
|
||||
* {@code AnsiStyle.BOLD}, {@code AnsiColor.RED} or {@code AnsiBackground.GREEN}. Also
|
||||
* supports a prefix of {@code Ansi.} which is an aggregation of everything (with
|
||||
* {@link PropertyResolver} for {@link AnsiStyle}, {@link AnsiColor},
|
||||
* {@link AnsiBackground} and {@link Ansi8BitColor} elements. Supports properties of the
|
||||
* form {@code AnsiStyle.BOLD}, {@code AnsiColor.RED} or {@code AnsiBackground.GREEN}.
|
||||
* Also supports a prefix of {@code Ansi.} which is an aggregation of everything (with
|
||||
* background colors prefixed {@code BG_}).
|
||||
* <p>
|
||||
* ANSI 8-bit color codes can be used with {@code AnsiColor} and {@code AnsiBackground}.
|
||||
* For example, {@code AnsiColor.208} will render orange text.
|
||||
* <a href="https://en.wikipedia.org/wiki/ANSI_escape_code">Wikipedia</a> has a complete
|
||||
* list of the 8-bit color codes that can be used.
|
||||
*
|
||||
* @author Phillip Webb
|
||||
* @author Toshiaki Maki
|
||||
* @since 1.3.0
|
||||
*/
|
||||
public class AnsiPropertySource extends PropertySource<AnsiElement> {
|
||||
|
||||
private static final Iterable<MappedEnum<?>> MAPPED_ENUMS;
|
||||
private static final Iterable<Mapping> MAPPINGS;
|
||||
|
||||
static {
|
||||
List<MappedEnum<?>> enums = new ArrayList<>();
|
||||
enums.add(new MappedEnum<>("AnsiStyle.", AnsiStyle.class));
|
||||
enums.add(new MappedEnum<>("AnsiColor.", AnsiColor.class));
|
||||
enums.add(new MappedEnum<>("AnsiBackground.", AnsiBackground.class));
|
||||
enums.add(new MappedEnum<>("Ansi.", AnsiStyle.class));
|
||||
enums.add(new MappedEnum<>("Ansi.", AnsiColor.class));
|
||||
enums.add(new MappedEnum<>("Ansi.BG_", AnsiBackground.class));
|
||||
MAPPED_ENUMS = Collections.unmodifiableList(enums);
|
||||
List<Mapping> mappings = new ArrayList<>();
|
||||
mappings.add(new EnumMapping<>("AnsiStyle.", AnsiStyle.class));
|
||||
mappings.add(new EnumMapping<>("AnsiColor.", AnsiColor.class));
|
||||
mappings.add(new Ansi8BitColorMapping("AnsiColor.", Ansi8BitColor::foreground));
|
||||
mappings.add(new EnumMapping<>("AnsiBackground.", AnsiBackground.class));
|
||||
mappings.add(new Ansi8BitColorMapping("AnsiBackground.", Ansi8BitColor::background));
|
||||
mappings.add(new EnumMapping<>("Ansi.", AnsiStyle.class));
|
||||
mappings.add(new EnumMapping<>("Ansi.", AnsiColor.class));
|
||||
mappings.add(new EnumMapping<>("Ansi.BG_", AnsiBackground.class));
|
||||
MAPPINGS = Collections.unmodifiableList(mappings);
|
||||
}
|
||||
|
||||
private final boolean encode;
|
||||
@ -66,16 +75,13 @@ public class AnsiPropertySource extends PropertySource<AnsiElement> {
|
||||
@Override
|
||||
public Object getProperty(String name) {
|
||||
if (StringUtils.hasLength(name)) {
|
||||
for (MappedEnum<?> mappedEnum : MAPPED_ENUMS) {
|
||||
if (name.startsWith(mappedEnum.getPrefix())) {
|
||||
String enumName = name.substring(mappedEnum.getPrefix().length());
|
||||
for (Enum<?> ansiEnum : mappedEnum.getEnums()) {
|
||||
if (ansiEnum.name().equals(enumName)) {
|
||||
if (this.encode) {
|
||||
return AnsiOutput.encode((AnsiElement) ansiEnum);
|
||||
}
|
||||
return ansiEnum;
|
||||
}
|
||||
for (Mapping mapping : MAPPINGS) {
|
||||
String prefix = mapping.getPrefix();
|
||||
if (name.startsWith(prefix)) {
|
||||
String postfix = name.substring(prefix.length());
|
||||
AnsiElement element = mapping.getElement(postfix);
|
||||
if (element != null) {
|
||||
return (this.encode) ? AnsiOutput.encode(element) : element;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -84,26 +90,79 @@ public class AnsiPropertySource extends PropertySource<AnsiElement> {
|
||||
}
|
||||
|
||||
/**
|
||||
* Mapping between an enum and the pseudo property source.
|
||||
* Mapping between a name and the pseudo property source.
|
||||
*/
|
||||
private static class MappedEnum<E extends Enum<E>> {
|
||||
private abstract static class Mapping {
|
||||
|
||||
private final String prefix;
|
||||
|
||||
private final Set<E> enums;
|
||||
|
||||
MappedEnum(String prefix, Class<E> enumType) {
|
||||
Mapping(String prefix) {
|
||||
this.prefix = prefix;
|
||||
this.enums = EnumSet.allOf(enumType);
|
||||
|
||||
}
|
||||
|
||||
String getPrefix() {
|
||||
return this.prefix;
|
||||
}
|
||||
|
||||
Set<E> getEnums() {
|
||||
return this.enums;
|
||||
abstract AnsiElement getElement(String postfix);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link Mapping} for {@link AnsiElement} enums.
|
||||
*/
|
||||
private static class EnumMapping<E extends Enum<E> & AnsiElement> extends Mapping {
|
||||
|
||||
private final Set<E> enums;
|
||||
|
||||
EnumMapping(String prefix, Class<E> enumType) {
|
||||
super(prefix);
|
||||
this.enums = EnumSet.allOf(enumType);
|
||||
}
|
||||
|
||||
@Override
|
||||
AnsiElement getElement(String postfix) {
|
||||
for (Enum<?> candidate : this.enums) {
|
||||
if (candidate.name().equals(postfix)) {
|
||||
return (AnsiElement) candidate;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link Mapping} for {@link Ansi8BitColor}.
|
||||
*/
|
||||
private static class Ansi8BitColorMapping extends Mapping {
|
||||
|
||||
private final IntFunction<Ansi8BitColor> factory;
|
||||
|
||||
Ansi8BitColorMapping(String prefix, IntFunction<Ansi8BitColor> factory) {
|
||||
super(prefix);
|
||||
this.factory = factory;
|
||||
}
|
||||
|
||||
@Override
|
||||
AnsiElement getElement(String postfix) {
|
||||
if (containsOnlyDigits(postfix)) {
|
||||
try {
|
||||
return this.factory.apply(Integer.parseInt(postfix));
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private boolean containsOnlyDigits(String postfix) {
|
||||
for (int i = 0; i < postfix.length(); i++) {
|
||||
if (!Character.isDigit(postfix.charAt(i))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return postfix.length() > 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -47,6 +47,12 @@
|
||||
"description": "Whether images should be inverted for dark terminal themes.",
|
||||
"defaultValue": false
|
||||
},
|
||||
{
|
||||
"name": "spring.banner.image.bitdepth",
|
||||
"type": "java.lang.Integer",
|
||||
"description": "The bit depth to use for ANSI colors. Supported values are 4 (16 color) or 8 (256 color).",
|
||||
"defaultValue": 4
|
||||
},
|
||||
{
|
||||
"name": "debug",
|
||||
"type": "java.lang.Boolean",
|
||||
|
||||
@ -23,6 +23,7 @@ import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import org.springframework.boot.ansi.Ansi8BitColor;
|
||||
import org.springframework.boot.ansi.AnsiBackground;
|
||||
import org.springframework.boot.ansi.AnsiColor;
|
||||
import org.springframework.boot.ansi.AnsiOutput;
|
||||
@ -168,6 +169,16 @@ class ImageBannerTests {
|
||||
assertThat(lines).hasSize(frames * linesPerFrame - 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void printBannerWhenBitDepthIs8ShouldUseColors() {
|
||||
String banner = printBanner("colors.gif", "spring.banner.image.bitdepth=8");
|
||||
assertThat(banner.contains(AnsiOutput.encode(Ansi8BitColor.foreground(124))));
|
||||
assertThat(banner.contains(AnsiOutput.encode(Ansi8BitColor.foreground(130))));
|
||||
assertThat(banner.contains(AnsiOutput.encode(Ansi8BitColor.foreground(19))));
|
||||
assertThat(banner.contains(AnsiOutput.encode(Ansi8BitColor.foreground(127))));
|
||||
assertThat(banner.contains(AnsiOutput.encode(Ansi8BitColor.foreground(37))));
|
||||
}
|
||||
|
||||
private int getBannerHeight(String banner) {
|
||||
return banner.split(System.lineSeparator()).length - 3;
|
||||
}
|
||||
|
||||
@ -39,6 +39,7 @@ import static org.assertj.core.api.Assertions.assertThat;
|
||||
*
|
||||
* @author Phillip Webb
|
||||
* @author Vedran Pavic
|
||||
* @author Toshiaki Maki
|
||||
*/
|
||||
class ResourceBannerTests {
|
||||
|
||||
@ -95,6 +96,22 @@ class ResourceBannerTests {
|
||||
assertThat(banner).startsWith("This is red.");
|
||||
}
|
||||
|
||||
@Test
|
||||
void renderWith256Colors() {
|
||||
Resource resource = new ByteArrayResource("${AnsiColor.208}This is orange.${Ansi.NORMAL}".getBytes());
|
||||
AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS);
|
||||
String banner = printBanner(resource, null, null, null);
|
||||
assertThat(banner).startsWith("\033[38;5;208mThis is orange.\u001B[0m");
|
||||
}
|
||||
|
||||
@Test
|
||||
void renderWith256ColorsButDisabled() {
|
||||
Resource resource = new ByteArrayResource("${AnsiColor.208}This is orange.${Ansi.NORMAL}".getBytes());
|
||||
AnsiOutput.setEnabled(AnsiOutput.Enabled.NEVER);
|
||||
String banner = printBanner(resource, null, null, null);
|
||||
assertThat(banner).startsWith("This is orange.");
|
||||
}
|
||||
|
||||
@Test
|
||||
void renderWithTitle() {
|
||||
Resource resource = new ByteArrayResource("banner ${application.title} ${a}".getBytes());
|
||||
|
||||
@ -0,0 +1,67 @@
|
||||
/*
|
||||
* Copyright 2012-2019 the original author or authors.
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* https://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.springframework.boot.ansi;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
|
||||
|
||||
/**
|
||||
* Tests for {@link Ansi8BitColor}.
|
||||
*
|
||||
* @author Toshiaki Maki
|
||||
* @author Phillip Webb
|
||||
*/
|
||||
class Ansi8BitColorTests {
|
||||
|
||||
@Test
|
||||
void toStringWhenForegroundAddsCorrectPrefix() {
|
||||
assertThat(Ansi8BitColor.foreground(208).toString()).isEqualTo("38;5;208");
|
||||
}
|
||||
|
||||
@Test
|
||||
void toStringWhenBackgroundAddsCorrectPrefix() {
|
||||
assertThat(Ansi8BitColor.background(208).toString()).isEqualTo("48;5;208");
|
||||
}
|
||||
|
||||
@Test
|
||||
void forgroundWhenOutsideBoundsThrowsException() {
|
||||
assertThatIllegalArgumentException().isThrownBy(() -> Ansi8BitColor.foreground(-1))
|
||||
.withMessage("Code must be between 0 and 255");
|
||||
assertThatIllegalArgumentException().isThrownBy(() -> Ansi8BitColor.foreground(256))
|
||||
.withMessage("Code must be between 0 and 255");
|
||||
}
|
||||
|
||||
@Test
|
||||
void backgroundWhenOutsideBoundsThrowsException() {
|
||||
assertThatIllegalArgumentException().isThrownBy(() -> Ansi8BitColor.background(-1))
|
||||
.withMessage("Code must be between 0 and 255");
|
||||
assertThatIllegalArgumentException().isThrownBy(() -> Ansi8BitColor.background(256))
|
||||
.withMessage("Code must be between 0 and 255");
|
||||
}
|
||||
|
||||
@Test
|
||||
void equalsAndHashCode() {
|
||||
Ansi8BitColor one = Ansi8BitColor.foreground(123);
|
||||
Ansi8BitColor two = Ansi8BitColor.foreground(123);
|
||||
Ansi8BitColor three = Ansi8BitColor.background(123);
|
||||
assertThat(one.hashCode()).isEqualTo(two.hashCode());
|
||||
assertThat(one).isEqualTo(one).isEqualTo(two).isNotEqualTo(three).isNotEqualTo(null).isNotEqualTo("foo");
|
||||
}
|
||||
|
||||
}
|
||||
@ -20,6 +20,8 @@ import java.awt.Color;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import org.springframework.boot.ansi.AnsiColors.BitDepth;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
/**
|
||||
@ -30,47 +32,73 @@ import static org.assertj.core.api.Assertions.assertThat;
|
||||
class AnsiColorsTests {
|
||||
|
||||
@Test
|
||||
void getClosestWhenExactMatchShouldReturnAnsiColor() {
|
||||
assertThat(getClosest(0x000000)).isEqualTo(AnsiColor.BLACK);
|
||||
assertThat(getClosest(0xAA0000)).isEqualTo(AnsiColor.RED);
|
||||
assertThat(getClosest(0x00AA00)).isEqualTo(AnsiColor.GREEN);
|
||||
assertThat(getClosest(0xAA5500)).isEqualTo(AnsiColor.YELLOW);
|
||||
assertThat(getClosest(0x0000AA)).isEqualTo(AnsiColor.BLUE);
|
||||
assertThat(getClosest(0xAA00AA)).isEqualTo(AnsiColor.MAGENTA);
|
||||
assertThat(getClosest(0x00AAAA)).isEqualTo(AnsiColor.CYAN);
|
||||
assertThat(getClosest(0xAAAAAA)).isEqualTo(AnsiColor.WHITE);
|
||||
assertThat(getClosest(0x555555)).isEqualTo(AnsiColor.BRIGHT_BLACK);
|
||||
assertThat(getClosest(0xFF5555)).isEqualTo(AnsiColor.BRIGHT_RED);
|
||||
assertThat(getClosest(0x55FF00)).isEqualTo(AnsiColor.BRIGHT_GREEN);
|
||||
assertThat(getClosest(0xFFFF55)).isEqualTo(AnsiColor.BRIGHT_YELLOW);
|
||||
assertThat(getClosest(0x5555FF)).isEqualTo(AnsiColor.BRIGHT_BLUE);
|
||||
assertThat(getClosest(0xFF55FF)).isEqualTo(AnsiColor.BRIGHT_MAGENTA);
|
||||
assertThat(getClosest(0x55FFFF)).isEqualTo(AnsiColor.BRIGHT_CYAN);
|
||||
assertThat(getClosest(0xFFFFFF)).isEqualTo(AnsiColor.BRIGHT_WHITE);
|
||||
void findClosest4BitWhenExactMatchShouldReturnAnsiColor() {
|
||||
assertThat(findClosest4Bit(0x000000)).isEqualTo(AnsiColor.BLACK);
|
||||
assertThat(findClosest4Bit(0xAA0000)).isEqualTo(AnsiColor.RED);
|
||||
assertThat(findClosest4Bit(0x00AA00)).isEqualTo(AnsiColor.GREEN);
|
||||
assertThat(findClosest4Bit(0xAA5500)).isEqualTo(AnsiColor.YELLOW);
|
||||
assertThat(findClosest4Bit(0x0000AA)).isEqualTo(AnsiColor.BLUE);
|
||||
assertThat(findClosest4Bit(0xAA00AA)).isEqualTo(AnsiColor.MAGENTA);
|
||||
assertThat(findClosest4Bit(0x00AAAA)).isEqualTo(AnsiColor.CYAN);
|
||||
assertThat(findClosest4Bit(0xAAAAAA)).isEqualTo(AnsiColor.WHITE);
|
||||
assertThat(findClosest4Bit(0x555555)).isEqualTo(AnsiColor.BRIGHT_BLACK);
|
||||
assertThat(findClosest4Bit(0xFF5555)).isEqualTo(AnsiColor.BRIGHT_RED);
|
||||
assertThat(findClosest4Bit(0x55FF00)).isEqualTo(AnsiColor.BRIGHT_GREEN);
|
||||
assertThat(findClosest4Bit(0xFFFF55)).isEqualTo(AnsiColor.BRIGHT_YELLOW);
|
||||
assertThat(findClosest4Bit(0x5555FF)).isEqualTo(AnsiColor.BRIGHT_BLUE);
|
||||
assertThat(findClosest4Bit(0xFF55FF)).isEqualTo(AnsiColor.BRIGHT_MAGENTA);
|
||||
assertThat(findClosest4Bit(0x55FFFF)).isEqualTo(AnsiColor.BRIGHT_CYAN);
|
||||
assertThat(findClosest4Bit(0xFFFFFF)).isEqualTo(AnsiColor.BRIGHT_WHITE);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getClosestWhenCloseShouldReturnAnsiColor() {
|
||||
assertThat(getClosest(0x292424)).isEqualTo(AnsiColor.BLACK);
|
||||
assertThat(getClosest(0x8C1919)).isEqualTo(AnsiColor.RED);
|
||||
assertThat(getClosest(0x0BA10B)).isEqualTo(AnsiColor.GREEN);
|
||||
assertThat(getClosest(0xB55F09)).isEqualTo(AnsiColor.YELLOW);
|
||||
assertThat(getClosest(0x0B0BA1)).isEqualTo(AnsiColor.BLUE);
|
||||
assertThat(getClosest(0xA312A3)).isEqualTo(AnsiColor.MAGENTA);
|
||||
assertThat(getClosest(0x0BB5B5)).isEqualTo(AnsiColor.CYAN);
|
||||
assertThat(getClosest(0xBAB6B6)).isEqualTo(AnsiColor.WHITE);
|
||||
assertThat(getClosest(0x615A5A)).isEqualTo(AnsiColor.BRIGHT_BLACK);
|
||||
assertThat(getClosest(0xF23333)).isEqualTo(AnsiColor.BRIGHT_RED);
|
||||
assertThat(getClosest(0x55E80C)).isEqualTo(AnsiColor.BRIGHT_GREEN);
|
||||
assertThat(getClosest(0xF5F54C)).isEqualTo(AnsiColor.BRIGHT_YELLOW);
|
||||
assertThat(getClosest(0x5656F0)).isEqualTo(AnsiColor.BRIGHT_BLUE);
|
||||
assertThat(getClosest(0xFA50FA)).isEqualTo(AnsiColor.BRIGHT_MAGENTA);
|
||||
assertThat(getClosest(0x56F5F5)).isEqualTo(AnsiColor.BRIGHT_CYAN);
|
||||
assertThat(getClosest(0xEDF5F5)).isEqualTo(AnsiColor.BRIGHT_WHITE);
|
||||
void getClosest4BitWhenCloseShouldReturnAnsiColor() {
|
||||
assertThat(findClosest4Bit(0x292424)).isEqualTo(AnsiColor.BLACK);
|
||||
assertThat(findClosest4Bit(0x8C1919)).isEqualTo(AnsiColor.RED);
|
||||
assertThat(findClosest4Bit(0x0BA10B)).isEqualTo(AnsiColor.GREEN);
|
||||
assertThat(findClosest4Bit(0xB55F09)).isEqualTo(AnsiColor.YELLOW);
|
||||
assertThat(findClosest4Bit(0x0B0BA1)).isEqualTo(AnsiColor.BLUE);
|
||||
assertThat(findClosest4Bit(0xA312A3)).isEqualTo(AnsiColor.MAGENTA);
|
||||
assertThat(findClosest4Bit(0x0BB5B5)).isEqualTo(AnsiColor.CYAN);
|
||||
assertThat(findClosest4Bit(0xBAB6B6)).isEqualTo(AnsiColor.WHITE);
|
||||
assertThat(findClosest4Bit(0x615A5A)).isEqualTo(AnsiColor.BRIGHT_BLACK);
|
||||
assertThat(findClosest4Bit(0xF23333)).isEqualTo(AnsiColor.BRIGHT_RED);
|
||||
assertThat(findClosest4Bit(0x55E80C)).isEqualTo(AnsiColor.BRIGHT_GREEN);
|
||||
assertThat(findClosest4Bit(0xF5F54C)).isEqualTo(AnsiColor.BRIGHT_YELLOW);
|
||||
assertThat(findClosest4Bit(0x5656F0)).isEqualTo(AnsiColor.BRIGHT_BLUE);
|
||||
assertThat(findClosest4Bit(0xFA50FA)).isEqualTo(AnsiColor.BRIGHT_MAGENTA);
|
||||
assertThat(findClosest4Bit(0x56F5F5)).isEqualTo(AnsiColor.BRIGHT_CYAN);
|
||||
assertThat(findClosest4Bit(0xEDF5F5)).isEqualTo(AnsiColor.BRIGHT_WHITE);
|
||||
}
|
||||
|
||||
private AnsiColor getClosest(int rgb) {
|
||||
return AnsiColors.getClosest(new Color(rgb));
|
||||
@Test
|
||||
void findClosest8BitWhenExactMatchShouldReturnAnsiColor() {
|
||||
assertThat(findClosest8Bit(0x000000)).isEqualTo(Ansi8BitColor.foreground(0));
|
||||
assertThat(findClosest8Bit(0xFFFFFF)).isEqualTo(Ansi8BitColor.foreground(15));
|
||||
assertThat(findClosest8Bit(0xFF00FF)).isEqualTo(Ansi8BitColor.foreground(13));
|
||||
assertThat(findClosest8Bit(0x008700)).isEqualTo(Ansi8BitColor.foreground(28));
|
||||
assertThat(findClosest8Bit(0xAF8700)).isEqualTo(Ansi8BitColor.foreground(136));
|
||||
}
|
||||
|
||||
@Test
|
||||
void getClosest8BitWhenCloseShouldReturnAnsiColor() {
|
||||
assertThat(findClosest8Bit(0x000001)).isEqualTo(Ansi8BitColor.foreground(0));
|
||||
assertThat(findClosest8Bit(0xFFFFFE)).isEqualTo(Ansi8BitColor.foreground(15));
|
||||
assertThat(findClosest8Bit(0xFF00FE)).isEqualTo(Ansi8BitColor.foreground(13));
|
||||
assertThat(findClosest8Bit(0x008701)).isEqualTo(Ansi8BitColor.foreground(28));
|
||||
assertThat(findClosest8Bit(0xAF8701)).isEqualTo(Ansi8BitColor.foreground(136));
|
||||
}
|
||||
|
||||
private AnsiElement findClosest4Bit(int rgb) {
|
||||
return findClosest(BitDepth.FOUR, rgb);
|
||||
}
|
||||
|
||||
private AnsiElement findClosest8Bit(int rgb) {
|
||||
return findClosest(BitDepth.EIGHT, rgb);
|
||||
}
|
||||
|
||||
private AnsiElement findClosest(BitDepth depth, int rgb) {
|
||||
return new AnsiColors(depth).findClosest(new Color(rgb));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -27,6 +27,7 @@ import static org.assertj.core.api.Assertions.assertThat;
|
||||
* Tests for {@link AnsiPropertySource}.
|
||||
*
|
||||
* @author Phillip Webb
|
||||
* @author Toshiaki Maki
|
||||
*/
|
||||
class AnsiPropertySourceTests {
|
||||
|
||||
@ -45,11 +46,13 @@ class AnsiPropertySourceTests {
|
||||
@Test
|
||||
void getAnsiColor() {
|
||||
assertThat(this.source.getProperty("AnsiColor.RED")).isEqualTo(AnsiColor.RED);
|
||||
assertThat(this.source.getProperty("AnsiColor.100")).isEqualTo(Ansi8BitColor.foreground(100));
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAnsiBackground() {
|
||||
assertThat(this.source.getProperty("AnsiBackground.GREEN")).isEqualTo(AnsiBackground.GREEN);
|
||||
assertThat(this.source.getProperty("AnsiBackground.100")).isEqualTo(Ansi8BitColor.background(100));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -69,6 +72,8 @@ class AnsiPropertySourceTests {
|
||||
AnsiOutput.setEnabled(Enabled.ALWAYS);
|
||||
AnsiPropertySource source = new AnsiPropertySource("ansi", true);
|
||||
assertThat(source.getProperty("Ansi.RED")).isEqualTo("\033[31m");
|
||||
assertThat(source.getProperty("AnsiColor.100")).isEqualTo("\033[38;5;100m");
|
||||
assertThat(source.getProperty("AnsiBackground.100")).isEqualTo("\033[48;5;100m");
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -76,6 +81,8 @@ class AnsiPropertySourceTests {
|
||||
AnsiOutput.setEnabled(Enabled.NEVER);
|
||||
AnsiPropertySource source = new AnsiPropertySource("ansi", true);
|
||||
assertThat(source.getProperty("Ansi.RED")).isEqualTo("");
|
||||
assertThat(source.getProperty("AnsiColor.100")).isEqualTo("");
|
||||
assertThat(source.getProperty("AnsiBackground.100")).isEqualTo("");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
name=Phil
|
||||
sample.name=Andy
|
||||
|
||||
spring.banner.image.bitdepth=8
|
||||
|
||||
Loading…
Reference in New Issue
Block a user