Plugin.java

package org.springframework.roo.project;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.roo.support.util.CollectionUtils;
import org.springframework.roo.support.util.DomUtils;
import org.springframework.roo.support.util.XmlUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Simplified immutable representation of a maven build plugin.
 * <p>
 * Structured after the model used by Maven.
 * 
 * @author Alan Stewart
 * @since 1.1
 */
public class Plugin implements Comparable<Plugin> {

  /**
   * The Maven groupId that will be assigned to a plugin if one is not
   * provided
   */
  public static final String DEFAULT_GROUP_ID = "org.apache.maven.plugins";

  /**
   * Parses the given plugin XML element for the plugin's Maven artifactId
   * 
   * @param plugin the XML element to parse (required)
   * @return a non-blank id
   */
  private static String getArtifactId(final Element plugin) {
    return plugin.getElementsByTagName("artifactId").item(0).getTextContent();
  }

  /**
   * Parses the configuration of the given plugin (global, not
   * execution-scoped)
   * 
   * @param plugin the XML element to parse (required)
   * @return <code>null</code> if there isn't one
   */
  private static Configuration getConfiguration(final Element plugin) {
    return Configuration.getInstance(XmlUtils.findFirstElement("configuration", plugin));
  }

  /**
   * Parses the given XML plugin element for the plugin's dependencies
   * 
   * @param plugin the XML element to parse (required)
   * @return a non-<code>null</code> list
   */
  private static List<Dependency> getDependencies(final Element plugin) {
    final List<Dependency> dependencies = new ArrayList<Dependency>();
    for (final Element dependencyElement : XmlUtils.findElements("dependencies/dependency", plugin)) {
      // groupId
      final Element groupIdElement = XmlUtils.findFirstElement("groupId", dependencyElement);
      final String groupId = DomUtils.getTextContent(groupIdElement, "");

      // artifactId
      final Element artifactIdElement = XmlUtils.findFirstElement("artifactId", dependencyElement);
      final String artifactId = DomUtils.getTextContent(artifactIdElement, "");

      // version
      final Element versionElement = XmlUtils.findFirstElement("version", dependencyElement);
      final String version = DomUtils.getTextContent(versionElement, "");

      final Dependency dependency = new Dependency(groupId, artifactId, version);

      // Parse any exclusions
      for (final Element exclusion : XmlUtils.findElements("exclusions/exclusion",
          dependencyElement)) {
        // groupId
        final Element exclusionGroupIdElement = XmlUtils.findFirstElement("groupId", exclusion);
        final String exclusionGroupId = DomUtils.getTextContent(exclusionGroupIdElement, "");

        // artifactId
        final Element exclusionArtifactIdElement =
            XmlUtils.findFirstElement("artifactId", exclusion);
        final String exclusionArtifactId = DomUtils.getTextContent(exclusionArtifactIdElement, "");

        if (StringUtils.isNotBlank(exclusionGroupId) && StringUtils.isNotBlank(exclusionArtifactId)) {
          dependency.addExclusion(exclusionGroupId, exclusionArtifactId);
        }
      }
      dependencies.add(dependency);
    }
    return dependencies;
  }

  /**
   * Parses the given XML plugin element for the plugin's executions
   * 
   * @param plugin the XML element to parse (required)
   * @return a non-<code>null</code> list
   */
  private static List<Execution> getExecutions(final Element plugin) {
    final List<Execution> executions = new ArrayList<Execution>();
    // Loop through the "execution" elements in the plugin element
    for (final Element execution : XmlUtils.findElements("executions/execution", plugin)) {
      final Element idElement = XmlUtils.findFirstElement("id", execution);
      final String id = DomUtils.getTextContent(idElement, "");
      final Element phaseElement = XmlUtils.findFirstElement("phase", execution);
      final String phase = DomUtils.getTextContent(phaseElement, "");
      final List<String> goals = new ArrayList<String>();
      for (final Element goalElement : XmlUtils.findElements("goals/goal", execution)) {
        goals.add(goalElement.getTextContent());
      }
      final Configuration configuration =
          Configuration.getInstance(XmlUtils.findFirstElement("configuration", execution));
      executions.add(new Execution(id, phase, configuration,
          goals.toArray(new String[goals.size()])));
    }
    return executions;
  }

  /**
   * Parses the plugin's Maven groupId from the given element
   * 
   * @param plugin the element to parse (required)
   * @return a non-blank groupId
   */
  public static String getGroupId(final Element plugin) {
    if (plugin.getElementsByTagName("groupId").getLength() > 0) {
      return plugin.getElementsByTagName("groupId").item(0).getTextContent();
    }
    return DEFAULT_GROUP_ID;
  }

  /**
   * Parses the plugin's version number from the given XML element
   * 
   * @param plugin the element to parse (required)
   * @return a non-<code>null</code> version number (might be empty)
   */
  private static String getVersion(final Element plugin) {
    final List<Element> versionElements = XmlUtils.findElements("./version", plugin);
    if (!versionElements.isEmpty()) {
      return versionElements.get(0).getTextContent();
    }
    return "";
  }

  private final Configuration configuration;
  private final List<Dependency> dependencies = new ArrayList<Dependency>();
  private final List<Execution> executions = new ArrayList<Execution>();
  private final GAV gav;

  /**
   * Constructor from a POM-style XML element that defines a Maven <plugin>.
   * 
   * @param plugin the XML element to parse (required)
   */
  public Plugin(final Element plugin) {
    this(getGroupId(plugin), getArtifactId(plugin), getVersion(plugin), getConfiguration(plugin),
        getDependencies(plugin), getExecutions(plugin));
  }

  /**
   * Constructor that takes the minimal Maven artifact coordinates.
   * 
   * @param groupId the group ID (required)
   * @param artifactId the artifact ID (required)
   * @param version the version (required)
   */
  public Plugin(final String groupId, final String artifactId, final String version) {
    this(groupId, artifactId, version, null, null, null);
  }

  /**
   * Constructor that allows all fields to be set.
   * 
   * @param groupId the group ID (required)
   * @param artifactId the artifact ID (required)
   * @param version the version (required)
   * @param configuration the configuration for this plugin (optional)
   * @param dependencies the dependencies for this plugin (can be
   *            <code>null</code>)
   * @param executions the executions for this plugin (can be
   *            <code>null</code>)
   */
  public Plugin(final String groupId, final String artifactId, final String version,
      final Configuration configuration, final Collection<? extends Dependency> dependencies,
      final Collection<? extends Execution> executions) {
    Validate.notNull(groupId, "Group ID required");
    Validate.notNull(artifactId, "Artifact ID required");
    //Validate.notNull(version, "Version required");
    if (version == null || version == "") {
      gav = new GAV(groupId, artifactId, "-");
    } else {
      gav = new GAV(groupId, artifactId, version);
    }
    this.configuration = configuration;
    // Defensively copy the given nullable collections
    CollectionUtils.populate(this.dependencies, dependencies);
    CollectionUtils.populate(this.executions, executions);
  }

  public int compareTo(final Plugin o) {
    if (o == null) {
      throw new NullPointerException();
    }
    int result = gav.compareTo(o.getGAV());
    if (result == 0 && configuration != null && o.configuration != null) {
      result = configuration.compareTo(o.configuration);
    }
    return result;
  }

  @Override
  public boolean equals(final Object obj) {
    return obj instanceof Plugin && compareTo((Plugin) obj) == 0;
  }

  public String getArtifactId() {
    return gav.getArtifactId();
  }

  /**
   * Returns the top-level configuration of this plugin, if any. Note that
   * individual {@link Execution}s may have their own {@link Configuration}s
   * instead of or in addition to this configuration.
   * 
   * @return <code>null</code> if none exists
   */
  public Configuration getConfiguration() {
    return configuration;
  }

  public List<Dependency> getDependencies() {
    return dependencies;
  }

  /**
   * Returns the {@link Element} to add to the given POM {@link Document} for
   * this plugin
   * 
   * @param plugin the plugin for which to create an XML Element (required)
   * @param document the document to which the element will belong (required)
   * @return a non-<code>null</code> element
   * @since 1.2.0
   */
  public Element getElement(final Document document) {
    final Element pluginElement = document.createElement("plugin");

    // Basic coordinates
    pluginElement.appendChild(XmlUtils.createTextElement(document, "groupId", getGroupId()));
    pluginElement.appendChild(XmlUtils.createTextElement(document, "artifactId", getArtifactId()));
    pluginElement.appendChild(XmlUtils.createTextElement(document, "version", getVersion()));

    // Configuration
    if (configuration != null) {
      final Node configuration = document.importNode(this.configuration.getConfiguration(), true);
      pluginElement.appendChild(configuration);
    }

    // Executions
    if (!executions.isEmpty()) {
      final Element executionsElement =
          DomUtils.createChildElement("executions", pluginElement, document);
      for (final Execution execution : executions) {
        executionsElement.appendChild(execution.getElement(document));
      }
    }

    // Dependencies
    if (!dependencies.isEmpty()) {
      final Element dependenciesElement =
          DomUtils.createChildElement("dependencies", pluginElement, document);
      for (final Dependency dependency : dependencies) {
        dependenciesElement.appendChild(dependency.getElement(document));
      }
    }

    return pluginElement;
  }

  public List<Execution> getExecutions() {
    return executions;
  }

  /**
   * Returns the Maven-style coordinates of this plugin
   * 
   * @return a non-<code>null</code> set of coordinates
   */
  public GAV getGAV() {
    return gav;
  }

  /**
   * Returns this plugin's groupId.
   * 
   * @return
   */
  public String getGroupId() {
    return gav.getGroupId();
  }

  /**
   * @return a simple description, as would be used for console output
   */
  public String getSimpleDescription() {
    return gav.toString();
  }

  public String getVersion() {
    return gav.getVersion();
  }

  @Override
  public int hashCode() {
    final int prime = 31;
    final int result = prime * 1 + gav.hashCode();
    return prime * result + (configuration == null ? 0 : configuration.hashCode());
  }

  /**
   * Indicates whether the given {@link Plugin} has the same Maven coordinates
   * as this one; this is not necessarily the same as calling
   * {@link #equals(Object)}, which may compare more fields beyond the basic
   * coordinates.
   * 
   * @param plugin the plugin to check (can be <code>null</code>)
   * @return <code>false</code> if any coordinates are different
   */
  public boolean hasSameCoordinates(final Plugin dependency) {
    return dependency != null && compareCoordinates(dependency) == 0;
  }

  /**
   * Compares this plugin's identifying coordinates (i.e. not the version) to
   * those of the given plugin
   * 
   * @param other the plugin being compared to (required)
   * @return see {@link Comparable#compareTo(Object)}
   */
  private int compareCoordinates(final Plugin other) {
    Validate.notNull(other, "Plugin being compared to cannot be null");
    int result = getGroupId().compareTo(other.getGroupId());
    if (result == 0) {
      result = getArtifactId().compareTo(other.getArtifactId());
    }
    return result;
  }

  @Override
  public String toString() {
    final ToStringBuilder builder = new ToStringBuilder(this);
    builder.append("gav", gav);
    if (configuration != null) {
      builder.append("configuration", configuration);
    }
    return builder.toString();
  }
}