ReportReferenceExtractor

/*
 * Copyright 2008-2013 smartics, Kronseder & Reiner GmbH
 *
 * 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 de.smartics.maven.issues.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.model.ReportPlugin;
import org.apache.maven.model.ReportSet;
import org.apache.maven.model.Reporting;
import org.codehaus.plexus.util.xml.Xpp3Dom;

/**
 * Responsible to extract report reference information from the report
 * configurations that reference previous reports.
 *
 * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
 * @version $Revision:591 $
 */
public class ReportReferenceExtractor
{
  // ********************************* Fields *********************************

  // --- constants ------------------------------------------------------------

  /**
   * Reference to the logger for this class.
   */
  private final Log log = LogFactory.getLog(ReportReferenceExtractor.class);

  /**
   * The reporting section of the POM to analyse.
   */
  private final Reporting reporting;

  /**
   * The identifier of the report that must match as prefix the
   * <code>outputName</code> of a report configuration for that configuration to
   * be eligable for reference.
   */
  private final String id;

  /**
   * The version of the current report to estimate if the referenced report is
   * previous.
   */
  private final ArtifactVersion version;

  // --- members --------------------------------------------------------------

  // ****************************** Initializer *******************************

  // ****************************** Constructors ******************************

  /**
   * Default constructor.
   *
   * @param id the identifier of the report that must match as prefix the
   *          <code>outputName</code> of a report configuration for that
   *          configuration to be eligable for reference.
   * @param version the version of the current report to estimate if the
   *          referenced report is previous.
   * @param reporting the reporting section of the POM to analyse.
   */
  public ReportReferenceExtractor(final String id,
      final ArtifactVersion version, final Reporting reporting)
  {
    this.id = id;
    this.version = version;
    this.reporting = reporting;
  }

  // ****************************** Inner Classes *****************************

  // ********************************* Methods ********************************

  // --- init -----------------------------------------------------------------

  // --- get&set --------------------------------------------------------------

  // --- business -------------------------------------------------------------

  /**
   * Reads the relevant report references. The reports must match the given
   * prefix (<code>id</code>), provide a readable version range and the range
   * must be previous to the current version.
   *
   * @return the references that match the criterias.
   */
  @SuppressWarnings("unchecked")
  public List<ReportReference> readReportReferences()
  {
    final List<ReportReference> references = new ArrayList<ReportReference>();
    final List<ReportPlugin> reportPlugins = reporting.getPlugins();
    for (ReportPlugin plugin : reportPlugins)
    {
      if (isIssueReportPlugin(plugin))
      {
        if (log.isTraceEnabled())
        {
          log.trace("Issue report found: " + plugin.getKey());
        }

        final List<ReportSet> reportSets = plugin.getReportSets();
        for (ReportSet reportSet : reportSets)
        {
          final Object object = reportSet.getConfiguration();
          if (object instanceof Xpp3Dom)
          {
            parseAndAddReportReferenceIfRelevant(references, (Xpp3Dom) object);
          }
        }
      }
    }
    Collections.sort(references);
    return references;
  }

  /**
   * Parses the information form the DOM fragment.
   *
   * @param references the references to add to.
   * @param dom the DOM fragment to extract reference information.
   */
  @SuppressWarnings("unchecked")
  private void parseAndAddReportReferenceIfRelevant(
      final List<ReportReference> references, final Xpp3Dom dom)
  {
    final String giConf = dom.getName();
    if ("configuration".equals(giConf))
    {
      final ReportReference ref = createReportReference(dom);
      if (ref != null && version.compareTo(ref.getVersionRepresentative()) > 0)
      {
        references.add(ref);
      }
    }
  }

  /**
   * Creates a report reference from the given configuration.
   *
   * @param dom the configuration to read the report reference information from.
   * @return the report reference or <code>null</code> if the information is not
   *         sufficient or invalid.
   */
  private ReportReference createReportReference(final Xpp3Dom dom)
  {
    try
    {
      return createReportReferenceInstance(dom);
    }
    catch (final IllegalArgumentException e)
    {
      return null;
    }
    catch (final InvalidVersionSpecificationException e)
    {
      return null;
    }
  }

  /**
   * Creates a report reference from the given configuration.
   *
   * @param dom the configuration to read the report reference information from.
   * @return the report reference or <code>null</code> if the information is not
   *         sufficient or invalid.
   * @throws InvalidVersionSpecificationException if the version information
   *           read cannot be parsed.
   * @throws IllegalArgumentException if the version representative cannot be
   *           determined from the version information.
   */
  private ReportReference createReportReferenceInstance(final Xpp3Dom dom)
    throws InvalidVersionSpecificationException, IllegalArgumentException
  {
    String outputName = null;
    String title = null;
    String versionRangeSpec = null;
    for (Xpp3Dom child : dom.getChildren())
    {
      final String name = child.getName();
      if ("outputName".equals(name))
      {
        outputName = child.getValue();
        if (isNotReportOfSameType(outputName))
        {
          return null;
        }
      }
      else if ("title".equals(name))
      {
        title = child.getValue();
      }
      else if ("versionRange".equals(name))
      {
        versionRangeSpec = child.getValue();
      }
    }

    return createReportReference(outputName, title, versionRangeSpec);
  }

  /**
   * Checks if the report is of the same type.
   *
   * @param outputName the report's output name.
   * @return <code>true</code> if the report's output name starts with the
   *         <code>id</code> but is not equal to it, <code>false</code>
   *         otherwise.
   */
  private boolean isNotReportOfSameType(final String outputName)
  {
    return !outputName.startsWith(id) || outputName.equals(id);
  }

  /**
   * Creates the report reference for the given information.
   *
   * @param outputName the <code>outputName</code> from the POM.
   * @param title the <code>title</code> from the POM.
   * @param versionRangeSpec the <code>versionRange</code> from the POM.
   * @return the report reference or <code>null</code> if none can be
   *         constructed.
   * @throws InvalidVersionSpecificationException if the version information
   *           read cannot be parsed.
   * @throws IllegalArgumentException if the version representative cannot be
   *           determined from the version information.
   */
  private ReportReference createReportReference(final String outputName,
      final String title, final String versionRangeSpec)
    throws InvalidVersionSpecificationException, IllegalArgumentException
  {
    if (versionRangeSpec == null)
    {
      return null;
    }

    final VersionRange range =
        VersionRange.createFromVersionSpec(versionRangeSpec);
    final ArtifactVersion representative =
        Utils.findVersionRepresentative(range);
    final ReportReference ref =
        new ReportReference(title, outputName, representative);
    return ref;
  }

  /**
   * Checks if the report plugin is an issues plugin.
   *
   * @param plugin the report plugin to check.
   * @return <code>true</code> if the plugin is an issues plugin,
   *         <code>false</code> otherwise.
   */
  private boolean isIssueReportPlugin(final ReportPlugin plugin)
  {
    return "issues-maven-plugin".equals(plugin.getArtifactId())
           && "de.smartics.maven.plugin".equals(plugin.getGroupId());
  }

  // --- object basics --------------------------------------------------------

}