| /******************************************************************************* |
| * Copyright (c) 2002, 2006 GEBIT Gesellschaft fuer EDV-Beratung |
| * und Informatik-Technologien mbH, |
| * Berlin, Duesseldorf, Frankfurt (Germany) 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: |
| * GEBIT Gesellschaft fuer EDV-Beratung und Informatik-Technologien mbH - initial API and implementation |
| * IBM Corporation - bug 24108 |
| *******************************************************************************/ |
| |
| package org.eclipse.ant.internal.ui.editor.tools; |
| |
| import java.io.IOException; |
| import java.net.URL; |
| import com.ibm.icu.text.MessageFormat; |
| import java.util.Vector; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.eclipse.ant.internal.ui.AntUIPlugin; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * This class can be used to merge the tasks.xml and XDOCtasks.xml. |
| * These files can be found in the Ant Editor Content Assist Dev folder. |
| * Move the files to the Ant Editor folder to use this class. |
| * |
| * The xml automatically generated from the proposed xdoclet in the Apache Ant's |
| * project currently has no information on required attributes. In the future the task writers |
| * hopefully will include this information in the source code comments. Our |
| * template currently inserts an attribute required="NOTDEFINED" and this class |
| * replaces that field if its defined in the xml file we have generated from the |
| * information based on the html files in the Apache Ant's manual directory. |
| */ |
| public class TaskXMLFileMerger { |
| |
| //Definitions for the HTML Generated XML File |
| public static String HTML_TASKS_DESCRIPTION_XML_FILE_NAME = "/tasks.xml"; //$NON-NLS-1$ |
| public static String HTML_XML_TAG_TASKS = "TASKS"; //$NON-NLS-1$ |
| public static String HTML_XML_TAG_TASK = "TASK"; //$NON-NLS-1$ |
| public static String HTML_XML_TAG_ATTRIBUTE = "ATTRIBUTE"; //$NON-NLS-1$ |
| //public static String HTML_XML_TAG_DESCRIPTION = "DESCRIPTION"; |
| public static String HTML_XML_ATTRIBUTE_NAME = "NAME"; //$NON-NLS-1$ |
| public static String HTML_XML_ATTRIBUTE_REQUIRED = "REQUIRED"; //$NON-NLS-1$ |
| |
| //Definitions for the XDoclet Genereated XML File |
| public static String XDOC_TASKS_DESCRIPTION_XML_FILE_NAME = "/XDOCtasks.xml"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_TASKS = "tasks"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_TASK = "task"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_NAME = "name"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_STRUCTURE = "structure"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_ATTRIBUTES = "attributes"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_ATTRIBUTE = "attribute"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_ELEMENTS = "elements"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_ELEMENT = "element"; //$NON-NLS-1$ |
| public static String XDOC_XML_TAG_REQUIRED = "required"; //$NON-NLS-1$ |
| |
| |
| protected NodeList taskNodes_HTML = null; |
| protected NodeList taskNodes_XDOC = null; |
| public Document xdocXMLDocument = null; |
| |
| /** |
| * Creates an initialized instance. |
| */ |
| public TaskXMLFileMerger() { |
| initialize(); |
| } |
| |
| |
| /** |
| * Parses the task description xml files and stores the information. |
| */ |
| private void initialize() { |
| |
| Document tmpDocument = null; |
| |
| //Get All the Tasks in the HTML XML Generated file and store in the taskNodes_HTML |
| tmpDocument = parseFile(HTML_TASKS_DESCRIPTION_XML_FILE_NAME); |
| taskNodes_HTML = tmpDocument.getFirstChild().getChildNodes(); |
| |
| //Do the same for the XDOC XML Generated file |
| tmpDocument = parseFile(XDOC_TASKS_DESCRIPTION_XML_FILE_NAME); |
| taskNodes_XDOC = tmpDocument.getFirstChild().getChildNodes(); |
| xdocXMLDocument = tmpDocument; |
| /* |
| Document tempDocument = parseFile(aFileName); |
| Node tempRootNode = tempDocument.getDocumentElement(); |
| NodeList tempChildNodes = tempRootNode.getChildNodes(); |
| for(int i=0; i<tempChildNodes.getLength(); i++) { |
| Node tempNode = tempChildNodes.item(i); |
| if(tempNode.getNodeType() == Node.ELEMENT_NODE) { |
| String tempTagName = tempNode.getNodeName(); |
| if(tempTagName.equals(anXML_TAG_TASK)) { |
| NamedNodeMap tempAttributes = tempNode.getAttributes(); |
| Node tempAttributeNode = tempAttributes.getNamedItem(anXML_ATTRIBUTE_NAME); |
| if(tempAttributeNode != null) { |
| String tempTaskName = tempAttributeNode.getNodeValue(); |
| if(tempTaskName != null) { |
| aHashMap.put(tempTaskName, tempNode); |
| } |
| } |
| } |
| } |
| } |
| */ |
| } |
| |
| |
| /** |
| * This is the function that does all the work. Calling this |
| * will cause all Required fields in all Attributes in the |
| * XMLDoc file to be replaced with the value in the corresponding |
| * Attributes Required field in the HTML Xml file. |
| */ |
| public void runReplaceAttributeRequiredProcess() { |
| |
| //Iterate over all the tasks. If task is found in sourceList, |
| //then iterate over all the attributes, try to find out if the |
| //the attribute is required. |
| for(int i = 0; i < taskNodes_XDOC.getLength(); ++i ) { |
| Node tmpTargetNode = taskNodes_XDOC.item(i); |
| |
| if(tmpTargetNode.getNodeType() == Node.ELEMENT_NODE ) { |
| replaceAttributeRequiredInTaskNode(tmpTargetNode); |
| } |
| } |
| } |
| |
| private void replaceAttributeRequiredInTaskNode(Node aTargetTaskNode) { |
| |
| String tmpTaskName = aTargetTaskNode.getAttributes().getNamedItem(XDOC_XML_TAG_NAME).getNodeValue(); |
| |
| if(tmpTaskName != null ) { |
| Node tmpSourceNode = getTaskInHTMLGeneratedTaskListNamed(tmpTaskName); |
| |
| if(tmpSourceNode != null) { |
| replaceAttributeRequiredInXMLTaskNodeWithAttributeRequiredInHTMLNode(aTargetTaskNode, |
| tmpSourceNode); |
| } |
| else { |
| System.out.println(MessageFormat.format("Did not find Task \"{0}\" in HTML XML file.", new String[]{tmpTaskName})); //$NON-NLS-1$ |
| } |
| } |
| else { |
| System.out.println(MessageFormat.format("Did not find TaskName in TargetTaskNode: {0}", new String[]{aTargetTaskNode.toString()})); //$NON-NLS-1$ |
| } |
| } |
| |
| private Node getTaskInHTMLGeneratedTaskListNamed(String aTaskName) { |
| |
| for(int i = 0; i<taskNodes_HTML.getLength(); ++i ) { |
| |
| Node tmpTaskNode = taskNodes_HTML.item(i); |
| if(tmpTaskNode.getNodeType() == Node.ELEMENT_NODE ) { |
| String tmpTagName = tmpTaskNode.getNodeName(); |
| if(tmpTagName.equals(HTML_XML_TAG_TASK)) { |
| NamedNodeMap tmpMap = tmpTaskNode.getAttributes(); |
| Node tmpNameNode = tmpMap.getNamedItem(HTML_XML_ATTRIBUTE_NAME); |
| if( aTaskName.equals(tmpNameNode.getNodeValue()) ) { |
| return tmpTaskNode; |
| } |
| } |
| } |
| } |
| //Not found |
| return null; |
| } |
| |
| private void replaceAttributeRequiredInXMLTaskNodeWithAttributeRequiredInHTMLNode(Node aTargetTaskNode, |
| Node aSourceTaskNode) { |
| |
| Node tmpStructureNode = getChildNodeNamedWithTypeFromNode( XDOC_XML_TAG_STRUCTURE, |
| Node.ELEMENT_NODE, |
| aTargetTaskNode ); |
| |
| if(tmpStructureNode != null ) { |
| Node tmpTargetAttributesNode = getChildNodeNamedWithTypeFromNode(XDOC_XML_TAG_ATTRIBUTES, |
| Node.ELEMENT_NODE, |
| tmpStructureNode); |
| if(tmpTargetAttributesNode != null ) { |
| Vector tmpTargetAttributesVector = getAttributeNodesFromXMLAttributesNode(tmpTargetAttributesNode); |
| Vector tmpSourceAttributesVector = getAttributeNodesFromHTMLTaskNode(aSourceTaskNode); |
| |
| //Iterate over all the attributes in the targetTaskNode |
| for(int i=0; i < tmpTargetAttributesVector.size(); ++i) { |
| Node tmpAttributeNode = (Node)tmpTargetAttributesVector.get(i); |
| replaceAttributeRequiredInAttributeNodeWithValueFoundInNodeVector(tmpAttributeNode, tmpSourceAttributesVector); |
| } |
| } |
| } |
| } |
| |
| private void replaceAttributeRequiredInAttributeNodeWithValueFoundInNodeVector(Node aTargetAttributeNode, Vector aSourceAttributeVector) { |
| |
| NamedNodeMap tmpTargetNamedNodeMap = aTargetAttributeNode.getAttributes(); |
| String tmpTargetAttributeName = tmpTargetNamedNodeMap.getNamedItem(XDOC_XML_TAG_NAME).getNodeValue(); |
| |
| String tmpSourceAttributeName = null; |
| String tmpSourceRequiredValue = null; |
| |
| for(int i=0; i < aSourceAttributeVector.size(); ++i) { |
| Node tmpSourceAttributeNode = (Node)aSourceAttributeVector.get(i); |
| NamedNodeMap tmpSourceAttributeNamedNodeMap = tmpSourceAttributeNode.getAttributes(); |
| tmpSourceAttributeName = tmpSourceAttributeNamedNodeMap.getNamedItem(HTML_XML_ATTRIBUTE_NAME).getNodeValue(); |
| //If the Attribute Name is the same we replace the REQUIRED Value |
| if(tmpTargetAttributeName.equals(tmpSourceAttributeName) ){ |
| tmpSourceRequiredValue = tmpSourceAttributeNamedNodeMap.getNamedItem(HTML_XML_ATTRIBUTE_REQUIRED).getNodeValue(); |
| //Set the Vaule to the on we just got. |
| tmpTargetNamedNodeMap.getNamedItem(XDOC_XML_TAG_REQUIRED).setNodeValue(tmpSourceRequiredValue); |
| } |
| } |
| } |
| |
| private Vector getAttributeNodesFromXMLAttributesNode(Node anXMLAttributesNode){ |
| |
| Vector allAttributes = new Vector(); |
| NodeList tmpList = anXMLAttributesNode.getChildNodes(); |
| |
| for(int i = 0; i<tmpList.getLength(); ++i) { |
| Node tmpNode = tmpList.item(i); |
| if(tmpNode.getNodeType() == Node.ELEMENT_NODE |
| && XDOC_XML_TAG_ATTRIBUTE.equals(tmpNode.getNodeName()) ) { |
| allAttributes.add(tmpNode); |
| } |
| } |
| return allAttributes; |
| } |
| |
| private Vector getAttributeNodesFromHTMLTaskNode(Node anHTTP_XML_TaskNode) { |
| |
| Vector tmpVector = new Vector(); |
| NodeList tmpList = anHTTP_XML_TaskNode.getChildNodes(); |
| |
| for(int i = 0; i < tmpList.getLength(); ++i) { |
| Node tmpNode = tmpList.item(i); |
| if(tmpNode.getNodeType() == Node.ELEMENT_NODE |
| && HTML_XML_TAG_ATTRIBUTE.equals(tmpNode.getNodeName()) ) { |
| tmpVector.add(tmpNode); |
| } |
| } |
| |
| return tmpVector; |
| } |
| |
| /** |
| * Returns the ChildNode of the node defined by the Arguments. The |
| * first child found matching the criterias is returned. |
| * |
| * @param aNodeName The Name of the Node to return. |
| * @param aType The Type of the node @see Node |
| * @param aParentNode The Node to get the child from |
| * |
| * @return The First Child Node found matching the criterias, |
| * or null if none is found. |
| */ |
| private Node getChildNodeNamedWithTypeFromNode(String aName, short aNodeType, Node aNode ) { |
| |
| NodeList tmpNodeList = aNode.getChildNodes(); |
| for(int i=0; i<tmpNodeList.getLength(); ++i ) { |
| Node tmpNode = tmpNodeList.item(i); |
| if( (tmpNode.getNodeType() == aNodeType) && aName.equals(tmpNode.getNodeName()) ) { |
| return tmpNode; |
| } |
| } |
| //Not found |
| return null; |
| } |
| |
| |
| /** |
| * Returns the (DOM) document as a result of parsing the file with the |
| * specified file name. |
| * <P> |
| * The file will be loaded as resource, thus must begin with '/' and must |
| * be relative to the classpath. |
| */ |
| private Document parseFile(String aFileName) { |
| Document tempDocument = null; |
| |
| DocumentBuilderFactory tempFactory = DocumentBuilderFactory.newInstance(); |
| tempFactory.setIgnoringComments(true); |
| tempFactory.setIgnoringElementContentWhitespace(true); |
| tempFactory.setCoalescing(true); |
| |
| try { |
| DocumentBuilder tempDocBuilder = tempFactory.newDocumentBuilder(); |
| URL tempURL = getClass().getResource(aFileName); |
| InputSource tempInputSource = new InputSource(tempURL.toExternalForm()); |
| tempDocument = tempDocBuilder.parse(tempInputSource); |
| } catch (ParserConfigurationException e) { |
| AntUIPlugin.log(e); |
| } |
| catch (IOException ioException) { |
| AntUIPlugin.log(ioException); |
| } |
| catch (SAXException saxException) { |
| AntUIPlugin.log(saxException); |
| } |
| |
| return tempDocument; |
| } |
| |
| /** |
| * This function writes the XMLDocument to the specified file. |
| * @param aFileName The filename to which the XMLDocument should be written. |
| */ |
| public void writeXMLDocumentToFile(String aFileName) { |
| |
| // try { |
| // XmlDocument xmlDocument = (XmlDocument)xdocXMLDocument; |
| // xmlDocument.write(new FileWriter(aFileName), "UTF-8"); //$NON-NLS-1$ |
| // } |
| // catch(IOException ioe) { |
| // System.out.println(MessageFormat.format(AntEditorToolsMessages.getString("TaskXMLFileMerger.Could_not_print"), new String[]{ioe.toString()})); //$NON-NLS-1$ |
| // } |
| } |
| |
| public static void main(String[] args) { |
| |
| TaskXMLFileMerger tmpTaskXMLFileMerger = new TaskXMLFileMerger(); |
| tmpTaskXMLFileMerger.runReplaceAttributeRequiredProcess(); |
| tmpTaskXMLFileMerger.writeXMLDocumentToFile("src\\anttasks_1.5b.xml"); //$NON-NLS-1$ |
| } |
| } |