TldRuleSet.java
/*
* 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.tomcat.util.descriptor.tld;
import java.lang.reflect.Method;
import javax.servlet.jsp.tagext.TagAttributeInfo;
import javax.servlet.jsp.tagext.TagVariableInfo;
import javax.servlet.jsp.tagext.VariableInfo;
import org.apache.tomcat.util.digester.Digester;
import org.apache.tomcat.util.digester.Rule;
import org.apache.tomcat.util.digester.RuleSetBase;
import org.xml.sax.Attributes;
/**
* RulesSet for digesting TLD files.
*/
@SuppressWarnings("deprecation")
public class TldRuleSet extends RuleSetBase {
private static final String PREFIX = "taglib";
private static final String VALIDATOR_PREFIX = PREFIX + "/validator";
private static final String TAG_PREFIX = PREFIX + "/tag";
private static final String TAGFILE_PREFIX = PREFIX + "/tag-file";
private static final String FUNCTION_PREFIX = PREFIX + "/function";
@Override
public void addRuleInstances(Digester digester) {
digester.addCallMethod(PREFIX + "/tlibversion", "setTlibVersion", 0);
digester.addCallMethod(PREFIX + "/tlib-version", "setTlibVersion", 0);
digester.addCallMethod(PREFIX + "/jspversion", "setJspVersion", 0);
digester.addCallMethod(PREFIX + "/jsp-version", "setJspVersion", 0);
digester.addRule(PREFIX, new Rule() {
// for TLD 2.0 and later, jsp-version is set by version attribute
@Override
public void begin(String namespace, String name, Attributes attributes) {
TaglibXml taglibXml = (TaglibXml) digester.peek();
taglibXml.setJspVersion(attributes.getValue("version"));
}
});
digester.addCallMethod(PREFIX + "/shortname", "setShortName", 0);
digester.addCallMethod(PREFIX + "/short-name", "setShortName", 0);
// common rules
digester.addCallMethod(PREFIX + "/uri", "setUri", 0);
digester.addCallMethod(PREFIX + "/info", "setInfo", 0);
digester.addCallMethod(PREFIX + "/description", "setInfo", 0);
digester.addCallMethod(PREFIX + "/listener/listener-class", "addListener", 0);
// validator
digester.addObjectCreate(VALIDATOR_PREFIX, ValidatorXml.class.getName());
digester.addCallMethod(VALIDATOR_PREFIX + "/validator-class", "setValidatorClass", 0);
digester.addCallMethod(VALIDATOR_PREFIX + "/init-param", "addInitParam", 2);
digester.addCallParam(VALIDATOR_PREFIX + "/init-param/param-name", 0);
digester.addCallParam(VALIDATOR_PREFIX + "/init-param/param-value", 1);
digester.addSetNext(VALIDATOR_PREFIX, "setValidator", ValidatorXml.class.getName());
// tag
digester.addObjectCreate(TAG_PREFIX, TagXml.class.getName());
addDescriptionGroup(digester, TAG_PREFIX);
digester.addCallMethod(TAG_PREFIX + "/name", "setName", 0);
digester.addCallMethod(TAG_PREFIX + "/tagclass", "setTagClass", 0);
digester.addCallMethod(TAG_PREFIX + "/tag-class", "setTagClass", 0);
digester.addCallMethod(TAG_PREFIX + "/teiclass", "setTeiClass", 0);
digester.addCallMethod(TAG_PREFIX + "/tei-class", "setTeiClass", 0);
digester.addCallMethod(TAG_PREFIX + "/bodycontent", "setBodyContent", 0);
digester.addCallMethod(TAG_PREFIX + "/body-content", "setBodyContent", 0);
digester.addRule(TAG_PREFIX + "/variable", new ScriptVariableRule());
digester.addCallMethod(TAG_PREFIX + "/variable/name-given", "setNameGiven", 0);
digester.addCallMethod(TAG_PREFIX + "/variable/name-from-attribute",
"setNameFromAttribute", 0);
digester.addCallMethod(TAG_PREFIX + "/variable/variable-class", "setClassName", 0);
digester.addRule(TAG_PREFIX + "/variable/declare",
new GenericBooleanRule(Variable.class, "setDeclare"));
digester.addCallMethod(TAG_PREFIX + "/variable/scope", "setScope", 0);
digester.addRule(TAG_PREFIX + "/attribute", new TagAttributeRule());
digester.addCallMethod(TAG_PREFIX + "/attribute/description", "setDescription", 0);
digester.addCallMethod(TAG_PREFIX + "/attribute/name", "setName", 0);
digester.addRule(TAG_PREFIX + "/attribute/required",
new GenericBooleanRule(Attribute.class, "setRequired"));
digester.addRule(TAG_PREFIX + "/attribute/rtexprvalue",
new GenericBooleanRule(Attribute.class, "setRequestTime"));
digester.addCallMethod(TAG_PREFIX + "/attribute/type", "setType", 0);
digester.addCallMethod(TAG_PREFIX + "/attribute/deferred-value", "setDeferredValue");
digester.addCallMethod(TAG_PREFIX + "/attribute/deferred-value/type",
"setExpectedTypeName", 0);
digester.addCallMethod(TAG_PREFIX + "/attribute/deferred-method", "setDeferredMethod");
digester.addCallMethod(TAG_PREFIX + "/attribute/deferred-method/method-signature",
"setMethodSignature", 0);
digester.addRule(TAG_PREFIX + "/attribute/fragment",
new GenericBooleanRule(Attribute.class, "setFragment"));
digester.addRule(TAG_PREFIX + "/dynamic-attributes",
new GenericBooleanRule(TagXml.class, "setDynamicAttributes"));
digester.addSetNext(TAG_PREFIX, "addTag", TagXml.class.getName());
// tag-file
digester.addObjectCreate(TAGFILE_PREFIX, TagFileXml.class.getName());
addDescriptionGroup(digester, TAGFILE_PREFIX);
digester.addCallMethod(TAGFILE_PREFIX + "/name", "setName", 0);
digester.addCallMethod(TAGFILE_PREFIX + "/path", "setPath", 0);
digester.addSetNext(TAGFILE_PREFIX, "addTagFile", TagFileXml.class.getName());
// function
digester.addCallMethod(FUNCTION_PREFIX, "addFunction", 3);
digester.addCallParam(FUNCTION_PREFIX + "/name", 0);
digester.addCallParam(FUNCTION_PREFIX + "/function-class", 1);
digester.addCallParam(FUNCTION_PREFIX + "/function-signature", 2);
}
private void addDescriptionGroup(Digester digester, String prefix) {
digester.addCallMethod(prefix + "/info", "setInfo", 0);
digester.addCallMethod(prefix + "small-icon", "setSmallIcon", 0);
digester.addCallMethod(prefix + "large-icon", "setLargeIcon", 0);
digester.addCallMethod(prefix + "/description", "setInfo", 0);
digester.addCallMethod(prefix + "/display-name", "setDisplayName", 0);
digester.addCallMethod(prefix + "/icon/small-icon", "setSmallIcon", 0);
digester.addCallMethod(prefix + "/icon/large-icon", "setLargeIcon", 0);
}
private static class TagAttributeRule extends Rule {
@Override
public void begin(String namespace, String name, Attributes attributes) throws Exception {
TaglibXml taglibXml = (TaglibXml) digester.peek(digester.getCount() - 1);
digester.push(new Attribute("1.2".equals(taglibXml.getJspVersion())));
}
@Override
public void end(String namespace, String name) throws Exception {
Attribute attribute = (Attribute) digester.pop();
TagXml tag = (TagXml) digester.peek();
tag.getAttributes().add(attribute.toTagAttributeInfo());
}
}
public static class Attribute {
private final boolean allowShortNames;
private String name;
private boolean required;
private String type;
private boolean requestTime;
private boolean fragment;
private String description;
private boolean deferredValue;
private boolean deferredMethod;
private String expectedTypeName;
private String methodSignature;
private Attribute(boolean allowShortNames) {
this.allowShortNames = allowShortNames;
}
public void setName(String name) {
this.name = name;
}
public void setRequired(boolean required) {
this.required = required;
}
public void setType(String type) {
if (allowShortNames) {
switch (type) {
case "Boolean":
this.type = "java.lang.Boolean";
break;
case "Character":
this.type = "java.lang.Character";
break;
case "Byte":
this.type = "java.lang.Byte";
break;
case "Short":
this.type = "java.lang.Short";
break;
case "Integer":
this.type = "java.lang.Integer";
break;
case "Long":
this.type = "java.lang.Long";
break;
case "Float":
this.type = "java.lang.Float";
break;
case "Double":
this.type = "java.lang.Double";
break;
case "String":
this.type = "java.lang.String";
break;
case "Object":
this.type = "java.lang.Object";
break;
default:
this.type = type;
break;
}
} else {
this.type = type;
}
}
public void setRequestTime(boolean requestTime) {
this.requestTime = requestTime;
}
public void setFragment(boolean fragment) {
this.fragment = fragment;
}
public void setDescription(String description) {
this.description = description;
}
public void setDeferredValue() {
this.deferredValue = true;
}
public void setDeferredMethod() {
this.deferredMethod = true;
}
public void setExpectedTypeName(String expectedTypeName) {
this.expectedTypeName = expectedTypeName;
}
public void setMethodSignature(String methodSignature) {
this.methodSignature = methodSignature;
}
public TagAttributeInfo toTagAttributeInfo() {
if (fragment) {
// JSP8.5.2: for a fragment type is fixed and rexprvalue is true
type = "javax.servlet.jsp.tagext.JspFragment";
requestTime = true;
} else if (deferredValue) {
type = "javax.el.ValueExpression";
if (expectedTypeName == null) {
expectedTypeName = "java.lang.Object";
}
} else if (deferredMethod) {
type = "javax.el.MethodExpression";
if (methodSignature == null) {
methodSignature = "java.lang.Object method()";
}
}
// According to JSP spec, for static values (those determined at
// translation time) the type is fixed at java.lang.String.
if (!requestTime && type == null) {
type = "java.lang.String";
}
return new TagAttributeInfo(
name,
required,
type,
requestTime,
fragment,
description,
deferredValue,
deferredMethod,
expectedTypeName,
methodSignature);
}
}
private static class ScriptVariableRule extends Rule {
@Override
public void begin(String namespace, String name, Attributes attributes) throws Exception {
digester.push(new Variable());
}
@Override
public void end(String namespace, String name) throws Exception {
Variable variable = (Variable) digester.pop();
TagXml tag = (TagXml) digester.peek();
tag.getVariables().add(variable.toTagVariableInfo());
}
}
public static class Variable {
private String nameGiven;
private String nameFromAttribute;
private String className = "java.lang.String";
private boolean declare = true;
private int scope = VariableInfo.NESTED;
public void setNameGiven(String nameGiven) {
this.nameGiven = nameGiven;
}
public void setNameFromAttribute(String nameFromAttribute) {
this.nameFromAttribute = nameFromAttribute;
}
public void setClassName(String className) {
this.className = className;
}
public void setDeclare(boolean declare) {
this.declare = declare;
}
public void setScope(String scopeName) {
switch (scopeName) {
case "NESTED":
scope = VariableInfo.NESTED;
break;
case "AT_BEGIN":
scope = VariableInfo.AT_BEGIN;
break;
case "AT_END":
scope = VariableInfo.AT_END;
break;
}
}
public TagVariableInfo toTagVariableInfo() {
return new TagVariableInfo(nameGiven, nameFromAttribute, className, declare, scope);
}
}
private static class GenericBooleanRule extends Rule {
private final Method setter;
private GenericBooleanRule(Class<?> type, String setterName) {
try {
this.setter = type.getMethod(setterName, Boolean.TYPE);
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException(e);
}
}
@Override
public void body(String namespace, String name, String text) throws Exception {
if(null != text) {
text = text.trim();
}
boolean value = "true".equalsIgnoreCase(text) || "yes".equalsIgnoreCase(text);
setter.invoke(digester.peek(), Boolean.valueOf(value));
}
}
}