org.archive.util.TextUtils Maven / Gradle / Ivy
The newest version!
/*
* This file is part of the Heritrix web crawler (crawler.archive.org).
*
* Licensed to the Internet Archive (IA) by one or more individual
* contributors.
*
* The IA 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.archive.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringEscapeUtils;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
public class TextUtils {
private static final String FIRSTWORD = "^([^\\s]*).*$";
/** thread-local cached matchers, by string key */
private static final ThreadLocal> TL_MATCHER_MAP
= new ThreadLocal>() {
protected Map initialValue() {
return new HashMap(50);
}
};
/** global soft-cache of Patterns, by string key */
private static final LoadingCache PATTERNS = CacheBuilder.newBuilder()
.concurrencyLevel(16)
.softValues()
.build(new CacheLoader() {
public Pattern load(String regex) {
return Pattern.compile(regex);
}
});
/**
* Get a matcher object for a precompiled regex pattern.
*
* This method tries to reuse Matcher objects for efficiency.
* It can hold for recycling one Matcher per pattern per thread.
*
* Matchers retrieved should be returned for reuse via the
* recycleMatcher() method, but no errors will occur if they
* are not.
*
* This method is a hotspot frequently accessed.
*
* @param pattern the string pattern to use
* @param input the character sequence the matcher should be using
* @return a matcher object loaded with the submitted character sequence
*/
public static Matcher getMatcher(String pattern, CharSequence input) {
if (pattern == null) {
throw new IllegalArgumentException("String 'pattern' must not be null");
}
input = new InterruptibleCharSequence(input);
final Map matchers = TL_MATCHER_MAP.get();
Matcher m = (Matcher)matchers.get(pattern);
if(m == null) {
m = PATTERNS.getUnchecked(pattern).matcher(input);
} else {
matchers.put(pattern,null);
m.reset(input);
}
return m;
}
public static void recycleMatcher(Matcher m) {
// while cached, eliminate reference to potentially-large prior 'input'
m.reset("");
final Map matchers = TL_MATCHER_MAP.get();
matchers.put(m.pattern().pattern(),m);
}
/**
* Utility method using a precompiled pattern instead of using the
* replaceAll method of the String class. This method will also be reusing
* Matcher objects.
*
* @see java.util.regex.Pattern
* @param pattern precompiled Pattern to match against
* @param input the character sequence to check
* @param replacement the String to substitute every match with
* @return the String with all the matches substituted
*/
public static String replaceAll(
String pattern, CharSequence input, String replacement) {
input = new InterruptibleCharSequence(input);
Matcher m = getMatcher(pattern, input);
String res = m.replaceAll(replacement);
recycleMatcher(m);
return res;
}
/**
* Utility method using a precompiled pattern instead of using the
* replaceFirst method of the String class. This method will also be reusing
* Matcher objects.
*
* @see java.util.regex.Pattern
* @param pattern precompiled Pattern to match against
* @param input the character sequence to check
* @param replacement the String to substitute the first match with
* @return the String with the first match substituted
*/
public static String replaceFirst(
String pattern, CharSequence input, String replacement) {
input = new InterruptibleCharSequence(input);
Matcher m = getMatcher(pattern, input);
String res = m.replaceFirst(replacement);
recycleMatcher(m);
return res;
}
/**
* Utility method using a precompiled pattern instead of using the matches
* method of the String class. This method will also be reusing Matcher
* objects.
*
* @see java.util.regex.Pattern
* @param pattern precompiled Pattern to match against
* @param input the character sequence to check
* @return true if character sequence matches
*/
public static boolean matches(String pattern, CharSequence input) {
input = new InterruptibleCharSequence(input);
Matcher m = getMatcher(pattern, input);
boolean res = m.matches();
recycleMatcher(m);
return res;
}
/**
* Utility method using a precompiled pattern instead of using the split
* method of the String class.
*
* @see java.util.regex.Pattern
* @param pattern precompiled Pattern to split by
* @param input the character sequence to split
* @return array of Strings split by pattern
*/
public static String[] split(String pattern, CharSequence input) {
input = new InterruptibleCharSequence(input);
Matcher m = getMatcher(pattern,input);
String[] retVal = m.pattern().split(input);
recycleMatcher(m);
return retVal;
}
/**
* @param s String to find first word in (Words are delimited by
* whitespace).
* @return First word in the passed string else null if no word found.
*/
public static String getFirstWord(String s) {
Matcher m = getMatcher(FIRSTWORD, s);
String retVal = (m != null && m.matches())? m.group(1): null;
recycleMatcher(m);
return retVal;
}
/**
* Escapes a string so that it can be passed as an argument to a javscript
* in a JSP page. This method takes a string and returns the same string
* with any single quote escaped by prepending the character with a
* backslash. Linebreaks are also replaced with '\n'. Also,
* less-than signs and ampersands are replaced with HTML entities.
*
* @param s The string to escape
* @return The same string escaped.
*/
public static String escapeForHTMLJavascript(String s) {
return escapeForHTML(StringEscapeUtils.escapeJavaScript(s));
}
/**
* Escapes a string so that it can be placed inside XML/HTML attribute.
* Replaces ampersand, less-than, greater-than, single-quote, and
* double-quote with escaped versions.
* @param s The string to escape
* @return The same string escaped.
*/
public static String escapeForMarkupAttribute(String s) {
return StringEscapeUtils.escapeXml(s);
}
/**
* Minimally escapes a string so that it can be placed inside XML/HTML
* attribute.
* Escapes lt and amp.
* @param s The string to escape
* @return The same string escaped.
*/
public static String escapeForHTML(String s) {
// TODO: do this in a single pass instead of creating 5 junk strings
String escaped = s.replaceAll("&","&");
return escaped.replaceAll("<","<");
}
/**
* Utility method for writing a (potentially large) String to a JspWriter,
* escaping it for HTML display, without constructing another large String
* of the whole content.
* @param s String to write
* @param w destination Writer
* @throws IOException
*/
public static void writeEscapedForHTML(String s, Writer w)
throws IOException {
PrintWriter out = new PrintWriter(w);
BufferedReader reader = new BufferedReader(new StringReader(s));
String line;
while((line=reader.readLine()) != null){
out.println(StringEscapeUtils.escapeHtml(line));
}
}
/**
* Replaces HTML Entity Encodings.
* @param cs The CharSequence to remove html codes from
* @return the same CharSequence or an escaped String.
*/
public static CharSequence unescapeHtml(final CharSequence cs) {
if (cs == null) {
return cs;
}
return StringEscapeUtils.unescapeHtml(cs.toString());
}
/**
* @param message Message to put at top of the string returned. May be
* null.
* @param e Exception to write into a string.
* @return Return formatted string made of passed message and stack trace
* of passed exception.
*/
public static String exceptionToString(String message, Throwable e) {
StringWriter sw = new StringWriter();
if (message == null || message.length() == 0) {
sw.write(message);
sw.write("\n");
}
e.printStackTrace(new PrintWriter(sw));
return sw.toString();
}
/**
* Exception- and warning-free URL-escaping utility method.
*
* @param s String to escape
* @return URL-escaped string
*/
@SuppressWarnings("deprecation")
public static String urlEscape(String s) {
try {
return URLEncoder.encode(s,"UTF8");
} catch (UnsupportedEncodingException e) {
// should be impossible; all JVMs must support UTF8
// but have a fallback just in case
return URLEncoder.encode(s);
}
}
/**
* Exception- and warning-free URL-unescaping utility method.
*
* @param s String do unescape
* @return URL-unescaped String
*/
@SuppressWarnings("deprecation")
public static String urlUnescape(String s) {
try {
return URLDecoder.decode(s, "UTF8");
} catch (UnsupportedEncodingException e) {
// should be impossible; all JVMs must support UTF8
// but have a fallback just in case
return URLDecoder.decode(s);
}
}
} © 2015 - 2024 Weber Informatics LLC | Privacy Policy