/*******************************************************************************
* Copyright (c) 2001, 2008 Oracle Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.validation.internal.strategy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.emf.common.util.BasicDiagnostic;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jst.jsf.common.dom.AttrDOMAdapter;
import org.eclipse.jst.jsf.common.dom.AttributeIdentifier;
import org.eclipse.jst.jsf.common.dom.DOMAdapter;
import org.eclipse.jst.jsf.common.internal.types.CompositeType;
import org.eclipse.jst.jsf.common.internal.types.TypeComparator;
import org.eclipse.jst.jsf.common.internal.types.TypeComparatorDiagnosticFactory;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.internal.types.TypeTransformer;
import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.region.Region2AttrAdapter;
import org.eclipse.jst.jsf.core.internal.region.Region2ElementAdapter;
import org.eclipse.jst.jsf.core.jsfappconfig.internal.IJSFAppConfigManager;
import org.eclipse.jst.jsf.core.jsfappconfig.internal.JSFAppConfigManagerFactory;
import org.eclipse.jst.jsf.designtime.DTAppManagerUtil;
import org.eclipse.jst.jsf.designtime.internal.view.DTUIViewRoot;
import org.eclipse.jst.jsf.designtime.internal.view.IDTViewHandler.ViewHandlerException;
import org.eclipse.jst.jsf.designtime.internal.view.XMLViewDefnAdapter;
import org.eclipse.jst.jsf.designtime.internal.view.XMLViewDefnAdapter.DTELExpression;
import org.eclipse.jst.jsf.designtime.internal.view.XMLViewObjectMappingService;
import org.eclipse.jst.jsf.designtime.internal.view.XMLViewObjectMappingService.ElementData;
import org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType;
import org.eclipse.jst.jsf.facesconfig.emf.ConverterType;
import org.eclipse.jst.jsf.metadataprocessors.MetaDataEnabledProcessingFactory;
import org.eclipse.jst.jsf.metadataprocessors.features.ELIsNotValidException;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidELValues;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidValues;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidationMessage;
import org.eclipse.jst.jsf.validation.internal.AbstractXMLViewValidationStrategy;
import org.eclipse.jst.jsf.validation.internal.JSFValidationContext;
import org.eclipse.jst.jsf.validation.internal.el.ELExpressionValidator;
import org.eclipse.jst.jsp.core.internal.regions.DOMJSPRegionContexts;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionCollection;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
/**
* An XML view validation strategy that validates
*
* @author cbateman
*
*/
public class AttributeValidatingStrategy extends
AbstractXMLViewValidationStrategy
{
private static final String DISABLE_ALTERATIVE_TYPES_KEY = "jsfCoreDisableConverterValidation"; //$NON-NLS-1$
private static final String ENABLE_ALTERATIVE_TYPES_KEY = "jsfCoreEnableConverterValidation"; //$NON-NLS-1$
static final boolean DEBUG;
static
{
final String value = Platform
.getDebugOption("org.eclipse.jst.jsf.validation.internal.el/debug/jspsemanticsvalidator"); //$NON-NLS-1$
DEBUG = value != null && value.equalsIgnoreCase("true"); //$NON-NLS-1$
}
/**
* identifier
*/
public final static String ID = "org.eclipse.jst.jsf.validation.strategy.AttributeValidatingStrategy"; //$NON-NLS-1$
private final static String DISPLAY_NAME = "Attribute Validator"; //$NON-NLS-1$
private final JSFValidationContext _validationContext;
private final TypeComparator _typeComparator;
private Set<String> _conversionTypes;
/**
* Default constructor
*
* @param validationContext
*/
public AttributeValidatingStrategy(final JSFValidationContext validationContext)
{
super(ID, DISPLAY_NAME);
_validationContext = validationContext;
_typeComparator = new TypeComparator(
new TypeComparatorDiagnosticFactory(validationContext
.getPrefs().getTypeComparatorPrefs()));
}
@Override
public boolean isInteresting(final DOMAdapter domAdapter)
{
return (domAdapter instanceof AttrDOMAdapter);
}
@Override
public void validate(final DOMAdapter domAdapter)
{
if (domAdapter instanceof AttrDOMAdapter)
{
final long curTime = System.nanoTime();
final Region2AttrAdapter attrAdapter = (Region2AttrAdapter) domAdapter;
// check that this is attribute value region - 221722
if (attrAdapter.getAttributeValueRegion() != null)
{
final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
.getContext(attrAdapter.getDocumentContext()
.getStructuredDocument(), attrAdapter
.getOwningElement().getDocumentContext()
.getDocumentPosition()
+ attrAdapter.getAttributeValueRegion()
.getStart());
validateAttributeValue(context, attrAdapter);
}
if (DEBUG)
{
System.out.println(String.format("Validation for attribute: %s took %d" //$NON-NLS-1$
, domAdapter.toString()
, Long.valueOf(System.nanoTime()-curTime)));
}
}
}
/**
* Validates the attribute value. Reports any problems to the reporter in
* the JSFValidationContext.
*
* @param context
* @param attrAdapter
*/
private void validateAttributeValue(
final IStructuredDocumentContext context,
final Region2AttrAdapter attrAdapter)
{
// so of the code in run calls out into extension code or code
// dependent on external data (meta-data)
SafeRunner.run(new ISafeRunnable()
{
public void handleException(final Throwable exception)
{
JSFCorePlugin.log(String.format(
"Error validating attribute: %s on element %s", //$NON-NLS-1$
attrAdapter.getNodeName(), attrAdapter
.getOwningElement().getNodeName()), exception);
}
public void run() throws Exception
{
final Region2ElementAdapter elementAdapter =
attrAdapter.getOwningElement();
// if there's elText then validate it
// TODO: this approach will fail with mixed expressions
if (!checkIfELAndValidate(elementAdapter, attrAdapter, context))
{
validateNonELAttributeValue(context, attrAdapter);
}
}
});
}
private boolean checkIfELAndValidate(final Region2ElementAdapter elementAdapter,
final Region2AttrAdapter attrAdapter,
final IStructuredDocumentContext context)
{
int offsetOfFirstEL = -1;
final String attrValue = attrAdapter.getValue();
// TODO: should find and validate all
offsetOfFirstEL = attrValue.indexOf('#');
if (offsetOfFirstEL != -1 && offsetOfFirstEL < attrValue.length() - 1
&& attrValue.charAt(offsetOfFirstEL + 1) == '{')
{
offsetOfFirstEL += 2;
}
else
{
offsetOfFirstEL = -1;
}
final XMLViewDefnAdapter adapter = DTAppManagerUtil
.getXMLViewDefnAdapter(context);
boolean isEL = false;
if (adapter != null && offsetOfFirstEL != -1)
{
try
{
// use the attribute's context plus the offset into the
// whole attribute value to find where we think the el
// expression starts. Add one since the attribute value
// string returned by attrAdapter will have the value quotes
// removed, but the region offsets include the quotes.
IStructuredDocumentContext elContext = IStructuredDocumentContextFactory.INSTANCE
.getContext(context.getStructuredDocument(), context
.getDocumentPosition()
+ offsetOfFirstEL + 1);
final DTELExpression elExpression = adapter
.getELExpression(elContext);
if (elExpression != null)
{
final String elText = elExpression.getText();
if (DEBUG)
{
System.out.println(addDebugSpacer(3) + "EL attrVal= " //$NON-NLS-1$
+ elText);
}
elContext = elExpression.getDocumentContext();
// EL validation is user configurable because
// it can be computationally costly.
if (_validationContext.shouldValidateEL())
{
// also, skip the validation if the expression is empty
// or only whitespace, since the parser doesn't handle
// it
// anyway.
if ("".equals(elText.trim())) //$NON-NLS-1$
{
final int offset = elContext.getDocumentPosition() - 1;
final int length = elText.length() + 2;
final Diagnostic diagnostic = _validationContext
.getDiagnosticFactory()
.create_EMPTY_EL_EXPRESSION();
// detected empty EL expression
if (_validationContext.shouldValidateEL())
{
_validationContext.getReporter().report(
diagnostic, offset, length);
}
}
else
{
final List elVals = MetaDataEnabledProcessingFactory
.getInstance()
.getAttributeValueRuntimeTypeFeatureProcessors(
IValidELValues.class,
elContext,
attrAdapter
.getAttributeIdentifier());
final String safeELText = elText.replaceAll(
"[\n\r\t]", " "); //$NON-NLS-1$ //$NON-NLS-2$
validateELExpression(context, elContext, elVals,
elementAdapter, attrAdapter, safeELText);
isEL = true;
}
} else {
isEL = true;
}
}
}
catch (final ViewHandlerException e)
{
// fall through to return false
}
}
// is el if we've already detected it or if the step 2 method
// finds it. Run the method first to avoid short-circuiting
final boolean isEL2 = checkIfELAndValidate2(attrAdapter, context);
return isEL || isEL2;
}
/**
* Checks the region to see if it contains an EL attribute value. If it
* does, validates it
*
* @return true if validated EL, false otherwise
*/
private boolean checkIfELAndValidate2(final Region2AttrAdapter attrAdapter,
final IStructuredDocumentContext sDocContext)
{
final ITextRegion attrValueRegion = attrAdapter
.getAttributeValueRegion();
if (attrValueRegion instanceof ITextRegionCollection)
{
final ITextRegionCollection parentRegion = ((ITextRegionCollection) attrValueRegion);
if (parentRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE)
{
final ITextRegionList regionList = parentRegion.getRegions();
if (regionList.size() >= 3)
{
final ITextRegion openQuote = regionList.get(0);
final ITextRegion vblOpen = regionList.get(1);
if ((openQuote.getType() == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_DQUOTE || openQuote
.getType() == DOMJSPRegionContexts.JSP_VBL_DQUOTE ||
openQuote.getType() == DOMJSPRegionContexts.JSP_TAG_ATTRIBUTE_VALUE_DQUOTE)
&& vblOpen.getType() == DOMJSPRegionContexts.JSP_VBL_OPEN)
{
boolean foundClosingQuote = false;
for (int i = 2; !foundClosingQuote
&& i < regionList.size(); i++)
{
final ITextRegion searchRegion = regionList.get(i);
if (searchRegion.getType() == DOMJSPRegionContexts.JSP_VBL_CLOSE)
{
foundClosingQuote = true;
}
}
if (!foundClosingQuote
&& _validationContext.shouldValidateEL())
{
final int offset = sDocContext
.getDocumentPosition() + 1;
final int length = parentRegion.getText().length();
final Diagnostic diagnostic = _validationContext
.getDiagnosticFactory()
.create_MISSING_CLOSING_EXPR_BRACKET();
_validationContext.getReporter().report(diagnostic,
offset, length);
}
return true;
}
}
}
}
return false;
}
private void validateELExpression(final IStructuredDocumentContext context,
final IStructuredDocumentContext elContext, final List elVals,
final Region2ElementAdapter elementAdapter,
final Region2AttrAdapter attrAdapter, final String elText)
{
// Call EL validator which will perform at least the syntactical
// validation
final ELExpressionValidator elValidator = new ELExpressionValidator(
elContext, elText, _validationContext
.getSymbolResolverFactory(), _validationContext
.getReporter());
elValidator.validateXMLNode();
final CompositeType exprType = elValidator.getExpressionType();
if (exprType != null)
{
// Ignore the expression whose last two segments are of types Object.
final CompositeType boxedType = TypeTransformer
.transformBoxPrimitives(exprType);
final String[] testSignatures = boxedType.getSignatures();
if (testSignatures.length > 0 && TypeConstants.TYPE_JAVAOBJECT.equals(testSignatures[0]))
{
if (elText.indexOf('.') != -1)
{
String elText2 = elText.substring(0, elText.lastIndexOf('.'));
final ELExpressionValidator elValidator2 = new ELExpressionValidator(
elContext, elText2, _validationContext
.getSymbolResolverFactory(), _validationContext
.getReporter());
elValidator2.validateXMLNode();
final CompositeType exprType2 = elValidator.getExpressionType();
final CompositeType boxedType2 = TypeTransformer.transformBoxPrimitives(exprType2);
final String[] testSignatures2 = boxedType2.getSignatures();
if (testSignatures2.length > 0 && TypeConstants.TYPE_JAVAOBJECT.equals(testSignatures2[0]))
{
return;
}
}
}
for (final Iterator it = elVals.iterator(); it.hasNext();)
{
final IValidELValues elval = (IValidELValues) it.next();
final String attributeVal = attrAdapter.getValue();
CompositeType expectedType;
Diagnostic status = null;
try
{
expectedType = elval.getExpectedRuntimeType();
if (expectedType != null)
{
expectedType = maybeAddAlternativeTypes(
expectedType, exprType, elementAdapter,
attrAdapter);
status = _typeComparator.calculateTypeCompatibility(
expectedType, exprType);
if (status.getSeverity() != Diagnostic.OK)
{
reportValidationMessage(status, context,
attributeVal);
}
}
}
catch (final ELIsNotValidException e)
{
reportValidationMessage(createValidationMessage(context,
attributeVal, IStatus.WARNING, e.getMessage(),
_validationContext.getFile()), context,
attributeVal);
}
}
}
}
private boolean disableAlternativeTypes()
{
if (hasProperty(DISABLE_ALTERATIVE_TYPES_KEY))
{
return true;
}
if (hasProperty(ENABLE_ALTERATIVE_TYPES_KEY))
{
return false;
}
// As of Helios, alternative type is disabled by default
return true;
// final IPreferenceStore prefStore = JSFCorePlugin.getDefault().getPreferenceStore();
// return prefStore.getBoolean("org.eclipse.jst.jsf.core."+DISABLE_ALTERATIVE_TYPES_KEY); //$NON-NLS-1$
}
private boolean hasProperty(final String key) {
String res = System.getProperty(key);
if (res == null) {
//check env var also
res = System.getenv(key);
}
return res != null;
}
/**
* @return true if alternative type comparison (i.e. post-conversion) passes
*/
private CompositeType maybeAddAlternativeTypes(
final CompositeType expectedType, final CompositeType exprTypes,
final Region2ElementAdapter elementAdapter,
final Region2AttrAdapter attrAdapter)
{
final long curTime = System.nanoTime();
//As of Helios, alternative type is disabled by default
//and enabled by the ENABLE_ALTERNATIVE_TYPES_KEY system/env property
if (disableAlternativeTypes())
{
return expectedType;
}
final IStructuredDocumentContext context = elementAdapter
.getDocumentContext();
final DTUIViewRoot viewRoot = _validationContext.getViewRootHandle().getCachedViewRoot();
final IAdaptable serviceAdaptable = viewRoot.getServices();
final XMLViewObjectMappingService mappingService = (XMLViewObjectMappingService) serviceAdaptable
.getAdapter(XMLViewObjectMappingService.class);
if (mappingService != null)
{
final ElementData elementData = XMLViewObjectMappingService
.createElementData(elementAdapter.getNamespace(),
elementAdapter.getLocalName(), context,
Collections.EMPTY_MAP);
final ViewObject viewObject = mappingService
.findViewObject(elementData);
// if the corresponding view object is a valueholder, then
// we need to see if you think there a valid conversion
// available
if (viewObject instanceof ComponentInfo
&& ((ComponentInfo) viewObject).getComponentTypeInfo() != null
&& ((ComponentInfo) viewObject).getComponentTypeInfo()
.isInstanceOf(
ComponentFactory.INTERFACE_VALUEHOLDER))
{
final ComponentInfo component = (ComponentInfo) viewObject;
// get the original elementData
final ElementData mappedElementData = mappingService
.findElementData(component);
final String propName = mappedElementData
.getPropertyName(attrAdapter.getLocalName());
if ("value".equals(propName)) //$NON-NLS-1$
{
// final List converters =
// component.getDecorators(ComponentFactory.CONVERTER);
// (ConverterDecorator) it.next();
final CompositeType alternativeTypes = createCompositeType(
expectedType, exprTypes, component
.getDecorators(ComponentFactory.CONVERTER));
if (DEBUG)
{
System.out.println(String.format(
"maybeAddAlternative took %d", Long.valueOf(System //$NON-NLS-1$
.nanoTime()
- curTime)));
}
return alternativeTypes;
}
}
}
if (DEBUG)
{
System.out.println(String.format("maybeAddAlternative took %d", Long //$NON-NLS-1$
.valueOf(System.nanoTime() - curTime)));
}
// don't add anything by default
return expectedType;
}
private CompositeType createCompositeType(final CompositeType initialTypes,
final CompositeType testTypes, final List<ConverterDecorator> decorators)
{
// indicates unknown converter
final Set<String> types = new HashSet(Arrays.asList(initialTypes
.getSignatures()));
// look for converters. If there's one where we don't know the type,
// simply copy over the testTypes to force validation to ignore, since
// we have no idea.
for (final ConverterDecorator decorator : decorators)
{
if (decorator.getTypeInfo() != null)
{
final ConverterTypeInfo converterTypeInfo = decorator.getTypeInfo();
if (converterTypeInfo.getForClass().length == 0)
{
types.addAll(Arrays.asList(testTypes.getSignatures()));
break;
}
types.addAll(createSignatures(converterTypeInfo.getForClass()));
}
}
types.addAll(getRegisteredConversionTypesByClass());
return new CompositeType(types.toArray(new String[0])
, initialTypes.getAssignmentTypeMask());
}
private Set<String> getRegisteredConversionTypesByClass()
{
if (_conversionTypes == null)
{
_conversionTypes = new HashSet<String>();
final IProject project = _validationContext.getFile().getProject();
final IJSFAppConfigManager appConfig = JSFAppConfigManagerFactory.getJSFAppConfigManagerInstance(project);
final List<ConverterType> converters = appConfig.getConverters();
for (final ConverterType converterType : converters)
{
final ConverterForClassType forClassType = converterType.getConverterForClass();
if (forClassType != null)
{
final String forClass = forClassType.getTextContent();
if (forClass != null)
{
String signature = forClass.trim();
try
{
// arrays are a special case where the
// [Ljava.lang.String; syntax is valid.
if (Signature.getArrayCount(signature)>0)
{
_conversionTypes.add(signature);
}
}
catch (final IllegalArgumentException e)
{
// ignore
}
try
{
signature = Signature.createTypeSignature(signature, true);
_conversionTypes.add(signature);
}
catch (final Exception e)
{
// ignore: JSFCorePlugin.log(IStatus.INFO, "Could not use registered converter for-class: "+forClass); //$NON-NLS-1$
}
}
}
}
}
return _conversionTypes;
}
private List<String> createSignatures(final String[] classNames)
{
final List<String> signatures = new ArrayList<String>();
for (final String className : classNames)
{
try
{
String signature = Signature.createTypeSignature(className, true);
signatures.add(signature);
}
catch (final Exception e)
{
JSFCorePlugin.log(e, "Trying to create signature"); //$NON-NLS-1$
}
}
return signatures;
}
/**
* Validates an attribute value in context using the JSF metadata processing
* framework
*
* @param context
* @param region
* @param uri
* @param tagName
* @param attrName
* @param attributeVal
* @param reporter
* @param file
*/
private void validateNonELAttributeValue(
final IStructuredDocumentContext context,
final Region2AttrAdapter attrAdapter)
{
final String attributeValue = attrAdapter.getValue();
// else validate as static attribute value
if (DEBUG)
{
System.out.println(addDebugSpacer(3) + "attrVal= " //$NON-NLS-1$
+ (attributeValue != null ? attributeValue : "null")); //$NON-NLS-1$
}
final AttributeIdentifier attributeId = attrAdapter
.getAttributeIdentifier();
if (attributeId.getTagIdentifier() == null
|| attributeId.getTagIdentifier().getTagName() == null
|| attributeId.getName() == null)
{
return;
}
final List vv = MetaDataEnabledProcessingFactory.getInstance()
.getAttributeValueRuntimeTypeFeatureProcessors(
IValidValues.class, context, attributeId);
if (!vv.isEmpty())
{
for (final Iterator it = vv.iterator(); it.hasNext();)
{
final IValidValues v = (IValidValues) it.next();
if (!v.isValidValue(attributeValue.trim()))
{
if (DEBUG)
{
System.out.println(addDebugSpacer(4) + "NOT VALID "); //$NON-NLS-1$
}
for (final Iterator msgs = v.getValidationMessages()
.iterator(); msgs.hasNext();)
{
final IValidationMessage msg = (IValidationMessage) msgs
.next();
reportValidationMessage(createValidationMessage(
context, attributeValue, msg.getSeverity(), msg
.getMessage(), _validationContext
.getFile()), context, attributeValue);
}
}
else if (DEBUG)
{
System.out.println(addDebugSpacer(5) + "VALID "); //$NON-NLS-1$
}
}
}
else if (DEBUG)
{
System.out.println(addDebugSpacer(4) + "NO META DATA "); //$NON-NLS-1$
}
}
private void reportValidationMessage(final Diagnostic problem,
final IStructuredDocumentContext context,
final String attributeValue)
{
final int start = context.getDocumentPosition() + 1;
final int length = attributeValue.length();
_validationContext.getReporter().report(problem, start, length);
}
private Diagnostic createValidationMessage(
final IStructuredDocumentContext context,
final String attributeValue, final int severity, final String msg,
final IFile file)
{
// TODO: need factory
final Diagnostic diagnostic = new BasicDiagnostic(severity, "", -1, //$NON-NLS-1$
msg, null);
return diagnostic;
}
private String addDebugSpacer(final int count)
{
final String TAB = "\t"; //$NON-NLS-1$
final StringBuffer ret = new StringBuffer(""); //$NON-NLS-1$
for (int i = 0; i <= count; i++)
{
ret.append(TAB);
}
return ret.toString();
}
}