stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8215489: Remove String::align

Browse Source 
Reviewed-by: vromero, sundar
This commit is contained in:
Jim Laskey 2019-01-09 16:41:16 -04:00
parent c7d085fa64
commit eeca4576d2
2 changed files with 4 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
src/java.base/share/classes/java/lang/String.java
View File

@ -2868,116 +2868,6 @@ public final class String
: StringUTF16.lastIndexOfNonWhitespace(value);
}
/**
* Removes vertical and horizontal white space margins from around the
* essential body of a multi-line string, while preserving relative
* indentation.
* <p>
* This string is first conceptually separated into lines as if by
* {@link String#lines()}.
* <p>
* Then, the <i>minimum indentation</i> (min) is determined as follows. For
* each non-blank line (as defined by {@link String#isBlank()}), the
* leading {@link Character#isWhitespace(int) white space} characters are
* counted. The <i>min</i> value is the smallest of these counts.
* <p>
* For each non-blank line, <i>min</i> leading white space characters are
* removed. Each white space character is treated as a single character. In
* particular, the tab character {@code "\t"} (U+0009) is considered a
* single character; it is not expanded.
* <p>
* Leading and trailing blank lines, if any, are removed. Trailing spaces are
* preserved.
* <p>
* Each line is suffixed with a line feed character {@code "\n"} (U+000A).
* <p>
* Finally, the lines are concatenated into a single string and returned.
*
* @apiNote
* This method's primary purpose is to shift a block of lines as far as
* possible to the left, while preserving relative indentation. Lines
* that were indented the least will thus have no leading white space.
*
* Example:
* <blockquote><pre>
* `
* This is the first line
* This is the second line
* `.align();
*
* returns
* This is the first line
* This is the second line
* </pre></blockquote>
*
* @return string with margins removed and line terminators normalized
*
* @see String#lines()
* @see String#isBlank()
* @see String#indent(int)
* @see Character#isWhitespace(int)
*
* @since 12
*/
public String align() {
return align(0);
}
/**
* Removes vertical and horizontal white space margins from around the
* essential body of a multi-line string, while preserving relative
* indentation and with optional indentation adjustment.
* <p>
* Invoking this method is equivalent to:
* <blockquote>
* {@code this.align().indent(n)}
* </blockquote>
*
* @apiNote
* Examples:
* <blockquote><pre>
* `
* This is the first line
* This is the second line
* `.align(0);
*
* returns
* This is the first line
* This is the second line
*
*
* `
* This is the first line
* This is the second line
* `.align(4);
* returns
* This is the first line
* This is the second line
* </pre></blockquote>
*
* @param n number of leading white space characters
* to add or remove
*
* @return string with margins removed, indentation adjusted and
* line terminators normalized
*
* @see String#align()
*
* @since 12
*/
public String align(int n) {
if (isEmpty()) {
return "";
}
int outdent = lines().filter(not(String::isBlank))
.mapToInt(String::indexOfNonWhitespace)
.min()
.orElse(0);
// overflow-conscious code
int indent = n - outdent;
return indent(indent > n ? Integer.MIN_VALUE : indent, true);
}
/**
* This method allows the application of a function to {@code this}
* string. The function should expect a single String argument

92
test/jdk/java/lang/String/AlignIndent.java → test/jdk/java/lang/String/Indent.java
View File

@ -23,8 +23,8 @@
/*
* @test
* @summary Unit tests for String#align and String#indent
* @run main AlignIndent
* @summary Unit tests for String#indent
* @run main Indent
*/
import java.util.Arrays;
@ -32,7 +32,7 @@ import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class AlignIndent {
public class Indent {
static final List<String> ENDS = List.of("", "\n", " \n", "\n\n", "\n\n\n");
static final List<String> MIDDLES = List.of(
"",
@ -51,84 +51,12 @@ public class AlignIndent {
public static void main(String[] args) {
test1();
test2();
test3();
test4();
}
/*
* Test String#align() functionality.
*/
static void test1() {
for (String prefix : ENDS) {
for (String suffix : ENDS) {
for (String middle : MIDDLES) {
{
String input = prefix + " abc \n" + middle + "\n def \n" + suffix;
String output = input.align();
String[] inLines = input.split("\\R");
String[] outLines = output.split("\\R");
String[] inLinesBody = getBody(inLines);
if (inLinesBody.length < outLines.length) {
report("String::align()", "Result has more lines than expected", input, output);
} else if (inLinesBody.length > outLines.length) {
report("String::align()", "Result has fewer lines than expected", input, output);
}
int indent = -1;
for (int i = 0; i < inLinesBody.length; i++) {
String in = inLinesBody[i];
String out = outLines[i];
if (!out.isBlank()) {
int offset = in.indexOf(out);
if (offset == -1) {
report("String::align()", "Portions of line are missing", input, output);
}
if (indent == -1) {
indent = offset;
} else if (offset != indent) {
report("String::align()",
"Inconsistent indentation in result", input, output);
}
}
}
}
}
}
}
}
/*
* Test String#align(int n) functionality.
*/
static void test2() {
for (int adjust : new int[] {-8, -7, -4, -3, -2, -1, 0, 1, 2, 3, 4, 7, 8}) {
for (String prefix : ENDS) {
for (String suffix : ENDS) {
for (String middle : MIDDLES) {
{
String input = prefix + " abc \n" + middle + "\n def \n" + suffix;
String output = input.align(adjust);
String expected = input.align().indent(adjust);
if (!output.equals(expected)) {
report("String::align(int n)",
"Result inconsistent with align().indent(n)", expected, output);
}
}
}
}
}
}
}
/*
* Test String#indent(int n) functionality.
*/
static void test3() {
static void test1() {
for (int adjust : new int[] {-8, -7, -4, -3, -2, -1, 0, 1, 2, 3, 4, 7, 8}) {
for (String prefix : ENDS) {
for (String suffix : ENDS) {
@ -155,18 +83,6 @@ public class AlignIndent {
}
}
/*
* JDK-8212694: Using Raw String Literals with align() and Integer.MIN_VALUE causes out of memory error
*/
static void test4() {
try {
String str = "\n A\n".align(Integer.MIN_VALUE);
} catch (OutOfMemoryError ex) {
System.err.println("align(Integer.MIN_VALUE) not clipping indentation");
throw new RuntimeException();
}
}
public static int indexOfNonWhitespace(String s) {
int left = 0;
while (left < s.length()) {