package org.apache.maven.report.projectinfo;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.doxia.sink.Sink;
import org.apache.maven.doxia.sink.SinkEventAttributeSet;
import org.apache.maven.doxia.sink.SinkEventAttributes;
import org.apache.maven.model.Dependency;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
import org.apache.maven.reporting.MavenReportException;
import org.codehaus.plexus.util.StringUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TreeMap;
/**
* Generates the Dependency Convergence report for reactor builds.
*
* @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton </a>
* @version $Id: DependencyConvergenceReport.java 1367255 2012-07-30 20:01:21Z hboutemy $
* @since 2.0
*/
@Mojo( name = "dependency-convergence", aggregator = true )
public class DependencyConvergenceReport
extends AbstractProjectInfoReport
{
private static final int PERCENTAGE = 100;
// ----------------------------------------------------------------------
// Mojo parameters
// ----------------------------------------------------------------------
/**
* The projects in the current build. The effective-POM for
* each of these projects will written.
*/
@Parameter( property = "reactorProjects", required = true, readonly = true )
private List<MavenProject> reactorProjects;
// ----------------------------------------------------------------------
// Public methods
// ----------------------------------------------------------------------
/** {@inheritDoc} */
public String getOutputName()
{
return "dependency-convergence";
}
@Override
protected String getI18Nsection()
{
return "dependency-convergence";
}
@Override
public boolean canGenerateReport()
{
// only generate the convergency report if we are running a reactor build
return reactorProjects.size() > 1;
}
// ----------------------------------------------------------------------
// Protected methods
// ----------------------------------------------------------------------
@Override
protected void executeReport( Locale locale )
throws MavenReportException
{
Sink sink = getSink();
sink.head();
sink.title();
sink.text( getI18nString( locale, "title" ) );
sink.title_();
sink.head_();
sink.body();
sink.section1();
sink.sectionTitle1();
sink.text( getI18nString( locale, "title" ) );
sink.sectionTitle1_();
Map<String, List<ReverseDependencyLink>> dependencyMap = getDependencyMap();
// legend
generateLegend( locale, sink );
sink.lineBreak();
// stats
generateStats( locale, sink, dependencyMap );
sink.section1_();
// convergence
generateConvergence( locale, sink, dependencyMap );
sink.body_();
sink.flush();
sink.close();
}
// ----------------------------------------------------------------------
// Private methods
// ----------------------------------------------------------------------
/**
* Generate the convergence table for all dependencies
*
* @param locale
* @param sink
* @param dependencyMap
*/
private void generateConvergence( Locale locale, Sink sink, Map<String, List<ReverseDependencyLink>> dependencyMap )
{
sink.section2();
sink.sectionTitle2();
sink.text( getI18nString( locale, "convergence.caption" ) );
sink.sectionTitle2_();
for ( Map.Entry<String, List<ReverseDependencyLink>> entry : dependencyMap.entrySet() )
{
String key = entry.getKey();
List<ReverseDependencyLink> depList = entry.getValue();
sink.section3();
sink.sectionTitle3();
sink.text( key );
sink.sectionTitle3_();
generateDependencyDetails( sink, depList );
sink.section3_();
}
sink.section2_();
}
/**
* Generate the detail table for a given dependency
*
* @param sink
* @param depList
*/
private void generateDependencyDetails( Sink sink, List<ReverseDependencyLink> depList )
{
sink.table();
Map<String, List<ReverseDependencyLink>> artifactMap = getSortedUniqueArtifactMap( depList );
sink.tableRow();
sink.tableCell( );
if ( artifactMap.size() > 1 )
{
iconError( sink );
}
else
{
iconSuccess( sink );
}
sink.tableCell_();
sink.tableCell();
sink.table();
for ( String version : artifactMap.keySet() )
{
sink.tableRow();
sink.tableCell( new SinkEventAttributeSet( new String[] {SinkEventAttributes.WIDTH, "25%"} ) );
sink.text( version );
sink.tableCell_();
sink.tableCell();
generateVersionDetails( sink, artifactMap, version );
sink.tableCell_();
sink.tableRow_();
}
sink.table_();
sink.tableCell_();
sink.tableRow_();
sink.table_();
}
private void generateVersionDetails( Sink sink, Map<String, List<ReverseDependencyLink>> artifactMap,
String version )
{
sink.numberedList( 1 ); // Use lower alpha numbering
List<ReverseDependencyLink> depList = artifactMap.get( version );
Collections.sort( depList, new ReverseDependencyLinkComparator() );
for ( ReverseDependencyLink rdl : depList )
{
sink.numberedListItem();
if ( StringUtils.isNotEmpty( rdl.project.getUrl() ) )
{
sink.link( rdl.project.getUrl() );
}
sink.text( rdl.project.getGroupId() + ":" + rdl.project.getArtifactId() );
if ( StringUtils.isNotEmpty( rdl.project.getUrl() ) )
{
sink.link_();
}
sink.numberedListItem_();
}
sink.numberedList_();
}
/**
* Produce a Map of relationships between dependencies (its version) and
* reactor projects.
*
* This is the structure of the Map:
* <pre>
* +--------------------+----------------------------------+
* | key | value |
* +--------------------+----------------------------------+
* | version of a | A List of ReverseDependencyLinks |
* | dependency | which each look like this: |
* | | +------------+-----------------+ |
* | | | dependency | reactor project | |
* | | +------------+-----------------+ |
* +--------------------+----------------------------------+
* </pre>
*
* @return A Map of sorted unique artifacts
*/
private Map<String, List<ReverseDependencyLink>> getSortedUniqueArtifactMap( List<ReverseDependencyLink> depList )
{
Map<String, List<ReverseDependencyLink>> uniqueArtifactMap = new TreeMap<String, List<ReverseDependencyLink>>();
for ( ReverseDependencyLink rdl : depList )
{
String key = rdl.getDependency().getVersion();
List<ReverseDependencyLink> projectList = uniqueArtifactMap.get( key );
if ( projectList == null )
{
projectList = new ArrayList<ReverseDependencyLink>();
}
projectList.add( rdl );
uniqueArtifactMap.put( key, projectList );
}
return uniqueArtifactMap;
}
/**
* Generate the legend table
*
* @param locale
* @param sink
*/
private void generateLegend( Locale locale, Sink sink )
{
sink.table();
sink.tableCaption();
sink.bold();
sink.text( getI18nString( locale, "legend" ) );
sink.bold_();
sink.tableCaption_();
sink.tableRow();
sink.tableCell( );
iconSuccess( sink );
sink.tableCell_();
sink.tableCell();
sink.text( getI18nString( locale, "legend.shared" ) );
sink.tableCell_();
sink.tableRow_();
sink.tableRow();
sink.tableCell( );
iconError( sink );
sink.tableCell_();
sink.tableCell();
sink.text( getI18nString( locale, "legend.different" ) );
sink.tableCell_();
sink.tableRow_();
sink.table_();
}
/**
* Generate the statistic table
*
* @param locale
* @param sink
* @param dependencyMap
*/
private void generateStats( Locale locale, Sink sink, Map<String, List<ReverseDependencyLink>> dependencyMap )
{
int depCount = dependencyMap.size();
int artifactCount = 0;
int snapshotCount = 0;
for ( List<ReverseDependencyLink> depList : dependencyMap.values() )
{
Map<String, List<ReverseDependencyLink>> artifactMap = getSortedUniqueArtifactMap( depList );
snapshotCount += countSnapshots( artifactMap );
artifactCount += artifactMap.size();
}
int convergence = (int) ( ( (double) depCount / (double) artifactCount ) * PERCENTAGE );
// Create report
sink.table();
sink.tableCaption();
sink.bold();
sink.text( getI18nString( locale, "stats.caption" ) );
sink.bold_();
sink.tableCaption_();
sink.tableRow();
sink.tableHeaderCell( );
sink.text( getI18nString( locale, "stats.subprojects" ) );
sink.tableHeaderCell_();
sink.tableCell();
sink.text( String.valueOf( reactorProjects.size() ) );
sink.tableCell_();
sink.tableRow_();
sink.tableRow();
sink.tableHeaderCell( );
sink.text( getI18nString( locale, "stats.dependencies" ) );
sink.tableHeaderCell_();
sink.tableCell();
sink.text( String.valueOf( depCount ) );
sink.tableCell_();
sink.tableRow_();
sink.tableRow();
sink.tableHeaderCell( );
sink.text( getI18nString( locale, "stats.artifacts" ) );
sink.tableHeaderCell_();
sink.tableCell();
sink.text( String.valueOf( artifactCount ) );
sink.tableCell_();
sink.tableRow_();
sink.tableRow();
sink.tableHeaderCell( );
sink.text( getI18nString( locale, "stats.snapshots" ) );
sink.tableHeaderCell_();
sink.tableCell();
sink.text( String.valueOf( snapshotCount ) );
sink.tableCell_();
sink.tableRow_();
sink.tableRow();
sink.tableHeaderCell( );
sink.text( getI18nString( locale, "stats.convergence" ) );
sink.tableHeaderCell_();
sink.tableCell();
if ( convergence < PERCENTAGE )
{
iconError( sink );
}
else
{
iconSuccess( sink );
}
sink.nonBreakingSpace();
sink.bold();
sink.text( String.valueOf( convergence ) + "%" );
sink.bold_();
sink.tableCell_();
sink.tableRow_();
sink.tableRow();
sink.tableHeaderCell( );
sink.text( getI18nString( locale, "stats.readyrelease" ) );
sink.tableHeaderCell_();
sink.tableCell();
if ( convergence >= PERCENTAGE && snapshotCount <= 0 )
{
iconSuccess( sink );
sink.nonBreakingSpace();
sink.bold();
sink.text( getI18nString( locale, "stats.readyrelease.success" ) );
sink.bold_();
}
else
{
iconError( sink );
sink.nonBreakingSpace();
sink.bold();
sink.text( getI18nString( locale, "stats.readyrelease.error" ) );
sink.bold_();
if ( convergence < PERCENTAGE )
{
sink.lineBreak();
sink.text( getI18nString( locale, "stats.readyrelease.error.convergence" ) );
}
if ( snapshotCount > 0 )
{
sink.lineBreak();
sink.text( getI18nString( locale, "stats.readyrelease.error.snapshots" ) );
}
}
sink.tableCell_();
sink.tableRow_();
sink.table_();
}
private int countSnapshots( Map<String, List<ReverseDependencyLink>> artifactMap )
{
int count = 0;
for ( Map.Entry<String, List<ReverseDependencyLink>> entry : artifactMap.entrySet() )
{
String version = entry.getKey();
boolean isReactorProject = false;
Iterator<ReverseDependencyLink> iterator = entry.getValue().iterator();
// It if enough to check just the first dependency here, because
// the dependency is the same in all the RDLs in the List. It's the
// reactorProjects that are different.
if ( iterator.hasNext() )
{
ReverseDependencyLink rdl = iterator.next();
if ( isReactorProject( rdl.getDependency() ) )
{
isReactorProject = true;
}
}
if ( version.endsWith( "-SNAPSHOT" ) && !isReactorProject )
{
count++;
}
}
return count;
}
/**
* Check to see if the specified dependency is among the reactor projects.
*
* @param dependency The dependency to check
* @return true if and only if the dependency is a reactor project
*/
private boolean isReactorProject( Dependency dependency )
{
for ( MavenProject mavenProject : reactorProjects )
{
if ( mavenProject.getGroupId().equals( dependency.getGroupId() )
&& mavenProject.getArtifactId().equals( dependency.getArtifactId() ) )
{
if ( getLog().isDebugEnabled() )
{
getLog().debug( dependency + " is a reactor project" );
}
return true;
}
}
return false;
}
private void iconSuccess( Sink sink )
{
sink.figure();
sink.figureCaption();
sink.text( "success" );
sink.figureCaption_();
sink.figureGraphics( "images/icon_success_sml.gif" );
sink.figure_();
}
private void iconError( Sink sink )
{
sink.figure();
sink.figureCaption();
sink.text( "error" );
sink.figureCaption_();
sink.figureGraphics( "images/icon_error_sml.gif" );
sink.figure_();
}
/**
* Produce a Map of relationships between dependencies
* (its groupId:artifactId) and reactor projects.
*
* This is the structure of the Map:
* <pre>
* +--------------------+----------------------------------+
* | key | value |
* +--------------------+----------------------------------+
* | groupId:artifactId | A List of ReverseDependencyLinks |
* | of a dependency | which each look like this: |
* | | +------------+-----------------+ |
* | | | dependency | reactor project | |
* | | +------------+-----------------+ |
* +--------------------+----------------------------------+
* </pre>
*
* @return A Map of relationships between dependencies and reactor projects
*/
private Map<String, List<ReverseDependencyLink>> getDependencyMap()
{
Map<String, List<ReverseDependencyLink>> dependencyMap = new TreeMap<String, List<ReverseDependencyLink>>();
for ( MavenProject reactorProject : reactorProjects )
{
@SuppressWarnings( "unchecked" )
Iterator<Dependency> itdep = reactorProject.getDependencies().iterator();
while ( itdep.hasNext() )
{
Dependency dep = itdep.next();
String key = dep.getGroupId() + ":" + dep.getArtifactId();
List<ReverseDependencyLink> depList = dependencyMap.get( key );
if ( depList == null )
{
depList = new ArrayList<ReverseDependencyLink>();
}
depList.add( new ReverseDependencyLink( dep, reactorProject ) );
dependencyMap.put( key, depList );
}
}
return dependencyMap;
}
/**
* Internal object
*/
private static class ReverseDependencyLink
{
private Dependency dependency;
protected MavenProject project;
ReverseDependencyLink( Dependency dependency, MavenProject project )
{
this.dependency = dependency;
this.project = project;
}
public Dependency getDependency()
{
return dependency;
}
public MavenProject getProject()
{
return project;
}
@Override
public String toString()
{
return project.getId();
}
}
/**
* Internal ReverseDependencyLink comparator
*/
static class ReverseDependencyLinkComparator
implements Comparator<ReverseDependencyLink>
{
/** {@inheritDoc} */
public int compare( ReverseDependencyLink p1, ReverseDependencyLink p2 )
{
return p1.getProject().getId().compareTo( p2.getProject().getId() );
}
}
}