package org.apache.maven.tools.plugin.annotations;
/*
* 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 com.thoughtworks.qdox.JavaDocBuilder;
import com.thoughtworks.qdox.model.DocletTag;
import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaField;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.plugin.descriptor.DuplicateParameterException;
import org.apache.maven.plugin.descriptor.InvalidParameterException;
import org.apache.maven.plugin.descriptor.InvalidPluginDescriptorException;
import org.apache.maven.plugin.descriptor.MojoDescriptor;
import org.apache.maven.plugin.descriptor.PluginDescriptor;
import org.apache.maven.plugin.descriptor.Requirement;
import org.apache.maven.project.MavenProject;
import org.apache.maven.tools.plugin.DefaultPluginToolsRequest;
import org.apache.maven.tools.plugin.ExtendedMojoDescriptor;
import org.apache.maven.tools.plugin.PluginToolsRequest;
import org.apache.maven.tools.plugin.annotations.datamodel.ComponentAnnotationContent;
import org.apache.maven.tools.plugin.annotations.datamodel.ExecuteAnnotationContent;
import org.apache.maven.tools.plugin.annotations.datamodel.MojoAnnotationContent;
import org.apache.maven.tools.plugin.annotations.datamodel.ParameterAnnotationContent;
import org.apache.maven.tools.plugin.annotations.scanner.MojoAnnotatedClass;
import org.apache.maven.tools.plugin.annotations.scanner.MojoAnnotationsScanner;
import org.apache.maven.tools.plugin.annotations.scanner.MojoAnnotationsScannerRequest;
import org.apache.maven.tools.plugin.extractor.ExtractionException;
import org.apache.maven.tools.plugin.extractor.MojoDescriptorExtractor;
import org.apache.maven.tools.plugin.util.PluginUtils;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.util.StringUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* JavaMojoDescriptorExtractor, a MojoDescriptor extractor to read descriptors from java classes with annotations.
*
* @author Olivier Lamy
* @since 3.0
*/
@Component( role = MojoDescriptorExtractor.class, hint = "java-annotations" )
public class JavaAnnotationsMojoDescriptorExtractor
extends AbstractLogEnabled
implements MojoDescriptorExtractor
{
@org.codehaus.plexus.component.annotations.Requirement
private MojoAnnotationsScanner mojoAnnotationsScanner;
@org.codehaus.plexus.component.annotations.Requirement
private ArtifactResolver artifactResolver;
@org.codehaus.plexus.component.annotations.Requirement
private ArtifactFactory artifactFactory;
@org.codehaus.plexus.component.annotations.Requirement
private ArchiverManager archiverManager;
public List<MojoDescriptor> execute( MavenProject project, PluginDescriptor pluginDescriptor )
throws ExtractionException, InvalidPluginDescriptorException
{
return execute( new DefaultPluginToolsRequest( project, pluginDescriptor ) );
}
public List<MojoDescriptor> execute( PluginToolsRequest request )
throws ExtractionException, InvalidPluginDescriptorException
{
Map<String, MojoAnnotatedClass> mojoAnnotatedClasses = scanAnnotations( request );
Map<String, JavaClass> javaClassesMap = scanJavadoc( request, mojoAnnotatedClasses.values() );
populateDataFromJavadoc( mojoAnnotatedClasses, javaClassesMap );
return toMojoDescriptors( mojoAnnotatedClasses, request.getPluginDescriptor() );
}
private Map<String, MojoAnnotatedClass> scanAnnotations( PluginToolsRequest request )
throws ExtractionException
{
MojoAnnotationsScannerRequest mojoAnnotationsScannerRequest = new MojoAnnotationsScannerRequest();
File output = new File( request.getProject().getBuild().getOutputDirectory() );
mojoAnnotationsScannerRequest.setClassesDirectories( Arrays.asList( output ) );
mojoAnnotationsScannerRequest.setDependencies( request.getDependencies() );
mojoAnnotationsScannerRequest.setProject( request.getProject() );
return mojoAnnotationsScanner.scan( mojoAnnotationsScannerRequest );
}
private Map<String, JavaClass> scanJavadoc( PluginToolsRequest request,
Collection<MojoAnnotatedClass> mojoAnnotatedClasses )
throws ExtractionException
{
// found artifact from reactors to scan sources
// we currently only scan sources from reactors
List<MavenProject> mavenProjects = new ArrayList<MavenProject>();
// if we need to scan sources from external artifacts
Set<Artifact> externalArtifacts = new HashSet<Artifact>();
for ( MojoAnnotatedClass mojoAnnotatedClass : mojoAnnotatedClasses )
{
if ( StringUtils.equals( mojoAnnotatedClass.getArtifact().getArtifactId(),
request.getProject().getArtifact().getArtifactId() ) )
{
continue;
}
if ( !isMojoAnnnotatedClassCandidate( mojoAnnotatedClass ) )
{
// we don't scan sources for classes without mojo annotations
continue;
}
MavenProject mavenProject =
getFromProjectReferences( mojoAnnotatedClass.getArtifact(), request.getProject() );
if ( mavenProject != null )
{
mavenProjects.add( mavenProject );
}
else
{
externalArtifacts.add( mojoAnnotatedClass.getArtifact() );
}
}
Map<String, JavaClass> javaClassesMap = new HashMap<String, JavaClass>();
// try to get artifact with sources classifier, extract somewhere then scan for @since, @deprecated
for ( Artifact artifact : externalArtifacts )
{
// parameter for test-sources too ?? olamy I need that for it test only
if ( StringUtils.equalsIgnoreCase( "tests", artifact.getClassifier() ) )
{
javaClassesMap.putAll( discoverClassesFromSourcesJar( artifact, request, "test-sources" ) );
}
else
{
javaClassesMap.putAll( discoverClassesFromSourcesJar( artifact, request, "sources" ) );
}
}
for ( MavenProject mavenProject : mavenProjects )
{
javaClassesMap.putAll( discoverClasses( request.getEncoding(), mavenProject ) );
}
javaClassesMap.putAll( discoverClasses( request ) );
return javaClassesMap;
}
private boolean isMojoAnnnotatedClassCandidate( MojoAnnotatedClass mojoAnnotatedClass )
{
if ( mojoAnnotatedClass == null )
{
return false;
}
return ( !mojoAnnotatedClass.getComponents().isEmpty() || !mojoAnnotatedClass.getParameters().isEmpty()
|| mojoAnnotatedClass.getExecute() != null || mojoAnnotatedClass.getMojo() != null );
}
protected Map<String, JavaClass> discoverClassesFromSourcesJar( Artifact artifact, PluginToolsRequest request,
String classifier )
throws ExtractionException
{
try
{
Artifact sourcesArtifact =
artifactFactory.createArtifactWithClassifier( artifact.getGroupId(), artifact.getArtifactId(),
artifact.getVersion(), artifact.getType(), classifier );
artifactResolver.resolve( sourcesArtifact, request.getRemoteRepos(), request.getLocal() );
if ( sourcesArtifact.getFile() == null || !sourcesArtifact.getFile().exists() )
{
// could not get artifact sources
return Collections.emptyMap();
}
// extract sources to target/maven-plugin-plugin-sources/${groupId}/${artifact}/sources
File extractDirectory = new File( request.getProject().getBuild().getDirectory(),
"maven-plugin-plugin-sources/" + sourcesArtifact.getGroupId() + "/"
+ sourcesArtifact.getArtifactId() + "/" + sourcesArtifact.getVersion()
+ "/" + sourcesArtifact.getClassifier() );
extractDirectory.mkdirs();
UnArchiver unArchiver = archiverManager.getUnArchiver( "jar" );
unArchiver.setSourceFile( sourcesArtifact.getFile() );
unArchiver.setDestDirectory( extractDirectory );
unArchiver.extract();
return discoverClasses( request.getEncoding(), Arrays.asList( extractDirectory ) );
}
catch ( ArtifactResolutionException e )
{
throw new ExtractionException( e.getMessage(), e );
}
catch ( ArtifactNotFoundException e )
{
//throw new ExtractionException( e.getMessage(), e );
getLogger().debug( "skip ArtifactNotFoundException:" + e.getMessage() );
getLogger().warn(
"Unable to get sources artifact for " + artifact.getGroupId() + ":" + artifact.getArtifactId() + ":"
+ artifact.getVersion() + ". Some javadoc tags (@since, @deprecated and comments) won't be used" );
return Collections.emptyMap();
}
catch ( NoSuchArchiverException e )
{
throw new ExtractionException( e.getMessage(), e );
}
}
/**
* from sources scan to get @since and @deprecated and description of classes and fields.
*
* @param mojoAnnotatedClasses
* @param javaClassesMap
*/
protected void populateDataFromJavadoc( Map<String, MojoAnnotatedClass> mojoAnnotatedClasses,
Map<String, JavaClass> javaClassesMap )
{
for ( Map.Entry<String, MojoAnnotatedClass> entry : mojoAnnotatedClasses.entrySet() )
{
JavaClass javaClass = javaClassesMap.get( entry.getKey() );
if ( javaClass == null )
{
continue;
}
// populate class-level content
MojoAnnotationContent mojoAnnotationContent = entry.getValue().getMojo();
if ( mojoAnnotationContent != null )
{
mojoAnnotationContent.setDescription( javaClass.getComment() );
DocletTag since = findInClassHierarchy( javaClass, "since" );
if ( since != null )
{
mojoAnnotationContent.setSince( since.getValue() );
}
DocletTag deprecated = findInClassHierarchy( javaClass, "deprecated" );
if ( deprecated != null )
{
mojoAnnotationContent.setDeprecated( deprecated.getValue() );
}
}
Map<String, JavaField> fieldsMap = extractFieldParameterTags( javaClass, javaClassesMap );
// populate parameters
Map<String, ParameterAnnotationContent> parameters =
getParametersParentHierarchy( entry.getValue(), new HashMap<String, ParameterAnnotationContent>(),
mojoAnnotatedClasses );
for ( Map.Entry<String, ParameterAnnotationContent> parameter : new TreeMap<String, ParameterAnnotationContent>(
parameters ).entrySet() )
{
JavaField javaField = fieldsMap.get( parameter.getKey() );
if ( javaField == null )
{
continue;
}
ParameterAnnotationContent parameterAnnotationContent = parameter.getValue();
parameterAnnotationContent.setDescription( javaField.getComment() );
DocletTag deprecated = javaField.getTagByName( "deprecated" );
if ( deprecated != null )
{
parameterAnnotationContent.setDeprecated( deprecated.getValue() );
}
DocletTag since = javaField.getTagByName( "since" );
if ( since != null )
{
parameterAnnotationContent.setSince( since.getValue() );
}
}
// populate components
for ( Map.Entry<String, ComponentAnnotationContent> component : entry.getValue().getComponents().entrySet() )
{
JavaField javaField = fieldsMap.get( component.getKey() );
if ( javaField == null )
{
continue;
}
ComponentAnnotationContent componentAnnotationContent = component.getValue();
componentAnnotationContent.setDescription( javaField.getComment() );
DocletTag deprecated = javaField.getTagByName( "deprecated" );
if ( deprecated != null )
{
componentAnnotationContent.setDeprecated( deprecated.getValue() );
}
DocletTag since = javaField.getTagByName( "since" );
if ( since != null )
{
componentAnnotationContent.setSince( since.getValue() );
}
}
}
}
/**
* @param javaClass not null
* @param tagName not null
* @return docletTag instance
*/
private DocletTag findInClassHierarchy( JavaClass javaClass, String tagName )
{
DocletTag tag = javaClass.getTagByName( tagName );
if ( tag == null )
{
JavaClass superClass = javaClass.getSuperJavaClass();
if ( superClass != null )
{
tag = findInClassHierarchy( superClass, tagName );
}
}
return tag;
}
/**
* extract fields that are either parameters or components.
*
* @param javaClass not null
* @return map with Mojo parameters names as keys
*/
private Map<String, JavaField> extractFieldParameterTags( JavaClass javaClass,
Map<String, JavaClass> javaClassesMap )
{
Map<String, JavaField> rawParams = new TreeMap<String, com.thoughtworks.qdox.model.JavaField>();
// we have to add the parent fields first, so that they will be overwritten by the local fields if
// that actually happens...
JavaClass superClass = javaClass.getSuperJavaClass();
if ( superClass != null )
{
if ( superClass.getFields().length > 0 )
{
rawParams = extractFieldParameterTags( superClass, javaClassesMap );
}
// maybe sources comes from scan of sources artifact
superClass = javaClassesMap.get( superClass.getFullyQualifiedName() );
if ( superClass != null )
{
rawParams = extractFieldParameterTags( superClass, javaClassesMap );
}
}
else
{
rawParams = new TreeMap<String, JavaField>();
}
JavaField[] classFields = javaClass.getFields();
if ( classFields != null )
{
for ( JavaField field : classFields )
{
rawParams.put( field.getName(), field );
}
}
return rawParams;
}
protected Map<String, JavaClass> discoverClasses( final PluginToolsRequest request )
{
return discoverClasses( request.getEncoding(), request.getProject() );
}
@SuppressWarnings( "unchecked" )
protected Map<String, JavaClass> discoverClasses( final String encoding, final MavenProject project )
{
List<File> sources = new ArrayList<File>();
for ( String source : (List<String>) project.getCompileSourceRoots() )
{
sources.add( new File( source ) );
}
// TODO be more dynamic
File generatedPlugin = new File( project.getBasedir(), "target/generated-sources/plugin" );
if ( !project.getCompileSourceRoots().contains( generatedPlugin.getAbsolutePath() )
&& generatedPlugin.exists() )
{
sources.add( generatedPlugin );
}
return discoverClasses( encoding, sources );
}
protected Map<String, JavaClass> discoverClasses( final String encoding, List<File> sourceDirectories )
{
JavaDocBuilder builder = new JavaDocBuilder();
builder.setEncoding( encoding );
for ( File source : sourceDirectories )
{
builder.addSourceTree( source );
}
JavaClass[] javaClasses = builder.getClasses();
if ( javaClasses == null || javaClasses.length < 1 )
{
return Collections.emptyMap();
}
Map<String, JavaClass> javaClassMap = new HashMap<String, JavaClass>( javaClasses.length );
for ( JavaClass javaClass : javaClasses )
{
javaClassMap.put( javaClass.getFullyQualifiedName(), javaClass );
}
return javaClassMap;
}
private List<MojoDescriptor> toMojoDescriptors( Map<String, MojoAnnotatedClass> mojoAnnotatedClasses,
PluginDescriptor pluginDescriptor )
throws DuplicateParameterException, InvalidParameterException
{
List<MojoDescriptor> mojoDescriptors = new ArrayList<MojoDescriptor>( mojoAnnotatedClasses.size() );
for ( MojoAnnotatedClass mojoAnnotatedClass : mojoAnnotatedClasses.values() )
{
// no mojo so skip it
if ( mojoAnnotatedClass.getMojo() == null )
{
continue;
}
ExtendedMojoDescriptor mojoDescriptor = new ExtendedMojoDescriptor();
//mojoDescriptor.setRole( mojoAnnotatedClass.getClassName() );
//mojoDescriptor.setRoleHint( "default" );
mojoDescriptor.setImplementation( mojoAnnotatedClass.getClassName() );
mojoDescriptor.setLanguage( "java" );
MojoAnnotationContent mojo = mojoAnnotatedClass.getMojo();
mojoDescriptor.setDescription( mojo.getDescription() );
mojoDescriptor.setSince( mojo.getSince() );
mojo.setDeprecated( mojo.getDeprecated() );
mojoDescriptor.setProjectRequired( mojo.requiresProject() );
mojoDescriptor.setRequiresReports( mojo.requiresReports() );
mojoDescriptor.setComponentConfigurator( mojo.configurator() );
mojoDescriptor.setInheritedByDefault( mojo.inheritByDefault() );
mojoDescriptor.setInstantiationStrategy( mojo.instantiationStrategy().id() );
mojoDescriptor.setAggregator( mojo.aggregator() );
mojoDescriptor.setDependencyResolutionRequired( mojo.requiresDependencyResolution().id() );
mojoDescriptor.setDependencyCollectionRequired( mojo.requiresDependencyCollection().id() );
mojoDescriptor.setDirectInvocationOnly( mojo.requiresDirectInvocation() );
mojoDescriptor.setDeprecated( mojo.getDeprecated() );
mojoDescriptor.setThreadSafe( mojo.threadSafe() );
ExecuteAnnotationContent execute = findExecuteInParentHierarchy( mojoAnnotatedClass, mojoAnnotatedClasses );
if ( execute != null )
{
mojoDescriptor.setExecuteGoal( execute.goal() );
mojoDescriptor.setExecuteLifecycle( execute.lifecycle() );
mojoDescriptor.setExecutePhase( execute.phase().id() );
}
mojoDescriptor.setExecutionStrategy( mojo.executionStrategy() );
// ???
//mojoDescriptor.alwaysExecute(mojo.a)
mojoDescriptor.setGoal( mojo.name() );
mojoDescriptor.setOnlineRequired( mojo.requiresOnline() );
mojoDescriptor.setPhase( mojo.defaultPhase().id() );
Map<String, ParameterAnnotationContent> parameters =
getParametersParentHierarchy( mojoAnnotatedClass, new HashMap<String, ParameterAnnotationContent>(),
mojoAnnotatedClasses );
for ( ParameterAnnotationContent parameterAnnotationContent : new TreeSet<ParameterAnnotationContent>(
parameters.values() ) )
{
org.apache.maven.plugin.descriptor.Parameter parameter =
new org.apache.maven.plugin.descriptor.Parameter();
parameter.setName( parameterAnnotationContent.getFieldName() );
parameter.setAlias( parameterAnnotationContent.alias() );
parameter.setDefaultValue( parameterAnnotationContent.defaultValue() );
parameter.setDeprecated( parameterAnnotationContent.getDeprecated() );
parameter.setDescription( parameterAnnotationContent.getDescription() );
parameter.setEditable( !parameterAnnotationContent.readonly() );
String property = parameterAnnotationContent.property();
if ( StringUtils.contains( property, '$' ) || StringUtils.contains( property, '{' )
|| StringUtils.contains( property, '}' ) )
{
throw new InvalidParameterException(
"Invalid property for parameter '" + parameter.getName() + "', " + "forbidden characters ${}: "
+ property, null );
}
parameter.setExpression( StringUtils.isEmpty( property ) ? "" : "${" + property + "}" );
parameter.setType( parameterAnnotationContent.getClassName() );
parameter.setSince( parameterAnnotationContent.getSince() );
parameter.setRequired( parameterAnnotationContent.required() );
mojoDescriptor.addParameter( parameter );
}
Map<String, ComponentAnnotationContent> components =
getComponentsParentHierarchy( mojoAnnotatedClass, new HashMap<String, ComponentAnnotationContent>(),
mojoAnnotatedClasses );
for ( ComponentAnnotationContent componentAnnotationContent : new TreeSet<ComponentAnnotationContent>(
components.values() ) )
{
org.apache.maven.plugin.descriptor.Parameter parameter =
new org.apache.maven.plugin.descriptor.Parameter();
parameter.setName( componentAnnotationContent.getFieldName() );
String expression = PluginUtils.MAVEN_COMPONENTS.get( componentAnnotationContent.getRoleClassName() );
if ( expression == null )
{
parameter.setRequirement( new Requirement( componentAnnotationContent.getRoleClassName(),
componentAnnotationContent.hint() ) );
}
else
{
parameter.setDefaultValue( expression );
parameter.setImplementation( componentAnnotationContent.getRoleClassName() );
parameter.setType( componentAnnotationContent.getRoleClassName() );
}
parameter.setDeprecated( componentAnnotationContent.getDeprecated() );
parameter.setSince( componentAnnotationContent.getSince() );
// same behaviour as JavaMojoDescriptorExtractor
//parameter.setRequired( ... );
parameter.setEditable( false );
mojoDescriptor.addParameter( parameter );
}
mojoDescriptor.setPluginDescriptor( pluginDescriptor );
mojoDescriptors.add( mojoDescriptor );
}
return mojoDescriptors;
}
protected ExecuteAnnotationContent findExecuteInParentHierarchy( MojoAnnotatedClass mojoAnnotatedClass,
Map<String, MojoAnnotatedClass> mojoAnnotatedClasses )
{
if ( mojoAnnotatedClass.getExecute() != null )
{
return mojoAnnotatedClass.getExecute();
}
String parentClassName = mojoAnnotatedClass.getParentClassName();
if ( StringUtils.isEmpty( parentClassName ) )
{
return null;
}
MojoAnnotatedClass parent = mojoAnnotatedClasses.get( parentClassName );
if ( parent == null )
{
return null;
}
return findExecuteInParentHierarchy( parent, mojoAnnotatedClasses );
}
protected Map<String, ParameterAnnotationContent> getParametersParentHierarchy(
MojoAnnotatedClass mojoAnnotatedClass, Map<String, ParameterAnnotationContent> parameters,
Map<String, MojoAnnotatedClass> mojoAnnotatedClasses )
{
List<ParameterAnnotationContent> parameterAnnotationContents = new ArrayList<ParameterAnnotationContent>();
parameterAnnotationContents =
getParametersParent( mojoAnnotatedClass, parameterAnnotationContents, mojoAnnotatedClasses );
// move to parent first to build the Map
Collections.reverse( parameterAnnotationContents );
Map<String, ParameterAnnotationContent> map =
new HashMap<String, ParameterAnnotationContent>( parameterAnnotationContents.size() );
for ( ParameterAnnotationContent parameterAnnotationContent : parameterAnnotationContents )
{
map.put( parameterAnnotationContent.getFieldName(), parameterAnnotationContent );
}
return map;
}
protected List<ParameterAnnotationContent> getParametersParent( MojoAnnotatedClass mojoAnnotatedClass,
List<ParameterAnnotationContent> parameterAnnotationContents,
Map<String, MojoAnnotatedClass> mojoAnnotatedClasses )
{
parameterAnnotationContents.addAll( mojoAnnotatedClass.getParameters().values() );
String parentClassName = mojoAnnotatedClass.getParentClassName();
if ( parentClassName != null )
{
MojoAnnotatedClass parent = mojoAnnotatedClasses.get( parentClassName );
if ( parent != null )
{
return getParametersParent( parent, parameterAnnotationContents, mojoAnnotatedClasses );
}
}
return parameterAnnotationContents;
}
protected Map<String, ComponentAnnotationContent> getComponentsParentHierarchy(
MojoAnnotatedClass mojoAnnotatedClass, Map<String, ComponentAnnotationContent> components,
Map<String, MojoAnnotatedClass> mojoAnnotatedClasses )
{
List<ComponentAnnotationContent> componentAnnotationContents = new ArrayList<ComponentAnnotationContent>();
componentAnnotationContents =
getComponentParent( mojoAnnotatedClass, componentAnnotationContents, mojoAnnotatedClasses );
// move to parent first to build the Map
Collections.reverse( componentAnnotationContents );
Map<String, ComponentAnnotationContent> map =
new HashMap<String, ComponentAnnotationContent>( componentAnnotationContents.size() );
for ( ComponentAnnotationContent componentAnnotationContent : componentAnnotationContents )
{
map.put( componentAnnotationContent.getFieldName(), componentAnnotationContent );
}
return map;
}
protected List<ComponentAnnotationContent> getComponentParent( MojoAnnotatedClass mojoAnnotatedClass,
List<ComponentAnnotationContent> componentAnnotationContents,
Map<String, MojoAnnotatedClass> mojoAnnotatedClasses )
{
componentAnnotationContents.addAll( mojoAnnotatedClass.getComponents().values() );
String parentClassName = mojoAnnotatedClass.getParentClassName();
if ( parentClassName != null )
{
MojoAnnotatedClass parent = mojoAnnotatedClasses.get( parentClassName );
if ( parent != null )
{
return getComponentParent( parent, componentAnnotationContents, mojoAnnotatedClasses );
}
}
return componentAnnotationContents;
}
protected MavenProject getFromProjectReferences( Artifact artifact, MavenProject project )
{
if ( project.getProjectReferences() == null || project.getProjectReferences().isEmpty() )
{
return null;
}
@SuppressWarnings( "unchecked" ) Collection<MavenProject> mavenProjects =
project.getProjectReferences().values();
for ( MavenProject mavenProject : mavenProjects )
{
if ( StringUtils.equals( mavenProject.getId(), artifact.getId() ) )
{
return mavenProject;
}
}
return null;
}
}