| /******************************************************************************* |
| * Copyright (c) 2001, 2004 IBM 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.wst.xml.ui.reconcile; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.wst.sse.core.IModelManager; |
| import org.eclipse.wst.sse.core.IStructuredModel; |
| import org.eclipse.wst.sse.core.IndexedRegion; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.validation.core.IFileDelta; |
| import org.eclipse.wst.validation.core.IHelper; |
| import org.eclipse.wst.validation.core.IMessage; |
| import org.eclipse.wst.validation.core.IMessageAccess; |
| import org.eclipse.wst.validation.core.IReporter; |
| import org.eclipse.wst.validation.core.IValidator; |
| import org.eclipse.wst.validation.core.ValidationException; |
| import org.eclipse.wst.xml.core.document.XMLAttr; |
| import org.eclipse.wst.xml.core.document.XMLDocument; |
| import org.eclipse.wst.xml.core.document.XMLElement; |
| import org.eclipse.wst.xml.core.document.XMLModel; |
| import org.eclipse.wst.xml.core.document.XMLNode; |
| import org.eclipse.wst.xml.core.document.XMLText; |
| import org.eclispe.wst.validation.internal.core.MessageLimitException; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| /** |
| * A DelegatingReconcileValidator calls its delegate validator |
| * to get a list of validation error IMessages. Using information |
| * in this IMessage the DelegatingReconcileValidator updates the IMessage with |
| * an offset and length to give a good range to be "squiggled" |
| * and adds the messages to the IReporter |
| * |
| * @author Mark Hutchinson |
| * |
| */ |
| public class DelegatingReconcileValidator implements IValidator |
| { //these are the selection Strategies: |
| protected static final String ALL_ATTRIBUTES = "ALL_ATTRIBUTES"; |
| protected static final String ATTRIBUTE_NAME ="ATTRIBUTE_NAME"; |
| protected static final String ATTRIBUTE_VALUE = "ATTRIBUTE_VALUE"; |
| protected static final String START_TAG = "START_TAG"; |
| protected static final String TEXT = "TEXT"; |
| protected static final String FIRST_NON_WHITESPACE_TEXT = "FIRST_NON_WHITESPACE_TEXT"; |
| protected static final String TEXT_ENTITY_REFERENCE = "TEXT_ENTITY_REFERENCE"; |
| protected static final String NAME_OF_ATTRIBUTE_WITH_GIVEN_VALUE = "NAME_OF_ATTRIBUTE_WITH_GIVEN_VALUE"; |
| |
| public DelegatingReconcileValidator() |
| { super(); //constructor |
| } |
| |
| public void cleanup(IReporter arg0) |
| { // don't need to implement |
| } |
| |
| // My Implementation of IHelper |
| class MyHelper implements IHelper |
| { |
| InputStream inputStream; |
| |
| IFile file; |
| |
| public MyHelper(InputStream inputStream, IFile file) |
| { this.inputStream = inputStream; |
| this.file = file; |
| } |
| |
| public Object loadModel(String symbolicName, Object[] parms) |
| { if (symbolicName.equals("getFile")) |
| { return file; |
| } |
| return null; |
| } |
| |
| public Object loadModel(String symbolicName) |
| { if (symbolicName.equals("inputStream")) |
| { return inputStream; |
| } |
| return null; |
| } |
| } |
| //My Implementation of IReporter |
| class MyReporter implements IReporter |
| { |
| List list = new ArrayList(); |
| |
| public MyReporter() |
| { super(); |
| } |
| |
| public void addMessage(IValidator origin, IMessage message) throws MessageLimitException |
| { list.add(message); |
| } |
| |
| public void displaySubtask(IValidator validator, IMessage message) |
| {//do not need to implement |
| } |
| |
| public IMessageAccess getMessageAccess() |
| { return null; //do not need to implement |
| } |
| |
| public boolean isCancelled() |
| { return false; //do not need to implement |
| } |
| |
| public void removeAllMessages(IValidator origin, Object object) |
| { //do not need to implement |
| } |
| |
| public void removeAllMessages(IValidator origin) |
| {//do not need to implement |
| } |
| |
| public void removeMessageSubset(IValidator validator, Object obj, String groupName) |
| {//do not need to implement |
| } |
| } |
| |
| protected IValidator getDelegateValidator() |
| { return null;//this class must be overridden by a subclass |
| } |
| |
| /** |
| * Calls a delegate validator getting and updates it's list of ValidationMessages |
| * with a good squiggle offset and length. |
| * |
| * @param helper |
| * loads an object. |
| * @param reporter |
| * Is an instance of an IReporter interface, which is used for |
| * interaction with the user. |
| * @param delta |
| * an array containing the file to be validated. Only position 0 will be validated |
| */ |
| public void validate(IHelper helper, IReporter reporter, IFileDelta[] delta) throws ValidationException |
| { |
| if (delta.length > 0) |
| { |
| // get the file, model and document: |
| IFile file = getFile(delta[0]); |
| XMLModel xmlModel = getModelForResource(file); |
| try |
| { |
| XMLDocument document = xmlModel.getDocument(); |
| |
| // store the text in a byte array; make a full copy to ease any threading problems |
| byte[] byteArray = xmlModel.getStructuredDocument().get().getBytes(); |
| |
| // get the Validator: |
| IValidator validator = getDelegateValidator(); |
| if (validator != null) |
| { |
| //Validate the file: |
| IHelper vHelper = new MyHelper(new ByteArrayInputStream(byteArray), file); |
| MyReporter vReporter = new MyReporter(); |
| validator.validate(vHelper, vReporter, delta); |
| List messages = vReporter.list; |
| |
| //set the offset and length |
| updateValidationMessages(messages, document, reporter); |
| } |
| } |
| catch (Exception e) |
| { //e.printStackTrace(); |
| } |
| finally |
| { |
| if (xmlModel != null) |
| xmlModel.releaseFromRead(); |
| } |
| } |
| } |
| |
| /** |
| * iterates through the messages and calculates a "better" offset and length |
| * |
| * @param messages - a List of IMessages |
| * @param document - the document |
| * @param reporter - the reporter the messages are to be added to |
| */ |
| protected void updateValidationMessages(List messages, XMLDocument document, IReporter reporter) |
| { |
| for (int i = 0; i < messages.size(); i++) |
| { |
| IMessage message = (IMessage) messages.get(i); |
| try |
| { //get the extra information stored in the parameters: |
| String[] params = message.getParams(); |
| int column = new Integer(params[0]).intValue(); |
| String key = params[1]; |
| String nameOrValue = params[2];//The name or value of what should be squiggled |
| |
| // convert the line and Column numbers to an offset: |
| int start = document.getStructuredDocument().getLineOffset(message.getLineNumber() - 1) + column - 1; |
| |
| // calculate the "better" start and end offset: |
| int[] result = computeStartEndLocation(start, message.getText(), key, nameOrValue, document); |
| if (result != null) |
| { |
| message.setOffset(result[0]); |
| message.setLength(result[1] - result[0]); |
| reporter.addMessage(this, message); |
| } |
| } |
| catch (Exception e) |
| { //e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * @param delta the IFileDelta containing the file name to get |
| * @return the IFile |
| */ |
| public IFile getFile(IFileDelta delta) |
| { |
| IResource res = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(delta.getFileName())); |
| return res instanceof IFile ? (IFile) res : null; |
| } |
| /** |
| * |
| * @param file the file to get the model for |
| * @return the file's XMLModel |
| */ |
| protected XMLModel getModelForResource(IFile file) |
| { |
| IStructuredModel model = null; |
| IModelManager manager = StructuredModelManager.getModelManager(); |
| |
| try |
| { model = manager.getModelForRead(file); |
| // TODO.. HTML validator tries again to get a model a 2nd way |
| } |
| catch (Exception e) |
| { |
| //e.printStackTrace(); |
| } |
| |
| return model instanceof XMLModel ? (XMLModel) model : null; |
| } |
| |
| /** |
| * Calculates the "better" offsets. |
| * |
| * @param startOffset - the offset given by Xerces |
| * @param errorMessage - the Xerces error Message |
| * @param key - the selectionStrategy |
| * @param document - the document |
| * @return int[] - position 0 has the start offset of the squiggle range, position 1 has the endOffset |
| */ |
| /* |
| * The way the offsets is calculated is: |
| * |
| * - find the indexed region (element) closest to the given offset |
| * - if we are between two elements, the one on the left is the one we want |
| * - based on the key select a strategy to find the better offset |
| * - use information from nameOrValue and the DOM to get better offsets |
| * |
| */ |
| protected int[] computeStartEndLocation(int startOffset, String errorMessage, String key, String nameOrValue, XMLDocument document) |
| { |
| try |
| { |
| int startEndPositions[] = new int[2]; |
| |
| IndexedRegion region = document.getModel().getIndexedRegion(startOffset); |
| IndexedRegion prevRegion = document.getModel().getIndexedRegion(startOffset - 1); |
| |
| if (prevRegion != region) |
| { // if between two regions, the one on the left is the one we are interested in |
| region = prevRegion; |
| } |
| |
| // initialize start and end positions to be the start positions this means if the |
| // special case is not taken care of below the start and end offset are set to be |
| // the start of the region where the error was |
| if (region != null) |
| { |
| startEndPositions[0] = region.getStartOffset(); |
| startEndPositions[1] = startEndPositions[0]; |
| } |
| else |
| { //this will message will not get added to the IReporter since the length is 0 |
| startEndPositions[0] = 0; |
| startEndPositions[1] = 0; |
| } |
| if (region instanceof Node) |
| { |
| Node node = (Node) region; |
| |
| if (key.equals(START_TAG)) |
| {// then we want to highlight the opening tag |
| if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| XMLElement element = (XMLElement) node; |
| startEndPositions[0] = element.getStartOffset() + 1; |
| startEndPositions[1] = startEndPositions[0] + element.getTagName().length(); |
| } |
| } |
| else if (key.equals(ATTRIBUTE_NAME)) |
| { // in this case we want to underline the offending attribute name |
| if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| XMLElement element = (XMLElement) node; |
| XMLNode attributeNode = (XMLNode) (element.getAttributeNode(nameOrValue)); |
| if (attributeNode != null) |
| { |
| startEndPositions[0] = attributeNode.getStartOffset(); |
| startEndPositions[1] = attributeNode.getStartOffset() + nameOrValue.length(); |
| } |
| } |
| } |
| else if (key.equals(ATTRIBUTE_VALUE)) |
| {// in this case we want to underline the attribute's value |
| if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| XMLElement element = (XMLElement) node; |
| XMLAttr attributeNode = (XMLAttr) (element.getAttributeNode(nameOrValue)); |
| if (attributeNode != null) |
| { |
| startEndPositions[0] = attributeNode.getValueRegionStartOffset(); |
| startEndPositions[1] = startEndPositions[0] + attributeNode.getValueRegionText().length(); |
| } |
| } |
| } |
| else if (key.equals(ALL_ATTRIBUTES)) |
| {// then underline ALL attributes |
| if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| XMLElement element = (XMLElement) node; |
| NamedNodeMap attributes = element.getAttributes(); |
| if (attributes != null) |
| { |
| XMLNode first = (XMLNode) attributes.item(0); |
| XMLNode last = (XMLNode) attributes.item(attributes.getLength() - 1); |
| if (first != null && last != null) |
| { |
| startEndPositions[0] = first.getStartOffset(); |
| startEndPositions[1] = last.getEndOffset(); |
| } |
| } |
| } |
| } |
| else if (key.equals(TEXT)) |
| {// in this case we want to underline the text (but not any extra whitespace) |
| if (node.getNodeType() == Node.TEXT_NODE) |
| { |
| XMLText textNode = (XMLText) node; |
| int start = textNode.getStartOffset(); |
| String value = textNode.getNodeValue(); |
| int index = 0; |
| char curChar = value.charAt(index); |
| //here we are finding start offset by skipping over whitespace: |
| while (curChar == '\n' || curChar == '\t' || curChar == '\r' || curChar == ' ') |
| { |
| curChar = value.charAt(index); |
| index++; |
| start++; |
| } |
| startEndPositions[0] = start - 1; |
| startEndPositions[1] = start + value.trim().length() - 1; |
| } |
| else if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| XMLElement element = (XMLElement) node; |
| Node child = element.getFirstChild(); |
| if (child instanceof XMLNode) |
| { |
| XMLNode xmlChild = ((XMLNode) child); |
| startEndPositions[0] = xmlChild.getStartOffset(); |
| startEndPositions[1] = xmlChild.getEndOffset(); |
| } |
| } |
| } |
| else if (key.equals(FIRST_NON_WHITESPACE_TEXT)) |
| { //here we search through all the child nodes, and give the range |
| // of the first non-whitespace node |
| if (node.getNodeType() == Node.ELEMENT_NODE) |
| { NodeList nodes = node.getChildNodes(); |
| for (int i = 0; i< nodes.getLength(); i++) |
| { |
| Node currentNode = nodes.item(i); |
| if (currentNode.getNodeType() == Node.TEXT_NODE) |
| { |
| XMLText textNode = (XMLText)currentNode; |
| if (textNode.getNodeValue().trim().length() > 0) |
| { |
| String value = textNode.getNodeValue(); |
| int index = 0; |
| int start = textNode.getStartOffset(); |
| char curChar = value.charAt(index); |
| //here we are finding start offset by skipping over whitespace: |
| while (curChar == '\n' || curChar == '\t' || curChar == '\r' || curChar == ' ') |
| { |
| curChar = value.charAt(index); |
| index++; |
| } |
| if (index > 0) |
| { index--; |
| |
| } |
| start = start + index; |
| startEndPositions[0] = start; |
| startEndPositions[1] = start + value.trim().length(); |
| break; |
| } |
| } |
| |
| } |
| } |
| } |
| |
| else if (key.equals(TEXT_ENTITY_REFERENCE)) |
| { if (node.getNodeType() == Node.ENTITY_REFERENCE_NODE) |
| { startEndPositions[0] = region.getStartOffset(); |
| startEndPositions[1] = region.getEndOffset(); |
| } |
| } |
| else if (key.equals(NAME_OF_ATTRIBUTE_WITH_GIVEN_VALUE)) |
| {//underline the name of the attribute containing the given value |
| if (node.getNodeType() == Node.ELEMENT_NODE) |
| { |
| //here we will search through all attributes for the one with the |
| //with the value we want: |
| NamedNodeMap attributes = node.getAttributes(); |
| for (int i=0; i<attributes.getLength(); i++) |
| { |
| XMLAttr attr = (XMLAttr)attributes.item(i); |
| String nodeValue = attr.getNodeValue().trim(); |
| if (nodeValue.equals(nameOrValue)) |
| { startEndPositions[0] = attr.getValueRegionStartOffset() + 1; |
| startEndPositions[1] = startEndPositions[0] + nodeValue.length(); |
| break; |
| } |
| } |
| } |
| } |
| } |
| return startEndPositions; |
| } |
| catch (Exception e) |
| { //e.printStackTrace(); |
| } |
| return null; |
| } |
| } |
