/*******************************************************************************
* Copyright (c) 2010 SAP AG.
* 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:
* Emil Simeonov - initial API and implementation.
* Dimitar Donchev - initial API and implementation.
* Dimitar Tenev - initial API and implementation.
* Nevena Manova - initial API and implementation.
* Georgi Konstantinov - initial API and implementation.
*******************************************************************************/
package org.eclipse.wst.sse.sieditor.model.validation.constraints;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.validation.IValidationContext;
import org.eclipse.emf.validation.model.ConstraintStatus;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDDiagnostic;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDMaxExclusiveFacet;
import org.eclipse.xsd.XSDMaxInclusiveFacet;
import org.eclipse.xsd.XSDMinExclusiveFacet;
import org.eclipse.xsd.XSDMinInclusiveFacet;
import org.eclipse.xsd.XSDPackage;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.w3c.dom.Node;
import org.eclipse.wst.sse.sieditor.model.i18n.Messages;
import org.eclipse.wst.sse.sieditor.model.utils.EmfXsdUtils;
public class ValidXSDEntity extends AbstractConstraint {
private Set<EClass> featureClasses = new HashSet<EClass>();
private IStatus convertDiagnosticsToStatus(final IValidationContext ctx, final List<XSDDiagnostic> diagnostics,
XSDSchema schema) {
final List<IStatus> statusList = new ArrayList<IStatus>();
statusList.add(ConstraintStatus.createSuccessStatus(ctx, schema, null));
if (diagnostics.size() == 0) {
final EObject target = ctx.getTarget();
if (target instanceof XSDDiagnostic) {
final XSDDiagnostic diagnostic = (XSDDiagnostic) target;
diagnostic.getPrimaryComponent().getDiagnostics().add(diagnostic);
}
statusList.add(ConstraintStatus.createSuccessStatus(ctx, target, null));
}
for (XSDDiagnostic diagnostic : new LinkedList<XSDDiagnostic>(diagnostics)) {
int severity = IStatus.INFO;
switch (diagnostic.getSeverity()) {
case FATAL_LITERAL:
case ERROR_LITERAL:
severity = IStatus.ERROR;
break;
case WARNING_LITERAL:
severity = IStatus.WARNING;
}
Collection<EObject> resultLocus = new ArrayList<EObject>();
// add the feature to the result locus
// IValidationContext#getFeature() does not work the way it is
// supposed to
EStructuralFeature feature = findFailedConstraintTrigger(diagnostic);
if (feature != null) {
resultLocus.add(feature);
}
// add other components to result locus
resultLocus.addAll(diagnostic.getComponents());
diagnostic.getPrimaryComponent().getDiagnostics().add(diagnostic);
statusList.add(ConstraintStatus.createStatus(ctx, diagnostic, resultLocus, diagnostic.getMessage(), severity,
diagnostic.getSubstitutions()));
}
return createStatus(ctx, statusList);
}
public ValidXSDEntity() {
super();
featureClasses.add(XSDPackage.Literals.XSD_NAMED_COMPONENT);
featureClasses.add(XSDPackage.Literals.XSD_TOTAL_DIGITS_FACET);
featureClasses.add(XSDPackage.Literals.XSD_MIN_LENGTH_FACET);
featureClasses.add(XSDPackage.Literals.XSD_MAX_LENGTH_FACET);
featureClasses.add(XSDPackage.Literals.XSD_LENGTH_FACET);
featureClasses.add(XSDPackage.Literals.XSD_ENUMERATION_FACET);
featureClasses.add(XSDPackage.Literals.XSD_WHITE_SPACE_FACET);
}
@Override
protected IStatus doValidate(IValidationContext ctx) {
final XSDSchema schema = ((XSDConcreteComponent) ctx.getTarget()).getSchema();
// without this check the XSD API throws NPEs everywhere
if (EmfXsdUtils.isSchemaElementMissing(schema)) {
return ConstraintStatus.createStatus(ctx, schema, ctx.getResultLocus(),
Messages.ValidXSDEntity_Missing_Schema_Element0, IStatus.ERROR);
}
if (EmfXsdUtils.isSchemaForSchemaMissing(schema)) {
return ConstraintStatus.createStatus(ctx, schema, ctx.getResultLocus(), Messages.EmfXsdUtils_MissingSchemaForSchema1,
IStatus.ERROR);
}
schema.clearDiagnostics();
schema.validate();
return convertDiagnosticsToStatus(ctx, schema.getAllDiagnostics(), schema);
}
@Override
protected boolean shouldExecute(IValidationContext ctx) {
EObject target = ctx.getTarget();
if (isBatchValidation(ctx)) {
return (target instanceof XSDSchema);
}
return !(target instanceof XSDDiagnostic);
}
/**
* Tries to find the particular feature which triggered the constraint
*/
public EStructuralFeature findFailedConstraintTrigger(XSDDiagnostic diagnostic) {
// First check if the constraint failed in an attribute and try to find
// the feature which corresponds to this attribute
Node node = diagnostic.getNode();
EStructuralFeature feature = null;
if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
String nodeName = node.getNodeName();
feature = diagnostic.getContainer().eClass().getEStructuralFeature(nodeName);
if (feature != null) {
EClass eClass = feature.getEContainingClass();
// this is done because for example xsd min exclusive and xsd
// min exclusive have both the same feature class
// - XSD_MIN_FACET and cannot be distinguished
if (featureClasses.contains(eClass)) {
return feature;
}
}
}
// Now try to find the feature by examining the primary component in
// which the constraint failed
XSDConcreteComponent component = diagnostic.getPrimaryComponent();
if (component instanceof XSDMinExclusiveFacet) {
return XSDPackage.Literals.XSD_MIN_FACET__EXCLUSIVE;
} else if (component instanceof XSDMinInclusiveFacet) {
return XSDPackage.Literals.XSD_MIN_FACET__INCLUSIVE;
} else if (component instanceof XSDMaxInclusiveFacet) {
return XSDPackage.Literals.XSD_MAX_FACET__INCLUSIVE;
} else if (component instanceof XSDMaxExclusiveFacet) {
return XSDPackage.Literals.XSD_MAX_FACET__EXCLUSIVE;
}
// if the component was none of the above check again if the constrained
// failed in an attribute; if it was not an attribute
// we can assume the following 2 cases to be true
if (feature != null) {
return feature;
}
// if the constraint failed in the simple type definition and not in one
// of its attributes it must be in its base type
else if (component instanceof XSDSimpleTypeDefinition) {
return XSDPackage.Literals.XSD_TYPE_DEFINITION__BASE_TYPE;
}
// if the constraint failed in the element or attribute
// declaration and not in one of its attributes it must be in its type;
// Use the XSD_TYPE_DEFINITION__ANNOTATION constant
// to mark it since there is no constant combining simple and
// complex types
else if (component instanceof XSDElementDeclaration || component instanceof XSDAttributeDeclaration) {
return XSDPackage.Literals.XSD_TYPE_DEFINITION__ANNOTATION;
}
return null;
}
}