* This Handler is a generalization of the convert attribute
* of the get tag of the SetTemplate. Unlike
* the implementation in the SetTemplate that implements a
* small, fixed set of conversions of property values in the context of
* get, this handler allows plug-able conversion filters, and
* performs the conversions any time ${...} substitutions are resolved, not
* just in the context of the get tag.
*
* This requires the addition of new syntax in ${...}
* substitutions to specify the both the
* conversion (or filter) to apply, and the value to apply it to.
* This new syntax is configurable using the match,
* key, and token attributes, but defaults to:
* ${filter(value)} where filter represents the conversion
* filter, and value represents the property name whose contents
* is filtered.
*
* Any class that implements the Convert interface can be
* loaded and called to perform filtering. Filters that implement all the
* options of the <get ... convert=xxx> conversion options
* are included.
*
* See the examples, below for the details. *
^([a-z]+)\([^)]+\)$
* \\2
* \\1
*
* Using the defaults for "match", "key", and "token", a property named
* "foo" would be represented as ${xxx(foo)} where
* "xxx" is the name of the conversion filter.
*
* This class contains sample implementations of the convert
* interface. See below for their functions.
*
* @author Stephen Uhler
* @version 1.5
*
* @see java.util.Properties
*/
public class SubstPropsHandler implements Handler {
MatchString isMine; // check for matching url
Regexp matchRe; // expr that matches a property
String keySub; // Substitution string that gets the real key
String tokenSub; // Substitution string that matches conversion token
Hashtable map = new Hashtable(); // map from token to mapping function
static Class[] types = new Class[] {String.class, Properties.class};
public boolean
init(Server server, String prefix) {
isMine = new MatchString(prefix, server.props);
matchRe = new Regexp(server.props.getProperty(prefix + "match",
"(^[a-z]+)\\(([^)]+)\\)$"));
keySub = server.props.getProperty(prefix + "key", "\\2");
tokenSub=server.props.getProperty(prefix + "token", "\\1");
StringTokenizer st = new StringTokenizer(
server.props.getProperty(prefix + "tokens"));
// build table of conversions
while(st.hasMoreTokens()) {
String token = st.nextToken();
String className = server.props.getProperty(token + ".class");
String match=server.props.getProperty(token + ".code", token);
String name = prefix;
if (className == null) {
className = token; // use token as prefix;
} else {
name = token;
}
try {
Class type = Class.forName(className);
Object obj = type.newInstance();
String pre;
if (name.endsWith(".")) {
pre=name;
} else {
pre= name + ".";
}
Object[] args = new Object[] {pre, server.props};
Object result = type.getMethod("init", types).invoke(obj, args);
if (Boolean.FALSE.equals(result)) {
continue;
}
if (! (obj instanceof Convert)) {
server.log(Server.LOG_WARNING,className, "wrong interface");
continue;
}
map.put(name, obj);
server.log(Server.LOG_DIAGNOSTIC, token,
"instantiating class: " + obj);
} catch (Exception e) {
server.log(Server.LOG_WARNING, prefix, "Oops: " + e);
e.printStackTrace();
}
}
return true;
}
public boolean
respond(Request request) throws IOException {
if (isMine.match(request.url)) {
SubstProps p = new SubstProps(request);
PropertiesList pl = new PropertiesList(p);
pl.addBefore(request.serverProps);
}
return false;
}
public String toString() {
return matchRe + "-" + keySub + "-" + tokenSub + "=" + map;
}
/**
* This class implements a properties object that knows how
* to extract the "name" and "filter" from a properly constructed
* name, and to invoke the filter on the value of the encoded
* name.
*/
public class SubstProps extends Properties {
Request r;
public SubstProps(Request r) {
super();
this.r = r;
}
/**
* If the key doesn't exist, but the "derived" key and value
* do exist, then return the substituted value
*/
public Object get(Object key) {
Object val = super.get(key);
String newKey;
if (val == null && key instanceof String &&
null != matchRe.match((String) key)) {
newKey = matchRe.sub((String) key, keySub);
val = r.props.get(newKey);
if (val != null) {
String t = matchRe.sub((String) key, tokenSub);
val = convert((String)val, t);
}
}
return val;
}
public String getProperty(String key) {
String val = super.getProperty(key);
if (val == null && null != matchRe.match(key)) {
String newKey = matchRe.sub(key, keySub);
val = r.props.getProperty(newKey);
if (val != null) {
String t = matchRe.sub((String) key, tokenSub);
val = convert(val, t);
}
}
return val;
}
/**
* Given a value, compute the converted value.
*/
String convert(String value, String token) {
String result=value;
if (token != null) {
Convert cnvt = (Convert) map.get(token);
if (cnvt != null) {
result = cnvt.map(value);
}
}
return result;
}
}
/**
* Class that maps strings to strings.
*/
public interface Convert {
/**
* This is called once at creation time to provide this
* class with configuration information. Any configuration
* parameters required in "p" are prefixed with [prefix].
*/
public boolean init(String prefix, Properties p);
/**
* Map the value.
*/
public String map(String value);
}
// Sample mapping classes
/**
* Convert a value to lowercase.
*/
public static class LowerCase implements Convert {
public boolean init(String prefix, Properties p) {
return true;
}
public String map(String value) {
return value.toLowerCase();
}
}
/**
* HTML escape a value.
*/
public static class Html implements Convert {
public boolean init(String prefix, Properties p) {
return true;
}
public String map(String value) {
return HttpUtil.htmlEncode(value);
}
}
/**
* URL encode a String.
*/
public static class Url implements Convert {
public boolean init(String prefix, Properties p) {
return true;
}
public String map(String value) {
return HttpUtil.urlEncode(value);
}
}
/**
* Do a regexp substitution on a value.
* This takes the following initialization parameters:
*