From cc3e72914add9c950f563bf37c6615e8721ad32e Mon Sep 17 00:00:00 2001 From: Niki Roo Date: Fri, 9 Mar 2018 08:43:44 +0100 Subject: [PATCH] New text justification (some tests missing) --- src/be/nikiroo/utils/StringJustifier.java | 244 ++++++++++++++++++ src/be/nikiroo/utils/StringUtils.java | 108 +++++++- .../nikiroo/utils/test/StringUtilsTest.java | 33 ++- 3 files changed, 370 insertions(+), 15 deletions(-) create mode 100644 src/be/nikiroo/utils/StringJustifier.java diff --git a/src/be/nikiroo/utils/StringJustifier.java b/src/be/nikiroo/utils/StringJustifier.java new file mode 100644 index 00000000..4aab2e78 --- /dev/null +++ b/src/be/nikiroo/utils/StringJustifier.java @@ -0,0 +1,244 @@ +/* + * This file was taken from: + * Jexer - Java Text User Interface + * + * The MIT License (MIT) + * + * Copyright (C) 2017 Kevin Lamonte + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * @author Kevin Lamonte [kevin.lamonte@gmail.com] + * @version 1 + */ +package be.nikiroo.utils; + +import java.util.LinkedList; +import java.util.List; + +/** + * StringJustifier contains methods to convert one or more long lines of strings + * into justified text paragraphs. + */ +class StringJustifier { + + /** + * Left-justify a string into a list of lines. + * + * @param str + * the string + * @param n + * the maximum number of characters in a line + * @return the list of lines + */ + static List left(final String str, final int n) { + List result = new LinkedList(); + + /* + * General procedure: + * + * 1. Split on '\n' into paragraphs. + * + * 2. Scan each line, noting the position of the last + * beginning-of-a-word. + * + * 3. Chop at the last #2 if the next beginning-of-a-word exceeds n. + * + * 4. Return the lines. + */ + + String[] rawLines = str.split("\n"); + for (int i = 0; i < rawLines.length; i++) { + StringBuilder line = new StringBuilder(); + StringBuilder word = new StringBuilder(); + boolean inWord = false; + for (int j = 0; j < rawLines[i].length(); j++) { + char ch = rawLines[i].charAt(j); + if ((ch == ' ') || (ch == '\t')) { + if (inWord == true) { + // We have just transitioned from a word to + // whitespace. See if we have enough space to add + // the word to the line. + if (word.length() + line.length() > n) { + // This word will exceed the line length. Wrap + // at it instead. + result.add(line.toString()); + line = new StringBuilder(); + } + if ((word.toString().startsWith(" ")) + && (line.length() == 0)) { + line.append(word.substring(1)); + } else { + line.append(word); + } + word = new StringBuilder(); + word.append(ch); + inWord = false; + } else { + // We are in the whitespace before another word. Do + // nothing. + } + } else { + if (inWord == true) { + // We are appending to a word. + word.append(ch); + } else { + // We have transitioned from whitespace to a word. + word.append(ch); + inWord = true; + } + } + } // for (int j = 0; j < rawLines[i].length(); j++) + + if (word.length() + line.length() > n) { + // This word will exceed the line length. Wrap at it + // instead. + result.add(line.toString()); + line = new StringBuilder(); + } + if ((word.toString().startsWith(" ")) && (line.length() == 0)) { + line.append(word.substring(1)); + } else { + line.append(word); + } + result.add(line.toString()); + } // for (int i = 0; i < rawLines.length; i++) { + + return result; + } + + /** + * Right-justify a string into a list of lines. + * + * @param str + * the string + * @param n + * the maximum number of characters in a line + * @return the list of lines + */ + static List right(final String str, final int n) { + List result = new LinkedList(); + + /* + * Same as left(), but preceed each line with spaces to make it n chars + * long. + */ + List lines = left(str, n); + for (String line : lines) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < n - line.length(); i++) { + sb.append(' '); + } + sb.append(line); + result.add(sb.toString()); + } + + return result; + } + + /** + * Center a string into a list of lines. + * + * @param str + * the string + * @param n + * the maximum number of characters in a line + * @return the list of lines + */ + static List center(final String str, final int n) { + List result = new LinkedList(); + + /* + * Same as left(), but preceed/succeed each line with spaces to make it + * n chars long. + */ + List lines = left(str, n); + for (String line : lines) { + StringBuilder sb = new StringBuilder(); + int l = (n - line.length()) / 2; + int r = n - line.length() - l; + for (int i = 0; i < l; i++) { + sb.append(' '); + } + sb.append(line); + for (int i = 0; i < r; i++) { + sb.append(' '); + } + result.add(sb.toString()); + } + + return result; + } + + /** + * Fully-justify a string into a list of lines. + * + * @param str + * the string + * @param n + * the maximum number of characters in a line + * @return the list of lines + */ + static List full(final String str, final int n) { + List result = new LinkedList(); + + /* + * Same as left(), but insert spaces between words to make each line n + * chars long. The "algorithm" here is pretty dumb: it performs a split + * on space and then re-inserts multiples of n between words. + */ + List lines = left(str, n); + for (int lineI = 0; lineI < lines.size() - 1; lineI++) { + String line = lines.get(lineI); + String[] words = line.split(" "); + if (words.length > 1) { + int charCount = 0; + for (int i = 0; i < words.length; i++) { + charCount += words[i].length(); + } + int spaceCount = n - charCount; + int q = spaceCount / (words.length - 1); + int r = spaceCount % (words.length - 1); + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < words.length - 1; i++) { + sb.append(words[i]); + for (int j = 0; j < q; j++) { + sb.append(' '); + } + if (r > 0) { + sb.append(' '); + r--; + } + } + for (int j = 0; j < r; j++) { + sb.append(' '); + } + sb.append(words[words.length - 1]); + result.add(sb.toString()); + } else { + result.add(line); + } + } + if (lines.size() > 0) { + result.add(lines.get(lines.size() - 1)); + } + + return result; + } +} diff --git a/src/be/nikiroo/utils/StringUtils.java b/src/be/nikiroo/utils/StringUtils.java index 1e9d7ed7..9e5d654a 100644 --- a/src/be/nikiroo/utils/StringUtils.java +++ b/src/be/nikiroo/utils/StringUtils.java @@ -10,6 +10,7 @@ import java.text.Normalizer.Form; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; +import java.util.List; import java.util.Scanner; import java.util.regex.Pattern; @@ -25,15 +26,46 @@ import org.unbescape.html.HtmlEscapeType; public class StringUtils { /** * This enum type will decide the alignment of a {@link String} when padding - * is applied or if there is enough horizontal space for it to be aligned. + * or justification is applied (if there is enough horizontal space for it + * to be aligned). */ public enum Alignment { /** Aligned at left. */ - Beginning, + LEFT, /** Centered. */ - Center, + CENTER, /** Aligned at right. */ - End + RIGHT, + /** Full justified (to both left and right). */ + JUSTIFY, + + // Old Deprecated values: + + /** DEPRECATED: please use LEFT. */ + @Deprecated + Beginning, + /** DEPRECATED: please use CENTER. */ + @Deprecated + Center, + /** DEPRECATED: please use RIGHT. */ + @Deprecated + End; + + /** + * Return the non-deprecated version of this enum if needed (or return + * self if not). + * + * @return the non-deprecated value + */ + Alignment undeprecate() { + if (this == Beginning) + return LEFT; + if (this == Center) + return CENTER; + if (this == End) + return RIGHT; + return this; + } } static private Pattern marks = getMarks(); @@ -74,9 +106,11 @@ public class StringUtils { Alignment align) { if (align == null) { - align = Alignment.Beginning; + align = Alignment.LEFT; } + align = align.undeprecate(); + if (width >= 0) { if (text == null) text = ""; @@ -87,23 +121,23 @@ public class StringUtils { if (cut) text = text.substring(0, width); } else if (diff > 0) { - if (diff < 2 && align != Alignment.End) - align = Alignment.Beginning; + if (diff < 2 && align != Alignment.RIGHT) + align = Alignment.LEFT; switch (align) { - case Beginning: - text = text + new String(new char[diff]).replace('\0', ' '); - break; - case End: + case RIGHT: text = new String(new char[diff]).replace('\0', ' ') + text; break; - case Center: - default: + case CENTER: int pad1 = (diff) / 2; int pad2 = (diff + 1) / 2; text = new String(new char[pad1]).replace('\0', ' ') + text + new String(new char[pad2]).replace('\0', ' '); break; + case LEFT: + default: + text = text + new String(new char[diff]).replace('\0', ' '); + break; } } } @@ -111,6 +145,54 @@ public class StringUtils { return text; } + /** + * Justify a text into width-sized (at the maximum) lines. + * + * @param text + * the {@link String} to justify + * @param width + * the maximum size of the resulting lines + * + * @return a list of justified text lines + */ + static public List justifyText(String text, int width) { + return justifyText(text, width, null); + } + + /** + * Justify a text into width-sized (at the maximum) lines. + * + * @param text + * the {@link String} to justify + * @param width + * the maximum size of the resulting lines + * @param align + * align the lines in this position (default is + * Alignment.Beginning) + * + * @return a list of justified text lines + */ + static public List justifyText(String text, int width, + Alignment align) { + if (align == null) { + align = Alignment.LEFT; + } + + align = align.undeprecate(); + + switch (align) { + case CENTER: + return StringJustifier.center(text, width); + case RIGHT: + return StringJustifier.right(text, width); + case JUSTIFY: + return StringJustifier.full(text, width); + case LEFT: + default: + return StringJustifier.left(text, width); + } + } + /** * Sanitise the given input to make it more Terminal-friendly by removing * combining characters. diff --git a/src/be/nikiroo/utils/test/StringUtilsTest.java b/src/be/nikiroo/utils/test/StringUtilsTest.java index 5c939575..274e5e88 100644 --- a/src/be/nikiroo/utils/test/StringUtilsTest.java +++ b/src/be/nikiroo/utils/test/StringUtilsTest.java @@ -76,7 +76,7 @@ class StringUtilsTest extends TestLauncher { true, data.trim().equals(result.trim())); result = StringUtils.padString(data, size, false, - Alignment.End); + Alignment.RIGHT); if (size > data.length()) { assertEquals( "Padding a String to the end should work as expected", @@ -84,7 +84,25 @@ class StringUtilsTest extends TestLauncher { } result = StringUtils.padString(data, size, false, - Alignment.Center); + Alignment.JUSTIFY); + if (size > data.length()) { + String unspacedData = data.trim(); + String unspacedResult = result.trim(); + for (int i = 0; i < size; i++) { + unspacedData = unspacedData.replace(" ", " "); + unspacedResult = unspacedResult.replace(" ", + " "); + } + + assertEquals( + "Justified text trimmed with all spaces collapsed " + + "sould be identical to original text " + + "trimmed with all spaces collapsed", + unspacedData, unspacedResult); + } + + result = StringUtils.padString(data, size, false, + Alignment.CENTER); if (size > data.length()) { int before = 0; for (int i = 0; i < result.length() @@ -120,6 +138,17 @@ class StringUtilsTest extends TestLauncher { } }); + addTest(new TestCase("Justifying") { + @Override + public void test() throws Exception { + for (String data : new String[] {}) { + // TODO: test it! + // String result = StringUtils.justifyText(data, 5, + // StringUtils.Alignment.LEFT); + } + } + }); + addTest(new TestCase("unhtml") { @Override public void test() throws Exception { -- 2.27.0