XMLWriterUtils.java

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.basepom.mojo.duplicatefinder;

import java.io.File;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Pattern;

import javax.xml.stream.XMLStreamException;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
import org.apache.maven.project.MavenProject;
import org.basepom.mojo.duplicatefinder.ResultCollector.ConflictResult;
import org.basepom.mojo.duplicatefinder.artifact.MavenCoordinates;
import org.basepom.mojo.duplicatefinder.classpath.ClasspathDescriptor;
import org.codehaus.staxmate.out.SMOutputElement;

public final class XMLWriterUtils {

    private XMLWriterUtils() {
        throw new AssertionError("do not instantiate");
    }

    public static SMOutputElement addElement(SMOutputElement document, String name, Object value)
            throws XMLStreamException {
        SMOutputElement element = document.addElement(name);
        if (value != null) {
            element.addCharacters(value.toString());
        }
        return element;
    }

    public static void addAttribute(SMOutputElement document, String name, Object value)
            throws XMLStreamException {
        if (value != null) {
            document.addAttribute(name, value.toString());
        }
    }

    public static void addProjectInformation(SMOutputElement rootElement, MavenProject project)
            throws XMLStreamException {
        SMOutputElement projectElement = rootElement.addElement("project");
        addAttribute(projectElement, "artifactId", project.getArtifact().getArtifactId());
        addAttribute(projectElement, "groupId", project.getArtifact().getGroupId());
        addAttribute(projectElement, "version", project.getArtifact().getVersion());
        addAttribute(projectElement, "classifier", project.getArtifact().getClassifier());
        addAttribute(projectElement, "type", project.getArtifact().getType());
    }

    public static void addConflictingDependency(SMOutputElement conflictingDependenciesElement, String name, ConflictingDependency conflictingDependency)
            throws XMLStreamException {
        SMOutputElement conflictingDependencyElement = conflictingDependenciesElement.addElement(name);

        addAttribute(conflictingDependencyElement, "currentProject", conflictingDependency.hasCurrentProject());
        addAttribute(conflictingDependencyElement, "currentProjectIncluded", conflictingDependency.isCurrentProjectIncluded());
        addAttribute(conflictingDependencyElement, "wildcard", conflictingDependency.isWildcard());

        SMOutputElement dependenciesElement = conflictingDependencyElement.addElement("dependencies");
        for (MavenCoordinates dependency : conflictingDependency.getDependencies()) {
            addMavenCoordinate(dependenciesElement, "dependency", dependency);
        }

        SMOutputElement packagesElement = conflictingDependencyElement.addElement("packages");
        for (String packageName : conflictingDependency.getPackages()) {
            addElement(packagesElement, "package", packageName);
        }

        SMOutputElement classesElement = conflictingDependencyElement.addElement("classes");
        for (String className : conflictingDependency.getClasses()) {
            addElement(classesElement, "class", className);
        }

        SMOutputElement resourcesElement = conflictingDependencyElement.addElement("resources");
        for (String resourceName : conflictingDependency.getResources()) {
            addElement(resourcesElement, "resource", resourceName);
        }

        SMOutputElement resourcePatternsElement = conflictingDependencyElement.addElement("resourcePatterns");
        for (Pattern resourcePattern : conflictingDependency.getResourcePatterns()) {
            addElement(resourcePatternsElement, "resourcePattern", resourcePattern.toString());
        }
    }

    public static void addMavenCoordinate(SMOutputElement dependenciesElement, String name, MavenCoordinates dependency)
            throws XMLStreamException {
        SMOutputElement dependencyElement = dependenciesElement.addElement(name);
        addAttribute(dependencyElement, "artifactId", dependency.getArtifactId());
        addAttribute(dependencyElement, "groupId", dependency.getGroupId());

        if (dependency.getVersion().isPresent()) {
            addAttribute(dependencyElement, "version", dependency.getVersion().get());
        }

        if (dependency.getVersionRange().isPresent()) {
            addAttribute(dependencyElement, "versionRange", dependency.getVersionRange().get());
        }

        if (dependency.getClassifier().isPresent()) {
            addAttribute(dependencyElement, "classifier", dependency.getClassifier().get());
        }

        addAttribute(dependencyElement, "type", dependency.getType());
    }

    public static void addArtifact(SMOutputElement artifactElement, String name, Artifact artifact)
            throws XMLStreamException, OverConstrainedVersionException {
        // lazy. Replace with a real dependency writer if that somehow loses or mangles information.
        MavenCoordinates coordinates = new MavenCoordinates(artifact);
        addMavenCoordinate(artifactElement, name, coordinates);
    }

    public static void addResultCollector(SMOutputElement resultElement, ResultCollector resultCollector)
            throws XMLStreamException, OverConstrainedVersionException {
        addAttribute(resultElement, "conflictState", resultCollector.getConflictState());
        addAttribute(resultElement, "failed", resultCollector.isFailed());
        SMOutputElement conflictsElement = resultElement.addElement("conflicts");

        for (Map.Entry<String, Collection<ConflictResult>> entry : resultCollector.getAllResults().entrySet()) {
            SMOutputElement conflictElement = conflictsElement.addElement("conflict");
            addAttribute(conflictElement, "name", entry.getKey());
            SMOutputElement conflictResultsElement = conflictElement.addElement("conflictResults");
            for (ConflictResult conflictResult : entry.getValue()) {
                addConflictResult(conflictResultsElement, conflictResult);
            }
        }
    }

    private static void addConflictResult(SMOutputElement conflictResultsElement, ConflictResult conflictResult)
            throws XMLStreamException, OverConstrainedVersionException {
        SMOutputElement conflictResultElement = conflictResultsElement.addElement("conflictResult");
        addAttribute(conflictResultElement, "name", conflictResult.getName());
        addAttribute(conflictResultElement, "type", conflictResult.getType());
        addAttribute(conflictResultElement, "excepted", conflictResult.isExcepted());
        addAttribute(conflictResultElement, "failed", conflictResult.isFailed());
        addAttribute(conflictResultElement, "printed", conflictResult.isPrinted());
        addAttribute(conflictResultElement, "conflictState", conflictResult.getConflictState());
        SMOutputElement conflictNames = conflictResultElement.addElement("conflictNames");
        for (ClasspathElement entry : conflictResult.getClasspathElements()) {
            SMOutputElement conflictName = conflictNames.addElement("conflictName");
            addAttribute(conflictName, "name", entry.getName());
            addAttribute(conflictName, "artifact", entry.hasArtifact());
            addAttribute(conflictName, "localFolder", entry.isLocalFolder());
            if (entry.hasArtifact()) {
                addArtifact(conflictName, "artifact", entry.getArtifact());
            } else {
                final File file = entry.getFile();
                if (file.isDirectory()) {
                    addElement(conflictName, "directory", file);
                } else {
                    addElement(conflictName, "file", file);
                }
            }
        }
    }

    public static void addClasspathDescriptor(SMOutputElement resultElement, int resultFileMinClasspathCount, ClasspathDescriptor classpathDescriptor)
            throws XMLStreamException {
        SMOutputElement resourceExclusionPatternsElement = resultElement.addElement("ignoredResourcePatterns");
        for (Pattern resourceExclusionPattern : classpathDescriptor.getIgnoredResourcePatterns()) {
            addElement(resourceExclusionPatternsElement, "ignoredResourcePattern", resourceExclusionPattern.toString());
        }

        SMOutputElement ignoredDirectoriesPatternsElement = resultElement.addElement("ignoredDirectoryPatterns");
        for (Pattern ignoredDirectoriesPattern : classpathDescriptor.getIgnoredDirectoryPatterns()) {
            addElement(ignoredDirectoriesPatternsElement, "ignoredDirectoryPattern", ignoredDirectoriesPattern.toString());
        }

        SMOutputElement classExclusionPatternsElement = resultElement.addElement("ignoredClassPatterns");
        for (Pattern classExclusionPattern : classpathDescriptor.getIgnoredClassPatterns()) {
            addElement(classExclusionPatternsElement, "ignoredClassPattern", classExclusionPattern.toString());
        }

        for (ConflictType type : ConflictType.values()) {
            SMOutputElement classpathElementsElement = resultElement.addElement("classpathElements");
            addAttribute(classpathElementsElement, "type", type);
            for (Map.Entry<String, Collection<File>> entry : classpathDescriptor.getClasspathElementLocations(type).entrySet()) {
                if (entry.getValue().size() >= resultFileMinClasspathCount) {
                    SMOutputElement classpathElementElement = classpathElementsElement.addElement("classpathElement");
                    addAttribute(classpathElementElement, "name", entry.getKey());
                    for (File file : entry.getValue()) {
                        addElement(classpathElementElement, "file", file.getPath());
                    }
                }
            }
        }
    }
}