Repository: commons-text Updated Branches: refs/heads/master edfe5f85b -> a28e32ea2
TEXT-55: Removing WordUtils to be put back in later Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/a28e32ea Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/a28e32ea Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/a28e32ea Branch: refs/heads/master Commit: a28e32ea2f3b887b34cbed19aa6436b8759e8d12 Parents: edfe5f8 Author: Rob Tompkins <chtom...@gmail.com> Authored: Tue Jan 3 07:33:04 2017 -0500 Committer: Rob Tompkins <chtom...@gmail.com> Committed: Tue Jan 3 07:33:04 2017 -0500 ---------------------------------------------------------------------- src/changes/changes.xml | 1 + .../java/org/apache/commons/text/WordUtils.java | 728 ------------------- .../org/apache/commons/text/WordUtilsTest.java | 420 ----------- 3 files changed, 1 insertion(+), 1148 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/commons-text/blob/a28e32ea/src/changes/changes.xml ---------------------------------------------------------------------- diff --git a/src/changes/changes.xml b/src/changes/changes.xml index 1ef9f66..09a684c 100644 --- a/src/changes/changes.xml +++ b/src/changes/changes.xml @@ -22,6 +22,7 @@ <body> <release version="1.0" date="tba" description="tba"> + <action issue="TEXT-55" type="remove" dev="chtompki">Remove WordUtils to be added back in an upcoming 1.X release</action> <action issue="TEXT-52" type="fix" dev="chtompki">Possible attacks through StringEscapeUtils.escapeEcmaScrip better javadoc</action> <action issue="TEXT-51" type="remove" dev="chtompki">Remove RandomStringGenerator to be added back in the 1.1 release</action> <action issue="TEXT-50" type="update" dev="chtompki">Upgrade from commons-parent version 41 to version 42</action> http://git-wip-us.apache.org/repos/asf/commons-text/blob/a28e32ea/src/main/java/org/apache/commons/text/WordUtils.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/text/WordUtils.java b/src/main/java/org/apache/commons/text/WordUtils.java deleted file mode 100644 index 7292d89..0000000 --- a/src/main/java/org/apache/commons/text/WordUtils.java +++ /dev/null @@ -1,728 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.text; - -import java.lang.reflect.Array; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -/** - * <p>Operations on Strings that contain words.</p> - * - * <p>This class tries to handle <code>null</code> input gracefully. - * An exception will not be thrown for a <code>null</code> input. - * Each method documents its behaviour in more detail.</p> - * - * @since 1.0 - */ -public class WordUtils { - - /** - * <p><code>WordUtils</code> instances should NOT be constructed in - * standard programming. Instead, the class should be used as - * <code>WordUtils.wrap("foo bar", 20);</code>.</p> - * - * <p>This constructor is public to permit tools that require a JavaBean - * instance to operate.</p> - */ - public WordUtils() { - super(); - } - - // Wrapping - //-------------------------------------------------------------------------- - /** - * <p>Wraps a single line of text, identifying words by <code>' '</code>.</p> - * - * <p>New lines will be separated by the system property line separator. - * Very long words, such as URLs will <i>not</i> be wrapped.</p> - * - * <p>Leading spaces on a new line are stripped. - * Trailing spaces are not stripped.</p> - * - * <table border="1" summary="Wrap Results"> - * <tr> - * <th>input</th> - * <th>wrapLength</th> - * <th>result</th> - * </tr> - * <tr> - * <td>null</td> - * <td>*</td> - * <td>null</td> - * </tr> - * <tr> - * <td>""</td> - * <td>*</td> - * <td>""</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>"Here is one line of\ntext that is going\nto be wrapped after\n20 columns."</td> - * </tr> - * <tr> - * <td>"Click here to jump to the commons website - http://commons.apache.org";</td> - * <td>20</td> - * <td>"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org";</td> - * </tr> - * <tr> - * <td>"Click here, http://commons.apache.org, to jump to the commons website"</td> - * <td>20</td> - * <td>"Click here,\nhttp://commons.apache.org,\nto jump to the\ncommons website"</td> - * </tr> - * </table> - * - * (assuming that '\n' is the systems line separator) - * - * @param str the String to be word wrapped, may be null - * @param wrapLength the column to wrap the words at, less than 1 is treated as 1 - * @return a line with newlines inserted, <code>null</code> if null input - */ - public static String wrap(final String str, final int wrapLength) { - return wrap(str, wrapLength, null, false); - } - - /** - * <p>Wraps a single line of text, identifying words by <code>' '</code>.</p> - * - * <p>Leading spaces on a new line are stripped. - * Trailing spaces are not stripped.</p> - * - * <table border="1" summary="Wrap Results"> - * <tr> - * <th>input</th> - * <th>wrapLenght</th> - * <th>newLineString</th> - * <th>wrapLongWords</th> - * <th>result</th> - * </tr> - * <tr> - * <td>null</td> - * <td>*</td> - * <td>*</td> - * <td>true/false</td> - * <td>null</td> - * </tr> - * <tr> - * <td>""</td> - * <td>*</td> - * <td>*</td> - * <td>true/false</td> - * <td>""</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>"\n"</td> - * <td>true/false</td> - * <td>"Here is one line of\ntext that is going\nto be wrapped after\n20 columns."</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>"<br />"</td> - * <td>true/false</td> - * <td>"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns."</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>null</td> - * <td>true/false</td> - * <td>"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns."</td> - * </tr> - * <tr> - * <td>"Click here to jump to the commons website - http://commons.apache.org";</td> - * <td>20</td> - * <td>"\n"</td> - * <td>false</td> - * <td>"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org";</td> - * </tr> - * <tr> - * <td>"Click here to jump to the commons website - http://commons.apache.org";</td> - * <td>20</td> - * <td>"\n"</td> - * <td>true</td> - * <td>"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org";</td> - * </tr> - * </table> - * - * @param str the String to be word wrapped, may be null - * @param wrapLength the column to wrap the words at, less than 1 is treated as 1 - * @param newLineStr the string to insert for a new line, - * <code>null</code> uses the system property line separator - * @param wrapLongWords true if long words (such as URLs) should be wrapped - * @return a line with newlines inserted, <code>null</code> if null input - */ - public static String wrap(final String str, final int wrapLength, final String newLineStr, final boolean wrapLongWords) { - return wrap(str, wrapLength, newLineStr, wrapLongWords, " "); - } - - /** - * <p>Wraps a single line of text, identifying words by <code>wrapOn</code>.</p> - * - * <p>Leading spaces on a new line are stripped. - * Trailing spaces are not stripped.</p> - * - * <table border="1" summary="Wrap Results"> - * <tr> - * <th>input</th> - * <th>wrapLenght</th> - * <th>newLineString</th> - * <th>wrapLongWords</th> - * <th>wrapOn</th> - * <th>result</th> - * </tr> - * <tr> - * <td>null</td> - * <td>*</td> - * <td>*</td> - * <td>true/false</td> - * <td>*</td> - * <td>null</td> - * </tr> - * <tr> - * <td>""</td> - * <td>*</td> - * <td>*</td> - * <td>true/false</td> - * <td>*</td> - * <td>""</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>"\n"</td> - * <td>true/false</td> - * <td>" "</td> - * <td>"Here is one line of\ntext that is going\nto be wrapped after\n20 columns."</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>"<br />"</td> - * <td>true/false</td> - * <td>" "</td> - * <td>"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns."</td> - * </tr> - * <tr> - * <td>"Here is one line of text that is going to be wrapped after 20 columns."</td> - * <td>20</td> - * <td>null</td> - * <td>true/false</td> - * <td>" "</td> - * <td>"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns."</td> - * </tr> - * <tr> - * <td>"Click here to jump to the commons website - http://commons.apache.org";</td> - * <td>20</td> - * <td>"\n"</td> - * <td>false</td> - * <td>" "</td> - * <td>"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org";</td> - * </tr> - * <tr> - * <td>"Click here to jump to the commons website - http://commons.apache.org";</td> - * <td>20</td> - * <td>"\n"</td> - * <td>true</td> - * <td>" "</td> - * <td>"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org";</td> - * </tr> - * <tr> - * <td>"flammable/inflammable"</td> - * <td>20</td> - * <td>"\n"</td> - * <td>true</td> - * <td>"/"</td> - * <td>"flammable\ninflammable"</td> - * </tr> - * </table> - * @param str the String to be word wrapped, may be null - * @param wrapLength the column to wrap the words at, less than 1 is treated as 1 - * @param newLineStr the string to insert for a new line, - * <code>null</code> uses the system property line separator - * @param wrapLongWords true if long words (such as URLs) should be wrapped - * @param wrapOn regex expression to be used as a breakable characters, - * if blank string is provided a space character will be used - * @return a line with newlines inserted, <code>null</code> if null input - */ - public static String wrap(final String str, int wrapLength, String newLineStr, final boolean wrapLongWords, String wrapOn) { - if (str == null) { - return null; - } - if (newLineStr == null) { - newLineStr = System.getProperty("line.separator"); - } - if (wrapLength < 1) { - wrapLength = 1; - } - if (wrapOn == null || wrapOn.length() == 0 || wrapOn.trim().length() == 0) { - wrapOn = " "; - } - final Pattern patternToWrapOn = Pattern.compile(wrapOn); - final int inputLineLength = str.length(); - int offset = 0; - final StringBuilder wrappedLine = new StringBuilder(inputLineLength + 32); - - while (offset < inputLineLength) { - int spaceToWrapAt = -1; - Matcher matcher = patternToWrapOn.matcher(str.substring(offset, Math - .min(offset + wrapLength + 1, inputLineLength))); - if (matcher.find()) { - if (matcher.start() == 0) { - offset += matcher.end(); - continue; - } - spaceToWrapAt = matcher.start(); - } - - // only last line without leading spaces is left - if(inputLineLength - offset <= wrapLength) { - break; - } - - while(matcher.find()){ - spaceToWrapAt = matcher.start() + offset; - } - - if (spaceToWrapAt >= offset) { - // normal case - wrappedLine.append(str.substring(offset, spaceToWrapAt)); - wrappedLine.append(newLineStr); - offset = spaceToWrapAt + 1; - - } else { - // really long word or URL - if (wrapLongWords) { - // wrap really long word one line at a time - wrappedLine.append(str.substring(offset, wrapLength + offset)); - wrappedLine.append(newLineStr); - offset += wrapLength; - } else { - // do not wrap really long word, just extend beyond limit - matcher = patternToWrapOn.matcher(str.substring(offset + wrapLength)); - if (matcher.find()) { - spaceToWrapAt = matcher.start() + offset + wrapLength; - } - - if (spaceToWrapAt >= 0) { - wrappedLine.append(str.substring(offset, spaceToWrapAt)); - wrappedLine.append(newLineStr); - offset = spaceToWrapAt + 1; - } else { - wrappedLine.append(str.substring(offset)); - offset = inputLineLength; - } - } - } - } - - // Whatever is left in line is short enough to just pass through - wrappedLine.append(str.substring(offset)); - - return wrappedLine.toString(); - } - - // Capitalizing - //----------------------------------------------------------------------- - /** - * <p>Capitalizes all the whitespace separated words in a String. - * Only the first character of each word is changed. To convert the - * rest of each word to lowercase at the same time, - * use {@link #capitalizeFully(String)}.</p> - * - * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>. - * Capitalization uses the Unicode title case, normally equivalent to - * upper case.</p> - * - * <pre> - * WordUtils.capitalize(null) = null - * WordUtils.capitalize("") = "" - * WordUtils.capitalize("i am FINE") = "I Am FINE" - * </pre> - * - * @param str the String to capitalize, may be null - * @return capitalized String, <code>null</code> if null String input - * @see #uncapitalize(String) - * @see #capitalizeFully(String) - */ - public static String capitalize(final String str) { - return capitalize(str, null); - } - - /** - * <p>Capitalizes all the delimiter separated words in a String. - * Only the first character of each word is changed. To convert the - * rest of each word to lowercase at the same time, - * use {@link #capitalizeFully(String, char[])}.</p> - * - * <p>The delimiters represent a set of characters understood to separate words. - * The first string character and the first non-delimiter character after a - * delimiter will be capitalized. </p> - * - * <p>A <code>null</code> input String returns <code>null</code>. - * Capitalization uses the Unicode title case, normally equivalent to - * upper case.</p> - * - * <pre> - * WordUtils.capitalize(null, *) = null - * WordUtils.capitalize("", *) = "" - * WordUtils.capitalize(*, new char[0]) = * - * WordUtils.capitalize("i am fine", null) = "I Am Fine" - * WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine" - * </pre> - * - * @param str the String to capitalize, may be null - * @param delimiters set of characters to determine capitalization, null means whitespace - * @return capitalized String, <code>null</code> if null String input - * @see #uncapitalize(String) - * @see #capitalizeFully(String) - */ - public static String capitalize(final String str, final char... delimiters) { - final int delimLen = delimiters == null ? -1 : delimiters.length; - if (str == null || str.length() == 0 || delimLen == 0) { - return str; - } - final char[] buffer = str.toCharArray(); - boolean capitalizeNext = true; - for (int i = 0; i < buffer.length; i++) { - final char ch = buffer[i]; - if (isDelimiter(ch, delimiters)) { - capitalizeNext = true; - } else if (capitalizeNext) { - buffer[i] = Character.toTitleCase(ch); - capitalizeNext = false; - } - } - return new String(buffer); - } - - //----------------------------------------------------------------------- - /** - * <p>Converts all the whitespace separated words in a String into capitalized words, - * that is each word is made up of a titlecase character and then a series of - * lowercase characters. </p> - * - * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>. - * Capitalization uses the Unicode title case, normally equivalent to - * upper case.</p> - * - * <pre> - * WordUtils.capitalizeFully(null) = null - * WordUtils.capitalizeFully("") = "" - * WordUtils.capitalizeFully("i am FINE") = "I Am Fine" - * </pre> - * - * @param str the String to capitalize, may be null - * @return capitalized String, <code>null</code> if null String input - */ - public static String capitalizeFully(final String str) { - return capitalizeFully(str, null); - } - - /** - * <p>Converts all the delimiter separated words in a String into capitalized words, - * that is each word is made up of a titlecase character and then a series of - * lowercase characters. </p> - * - * <p>The delimiters represent a set of characters understood to separate words. - * The first string character and the first non-delimiter character after a - * delimiter will be capitalized. </p> - * - * <p>A <code>null</code> input String returns <code>null</code>. - * Capitalization uses the Unicode title case, normally equivalent to - * upper case.</p> - * - * <pre> - * WordUtils.capitalizeFully(null, *) = null - * WordUtils.capitalizeFully("", *) = "" - * WordUtils.capitalizeFully(*, null) = * - * WordUtils.capitalizeFully(*, new char[0]) = * - * WordUtils.capitalizeFully("i aM.fine", {'.'}) = "I am.Fine" - * </pre> - * - * @param str the String to capitalize, may be null - * @param delimiters set of characters to determine capitalization, null means whitespace - * @return capitalized String, <code>null</code> if null String input - */ - public static String capitalizeFully(String str, final char... delimiters) { - final int delimLen = delimiters == null ? -1 : delimiters.length; - if (str == null || str.length() == 0 || delimLen == 0) { - return str; - } - str = str.toLowerCase(); - return capitalize(str, delimiters); - } - - //----------------------------------------------------------------------- - /** - * <p>Uncapitalizes all the whitespace separated words in a String. - * Only the first character of each word is changed.</p> - * - * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>.</p> - * - * <pre> - * WordUtils.uncapitalize(null) = null - * WordUtils.uncapitalize("") = "" - * WordUtils.uncapitalize("I Am FINE") = "i am fINE" - * </pre> - * - * @param str the String to uncapitalize, may be null - * @return uncapitalized String, <code>null</code> if null String input - * @see #capitalize(String) - */ - public static String uncapitalize(final String str) { - return uncapitalize(str, null); - } - - /** - * <p>Uncapitalizes all the whitespace separated words in a String. - * Only the first character of each word is changed.</p> - * - * <p>The delimiters represent a set of characters understood to separate words. - * The first string character and the first non-delimiter character after a - * delimiter will be uncapitalized. </p> - * - * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>.</p> - * - * <pre> - * WordUtils.uncapitalize(null, *) = null - * WordUtils.uncapitalize("", *) = "" - * WordUtils.uncapitalize(*, null) = * - * WordUtils.uncapitalize(*, new char[0]) = * - * WordUtils.uncapitalize("I AM.FINE", {'.'}) = "i AM.fINE" - * </pre> - * - * @param str the String to uncapitalize, may be null - * @param delimiters set of characters to determine uncapitalization, null means whitespace - * @return uncapitalized String, <code>null</code> if null String input - * @see #capitalize(String) - */ - public static String uncapitalize(final String str, final char... delimiters) { - final int delimLen = delimiters == null ? -1 : delimiters.length; - if (str == null || str.length() == 0 || delimLen == 0) { - return str; - } - final char[] buffer = str.toCharArray(); - boolean uncapitalizeNext = true; - for (int i = 0; i < buffer.length; i++) { - final char ch = buffer[i]; - if (isDelimiter(ch, delimiters)) { - uncapitalizeNext = true; - } else if (uncapitalizeNext) { - buffer[i] = Character.toLowerCase(ch); - uncapitalizeNext = false; - } - } - return new String(buffer); - } - - //----------------------------------------------------------------------- - /** - * <p>Swaps the case of a String using a word based algorithm.</p> - * - * <ul> - * <li>Upper case character converts to Lower case</li> - * <li>Title case character converts to Lower case</li> - * <li>Lower case character after Whitespace or at start converts to Title case</li> - * <li>Other Lower case character converts to Upper case</li> - * </ul> - * - * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>.</p> - * - * <pre> - * StringUtils.swapCase(null) = null - * StringUtils.swapCase("") = "" - * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone" - * </pre> - * - * @param str the String to swap case, may be null - * @return the changed String, <code>null</code> if null String input - */ - public static String swapCase(final String str) { - if (str == null || str.length() == 0) { - return str; - } - final char[] buffer = str.toCharArray(); - - boolean whitespace = true; - - for (int i = 0; i < buffer.length; i++) { - final char ch = buffer[i]; - if (Character.isUpperCase(ch)) { - buffer[i] = Character.toLowerCase(ch); - whitespace = false; - } else if (Character.isTitleCase(ch)) { - buffer[i] = Character.toLowerCase(ch); - whitespace = false; - } else if (Character.isLowerCase(ch)) { - if (whitespace) { - buffer[i] = Character.toTitleCase(ch); - whitespace = false; - } else { - buffer[i] = Character.toUpperCase(ch); - } - } else { - whitespace = Character.isWhitespace(ch); - } - } - return new String(buffer); - } - - //----------------------------------------------------------------------- - /** - * <p>Extracts the initial characters from each word in the String.</p> - * - * <p>All first characters after whitespace are returned as a new string. - * Their case is not changed.</p> - * - * <p>Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>.</p> - * - * <pre> - * WordUtils.initials(null) = null - * WordUtils.initials("") = "" - * WordUtils.initials("Ben John Lee") = "BJL" - * WordUtils.initials("Ben J.Lee") = "BJ" - * </pre> - * - * @param str the String to get initials from, may be null - * @return String of initial letters, <code>null</code> if null String input - * @see #initials(String,char[]) - */ - public static String initials(final String str) { - return initials(str, null); - } - - /** - * <p>Extracts the initial characters from each word in the String.</p> - * - * <p>All first characters after the defined delimiters are returned as a new string. - * Their case is not changed.</p> - * - * <p>If the delimiters array is null, then Whitespace is used. - * Whitespace is defined by {@link Character#isWhitespace(char)}. - * A <code>null</code> input String returns <code>null</code>. - * An empty delimiter array returns an empty String.</p> - * - * <pre> - * WordUtils.initials(null, *) = null - * WordUtils.initials("", *) = "" - * WordUtils.initials("Ben John Lee", null) = "BJL" - * WordUtils.initials("Ben J.Lee", null) = "BJ" - * WordUtils.initials("Ben J.Lee", [' ','.']) = "BJL" - * WordUtils.initials(*, new char[0]) = "" - * </pre> - * - * @param str the String to get initials from, may be null - * @param delimiters set of characters to determine words, null means whitespace - * @return String of initial characters, <code>null</code> if null String input - * @see #initials(String) - */ - public static String initials(final String str, final char... delimiters) { - if (str == null || str.length() == 0) { - return str; - } - if (delimiters != null && delimiters.length == 0) { - return ""; - } - final int strLen = str.length(); - final char[] buf = new char[strLen / 2 + 1]; - int count = 0; - boolean lastWasGap = true; - for (int i = 0; i < strLen; i++) { - final char ch = str.charAt(i); - - if (isDelimiter(ch, delimiters)) { - lastWasGap = true; - } else if (lastWasGap) { - buf[count++] = ch; - lastWasGap = false; - } else { - continue; // ignore ch - } - } - return new String(buf, 0, count); - } - - //----------------------------------------------------------------------- - /** - * <p>Checks if the String contains all words in the given array.</p> - * - * <p> - * A {@code null} String will return {@code false}. A {@code null}, zero - * length search array or if one element of array is null will return {@code false}. - * </p> - * - * <pre> - * WordUtils.containsAllWords(null, *) = false - * WordUtils.containsAllWords("", *) = false - * WordUtils.containsAllWords(*, null) = false - * WordUtils.containsAllWords(*, []) = false - * WordUtils.containsAllWords("abcd", "ab", "cd") = false - * WordUtils.containsAllWords("abc def", "def", "abc") = true - * </pre> - * - * - * @param word The CharSequence to check, may be null - * @param words The array of String words to search for, may be null - * @return {@code true} if all search words are found, {@code false} otherwise - */ - public static boolean containsAllWords(final CharSequence word, final CharSequence... words) { - if (word == null || word.length() == 0 || words == null || Array.getLength(words) == 0) { - return false; - } - for (final CharSequence w : words) { - if (w == null || w.length() == 0 || String.valueOf(w).trim().length() == 0 ) { - return false; - } - final Pattern p = Pattern.compile(".*\\b" + w + "\\b.*"); - if (!p.matcher(word).matches()) { - return false; - } - } - return true; - } - - //----------------------------------------------------------------------- - /** - * Is the character a delimiter. - * - * @param ch the character to check - * @param delimiters the delimiters - * @return true if it is a delimiter - */ - private static boolean isDelimiter(final char ch, final char[] delimiters) { - if (delimiters == null) { - return Character.isWhitespace(ch); - } - for (final char delimiter : delimiters) { - if (ch == delimiter) { - return true; - } - } - return false; - } - -} http://git-wip-us.apache.org/repos/asf/commons-text/blob/a28e32ea/src/test/java/org/apache/commons/text/WordUtilsTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/WordUtilsTest.java b/src/test/java/org/apache/commons/text/WordUtilsTest.java deleted file mode 100644 index 0ab8b09..0000000 --- a/src/test/java/org/apache/commons/text/WordUtilsTest.java +++ /dev/null @@ -1,420 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.text; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -import java.lang.reflect.Constructor; -import java.lang.reflect.Modifier; - -import org.junit.Test; - -/** - * Unit tests for {@link WordUtils} class. - */ -public class WordUtilsTest { - - //----------------------------------------------------------------------- - @Test - public void testConstructor() { - assertNotNull(new WordUtils()); - final Constructor<?>[] cons = WordUtils.class.getDeclaredConstructors(); - assertEquals(1, cons.length); - assertTrue(Modifier.isPublic(cons[0].getModifiers())); - assertTrue(Modifier.isPublic(WordUtils.class.getModifiers())); - assertFalse(Modifier.isFinal(WordUtils.class.getModifiers())); - } - - //----------------------------------------------------------------------- - @Test - public void testWrap_StringInt() { - assertEquals(null, WordUtils.wrap(null, 20)); - assertEquals(null, WordUtils.wrap(null, -1)); - - assertEquals("", WordUtils.wrap("", 20)); - assertEquals("", WordUtils.wrap("", -1)); - - // normal - final String systemNewLine = System.lineSeparator(); - String input = "Here is one line of text that is going to be wrapped after 20 columns."; - String expected = "Here is one line of" + systemNewLine + "text that is going" - + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns."; - assertEquals(expected, WordUtils.wrap(input, 20)); - - // long word at end - input = "Click here to jump to the commons website - http://commons.apache.org";; - expected = "Click here to jump" + systemNewLine + "to the commons" + systemNewLine - + "website -" + systemNewLine + "http://commons.apache.org";; - assertEquals(expected, WordUtils.wrap(input, 20)); - - // long word in middle - input = "Click here, http://commons.apache.org, to jump to the commons website"; - expected = "Click here," + systemNewLine + "http://commons.apache.org,"; + systemNewLine - + "to jump to the" + systemNewLine + "commons website"; - assertEquals(expected, WordUtils.wrap(input, 20)); - - // leading spaces on a new line are stripped - // trailing spaces are not stripped - input = "word1 word2 word3"; - expected = "word1 " + systemNewLine + "word2 " + systemNewLine + "word3"; - assertEquals(expected, WordUtils.wrap(input, 7)); - } - - @Test - public void testWrap_StringIntStringBoolean() { - assertEquals(null, WordUtils.wrap(null, 20, "\n", false)); - assertEquals(null, WordUtils.wrap(null, 20, "\n", true)); - assertEquals(null, WordUtils.wrap(null, 20, null, true)); - assertEquals(null, WordUtils.wrap(null, 20, null, false)); - assertEquals(null, WordUtils.wrap(null, -1, null, true)); - assertEquals(null, WordUtils.wrap(null, -1, null, false)); - - assertEquals("", WordUtils.wrap("", 20, "\n", false)); - assertEquals("", WordUtils.wrap("", 20, "\n", true)); - assertEquals("", WordUtils.wrap("", 20, null, false)); - assertEquals("", WordUtils.wrap("", 20, null, true)); - assertEquals("", WordUtils.wrap("", -1, null, false)); - assertEquals("", WordUtils.wrap("", -1, null, true)); - - // normal - String input = "Here is one line of text that is going to be wrapped after 20 columns."; - String expected = "Here is one line of\ntext that is going\nto be wrapped after\n20 columns."; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", false)); - assertEquals(expected, WordUtils.wrap(input, 20, "\n", true)); - - // unusual newline char - input = "Here is one line of text that is going to be wrapped after 20 columns."; - expected = "Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns."; - assertEquals(expected, WordUtils.wrap(input, 20, "<br />", false)); - assertEquals(expected, WordUtils.wrap(input, 20, "<br />", true)); - - // short line length - input = "Here is one line"; - expected = "Here\nis one\nline"; - assertEquals(expected, WordUtils.wrap(input, 6, "\n", false)); - expected = "Here\nis\none\nline"; - assertEquals(expected, WordUtils.wrap(input, 2, "\n", false)); - assertEquals(expected, WordUtils.wrap(input, -1, "\n", false)); - - // system newline char - final String systemNewLine = System.lineSeparator(); - input = "Here is one line of text that is going to be wrapped after 20 columns."; - expected = "Here is one line of" + systemNewLine + "text that is going" + systemNewLine - + "to be wrapped after" + systemNewLine + "20 columns."; - assertEquals(expected, WordUtils.wrap(input, 20, null, false)); - assertEquals(expected, WordUtils.wrap(input, 20, null, true)); - - // with extra spaces - input = " Here: is one line of text that is going to be wrapped after 20 columns."; - expected = "Here: is one line\nof text that is \ngoing to be \nwrapped after 20 \ncolumns."; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", false)); - assertEquals(expected, WordUtils.wrap(input, 20, "\n", true)); - - // with tab - input = "Here is\tone line of text that is going to be wrapped after 20 columns."; - expected = "Here is\tone line of\ntext that is going\nto be wrapped after\n20 columns."; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", false)); - assertEquals(expected, WordUtils.wrap(input, 20, "\n", true)); - - // with tab at wrapColumn - input = "Here is one line of\ttext that is going to be wrapped after 20 columns."; - expected = "Here is one line\nof\ttext that is\ngoing to be wrapped\nafter 20 columns."; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", false)); - assertEquals(expected, WordUtils.wrap(input, 20, "\n", true)); - - // difference because of long word - input = "Click here to jump to the commons website - http://commons.apache.org";; - expected = "Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org";; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", false)); - expected = "Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org";; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", true)); - - // difference because of long word in middle - input = "Click here, http://commons.apache.org, to jump to the commons website"; - expected = "Click here,\nhttp://commons.apache.org,\nto jump to the\ncommons website"; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", false)); - expected = "Click here,\nhttp://commons.apach\ne.org, to jump to\nthe commons website"; - assertEquals(expected, WordUtils.wrap(input, 20, "\n", true)); - } - - @Test - public void testWrap_StringIntStringBooleanString() { - - //no changes test - String input = "flammable/inflammable"; - String expected = "flammable/inflammable"; - assertEquals(expected, WordUtils.wrap(input, 30, "\n", false, "/")); - - // wrap on / and small width - expected = "flammable\ninflammable"; - assertEquals(expected, WordUtils.wrap(input, 2, "\n", false, "/")); - - // wrap long words on / 1 - expected = "flammable\ninflammab\nle"; - assertEquals(expected, WordUtils.wrap(input, 9, "\n", true, "/")); - - // wrap long words on / 2 - expected = "flammable\ninflammable"; - assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/")); - - // wrap long words on / 3 - input = "flammableinflammable"; - expected = "flammableinflam\nmable"; - assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/")); - } - - //----------------------------------------------------------------------- - @Test - public void testCapitalize_String() { - assertEquals(null, WordUtils.capitalize(null)); - assertEquals("", WordUtils.capitalize("")); - assertEquals(" ", WordUtils.capitalize(" ")); - - assertEquals("I", WordUtils.capitalize("I") ); - assertEquals("I", WordUtils.capitalize("i") ); - assertEquals("I Am Here 123", WordUtils.capitalize("i am here 123") ); - assertEquals("I Am Here 123", WordUtils.capitalize("I Am Here 123") ); - assertEquals("I Am HERE 123", WordUtils.capitalize("i am HERE 123") ); - assertEquals("I AM HERE 123", WordUtils.capitalize("I AM HERE 123") ); - } - - @Test - public void testCapitalizeWithDelimiters_String() { - assertEquals(null, WordUtils.capitalize(null, null)); - assertEquals("", WordUtils.capitalize("", new char[0])); - assertEquals(" ", WordUtils.capitalize(" ", new char[0])); - - char[] chars = new char[] { '-', '+', ' ', '@' }; - assertEquals("I", WordUtils.capitalize("I", chars) ); - assertEquals("I", WordUtils.capitalize("i", chars) ); - assertEquals("I-Am Here+123", WordUtils.capitalize("i-am here+123", chars) ); - assertEquals("I Am+Here-123", WordUtils.capitalize("I Am+Here-123", chars) ); - assertEquals("I+Am-HERE 123", WordUtils.capitalize("i+am-HERE 123", chars) ); - assertEquals("I-AM HERE+123", WordUtils.capitalize("I-AM HERE+123", chars) ); - chars = new char[] {'.'}; - assertEquals("I aM.Fine", WordUtils.capitalize("i aM.fine", chars) ); - assertEquals("I Am.fine", WordUtils.capitalize("i am.fine", null) ); - } - - @Test - public void testCapitalizeFully_String() { - assertEquals(null, WordUtils.capitalizeFully(null)); - assertEquals("", WordUtils.capitalizeFully("")); - assertEquals(" ", WordUtils.capitalizeFully(" ")); - - assertEquals("I", WordUtils.capitalizeFully("I") ); - assertEquals("I", WordUtils.capitalizeFully("i") ); - assertEquals("I Am Here 123", WordUtils.capitalizeFully("i am here 123") ); - assertEquals("I Am Here 123", WordUtils.capitalizeFully("I Am Here 123") ); - assertEquals("I Am Here 123", WordUtils.capitalizeFully("i am HERE 123") ); - assertEquals("I Am Here 123", WordUtils.capitalizeFully("I AM HERE 123") ); - } - - @Test - public void testCapitalizeFullyWithDelimiters_String() { - assertEquals(null, WordUtils.capitalizeFully(null, null)); - assertEquals("", WordUtils.capitalizeFully("", new char[0])); - assertEquals(" ", WordUtils.capitalizeFully(" ", new char[0])); - - char[] chars = new char[] { '-', '+', ' ', '@' }; - assertEquals("I", WordUtils.capitalizeFully("I", chars) ); - assertEquals("I", WordUtils.capitalizeFully("i", chars) ); - assertEquals("I-Am Here+123", WordUtils.capitalizeFully("i-am here+123", chars) ); - assertEquals("I Am+Here-123", WordUtils.capitalizeFully("I Am+Here-123", chars) ); - assertEquals("I+Am-Here 123", WordUtils.capitalizeFully("i+am-HERE 123", chars) ); - assertEquals("I-Am Here+123", WordUtils.capitalizeFully("I-AM HERE+123", chars) ); - chars = new char[] {'.'}; - assertEquals("I am.Fine", WordUtils.capitalizeFully("i aM.fine", chars) ); - assertEquals("I Am.fine", WordUtils.capitalizeFully("i am.fine", null) ); - } - - @Test - public void testContainsAllWords_StringString() { - assertFalse(WordUtils.containsAllWords(null, (String) null)); - assertFalse(WordUtils.containsAllWords(null, "")); - assertFalse(WordUtils.containsAllWords(null, "ab")); - - assertFalse(WordUtils.containsAllWords("", (String) null)); - assertFalse(WordUtils.containsAllWords("", "")); - assertFalse(WordUtils.containsAllWords("", "ab")); - - assertFalse(WordUtils.containsAllWords("foo", (String) null)); - assertFalse(WordUtils.containsAllWords("bar", "")); - assertFalse(WordUtils.containsAllWords("zzabyycdxx", "by")); - assertTrue(WordUtils.containsAllWords("lorem ipsum dolor sit amet", "ipsum", "lorem", "dolor")); - assertFalse(WordUtils.containsAllWords("lorem ipsum dolor sit amet", "ipsum", null, "lorem", "dolor")); - assertFalse(WordUtils.containsAllWords("lorem ipsum null dolor sit amet", "ipsum", null, "lorem", "dolor")); - assertFalse(WordUtils.containsAllWords("ab", "b")); - assertFalse(WordUtils.containsAllWords("ab", "z")); - } - - @Test - public void testUncapitalize_String() { - assertEquals(null, WordUtils.uncapitalize(null)); - assertEquals("", WordUtils.uncapitalize("")); - assertEquals(" ", WordUtils.uncapitalize(" ")); - - assertEquals("i", WordUtils.uncapitalize("I") ); - assertEquals("i", WordUtils.uncapitalize("i") ); - assertEquals("i am here 123", WordUtils.uncapitalize("i am here 123") ); - assertEquals("i am here 123", WordUtils.uncapitalize("I Am Here 123") ); - assertEquals("i am hERE 123", WordUtils.uncapitalize("i am HERE 123") ); - assertEquals("i aM hERE 123", WordUtils.uncapitalize("I AM HERE 123") ); - } - - @Test - public void testUncapitalizeWithDelimiters_String() { - assertEquals(null, WordUtils.uncapitalize(null, null)); - assertEquals("", WordUtils.uncapitalize("", new char[0])); - assertEquals(" ", WordUtils.uncapitalize(" ", new char[0])); - - char[] chars = new char[] { '-', '+', ' ', '@' }; - assertEquals("i", WordUtils.uncapitalize("I", chars) ); - assertEquals("i", WordUtils.uncapitalize("i", chars) ); - assertEquals("i am-here+123", WordUtils.uncapitalize("i am-here+123", chars) ); - assertEquals("i+am here-123", WordUtils.uncapitalize("I+Am Here-123", chars) ); - assertEquals("i-am+hERE 123", WordUtils.uncapitalize("i-am+HERE 123", chars) ); - assertEquals("i aM-hERE+123", WordUtils.uncapitalize("I AM-HERE+123", chars) ); - chars = new char[] {'.'}; - assertEquals("i AM.fINE", WordUtils.uncapitalize("I AM.FINE", chars) ); - assertEquals("i aM.FINE", WordUtils.uncapitalize("I AM.FINE", null) ); - } - - //----------------------------------------------------------------------- - @Test - public void testInitials_String() { - assertEquals(null, WordUtils.initials(null)); - assertEquals("", WordUtils.initials("")); - assertEquals("", WordUtils.initials(" ")); - - assertEquals("I", WordUtils.initials("I")); - assertEquals("i", WordUtils.initials("i")); - assertEquals("BJL", WordUtils.initials("Ben John Lee")); - assertEquals("BJL", WordUtils.initials(" Ben \n John\tLee\t")); - assertEquals("BJ", WordUtils.initials("Ben J.Lee")); - assertEquals("BJ.L", WordUtils.initials(" Ben John . Lee")); - assertEquals("iah1", WordUtils.initials("i am here 123")); - } - - // ----------------------------------------------------------------------- - @Test - public void testInitials_String_charArray() { - char[] array = null; - assertEquals(null, WordUtils.initials(null, array)); - assertEquals("", WordUtils.initials("", array)); - assertEquals("", WordUtils.initials(" ", array)); - assertEquals("I", WordUtils.initials("I", array)); - assertEquals("i", WordUtils.initials("i", array)); - assertEquals("S", WordUtils.initials("SJC", array)); - assertEquals("BJL", WordUtils.initials("Ben John Lee", array)); - assertEquals("BJL", WordUtils.initials(" Ben \n John\tLee\t", array)); - assertEquals("BJ", WordUtils.initials("Ben J.Lee", array)); - assertEquals("BJ.L", WordUtils.initials(" Ben John . Lee", array)); - assertEquals("KO", WordUtils.initials("Kay O'Murphy", array)); - assertEquals("iah1", WordUtils.initials("i am here 123", array)); - - array = new char[0]; - assertEquals(null, WordUtils.initials(null, array)); - assertEquals("", WordUtils.initials("", array)); - assertEquals("", WordUtils.initials(" ", array)); - assertEquals("", WordUtils.initials("I", array)); - assertEquals("", WordUtils.initials("i", array)); - assertEquals("", WordUtils.initials("SJC", array)); - assertEquals("", WordUtils.initials("Ben John Lee", array)); - assertEquals("", WordUtils.initials(" Ben \n John\tLee\t", array)); - assertEquals("", WordUtils.initials("Ben J.Lee", array)); - assertEquals("", WordUtils.initials(" Ben John . Lee", array)); - assertEquals("", WordUtils.initials("Kay O'Murphy", array)); - assertEquals("", WordUtils.initials("i am here 123", array)); - - array = " ".toCharArray(); - assertEquals(null, WordUtils.initials(null, array)); - assertEquals("", WordUtils.initials("", array)); - assertEquals("", WordUtils.initials(" ", array)); - assertEquals("I", WordUtils.initials("I", array)); - assertEquals("i", WordUtils.initials("i", array)); - assertEquals("S", WordUtils.initials("SJC", array)); - assertEquals("BJL", WordUtils.initials("Ben John Lee", array)); - assertEquals("BJ", WordUtils.initials("Ben J.Lee", array)); - assertEquals("B\nJ", WordUtils.initials(" Ben \n John\tLee\t", array)); - assertEquals("BJ.L", WordUtils.initials(" Ben John . Lee", array)); - assertEquals("KO", WordUtils.initials("Kay O'Murphy", array)); - assertEquals("iah1", WordUtils.initials("i am here 123", array)); - - array = " .".toCharArray(); - assertEquals(null, WordUtils.initials(null, array)); - assertEquals("", WordUtils.initials("", array)); - assertEquals("", WordUtils.initials(" ", array)); - assertEquals("I", WordUtils.initials("I", array)); - assertEquals("i", WordUtils.initials("i", array)); - assertEquals("S", WordUtils.initials("SJC", array)); - assertEquals("BJL", WordUtils.initials("Ben John Lee", array)); - assertEquals("BJL", WordUtils.initials("Ben J.Lee", array)); - assertEquals("BJL", WordUtils.initials(" Ben John . Lee", array)); - assertEquals("KO", WordUtils.initials("Kay O'Murphy", array)); - assertEquals("iah1", WordUtils.initials("i am here 123", array)); - - array = " .'".toCharArray(); - assertEquals(null, WordUtils.initials(null, array)); - assertEquals("", WordUtils.initials("", array)); - assertEquals("", WordUtils.initials(" ", array)); - assertEquals("I", WordUtils.initials("I", array)); - assertEquals("i", WordUtils.initials("i", array)); - assertEquals("S", WordUtils.initials("SJC", array)); - assertEquals("BJL", WordUtils.initials("Ben John Lee", array)); - assertEquals("BJL", WordUtils.initials("Ben J.Lee", array)); - assertEquals("BJL", WordUtils.initials(" Ben John . Lee", array)); - assertEquals("KOM", WordUtils.initials("Kay O'Murphy", array)); - assertEquals("iah1", WordUtils.initials("i am here 123", array)); - - array = "SIJo1".toCharArray(); - assertEquals(null, WordUtils.initials(null, array)); - assertEquals("", WordUtils.initials("", array)); - assertEquals(" ", WordUtils.initials(" ", array)); - assertEquals("", WordUtils.initials("I", array)); - assertEquals("i", WordUtils.initials("i", array)); - assertEquals("C", WordUtils.initials("SJC", array)); - assertEquals("Bh", WordUtils.initials("Ben John Lee", array)); - assertEquals("B.", WordUtils.initials("Ben J.Lee", array)); - assertEquals(" h", WordUtils.initials(" Ben John . Lee", array)); - assertEquals("K", WordUtils.initials("Kay O'Murphy", array)); - assertEquals("i2", WordUtils.initials("i am here 123", array)); - } - - // ----------------------------------------------------------------------- - @Test - public void testSwapCase_String() { - assertEquals(null, WordUtils.swapCase(null)); - assertEquals("", WordUtils.swapCase("")); - assertEquals(" ", WordUtils.swapCase(" ")); - - assertEquals("i", WordUtils.swapCase("I") ); - assertEquals("I", WordUtils.swapCase("i") ); - assertEquals("I AM HERE 123", WordUtils.swapCase("i am here 123") ); - assertEquals("i aM hERE 123", WordUtils.swapCase("I Am Here 123") ); - assertEquals("I AM here 123", WordUtils.swapCase("i am HERE 123") ); - assertEquals("i am here 123", WordUtils.swapCase("I AM HERE 123") ); - - final String test = "This String contains a TitleCase character: \u01C8"; - final String expect = "tHIS sTRING CONTAINS A tITLEcASE CHARACTER: \u01C9"; - assertEquals(expect, WordUtils.swapCase(test)); - } - -}
