changeset 53231:ee1f64096d7c

8215489: Remove String::align Reviewed-by: vromero, sundar
author jlaskey
date Wed, 09 Jan 2019 16:41:16 -0400
parents b5f085197234
children 32c6cc430526 05c5c27b5a54 5fa71cce89eb
files src/java.base/share/classes/java/lang/String.java test/jdk/java/lang/String/AlignIndent.java test/jdk/java/lang/String/Indent.java
diffstat 3 files changed, 130 insertions(+), 324 deletions(-) [+]
line wrap: on
line diff
--- a/src/java.base/share/classes/java/lang/String.java	Wed Jan 09 15:23:11 2019 -0400
+++ b/src/java.base/share/classes/java/lang/String.java	Wed Jan 09 16:41:16 2019 -0400
@@ -2869,116 +2869,6 @@
     }
 
     /**
-     * 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
      * and produce an {@code R} result.
--- a/test/jdk/java/lang/String/AlignIndent.java	Wed Jan 09 15:23:11 2019 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/*
- * @test
- * @summary Unit tests for String#align and String#indent
- * @run main AlignIndent
- */
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class AlignIndent {
-    static final List<String> ENDS = List.of("", "\n", "   \n", "\n\n", "\n\n\n");
-    static final List<String> MIDDLES = List.of(
-            "",
-            "xyz",
-            "   xyz",
-            "      xyz",
-            "xyz   ",
-            "   xyz   ",
-            "      xyz   ",
-            "xyz\u2022",
-            "   xyz\u2022",
-            "xyz\u2022   ",
-            "   xyz\u2022   ",
-            "   // comment"
-    );
-
-    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() {
-        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.indent(adjust);
-
-                        Stream<String> stream = input.lines();
-                        if (adjust > 0) {
-                            final String spaces = " ".repeat(adjust);
-                            stream = stream.map(s -> s.isBlank() ? s : spaces + s);
-                        } else if (adjust < 0) {
-                            stream = stream.map(s -> s.substring(Math.min(-adjust, indexOfNonWhitespace(s))));
-                        }
-                        String expected = stream.collect(Collectors.joining("\n", "", "\n"));
-
-                        if (!output.equals(expected)) {
-                            report("String::indent(int n)",
-                                    "Result indentation not as expected", expected, output);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /*
-     * 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()) {
-            char ch = s.charAt(left);
-            if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
-                break;
-            }
-            left++;
-        }
-        return left;
-    }
-
-
-    private static String[] getBody(String[] inLines) {
-        int from = -1, to = -1;
-        for (int i = 0; i < inLines.length; i++) {
-            String line = inLines[i];
-            if (!line.isBlank()) {
-                if (from == -1) {
-                    from = i;
-                }
-                to = i + 1;
-            }
-        }
-        return Arrays.copyOfRange(inLines, from, to);
-    }
-
-    /*
-     * Report difference in result.
-     */
-    static void report(String test, String message, String input, String output) {
-        System.err.println("Testing " + test + ": " + message);
-        System.err.println();
-        System.err.println("Input: length = " + input.length());
-        System.err.println("_".repeat(40));
-        System.err.print(input.replaceAll(" ", "."));
-        System.err.println("_".repeat(40));
-        System.err.println();
-        System.err.println("Output: length = " + output.length());
-        System.err.println("_".repeat(40));
-        System.err.print(output.replaceAll(" ", "."));
-        System.err.println("_".repeat(40));
-        throw new RuntimeException();
-    }
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/java/lang/String/Indent.java	Wed Jan 09 16:41:16 2019 -0400
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @summary Unit tests for String#indent
+ * @run main Indent
+ */
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Indent {
+    static final List<String> ENDS = List.of("", "\n", "   \n", "\n\n", "\n\n\n");
+    static final List<String> MIDDLES = List.of(
+            "",
+            "xyz",
+            "   xyz",
+            "      xyz",
+            "xyz   ",
+            "   xyz   ",
+            "      xyz   ",
+            "xyz\u2022",
+            "   xyz\u2022",
+            "xyz\u2022   ",
+            "   xyz\u2022   ",
+            "   // comment"
+    );
+
+    public static void main(String[] args) {
+        test1();
+    }
+
+    /*
+     * Test String#indent(int n) functionality.
+     */
+    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) {
+                    for (String middle : MIDDLES) {
+                        String input = prefix + "   abc   \n" + middle + "\n   def   \n" + suffix;
+                        String output = input.indent(adjust);
+
+                        Stream<String> stream = input.lines();
+                        if (adjust > 0) {
+                            final String spaces = " ".repeat(adjust);
+                            stream = stream.map(s -> s.isBlank() ? s : spaces + s);
+                        } else if (adjust < 0) {
+                            stream = stream.map(s -> s.substring(Math.min(-adjust, indexOfNonWhitespace(s))));
+                        }
+                        String expected = stream.collect(Collectors.joining("\n", "", "\n"));
+
+                        if (!output.equals(expected)) {
+                            report("String::indent(int n)",
+                                    "Result indentation not as expected", expected, output);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public static int indexOfNonWhitespace(String s) {
+        int left = 0;
+        while (left < s.length()) {
+            char ch = s.charAt(left);
+            if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
+                break;
+            }
+            left++;
+        }
+        return left;
+    }
+
+
+    private static String[] getBody(String[] inLines) {
+        int from = -1, to = -1;
+        for (int i = 0; i < inLines.length; i++) {
+            String line = inLines[i];
+            if (!line.isBlank()) {
+                if (from == -1) {
+                    from = i;
+                }
+                to = i + 1;
+            }
+        }
+        return Arrays.copyOfRange(inLines, from, to);
+    }
+
+    /*
+     * Report difference in result.
+     */
+    static void report(String test, String message, String input, String output) {
+        System.err.println("Testing " + test + ": " + message);
+        System.err.println();
+        System.err.println("Input: length = " + input.length());
+        System.err.println("_".repeat(40));
+        System.err.print(input.replaceAll(" ", "."));
+        System.err.println("_".repeat(40));
+        System.err.println();
+        System.err.println("Output: length = " + output.length());
+        System.err.println("_".repeat(40));
+        System.err.print(output.replaceAll(" ", "."));
+        System.err.println("_".repeat(40));
+        throw new RuntimeException();
+    }
+}