[fanfix.git] / src / jexer / bits / StringUtils.java

/*
 * Jexer - Java Text User Interface
 *
 * The MIT License (MIT)
 *
 * Copyright (C) 2019 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 jexer.bits;

import java.util.List;
import java.util.LinkedList;

/**
 * StringUtils contains methods to:
 *
 *    - Convert one or more long lines of strings into justified text
 *      paragraphs.
 *
 *    - Unescape C0 control codes.
 *
 */
public class StringUtils {

    /**
     * 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
     */
    public 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
     */
    public 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
     */
    public 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
     */
    public 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;
    }

    /**
     * Convert raw strings into escaped strings that be splatted on the
     * screen.
     *
     * @param str the string
     * @return a string that can be passed into Screen.putStringXY()
     */
    public static String unescape(final String str) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            if ((ch < 0x20) || (ch == 0x7F)) {
                switch (ch) {
                case '\b':
                    sb.append("\\b");
                    continue;
                case '\f':
                    sb.append("\\f");
                    continue;
                case '\n':
                    sb.append("\\n");
                    continue;
                case '\r':
                    sb.append("\\r");
                    continue;
                case '\t':
                    sb.append("\\t");
                    continue;
                case 0x7f:
                    sb.append("^?");
                    continue;
                default:
                    sb.append(' ');
                    continue;
                }
            }
            sb.append(ch);
        }
        return sb.toString();
    }

}
Commit	Line	Data
7657ad8c KL	1	/*
	2	* Jexer - Java Text User Interface
	3	*
	4	* The MIT License (MIT)
	5	*
a69ed767	6	* Copyright (C) 2019 Kevin Lamonte
7657ad8c KL	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a
	9	* copy of this software and associated documentation files (the "Software"),
	10	* to deal in the Software without restriction, including without limitation
	11	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	12	* and/or sell copies of the Software, and to permit persons to whom the
	13	* Software is furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	21	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	22	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	23	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	24	* DEALINGS IN THE SOFTWARE.
	25	*
	26	* @author Kevin Lamonte [kevin.lamonte@gmail.com]
	27	* @version 1
	28	*/
	29	package jexer.bits;
	30
	31	import java.util.List;
	32	import java.util.LinkedList;
	33
	34	/**
d36057df KL	35	* StringUtils contains methods to:
	36	*
	37	* - Convert one or more long lines of strings into justified text
	38	* paragraphs.
	39	*
	40	* - Unescape C0 control codes.
	41	*
7657ad8c	42	*/
051e2913	43	public class StringUtils {
7657ad8c KL	44
	45	/**
	46	* Left-justify a string into a list of lines.
	47	*
	48	* @param str the string
	49	* @param n the maximum number of characters in a line
	50	* @return the list of lines
	51	*/
	52	public static List<String> left(final String str, final int n) {
	53	List<String> result = new LinkedList<String>();
	54
	55	/*
	56	* General procedure:
	57	*
	58	* 1. Split on '\n' into paragraphs.
	59	*
	60	* 2. Scan each line, noting the position of the last
	61	* beginning-of-a-word.
	62	*
	63	* 3. Chop at the last #2 if the next beginning-of-a-word exceeds
	64	* n.
	65	*
	66	* 4. Return the lines.
	67	*/
	68
	69	String [] rawLines = str.split("\n");
	70	for (int i = 0; i < rawLines.length; i++) {
	71	StringBuilder line = new StringBuilder();
	72	StringBuilder word = new StringBuilder();
	73	boolean inWord = false;
	74	for (int j = 0; j < rawLines[i].length(); j++) {
	75	char ch = rawLines[i].charAt(j);
	76	if ((ch == ' ') \|\| (ch == '\t')) {
	77	if (inWord == true) {
	78	// We have just transitioned from a word to
	79	// whitespace. See if we have enough space to add
	80	// the word to the line.
	81	if (word.length() + line.length() > n) {
	82	// This word will exceed the line length. Wrap
	83	// at it instead.
	84	result.add(line.toString());
	85	line = new StringBuilder();
	86	}
	87	if ((word.toString().startsWith(" "))
	88	&& (line.length() == 0)
	89	) {
	90	line.append(word.substring(1));
	91	} else {
	92	line.append(word);
	93	}
	94	word = new StringBuilder();
	95	word.append(ch);
	96	inWord = false;
	97	} else {
	98	// We are in the whitespace before another word. Do
	99	// nothing.
	100	}
	101	} else {
	102	if (inWord == true) {
	103	// We are appending to a word.
	104	word.append(ch);
	105	} else {
	106	// We have transitioned from whitespace to a word.
	107	word.append(ch);
108	inWord = true;
109	}
110	}
111	} // for (int j = 0; j < rawLines[i].length(); j++)
112
113	if (word.length() + line.length() > n) {
114	// This word will exceed the line length. Wrap at it
115	// instead.
116	result.add(line.toString());
117	line = new StringBuilder();
118	}
119	if ((word.toString().startsWith(" "))
120	&& (line.length() == 0)
121	) {
122	line.append(word.substring(1));
123	} else {
124	line.append(word);
125	}
126	result.add(line.toString());
127	} // for (int i = 0; i < rawLines.length; i++) {
128
129	return result;
130	}
131
132	/**
133	* Right-justify a string into a list of lines.
134	*
135	* @param str the string
136	* @param n the maximum number of characters in a line
137	* @return the list of lines
138	*/
139	public static List<String> right(final String str, final int n) {
140	List<String> result = new LinkedList<String>();
141
142	/*
143	* Same as left(), but preceed each line with spaces to make it n
144	* chars long.
145	*/
146	List<String> lines = left(str, n);
147	for (String line: lines) {
148	StringBuilder sb = new StringBuilder();
149	for (int i = 0; i < n - line.length(); i++) {
150	sb.append(' ');
151	}
152	sb.append(line);
153	result.add(sb.toString());
154	}
155
156	return result;
157	}
158
159	/**
160	* Center a string into a list of lines.
161	*
162	* @param str the string
163	* @param n the maximum number of characters in a line
164	* @return the list of lines
165	*/
166	public static List<String> center(final String str, final int n) {
167	List<String> result = new LinkedList<String>();
168
169	/*
170	* Same as left(), but preceed/succeed each line with spaces to make
171	* it n chars long.
172	*/
173	List<String> lines = left(str, n);
174	for (String line: lines) {
175	StringBuilder sb = new StringBuilder();
176	int l = (n - line.length()) / 2;
177	int r = n - line.length() - l;
178	for (int i = 0; i < l; i++) {
179	sb.append(' ');
180	}
181	sb.append(line);
182	for (int i = 0; i < r; i++) {
183	sb.append(' ');
184	}
185	result.add(sb.toString());
186	}
187
188	return result;
189	}
190
191	/**
192	* Fully-justify a string into a list of lines.
193	*
194	* @param str the string
195	* @param n the maximum number of characters in a line
196	* @return the list of lines
197	*/
198	public static List<String> full(final String str, final int n) {
199	List<String> result = new LinkedList<String>();
200
201	/*
202	* Same as left(), but insert spaces between words to make each line
203	* n chars long. The "algorithm" here is pretty dumb: it performs a
204	* split on space and then re-inserts multiples of n between words.
205	*/
206	List<String> lines = left(str, n);
207	for (int lineI = 0; lineI < lines.size() - 1; lineI++) {
208	String line = lines.get(lineI);
209	String [] words = line.split(" ");
210	if (words.length > 1) {
211	int charCount = 0;
212	for (int i = 0; i < words.length; i++) {
213	charCount += words[i].length();
214	}
215	int spaceCount = n - charCount;
216	int q = spaceCount / (words.length - 1);
217	int r = spaceCount % (words.length - 1);
218	StringBuilder sb = new StringBuilder();
219	for (int i = 0; i < words.length - 1; i++) {
220	sb.append(words[i]);
221	for (int j = 0; j < q; j++) {
222	sb.append(' ');
223	}
224	if (r > 0) {
225	sb.append(' ');
226	r--;
227	}
228	}
229	for (int j = 0; j < r; j++) {
230	sb.append(' ');
231	}
232	sb.append(words[words.length - 1]);
233	result.add(sb.toString());
234	} else {
235	result.add(line);
236	}
237	}
238	if (lines.size() > 0) {
239	result.add(lines.get(lines.size() - 1));
240	}
241
242	return result;
243	}
244
d36057df KL	245	/**
	246	* Convert raw strings into escaped strings that be splatted on the
	247	* screen.
	248	*
	249	* @param str the string
	250	* @return a string that can be passed into Screen.putStringXY()
	251	*/
	252	public static String unescape(final String str) {
	253	StringBuilder sb = new StringBuilder();
	254	for (int i = 0; i < str.length(); i++) {
	255	char ch = str.charAt(i);
	256	if ((ch < 0x20) \|\| (ch == 0x7F)) {
	257	switch (ch) {
	258	case '\b':
	259	sb.append("\\b");
	260	continue;
	261	case '\f':
	262	sb.append("\\f");
	263	continue;
	264	case '\n':
	265	sb.append("\\n");
	266	continue;
	267	case '\r':
	268	sb.append("\\r");
	269	continue;
	270	case '\t':
	271	sb.append("\\t");
	272	continue;
	273	case 0x7f:
	274	sb.append("^?");
	275	continue;
	276	default:
	277	sb.append(' ');
	278	continue;
	279	}
	280	}
	281	sb.append(ch);
	282	}
	283	return sb.toString();
	284	}
	285
7657ad8c	286	}