org.apache.maven.plugin.idea.AbstractIdeaMojo Maven / Gradle / Ivy
package org.apache.maven.plugin.idea;
/*
* 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.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.DependencyManagement;
import org.apache.maven.model.Exclusion;
import org.apache.maven.model.Plugin;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.ProjectBuildingException;
import org.apache.maven.project.artifact.InvalidDependencyVersionException;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
/**
* @author Edwin Punzalan
*/
public abstract class AbstractIdeaMojo
extends AbstractMojo
{
/**
* The Maven Project.
*
* @parameter expression="${executedProject}"
* @required
* @readonly
*/
protected MavenProject executedProject;
/* holder for the log object only */
protected Log log;
/**
* Whether to update the existing project files or overwrite them.
*
* @parameter expression="${overwrite}" default-value="false"
*/
protected boolean overwrite;
/**
* @component
*/
protected ArtifactFactory artifactFactory;
/**
* @parameter expression="${localRepository}"
* @required
* @readonly
*/
protected ArtifactRepository localRepo;
/**
* @component
*/
protected ArtifactResolver artifactResolver;
/**
* @component role="org.apache.maven.artifact.metadata.ArtifactMetadataSource" hint="maven"
*/
protected ArtifactMetadataSource artifactMetadataSource;
public void initParam( MavenProject project, ArtifactFactory artifactFactory, ArtifactRepository localRepo,
ArtifactResolver artifactResolver, ArtifactMetadataSource artifactMetadataSource, Log log,
boolean overwrite )
{
this.executedProject = project;
this.log = log;
this.artifactFactory = artifactFactory;
this.localRepo = localRepo;
this.artifactResolver = artifactResolver;
this.artifactMetadataSource = artifactMetadataSource;
this.overwrite = overwrite;
}
protected Document readXmlDocument( File file, String altFilename )
throws DocumentException
{
SAXReader reader = new SAXReader();
if ( file.exists() && !overwrite )
{
return reader.read( file );
}
else
{
File altFile = new File( executedProject.getBasedir(), "src/main/idea/" + altFilename );
if ( altFile.exists() )
{
return reader.read( altFile );
}
else
{
return reader.read( getClass().getResourceAsStream( "/templates/default/" + altFilename ) );
}
}
}
protected void writeXmlDocument( File file, Document document )
throws IOException
{
XMLWriter writer = new IdeaXmlWriter( file );
writer.write( document );
writer.close();
}
/**
* Finds element from the module element.
*
* @param module Xpp3Dom element
* @param name Name attribute to find
* @return component Returns the Xpp3Dom element found.
*/
protected Element findComponent( Element module, String name )
{
return findElement( module, "component", name );
}
protected Element findElement( Element element, String elementName, String attributeName )
{
for ( Iterator children = element.elementIterator( elementName ); children.hasNext(); )
{
Element child = (Element) children.next();
if ( attributeName.equals( child.attributeValue( "name" ) ) )
{
return child;
}
}
return createElement( element, elementName ).addAttribute( "name", attributeName );
}
protected Element findElement( Element component, String name )
{
Element element = component.element( name );
if ( element == null )
{
element = createElement( component, name );
}
return element;
}
/**
* Creates an Xpp3Dom element.
*
* @param module Xpp3Dom element
* @param name Name of the element
* @return component Xpp3Dom element
*/
protected Element createElement( Element module, String name )
{
return module.addElement( name );
}
/**
* Translate the absolutePath into its relative path.
*
* @param basedir The basedir of the project.
* @param absolutePath The absolute path that must be translated to relative path.
* @return relative Relative path of the parameter absolute path.
*/
protected String toRelative( String basedir, String absolutePath )
{
String relative;
// Convert drive letter
String convertedBasedir = convertDriveLetter( basedir );
String convertedAbsolutePath = convertDriveLetter( absolutePath );
// Normalize path separators
convertedBasedir = StringUtils.replace( convertedBasedir, "\\", "/" );
convertedAbsolutePath = StringUtils.replace( convertedAbsolutePath, "\\", "/" );
// Strip trailing slash
if ( convertedBasedir.endsWith( "/" ) )
{
convertedBasedir = convertedBasedir.substring( 0, convertedBasedir.length() - 1 );
}
if ( convertedAbsolutePath.endsWith( "/" ) )
{
convertedAbsolutePath = convertedAbsolutePath.substring( 0, convertedAbsolutePath.length() - 1 );
}
// IDEA-103 Make sure that the basedir is appended with a / before we attempt to match it to the absolute path
String matchableBasedir = convertedBasedir + "/";
if ( convertedAbsolutePath.startsWith( matchableBasedir )
&& convertedAbsolutePath.length() > matchableBasedir.length() )
{
// Simple case, path starts with basepath
relative = convertedAbsolutePath.substring( matchableBasedir.length() );
}
else
{
// It's more complex...
StringTokenizer baseTokens = new StringTokenizer( convertedBasedir, "/", false );
int baseCount = baseTokens.countTokens();
List baseTokenList = new ArrayList( baseCount );
while ( baseTokens.hasMoreTokens() )
{
baseTokenList.add( baseTokens.nextToken() );
}
StringTokenizer pathTokens = new StringTokenizer( convertedAbsolutePath, "/", false );
int pathCount = pathTokens.countTokens();
List pathTokenList = new ArrayList( pathCount );
while ( pathTokens.hasMoreTokens() )
{
pathTokenList.add( pathTokens.nextToken() );
}
int maxCount = Math.max( baseTokenList.size(), pathTokenList.size() );
int differIndex = -1;
for ( int i = 0; i < maxCount; i++ )
{
if ( i >= pathTokenList.size() || i >= baseTokenList.size() )
{
differIndex = i;
break;
}
String basePart = (String) baseTokenList.get( i );
String pathPart = (String) pathTokenList.get( i );
if ( !basePart.equals( pathPart ) )
{
differIndex = i;
break;
}
}
if ( getLog().isDebugEnabled() )
{
getLog().debug( "Construction of relative path... differIndex=" + differIndex );
}
if ( differIndex < 1 )
{
// Paths are either equal or completely different
relative = convertedAbsolutePath;
}
else
{
StringBuilder result = new StringBuilder();
int parentCount = baseTokenList.size() - differIndex;
if ( getLog().isDebugEnabled() )
{
getLog().debug( "parentCount=" + parentCount );
}
boolean isFirst = true;
for ( int i = 0; i < parentCount; i++ )
{
// Add parents
if ( isFirst )
{
isFirst = false;
}
else
{
result.append( "/" );
}
result.append( ".." );
}
for ( int i = differIndex; i < pathTokenList.size(); i++ )
{
// Add the remaining path elements
if ( isFirst )
{
isFirst = false;
}
else
{
result.append( "/" );
}
result.append( pathTokenList.get( i ) );
}
relative = result.toString();
}
}
if ( getLog().isDebugEnabled() )
{
getLog().debug( "toRelative(" + basedir + ", " + absolutePath + ") => " + relative );
}
return relative;
}
/**
* Convert the drive letter, if there is one, to upper case. This is done
* to avoid case mismatch when running cygwin on Windows.
*
* @param absolutePath The path to convert
* @return The path that came in with its drive letter converted to upper case
*/
String convertDriveLetter( String absolutePath )
{
if ( absolutePath != null && absolutePath.length() >= 3 && !absolutePath.startsWith( "/" ) )
{
// See if the path starts with "?:\", where ? must be a letter
if ( Character.isLetter( absolutePath.substring( 0, 1 ).charAt( 0 ) )
&& absolutePath.substring( 1, 3 ).equals( ":\\" ) )
{
// In that case we convert the first character to upper case
return absolutePath.substring( 0, 1 ).toUpperCase() + absolutePath.substring( 1 );
}
}
return absolutePath;
}
/**
* Remove elements from content (Xpp3Dom).
*
* @param content Xpp3Dom element
* @param name Name of the element to be removed
*/
protected void removeOldElements( Element content, String name )
{
for ( Iterator children = content.elementIterator(); children.hasNext(); )
{
Element child = (Element) children.next();
if ( name.equals( child.getName() ) )
{
content.remove( child );
}
}
}
protected void doDependencyResolution( MavenProject project, ArtifactRepository localRepo )
throws InvalidDependencyVersionException, ProjectBuildingException, InvalidVersionSpecificationException
{
Map managedVersions =
createManagedVersionMap( artifactFactory, project.getId(), project.getDependencyManagement() );
try
{
ArtifactResolutionResult result = artifactResolver.resolveTransitively( getProjectArtifacts(),
project.getArtifact(),
managedVersions, localRepo,
project.getRemoteArtifactRepositories(),
artifactMetadataSource );
project.setArtifacts( result.getArtifacts() );
}
catch ( ArtifactNotFoundException e )
{
getLog().debug( e.getMessage(), e );
StringBuilder msg = new StringBuilder();
msg.append( "An error occurred during dependency resolution.\n\n" );
msg.append( " Failed to retrieve " + e.getDownloadUrl() + "\n" );
msg.append( "from the following repositories:" );
for ( Iterator repositories = e.getRemoteRepositories().iterator(); repositories.hasNext(); )
{
ArtifactRepository repository = (ArtifactRepository) repositories.next();
msg.append( "\n " + repository.getId() + "(" + repository.getUrl() + ")" );
}
msg.append( "\nCaused by: " + e.getMessage() );
getLog().warn( msg );
}
catch ( ArtifactResolutionException e )
{
getLog().debug( e.getMessage(), e );
StringBuilder msg = new StringBuilder();
msg.append( "An error occurred during dependency resolution of the following artifact:\n\n" );
msg.append( " " + e.getGroupId() + ":" + e.getArtifactId() + e.getVersion() + "\n\n" );
msg.append( "Caused by: " + e.getMessage() );
getLog().warn( msg );
}
}
/*
* @todo we need a more permanent feature that does this properly
*/
protected String getPluginSetting( String artifactId, String optionName, String defaultValue )
{
for ( Iterator it = executedProject.getBuildPlugins().iterator(); it.hasNext(); )
{
Plugin plugin = (Plugin) it.next();
if ( plugin.getArtifactId().equals( artifactId ) )
{
Xpp3Dom o = (Xpp3Dom) plugin.getConfiguration();
if ( o != null && o.getChild( optionName ) != null )
{
return o.getChild( optionName ).getValue();
}
}
}
return defaultValue;
}
private Set getProjectArtifacts()
throws InvalidVersionSpecificationException
{
Set artifacts = new HashSet();
for ( Iterator dependencies = executedProject.getDependencies().iterator(); dependencies.hasNext(); )
{
Dependency dep = (Dependency) dependencies.next();
String groupId = dep.getGroupId();
String artifactId = dep.getArtifactId();
VersionRange versionRange = VersionRange.createFromVersionSpec( dep.getVersion() );
String type = dep.getType();
if ( type == null )
{
type = "jar";
}
String classifier = dep.getClassifier();
boolean optional = dep.isOptional();
String scope = dep.getScope();
if ( scope == null )
{
scope = Artifact.SCOPE_COMPILE;
}
Artifact artifact = artifactFactory.createDependencyArtifact( groupId, artifactId, versionRange, type,
classifier, scope, optional );
if ( scope.equalsIgnoreCase( Artifact.SCOPE_SYSTEM ) )
{
artifact.setFile( new File( dep.getSystemPath() ) );
}
List exclusions = new ArrayList();
for ( Iterator j = dep.getExclusions().iterator(); j.hasNext(); )
{
Exclusion e = (Exclusion) j.next();
exclusions.add( e.getGroupId() + ":" + e.getArtifactId() );
}
ArtifactFilter newFilter = new ExcludesArtifactFilter( exclusions );
artifact.setDependencyFilter( newFilter );
artifacts.add( artifact );
}
return artifacts;
}
private Map createManagedVersionMap( ArtifactFactory artifactFactory, String projectId,
DependencyManagement dependencyManagement )
throws ProjectBuildingException
{
Map map;
if ( dependencyManagement != null && dependencyManagement.getDependencies() != null )
{
map = new HashMap();
for ( Iterator i = dependencyManagement.getDependencies().iterator(); i.hasNext(); )
{
Dependency d = (Dependency) i.next();
try
{
VersionRange versionRange = VersionRange.createFromVersionSpec( d.getVersion() );
Artifact artifact = artifactFactory.createDependencyArtifact( d.getGroupId(), d.getArtifactId(),
versionRange, d.getType(),
d.getClassifier(), d.getScope(),
d.isOptional() );
map.put( d.getManagementKey(), artifact );
}
catch ( InvalidVersionSpecificationException e )
{
throw new ProjectBuildingException( projectId, "Unable to parse version '" + d.getVersion()
+ "' for dependency '" + d.getManagementKey() + "': " + e.getMessage(), e );
}
}
}
else
{
map = Collections.EMPTY_MAP;
}
return map;
}
public Log getLog()
{
if ( log == null )
{
log = super.getLog();
}
return log;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy