| package org.apache.maven.plugin.changes; |
| |
| /* |
| * 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 java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.ResourceBundle; |
| |
| import org.apache.commons.lang.StringUtils; |
| |
| 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.doxia.util.HtmlTools; |
| import org.apache.maven.plugin.issues.AbstractIssuesReportGenerator; |
| import org.apache.maven.plugins.changes.model.Action; |
| import org.apache.maven.plugins.changes.model.Component; |
| import org.apache.maven.plugins.changes.model.DueTo; |
| import org.apache.maven.plugins.changes.model.FixedIssue; |
| import org.apache.maven.plugins.changes.model.Release; |
| |
| /** |
| * Generates a changes report. |
| * |
| * @version $Id$ |
| */ |
| public class ChangesReportGenerator |
| extends AbstractIssuesReportGenerator |
| { |
| |
| /** |
| * The token in {@link #issueLinksPerSystem} denoting the base URL for the issue management. |
| */ |
| private static final String URL_TOKEN = "%URL%"; |
| |
| /** |
| * The token in {@link #issueLinksPerSystem} denoting the issue ID. |
| */ |
| private static final String ISSUE_TOKEN = "%ISSUE%"; |
| |
| static final String DEFAULT_ISSUE_SYSTEM_KEY = "default"; |
| |
| private static final String NO_TEAMLIST = "none"; |
| |
| /** |
| * The issue management system to use, for actions that do not specify a system. |
| * |
| * @since 2.4 |
| */ |
| private String system; |
| |
| private String teamlist; |
| |
| private String url; |
| |
| private Map<String, String> issueLinksPerSystem; |
| |
| private boolean addActionDate; |
| |
| private boolean linkToFeed; |
| |
| /** |
| * @since 2.4 |
| */ |
| private boolean escapeHTML; |
| |
| /** |
| * @since 2.4 |
| */ |
| private List<Release> releaseList; |
| |
| public ChangesReportGenerator() |
| { |
| issueLinksPerSystem = new HashMap<String, String>(); |
| } |
| |
| public ChangesReportGenerator( List<Release> releaseList ) |
| { |
| this(); |
| this.releaseList = releaseList; |
| } |
| |
| /** |
| * @since 2.4 |
| */ |
| public boolean isEscapeHTML() |
| { |
| return escapeHTML; |
| } |
| |
| /** |
| * @since 2.4 |
| */ |
| public void setEscapeHTML( boolean escapeHTML ) |
| { |
| this.escapeHTML = escapeHTML; |
| } |
| |
| /** |
| * @since 2.4 |
| */ |
| public String getSystem() |
| { |
| return system; |
| } |
| |
| /** |
| * @since 2.4 |
| */ |
| public void setSystem( String system ) |
| { |
| this.system = system; |
| } |
| |
| public void setTeamlist( final String teamlist ) |
| { |
| this.teamlist = teamlist; |
| } |
| |
| public String getTeamlist() |
| { |
| return teamlist; |
| } |
| |
| public void setUrl( String url ) |
| { |
| this.url = url; |
| } |
| |
| public String getUrl() |
| { |
| return url; |
| } |
| |
| public Map<String, String> getIssueLinksPerSystem() |
| { |
| return issueLinksPerSystem; |
| } |
| |
| public void setIssueLinksPerSystem( Map<String, String> issueLinksPerSystem ) |
| { |
| if ( this.issueLinksPerSystem != null && issueLinksPerSystem == null ) |
| { |
| return; |
| } |
| this.issueLinksPerSystem = issueLinksPerSystem; |
| } |
| |
| public boolean isAddActionDate() |
| { |
| return addActionDate; |
| } |
| |
| public void setAddActionDate( boolean addActionDate ) |
| { |
| this.addActionDate = addActionDate; |
| } |
| |
| public boolean isLinkToFeed() |
| { |
| return linkToFeed; |
| } |
| |
| public void setLinkToFeed( boolean generateLinkTofeed ) |
| { |
| this.linkToFeed = generateLinkTofeed; |
| } |
| |
| /** |
| * Checks whether links to the issues can be generated for the given system. |
| * |
| * @param system The issue management system |
| * @return <code>true</code> if issue links can be generated, <code>false</code> otherwise. |
| */ |
| public boolean canGenerateIssueLinks( String system ) |
| { |
| if ( !this.issueLinksPerSystem.containsKey( system ) ) |
| { |
| return false; |
| } |
| String issueLink = this.issueLinksPerSystem.get( system ); |
| |
| // If the issue link entry is blank then no links are possible |
| if ( StringUtils.isBlank( issueLink ) ) |
| { |
| return false; |
| } |
| |
| // If the %URL% token is used then the issue management system URL must be set. |
| if ( issueLink.contains( URL_TOKEN ) && StringUtils.isBlank( getUrl() ) ) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| public void doGenerateEmptyReport( ResourceBundle bundle, Sink sink, String message ) |
| { |
| sinkBeginReport( sink, bundle ); |
| |
| sink.text( message ); |
| |
| sinkEndReport( sink ); |
| } |
| |
| public void doGenerateReport( ResourceBundle bundle, Sink sink ) |
| { |
| sinkBeginReport( sink, bundle ); |
| |
| constructReleaseHistory( sink, bundle, releaseList ); |
| |
| constructReleases( sink, bundle, releaseList ); |
| |
| sinkEndReport( sink ); |
| } |
| |
| /** |
| * Constructs table row for specified action with all calculated content (e.g. issue link). |
| * |
| * @param sink Sink |
| * @param bundle Resource bundle |
| * @param action Action to generate content for |
| */ |
| private void constructAction( Sink sink, ResourceBundle bundle, Action action ) |
| { |
| sink.tableRow(); |
| |
| sinkShowTypeIcon( sink, action.getType() ); |
| |
| sink.tableCell(); |
| |
| String actionDescription = action.getAction(); |
| |
| if ( escapeHTML ) |
| { |
| sink.text( actionDescription ); |
| } |
| else |
| { |
| sink.rawText( actionDescription ); |
| } |
| |
| // no null check needed classes from modello return a new ArrayList |
| if ( StringUtils.isNotEmpty( action.getIssue() ) || ( !action.getFixedIssues().isEmpty() ) ) |
| { |
| if ( StringUtils.isNotBlank( actionDescription ) && !actionDescription.endsWith( "." ) ) |
| { |
| sink.text( "." ); |
| } |
| sink.text( " " + bundle.getString( "report.changes.text.fixes" ) + " " ); |
| |
| // Try to get the issue management system specified in the changes.xml file |
| String system = action.getSystem(); |
| // Try to get the issue management system configured in the POM |
| if ( StringUtils.isEmpty( system ) ) |
| { |
| system = this.system; |
| } |
| // Use the default issue management system |
| if ( StringUtils.isEmpty( system ) ) |
| { |
| system = DEFAULT_ISSUE_SYSTEM_KEY; |
| } |
| if ( !canGenerateIssueLinks( system ) ) |
| { |
| constructIssueText( action.getIssue(), sink, action.getFixedIssues() ); |
| } |
| else |
| { |
| constructIssueLink( action.getIssue(), system, sink, action.getFixedIssues() ); |
| } |
| sink.text( "." ); |
| } |
| |
| if ( StringUtils.isNotEmpty( action.getDueTo() ) || ( !action.getDueTos().isEmpty() ) ) |
| { |
| constructDueTo( sink, action, bundle, action.getDueTos() ); |
| } |
| |
| sink.tableCell_(); |
| |
| if ( NO_TEAMLIST.equals( teamlist ) ) |
| { |
| sinkCell( sink, action.getDev() ); |
| } |
| else |
| { |
| sinkCellLink( sink, action.getDev(), teamlist + "#" + action.getDev() ); |
| } |
| |
| if ( this.isAddActionDate() ) |
| { |
| sinkCell( sink, action.getDate() ); |
| } |
| |
| sink.tableRow_(); |
| } |
| |
| /** |
| * Construct a text or link that mention the people that helped with an action. |
| * |
| * @param sink The sink |
| * @param action The action that was done |
| * @param bundle A resource bundle for i18n |
| * @param dueTos Other people that helped with an action |
| */ |
| private void constructDueTo( Sink sink, Action action, ResourceBundle bundle, List<DueTo> dueTos ) |
| { |
| |
| // Create a Map with key : dueTo name, value : dueTo email |
| Map<String, String> namesEmailMap = new LinkedHashMap<String, String>(); |
| |
| // Only add the dueTo specified as attributes, if it has either a dueTo or a dueToEmail |
| if ( StringUtils.isNotEmpty( action.getDueTo() ) || StringUtils.isNotEmpty( action.getDueToEmail() ) ) |
| { |
| namesEmailMap.put( action.getDueTo(), action.getDueToEmail() ); |
| } |
| |
| for ( DueTo dueTo : dueTos ) |
| { |
| namesEmailMap.put( dueTo.getName(), dueTo.getEmail() ); |
| } |
| |
| if ( namesEmailMap.isEmpty() ) |
| { |
| return; |
| } |
| |
| sink.text( " " + bundle.getString( "report.changes.text.thanx" ) + " " ); |
| int i = 0; |
| for ( String currentDueTo : namesEmailMap.keySet() ) |
| { |
| String currentDueToEmail = namesEmailMap.get( currentDueTo ); |
| i++; |
| |
| if ( StringUtils.isNotEmpty( currentDueToEmail ) ) |
| { |
| sinkLink( sink, currentDueTo, "mailto:" + currentDueToEmail ); |
| } |
| else if ( StringUtils.isNotEmpty( currentDueTo ) ) |
| { |
| sink.text( currentDueTo ); |
| } |
| |
| if ( i < namesEmailMap.size() ) |
| { |
| sink.text( ", " ); |
| } |
| } |
| |
| sink.text( "." ); |
| } |
| |
| /** |
| * Construct links to the issues that were solved by an action. |
| * |
| * @param issue The issue specified by attributes |
| * @param system The issue management system |
| * @param sink The sink |
| * @param fixes The List of issues specified as fixes elements |
| */ |
| private void constructIssueLink( String issue, String system, Sink sink, List<FixedIssue> fixes ) |
| { |
| if ( StringUtils.isNotEmpty( issue ) ) |
| { |
| sink.link( parseIssueLink( issue, system ) ); |
| |
| sink.text( issue ); |
| |
| sink.link_(); |
| |
| if ( !fixes.isEmpty() ) |
| { |
| sink.text( ", " ); |
| } |
| } |
| |
| for ( Iterator<FixedIssue> iterator = fixes.iterator(); iterator.hasNext(); ) |
| { |
| FixedIssue fixedIssue = iterator.next(); |
| String currentIssueId = fixedIssue.getIssue(); |
| if ( StringUtils.isNotEmpty( currentIssueId ) ) |
| { |
| sink.link( parseIssueLink( currentIssueId, system ) ); |
| |
| sink.text( currentIssueId ); |
| |
| sink.link_(); |
| } |
| |
| if ( iterator.hasNext() ) |
| { |
| sink.text( ", " ); |
| } |
| } |
| } |
| |
| /** |
| * Construct a text that references (but does not link to) the issues that were solved by an action. |
| * |
| * @param issue The issue specified by attributes |
| * @param sink The sink |
| * @param fixes The List of issues specified as fixes elements |
| */ |
| private void constructIssueText( String issue, Sink sink, List<FixedIssue> fixes ) |
| { |
| if ( StringUtils.isNotEmpty( issue ) ) |
| { |
| sink.text( issue ); |
| |
| if ( !fixes.isEmpty() ) |
| { |
| sink.text( ", " ); |
| } |
| } |
| |
| for ( Iterator<FixedIssue> iterator = fixes.iterator(); iterator.hasNext(); ) |
| { |
| FixedIssue fixedIssue = iterator.next(); |
| |
| String currentIssueId = fixedIssue.getIssue(); |
| if ( StringUtils.isNotEmpty( currentIssueId ) ) |
| { |
| sink.text( currentIssueId ); |
| } |
| |
| if ( iterator.hasNext() ) |
| { |
| sink.text( ", " ); |
| } |
| } |
| } |
| |
| private void constructReleaseHistory( Sink sink, ResourceBundle bundle, List<Release> releaseList ) |
| { |
| sink.section2(); |
| |
| sink.sectionTitle2(); |
| sink.text( bundle.getString( "report.changes.label.releasehistory" ) ); |
| sink.sectionTitle2_(); |
| |
| sink.table(); |
| |
| sink.tableRow(); |
| |
| sinkHeader( sink, bundle.getString( "report.issues.label.fixVersion" ) ); |
| |
| sinkHeader( sink, bundle.getString( "report.changes.label.releaseDate" ) ); |
| |
| sinkHeader( sink, bundle.getString( "report.changes.label.releaseDescription" ) ); |
| |
| sink.tableRow_(); |
| |
| for ( Release release : releaseList ) |
| { |
| sink.tableRow(); |
| |
| sinkCellLink( sink, release.getVersion(), "#" + HtmlTools.encodeId( release.getVersion() ) ); |
| |
| sinkCell( sink, release.getDateRelease() ); |
| |
| sinkCell( sink, release.getDescription() ); |
| |
| sink.tableRow_(); |
| } |
| |
| sink.table_(); |
| |
| // MCHANGES-46 |
| if ( linkToFeed ) |
| { |
| sink.paragraph(); |
| sink.text( bundle.getString( "report.changes.text.rssfeed" ) ); |
| sink.nonBreakingSpace(); |
| sink.link( "changes.rss" ); |
| sinkFigure( sink, "images/rss.png", "rss feed" ); |
| sink.link_(); |
| sink.paragraph_(); |
| } |
| |
| sink.section2_(); |
| } |
| |
| /** |
| * Constructs document sections for each of specified releases. |
| * |
| * @param sink Sink |
| * @param bundle Resource bundle |
| * @param releaseList Releases to create content for |
| */ |
| private void constructReleases( Sink sink, ResourceBundle bundle, List<Release> releaseList ) |
| { |
| for ( Release release : releaseList ) |
| { |
| constructRelease( sink, bundle, release ); |
| } |
| } |
| |
| /** |
| * Constructs document section for specified release. |
| * |
| * @param sink Sink |
| * @param bundle Resource bundle |
| * @param release Release to create document section for |
| */ |
| private void constructRelease( Sink sink, ResourceBundle bundle, Release release ) |
| { |
| sink.section2(); |
| |
| final String date = ( release.getDateRelease() == null ) ? "" : " \u2013 " + release.getDateRelease(); |
| |
| SinkEventAttributes attrs = new SinkEventAttributeSet(); |
| attrs.addAttribute( SinkEventAttributes.ID, HtmlTools.encodeId( release.getVersion() ) ); |
| sink.sectionTitle( Sink.SECTION_LEVEL_2, attrs ); |
| sink.text( bundle.getString( "report.changes.label.release" ) + " " + release.getVersion() + date ); |
| sink.sectionTitle_( Sink.SECTION_LEVEL_2 ); |
| |
| if ( isReleaseEmpty( release ) ) |
| { |
| sink.paragraph(); |
| sink.text( bundle.getString( "report.changes.text.no.changes" ) ); |
| sink.paragraph_(); |
| } |
| else |
| { |
| sink.table(); |
| |
| sink.tableRow(); |
| sinkHeader( sink, bundle.getString( "report.issues.label.type" ) ); |
| sinkHeader( sink, bundle.getString( "report.issues.label.summary" ) ); |
| sinkHeader( sink, bundle.getString( "report.issues.label.assignee" ) ); |
| if ( this.isAddActionDate() ) |
| { |
| sinkHeader( sink, bundle.getString( "report.issues.label.updated" ) ); |
| } |
| sink.tableRow_(); |
| |
| for ( Action action : release.getActions() ) |
| { |
| constructAction( sink, bundle, action ); |
| } |
| |
| for ( Object o : release.getComponents() ) |
| { |
| Component component = (Component) o; |
| constructComponent( sink, bundle, component ); |
| } |
| |
| sink.table_(); |
| } |
| |
| sink.section2_(); |
| } |
| |
| /** |
| * Constructs table rows for specified release component. It will create header row for component name and action |
| * rows for all component issues. |
| * |
| * @param sink Sink |
| * @param bundle Resource bundle |
| * @param component Release component to generate content for. |
| */ |
| private void constructComponent( Sink sink, ResourceBundle bundle, Component component ) |
| { |
| if ( !component.getActions().isEmpty() ) |
| { |
| sink.tableRow(); |
| |
| sink.tableHeaderCell(); |
| sink.tableHeaderCell_(); |
| |
| sink.tableHeaderCell(); |
| sink.text( component.getName() ); |
| sink.tableHeaderCell_(); |
| |
| sink.tableHeaderCell(); |
| sink.tableHeaderCell_(); |
| |
| if ( isAddActionDate() ) |
| { |
| sink.tableHeaderCell(); |
| sink.tableHeaderCell_(); |
| } |
| |
| sink.tableRow_(); |
| |
| for ( Action action : component.getActions() ) |
| { |
| constructAction( sink, bundle, action ); |
| } |
| } |
| } |
| |
| /** |
| * Checks if specified release contains own issues or issues inside the child components. |
| * |
| * @param release Release to check |
| * @return <code>true</code> if release doesn't contain any issues, <code>false</code> otherwise |
| */ |
| private boolean isReleaseEmpty( Release release ) |
| { |
| if ( !release.getActions().isEmpty() ) |
| { |
| return false; |
| } |
| |
| for ( Object o : release.getComponents() ) |
| { |
| Component component = (Component) o; |
| if ( !component.getActions().isEmpty() ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Replace tokens in the issue link template with the real values. |
| * |
| * @param issue The issue identifier |
| * @param system The issue management system |
| * @return An interpolated issue link |
| */ |
| private String parseIssueLink( String issue, String system ) |
| { |
| String parseLink; |
| String issueLink = (String) this.issueLinksPerSystem.get( system ); |
| parseLink = issueLink.replaceFirst( ISSUE_TOKEN, issue ); |
| if ( parseLink.contains( URL_TOKEN ) ) |
| { |
| String url = this.url.substring( 0, this.url.lastIndexOf( "/" ) ); |
| parseLink = parseLink.replaceFirst( URL_TOKEN, url ); |
| } |
| |
| return parseLink; |
| } |
| |
| } |
