You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ch...@apache.org on 2017/05/03 00:56:37 UTC
[1/4] [text] pulling back WordUtils as per Jira TEXT-55
Repository: commons-text
Updated Branches:
refs/heads/master c0dd79eca -> 0b6a285bb
pulling back WordUtils as per Jira TEXT-55
Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/5b89b382
Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/5b89b382
Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/5b89b382
Branch: refs/heads/master
Commit: 5b89b382021600d2dac0ee2d06265fd4d9e08264
Parents: c0dd79e
Author: Amey Jadiye <am...@gmail.com>
Authored: Wed May 3 00:23:05 2017 +0530
Committer: Amey Jadiye <am...@gmail.com>
Committed: Wed May 3 00:23:05 2017 +0530
----------------------------------------------------------------------
.../java/org/apache/commons/text/WordUtils.java | 728 +++++++++++++++++++
.../org/apache/commons/text/WordUtilsTest.java | 420 +++++++++++
2 files changed, 1148 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-text/blob/5b89b382/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
new file mode 100644
index 0000000..7292d89
--- /dev/null
+++ b/src/main/java/org/apache/commons/text/WordUtils.java
@@ -0,0 +1,728 @@
+/*
+ * 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/5b89b382/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
new file mode 100644
index 0000000..0ab8b09
--- /dev/null
+++ b/src/test/java/org/apache/commons/text/WordUtilsTest.java
@@ -0,0 +1,420 @@
+/*
+ * 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));
+ }
+
+}
[2/4] [text] corrected checkstyle errors
Posted by ch...@apache.org.
corrected checkstyle errors
Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/bd4cba26
Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/bd4cba26
Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/bd4cba26
Branch: refs/heads/master
Commit: bd4cba26cff7d7d7fdb90727362e66f533f4b59f
Parents: 5b89b38
Author: Amey Jadiye <am...@gmail.com>
Authored: Wed May 3 02:16:49 2017 +0530
Committer: Amey Jadiye <am...@gmail.com>
Committed: Wed May 3 02:16:49 2017 +0530
----------------------------------------------------------------------
.../java/org/apache/commons/text/WordUtils.java | 91 +++++++++++---------
1 file changed, 52 insertions(+), 39 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-text/blob/bd4cba26/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
index 7292d89..69747dc 100644
--- a/src/main/java/org/apache/commons/text/WordUtils.java
+++ b/src/main/java/org/apache/commons/text/WordUtils.java
@@ -5,9 +5,9 @@
* 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.
@@ -22,7 +22,7 @@ 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>
@@ -31,6 +31,8 @@ import java.util.regex.Pattern;
*/
public class WordUtils {
+ private static final int THIRTY_TWO = 32;
+
/**
* <p><code>WordUtils</code> instances should NOT be constructed in
* standard programming. Instead, the class should be used as
@@ -47,10 +49,10 @@ public class WordUtils {
//--------------------------------------------------------------------------
/**
* <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>
*
@@ -96,10 +98,10 @@ public class WordUtils {
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>
*
@@ -137,14 +139,16 @@ public class WordUtils {
* <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>
+ * <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>
+ * <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>
@@ -164,12 +168,15 @@ public class WordUtils {
*
* @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,
+ * @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) {
+ public static String wrap(final String str,
+ final int wrapLength,
+ final String newLineStr,
+ final boolean wrapLongWords) {
return wrap(str, wrapLength, newLineStr, wrapLongWords, " ");
}
@@ -218,7 +225,8 @@ public class WordUtils {
* <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>
+ * <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>
@@ -226,7 +234,8 @@ public class WordUtils {
* <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>
+ * <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>
@@ -262,7 +271,11 @@ public class WordUtils {
* 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) {
+ public static String wrap(final String str,
+ int wrapLength,
+ String newLineStr,
+ final boolean wrapLongWords,
+ String wrapOn) {
if (str == null) {
return null;
}
@@ -278,7 +291,7 @@ public class WordUtils {
final Pattern patternToWrapOn = Pattern.compile(wrapOn);
final int inputLineLength = str.length();
int offset = 0;
- final StringBuilder wrappedLine = new StringBuilder(inputLineLength + 32);
+ final StringBuilder wrappedLine = new StringBuilder(inputLineLength + THIRTY_TWO);
while (offset < inputLineLength) {
int spaceToWrapAt = -1;
@@ -293,11 +306,11 @@ public class WordUtils {
}
// only last line without leading spaces is left
- if(inputLineLength - offset <= wrapLength) {
+ if (inputLineLength - offset <= wrapLength) {
break;
}
- while(matcher.find()){
+ while (matcher.find()) {
spaceToWrapAt = matcher.start() + offset;
}
@@ -343,8 +356,8 @@ public class WordUtils {
//-----------------------------------------------------------------------
/**
* <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,
+ * 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)}.
@@ -357,7 +370,7 @@ public class WordUtils {
* 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)
@@ -369,8 +382,8 @@ public class WordUtils {
/**
* <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,
+ * 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.
@@ -388,7 +401,7 @@ public class WordUtils {
* 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
@@ -416,8 +429,8 @@ public class WordUtils {
//-----------------------------------------------------------------------
/**
- * <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
+ * <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)}.
@@ -430,7 +443,7 @@ public class WordUtils {
* 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
*/
@@ -439,8 +452,8 @@ public class WordUtils {
}
/**
- * <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
+ * <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.
@@ -458,7 +471,7 @@ public class WordUtils {
* 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
@@ -485,7 +498,7 @@ public class WordUtils {
* 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)
@@ -512,7 +525,7 @@ public class WordUtils {
* 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
@@ -540,23 +553,23 @@ public class WordUtils {
//-----------------------------------------------------------------------
/**
* <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
*/
@@ -593,7 +606,7 @@ public class WordUtils {
//-----------------------------------------------------------------------
/**
* <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>
*
@@ -617,7 +630,7 @@ public class WordUtils {
/**
* <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>
*
@@ -634,7 +647,7 @@ public class WordUtils {
* 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
@@ -694,7 +707,7 @@ public class WordUtils {
return false;
}
for (final CharSequence w : words) {
- if (w == null || w.length() == 0 || String.valueOf(w).trim().length() == 0 ) {
+ if (w == null || w.length() == 0 || String.valueOf(w).trim().length() == 0) {
return false;
}
final Pattern p = Pattern.compile(".*\\b" + w + "\\b.*");
[3/4] [text] TEXT-82: thanks to Amey Jadiye
Posted by ch...@apache.org.
TEXT-82: thanks to Amey Jadiye
Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/3b11cb60
Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/3b11cb60
Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/3b11cb60
Branch: refs/heads/master
Commit: 3b11cb60cb89b102071f925502a8037ea7c20a04
Parents: bd4cba2
Author: Rob Tompkins <ch...@apache.org>
Authored: Tue May 2 20:53:42 2017 -0400
Committer: Rob Tompkins <ch...@apache.org>
Committed: Tue May 2 20:53:42 2017 -0400
----------------------------------------------------------------------
pom.xml | 3 +++
src/changes/changes.xml | 1 +
2 files changed, 4 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-text/blob/3b11cb60/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index eade4ce..750da98 100644
--- a/pom.xml
+++ b/pom.xml
@@ -84,6 +84,9 @@
<contributor>
<name>Lee Adcock</name>
</contributor>
+ <contributor>
+ <name>Amey Jadiye</name>
+ </contributor>
</contributors>
<dependencies>
http://git-wip-us.apache.org/repos/asf/commons-text/blob/3b11cb60/src/changes/changes.xml
----------------------------------------------------------------------
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index c862bf7..3ced620 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -46,6 +46,7 @@ The <action> type attribute can be add,update,fix,remove.
<body>
<release version="1.1" date="tbd" description="tbd">
+ <action issue="TEXT-82" type="add" dev="chtompki" due-to="Amey Jadiye">Putting WordUtils back in to the codebase</action>
<action issue="TEXT-81" type="add" dev="pschumacher" due-to="djones">Add RandomStringGenerator</action>
<action issue="TEXT-36" type="add" dev="pschumacher" due-to="Raymond DeCampo">RandomStringGenerator: allow users to provide source of randomness</action>
<action issue="TEXT-76" type="fix" dev="kinow">Correct round issue in Jaro Winkler implementation</action>
[4/4] [text] (chore) re-arranging some whitespace
Posted by ch...@apache.org.
(chore) re-arranging some whitespace
Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/0b6a285b
Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/0b6a285b
Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/0b6a285b
Branch: refs/heads/master
Commit: 0b6a285bb3884128f833f368bd9ff3538edfc916
Parents: 3b11cb6
Author: Rob Tompkins <ch...@apache.org>
Authored: Tue May 2 20:55:22 2017 -0400
Committer: Rob Tompkins <ch...@apache.org>
Committed: Tue May 2 20:55:22 2017 -0400
----------------------------------------------------------------------
src/main/java/org/apache/commons/text/WordUtils.java | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-text/blob/0b6a285b/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
index 69747dc..0cee2f6 100644
--- a/src/main/java/org/apache/commons/text/WordUtils.java
+++ b/src/main/java/org/apache/commons/text/WordUtils.java
@@ -174,9 +174,9 @@ public class WordUtils {
* @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) {
+ final int wrapLength,
+ final String newLineStr,
+ final boolean wrapLongWords) {
return wrap(str, wrapLength, newLineStr, wrapLongWords, " ");
}
@@ -272,10 +272,10 @@ public class WordUtils {
* @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) {
+ int wrapLength,
+ String newLineStr,
+ final boolean wrapLongWords,
+ String wrapOn) {
if (str == null) {
return null;
}