--- /dev/null
+/*
+ * 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<String> left(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * 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<String> right(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * Same as left(), but preceed each line with spaces to make it n chars
+ * long.
+ */
+ List<String> 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<String> center(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * Same as left(), but preceed/succeed each line with spaces to make it
+ * n chars long.
+ */
+ List<String> 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<String> full(final String str, final int n) {
+ List<String> result = new LinkedList<String>();
+
+ /*
+ * 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<String> 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;
+ }
+}
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;
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();
Alignment align) {
if (align == null) {
- align = Alignment.Beginning;
+ align = Alignment.LEFT;
}
+ align = align.undeprecate();
+
if (width >= 0) {
if (text == null)
text = "";
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;
}
}
}
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<String> 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<String> 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.
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",
}
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()
}
});
+ 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 {
git://git.nikiroo.be / nikiroo-utils.git / commitdiff