Grammar generator from XML

Fixes eclipse-lemminx#778

Signed-off-by: azerr <azerr@redhat.com>

org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/generators/AbstractXML2GrammarGenerator.java

@@ -0,0 +1,164 @@
+/*******************************************************************************
+* Copyright (c) 2020 Red Hat Inc. and others.
+* All rights reserved. This program and the accompanying materials
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v20.html
+*
+* SPDX-License-Identifier: EPL-2.0
+*
+* Contributors:
+*     Red Hat Inc. - initial API and implementation
+*******************************************************************************/
+package org.eclipse.lemminx.extensions.generators;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.lemminx.commons.TextDocument;
+import org.eclipse.lemminx.dom.DOMAttr;
+import org.eclipse.lemminx.services.IXMLFullFormatter;
+import org.eclipse.lemminx.settings.SharedSettings;
+import org.eclipse.lemminx.utils.StringUtils;
+import org.eclipse.lemminx.utils.XMLBuilder;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * Abstract class to generate a grammar (XSD, DTD, etcc) from a given XML
+ * source.
+ * 
+ * <p>
+ * The process is to build a generic {@link Grammar} instance from the XML
+ * source and each implementation uses this grammar information to generate the
+ * proper grammar.
+ * </p>
+ * 
+ * @param <T> the grammar generator settings.
+ */
+public abstract class AbstractXML2GrammarGenerator<T extends FileContentGeneratorSettings>
+		implements IFileContentGenerator<Document, T> {
+
+	@Override
+	public String generate(Document document, SharedSettings sharedSettings, T generatorSettings,
+			IXMLFullFormatter formatter) {
+		String newText = doGenerate(document, sharedSettings, generatorSettings);
+		if (formatter == null) {
+			return newText;
+		}
+		return formatter.formatFull(new TextDocument(newText, "grammar." + getFileExtension()), sharedSettings);
+	}
+
+	protected abstract String getFileExtension();
+
+	private String doGenerate(Document document, SharedSettings sharedSettings, T generatorSettings) {
+		// Create the generic grammar information from the XML source document.
+		Grammar grammar = createGrammar(document, isFlat());
+		XMLBuilder builder = new XMLBuilder(sharedSettings, "", "");
+		// Generate the grammar content from the grammar information.
+		generate(grammar, generatorSettings, builder);
+		return builder.toString();
+	}
+
+	protected boolean isFlat() {
+		return false;
+	}
+
+	/**
+	 * Generate the grammar content from the given grammr information into the given
+	 * builder.
+	 * 
+	 * @param grammar         the grammar information.
+	 * @param grammarSettings the grammar settings
+	 * @param out             the XML builder to update.
+	 */
+	protected abstract void generate(Grammar grammar, T grammarSettings, XMLBuilder out);
+
+	private Grammar createGrammar(Document document, boolean flat) {
+		Grammar grammar = new Grammar();
+		// Update default namespace
+		String defaultNamespace = null;
+		Element documentElement = document.getDocumentElement();
+		if (documentElement != null) {
+			defaultNamespace = document.getDocumentElement().getAttribute(DOMAttr.XMLNS_ATTR);
+		}
+		grammar.setDefaultNamespace(defaultNamespace);
+		// Update elements information
+		fillElements(document, grammar, grammar, flat);
+		return grammar;
+	}
+
+	private static void fillElements(Node node, Grammar grammar, ContainerDeclaration parent, boolean flat) {
+		if (!node.hasChildNodes()) {
+			return;
+		}
+		NodeList children = node.getChildNodes();
+
+		// Parent
+		if (parent instanceof ElementDeclaration) {
+			List<String> tags = new ArrayList<>(); 
+			ElementDeclaration parentDecl = (ElementDeclaration) parent;
+			for (int i = 0; i < children.getLength(); i++) {
+				Node child = children.item(i);
+				if (child.getNodeType() == Node.ELEMENT_NODE) {
+					Element element = (Element) child;
+					String localName = element.getLocalName();
+					if (!StringUtils.isEmpty(localName)) {
+						tags.add(localName);
+					}
+				}
+			}
+			parentDecl.addChildHierarchy(tags);
+
+			// ((ElementDeclaration) container).addTagName(element.getTagName());
+		}
+
+		for (int i = 0; i < children.getLength(); i++) {
+			Node child = children.item(i);
+			if (child.getNodeType() == Node.ELEMENT_NODE) {
+				Element element = (Element) child;
+				ElementDeclaration elementDecl = getElementDecl(grammar, parent, flat, element);
+				// Update count occurrences
+				elementDecl.incrementOccurrences();
+				// Update has text
+				if (!elementDecl.hasCharacterContent()) {
+					elementDecl.setHasCharacterContent(hasCharacterContent(element));
+				}
+				// Update attributes
+				NamedNodeMap attributes = element.getAttributes();
+				if (attributes != null) {
+					for (int j = 0; j < attributes.getLength(); j++) {
+						Attr attr = (Attr) attributes.item(i);
+						elementDecl.getAttribute(attr.getName());
+					}
+				}
+				fillElements(element, grammar, elementDecl, flat);
+			}
+		}
+	}
+
+	private static ElementDeclaration getElementDecl(Grammar grammar, ContainerDeclaration container, boolean flat,
+			Element element) {
+		String name = element.getLocalName();
+		if (flat) {
+			ElementDeclaration elementDecl = grammar.getElement(name);
+			container.addElement(elementDecl);
+			return elementDecl;
+		}
+		return container.getElement(element.getLocalName());
+	}
+
+	private static boolean hasCharacterContent(Element element) {
+		NodeList children = element.getChildNodes();
+		for (int i = 0; i < children.getLength(); i++) {
+			Node child = children.item(i);
+			if (child.getNodeType() == Node.TEXT_NODE) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/generators/AttributeDeclaration.java

@@ -0,0 +1,34 @@
+/*******************************************************************************
+* Copyright (c) 2020 Red Hat Inc. and others.
+* All rights reserved. This program and the accompanying materials
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v20.html
+*
+* SPDX-License-Identifier: EPL-2.0
+*
+* Contributors:
+*     Red Hat Inc. - initial API and implementation
+*******************************************************************************/
+package org.eclipse.lemminx.extensions.generators;
+
+/**
+ * Attribute declaration.
+ *
+ */
+public class AttributeDeclaration {
+
+	private final String name;
+
+	public AttributeDeclaration(String name) {
+		this.name = name;
+	}
+
+	/**
+	 * Returns the attribute name.
+	 * 
+	 * @return the attribute name.
+	 */
+	public String getName() {
+		return name;
+	}
+}

org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/generators/Cardinality.java

@@ -0,0 +1,43 @@
+package org.eclipse.lemminx.extensions.generators;
+
+public class Cardinality {
+
+	private long min;
+
+	private long max;
+
+	public void setMin(long min) {
+		this.min = min;
+	}
+
+	public void setMax(long max) {
+		this.max = max;
+	}
+
+	public long getMin() {
+		return min;
+	}
+
+	public long getMax() {
+		return max;
+	}
+
+	public void updateMin(long min) {
+		setMin(Math.min(min, getMin()));
+	}
+
+	public void updateMax(long max) {
+		setMax(Math.max(max, getMax()));
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+		result.append("[");
+		result.append(getMin());
+		result.append("-");
+		result.append(getMax());
+		result.append("]");
+		return result.toString();
+	}
+}

org.eclipse.lemminx/src/main/java/org/eclipse/lemminx/extensions/generators/ChildrenProperties.java

@@ -0,0 +1,140 @@
+/*******************************************************************************
+* Copyright (c) 2020 Red Hat Inc. and others.
+* All rights reserved. This program and the accompanying materials
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v20.html
+*
+* SPDX-License-Identifier: EPL-2.0
+*
+* Contributors:
+*     Red Hat Inc. - initial API and implementation
+*******************************************************************************/
+package org.eclipse.lemminx.extensions.generators;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Children properties of an element declaration:
+ * 
+ * <ul>
+ * <li>sequenced if all children have the same order.</li>
+ * <li>cardinalities for each child.</li>
+ * </ul>
+ *
+ */
+public class ChildrenProperties {
+
+	/**
+	 * Current ordered tags.
+	 */
+	private List<String> orderedTags;
+
+	/**
+	 * True if tags for each child hierarchy have the same order and false
+	 * otherwise.
+	 */
+	private boolean sequenced;
+
+	/**
+	 * Map which stores cardinality per tag.
+	 */
+	private Map<String, Cardinality> cardinalities;
+
+	public ChildrenProperties() {
+		this.cardinalities = new LinkedHashMap<>();
+		this.sequenced = true;
+	}
+
+	public void addChildHierarchy(List<String> tags) {
+		boolean first = orderedTags == null;
+
+		// Group by tags (by keeping the order) to count it
+		// For the given tags "a", "b", "c", "b", we compute this map:
+		// - "a" : 1
+		// - "b" : 2
+		// - "c": 1
+		Map<String, Long> tagsCount = tags.stream().collect( //
+				Collectors.groupingBy( //
+						Function.identity(), LinkedHashMap::new, Collectors.counting() //
+				));
+		// Get ordered distinct tags (ex : "a", "b", "c")
+		List<String> newOrderedTags = new LinkedList<>(tagsCount.keySet());
+
+		// Update cardinality for existing tags
+		for (Map.Entry<String, Cardinality> entry : cardinalities.entrySet()) {
+			String tag = entry.getKey();
+			Cardinality cardinality = entry.getValue();
+			// Get the count of the existing tag from the new tags by removing it
+			Long count = tagsCount.remove(tag);
+			if (count != null) {
+				cardinality.updateMin(count);
+				cardinality.updateMax(count);
+			} else {
+				// the current tag doesn't exist in the existings tags, set min to 0
+				cardinality.setMin(0);
+			}
+		}
+
+		// Update cardinality for the new tags
+		for (Map.Entry<String, Long> entry : tagsCount.entrySet()) {
+			String tag = entry.getKey();
+			Cardinality cardinality = cardinalities.get(tag);
+			if (cardinality == null) {
+				cardinality = new Cardinality();
+				cardinalities.put(tag, cardinality);
+			}
+			Long count = tagsCount.get(tag);
+			if (first) {
+				cardinality.setMin(count);
+				cardinality.setMax(count);
+			} else {
+				cardinality.updateMin(count);
+				cardinality.updateMax(count);
+			}
+		}
+
+		// Update ordered tags by removing tag which have 0 as min cardinality (optional
+		// tag)
+		for (Map.Entry<String, Cardinality> entry : cardinalities.entrySet()) {
+			String tag = entry.getKey();
+			Cardinality cardinality = entry.getValue();
+			if (cardinality.getMin() == 0) {
+				if (this.orderedTags != null) {
+					this.orderedTags.remove(tag);
+				}
+				newOrderedTags.remove(tag);
+			}
+		}
+
+		// Compute sequenced
+		if (sequenced && this.orderedTags != null) {
+			sequenced = this.orderedTags.equals(newOrderedTags);
+		}
+		this.orderedTags = newOrderedTags;
+	}
+
+	/**
+	 * Returns map which stores cardinality per tag.
+	 * 
+	 * @return map which stores cardinality per tag
+	 */
+	public Map<String /* tag */ , Cardinality> getCardinalities() {
+		return cardinalities;
+	}
+
+	/**
+	 * Returns true if tags for each child hierarchy have the same order and false
+	 * otherwise.
+	 * 
+	 * @return true if tags for each child hierarchy have the same order and false
+	 *         otherwise.
+	 */
+	public boolean isSequenced() {
+		return sequenced;
+	}
+}