WorkspaceConfigurationMerger

/**
 * This file Copyright (c) 2020 Magnolia International
 * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
 *
 *
 * This file is dual-licensed under both the Magnolia
 * Network Agreement and the GNU General Public License.
 * You may elect to use one or the other of these licenses.
 *
 * This file is distributed in the hope that it will be
 * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
 * Redistribution, except as permitted by whichever of the GPL
 * or MNA you select, is prohibited.
 *
 * 1. For the GPL license (GPL), you can redistribute and/or
 * modify this file under the terms of the GNU General
 * Public License, Version 3, as published by the Free Software
 * Foundation.  You should have received a copy of the GNU
 * General Public License, Version 3 along with this program;
 * if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 2. For the Magnolia Network Agreement (MNA), this file
 * and the accompanying materials are made available under the
 * terms of the MNA which accompanies this distribution, and
 * is available at http://www.magnolia-cms.com/mna.html
 *
 * Any modifications to this file must keep this entire header
 * intact.
 *
 */
package info.magnolia.jackrabbit;

import static java.util.Collections.emptyList;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Predicate;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * Helper class for creating an on the fly workspace.xml configurations from a template repository.xml
 * and a stub workspace.xml.
 */
public class WorkspaceConfigurationMerger {

    /**
     * Create an on the fly {@code workspaceXml} configuration by merging elements from {@code repositoryXml}
     * into {@code workspaceStubXml}:
     *
     * <ul>
     * <li>Every direct child element of the {@code Workspace} element of {@code repositoryXml} is added as a direct
     * child element to the {@code Workspace} element of {@code workspaceStubXml} unless an element of the same
     * name already exists.</li>
     * <li>No elements are added if a {@code Workspace} element does not exist in either  {@code repositoryXml} or
     * {@code workspaceStubXml}.</li>
     * <li>Every empty direct child element from thw {@code Workspace} element of {@code workspaceStubXml} is removed. </li>
     * </ul>
     *
     * This arrangement allows inheriting, overriding and removing elements from {@code repositoryXml} in
     * {@code workspaceStubXml}.
     *
     * @param repositoryXml     input stream containing a valid repository.xml. It is the responsibility of the caller
     *                          to close this stream.
     * @param workspaceStubXml  input stream containing a stub workspace.xml. It is the responsibility of the caller
     *                          to close this stream.
     * @param workspaceXml      output stream receiving the result of the merge operation. It is the responsibility of
     *                          the caller to close this stream.
     * @throws ParserConfigurationException when failing to acquire an XML parser
     * @throws IOException when an IO error occurs during reading from the input streams
     * @throws SAXException if any error occurs when parsing the xml from the input streams
     * @throws TransformerException when an error occurs while during merging
     */
    public static void merge(InputStream repositoryXml, InputStream workspaceStubXml, OutputStream workspaceXml)
            throws ParserConfigurationException, IOException, SAXException, TransformerException {

        DocumentBuilder xmlParser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
        Document repositoryConfig = xmlParser.parse(repositoryXml);
        Document workspaceConfig = xmlParser.parse(workspaceStubXml);

        getElement(workspaceConfig, "Workspace")

            // If the workspace configuration stub has a workspace element
            .ifPresent(workspaceElement -> {

                // the workspace configuration inherits all child elements from the Workspace element of the
                // repository configuration for which an element of the same name is not already present.
                getWorkspaceChildren(repositoryConfig).stream()
                    .filter(notChildOf(workspaceElement))
                    .forEach(addChild(workspaceConfig, workspaceElement));

                // Remove all empty elements from the workspace configuration
                removeEmptyElements(workspaceElement);
        });

        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        transformer.transform(new DOMSource(workspaceConfig), new StreamResult(workspaceXml));
    }

    private static Predicate<Node> notChildOf(Element parent) {
        return node -> !getElement(parent, node.getNodeName()).isPresent();
    }

    private static Consumer<Node> addChild(Document document, Element parent) {
        return node -> parent.appendChild(document.importNode(node, true));
    }

    private static Collection<Node> getWorkspaceChildren(Document repositoryConfig) {
        return getElement(repositoryConfig, "Repository")
            .flatMap(repository -> getElement(repository, "Workspace"))
            .map(WorkspaceConfigurationMerger::getChildNodes)
            .orElse(emptyList());
    }

    private static void removeEmptyElements(Node parent) {
        getChildNodes(parent).stream()
            .filter(WorkspaceConfigurationMerger::emptyElement)
            .forEach(parent::removeChild);
    }

    private static boolean emptyElement(Node node) {
        return node.getNodeType() == Node.ELEMENT_NODE && !node.hasAttributes() && !node.hasChildNodes();
    }

    private static Optional<Element> getElement(Node parent, String childName) {
        return getChildNodes(parent).stream()
            .filter(elementWithName(childName))
            .findFirst()
            .map(Element.class::cast);
    }

    private static Predicate<Node> elementWithName(String childName) {
        return node -> node.getNodeType() == Node.ELEMENT_NODE && childName.equals(node.getNodeName());
    }

    private static Collection<Node> getChildNodes(Node parent) {
        List<Node> nodes = new ArrayList<>();
        NodeList children = parent.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            nodes.add(children.item(i));
        }
        return nodes;
    }

}