| package org.apache.maven.tools.plugin.extractor.annotations.scanner; |
| |
| /* |
| * 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.io.BufferedInputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.regex.Pattern; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.plugins.annotations.Component; |
| import org.apache.maven.plugins.annotations.Execute; |
| import org.apache.maven.plugins.annotations.Mojo; |
| import org.apache.maven.plugins.annotations.Parameter; |
| import org.apache.maven.tools.plugin.extractor.ExtractionException; |
| import org.apache.maven.tools.plugin.extractor.annotations.datamodel.ComponentAnnotationContent; |
| import org.apache.maven.tools.plugin.extractor.annotations.datamodel.ExecuteAnnotationContent; |
| import org.apache.maven.tools.plugin.extractor.annotations.datamodel.MojoAnnotationContent; |
| import org.apache.maven.tools.plugin.extractor.annotations.datamodel.ParameterAnnotationContent; |
| import org.apache.maven.tools.plugin.extractor.annotations.scanner.visitors.MojoAnnotationVisitor; |
| import org.apache.maven.tools.plugin.extractor.annotations.scanner.visitors.MojoClassVisitor; |
| import org.apache.maven.tools.plugin.extractor.annotations.scanner.visitors.MojoFieldVisitor; |
| import org.codehaus.plexus.logging.AbstractLogEnabled; |
| import org.codehaus.plexus.util.DirectoryScanner; |
| import org.codehaus.plexus.util.IOUtil; |
| import org.codehaus.plexus.util.StringUtils; |
| import org.codehaus.plexus.util.reflection.Reflector; |
| import org.codehaus.plexus.util.reflection.ReflectorException; |
| import org.objectweb.asm.ClassReader; |
| import org.objectweb.asm.Type; |
| |
| /** |
| * @author Olivier Lamy |
| * @since 3.0 |
| */ |
| @org.codehaus.plexus.component.annotations.Component( role = MojoAnnotationsScanner.class ) |
| public class DefaultMojoAnnotationsScanner |
| extends AbstractLogEnabled |
| implements MojoAnnotationsScanner |
| { |
| // classes with a dash must be ignored |
| private static final Pattern SCANNABLE_CLASS = Pattern.compile( "[^-]+\\.class" ); |
| |
| private Reflector reflector = new Reflector(); |
| |
| public Map<String, MojoAnnotatedClass> scan( MojoAnnotationsScannerRequest request ) |
| throws ExtractionException |
| { |
| Map<String, MojoAnnotatedClass> mojoAnnotatedClasses = new HashMap<String, MojoAnnotatedClass>(); |
| |
| try |
| { |
| for ( Artifact dependency : request.getDependencies() ) |
| { |
| scan( mojoAnnotatedClasses, dependency.getFile(), request.getIncludePatterns(), dependency, true ); |
| } |
| |
| for ( File classDirectory : request.getClassesDirectories() ) |
| { |
| scan( mojoAnnotatedClasses, classDirectory, request.getIncludePatterns(), |
| request.getProject().getArtifact(), false ); |
| } |
| } |
| catch ( IOException e ) |
| { |
| throw new ExtractionException( e.getMessage(), e ); |
| } |
| |
| return mojoAnnotatedClasses; |
| } |
| |
| protected void scan( Map<String, MojoAnnotatedClass> mojoAnnotatedClasses, File source, |
| List<String> includePatterns, Artifact artifact, boolean excludeMojo ) |
| throws IOException, ExtractionException |
| { |
| if ( source == null || ! source.exists() ) |
| { |
| return; |
| } |
| |
| Map<String, MojoAnnotatedClass> scanResult; |
| if ( source.isDirectory() ) |
| { |
| scanResult = scanDirectory( source, includePatterns, artifact, excludeMojo ); |
| } |
| else |
| { |
| scanResult = scanArchive( source, artifact, excludeMojo ); |
| } |
| |
| mojoAnnotatedClasses.putAll( scanResult ); |
| } |
| |
| /** |
| * @param archiveFile |
| * @param artifact |
| * @param excludeMojo for dependencies, we exclude Mojo annotations found |
| * @return annotated classes found |
| * @throws IOException |
| * @throws ExtractionException |
| */ |
| protected Map<String, MojoAnnotatedClass> scanArchive( File archiveFile, Artifact artifact, boolean excludeMojo ) |
| throws IOException, ExtractionException |
| { |
| Map<String, MojoAnnotatedClass> mojoAnnotatedClasses = new HashMap<String, MojoAnnotatedClass>(); |
| |
| ZipInputStream archiveStream = new ZipInputStream( new FileInputStream( archiveFile ) ); |
| |
| String zipEntryName = null; |
| try |
| { |
| |
| for ( ZipEntry zipEntry = archiveStream.getNextEntry(); zipEntry != null; |
| zipEntry = archiveStream.getNextEntry() ) |
| { |
| zipEntryName = zipEntry.getName(); |
| if ( !SCANNABLE_CLASS.matcher( zipEntryName ).matches() ) |
| { |
| continue; |
| } |
| analyzeClassStream( mojoAnnotatedClasses, archiveStream, artifact, excludeMojo ); |
| } |
| } |
| catch ( IllegalArgumentException e ) |
| { |
| // In case of a class with newer specs an IllegalArgumentException can be thrown |
| getLogger().error( "Failed to analyze " + archiveFile.getAbsolutePath() + "!/" + zipEntryName ); |
| |
| throw e; |
| } |
| finally |
| { |
| IOUtil.close( archiveStream ); |
| } |
| |
| return mojoAnnotatedClasses; |
| } |
| |
| /** |
| * @param classDirectory |
| * @param includePatterns |
| * @param artifact |
| * @param excludeMojo for dependencies, we exclude Mojo annotations found |
| * @return annotated classes found |
| * @throws IOException |
| * @throws ExtractionException |
| */ |
| protected Map<String, MojoAnnotatedClass> scanDirectory( File classDirectory, List<String> includePatterns, |
| Artifact artifact, boolean excludeMojo ) |
| throws IOException, ExtractionException |
| { |
| Map<String, MojoAnnotatedClass> mojoAnnotatedClasses = new HashMap<String, MojoAnnotatedClass>(); |
| |
| DirectoryScanner scanner = new DirectoryScanner(); |
| scanner.setBasedir( classDirectory ); |
| scanner.addDefaultExcludes(); |
| if ( includePatterns != null ) |
| { |
| scanner.setIncludes( includePatterns.toArray( new String[includePatterns.size()] ) ); |
| } |
| scanner.scan(); |
| String[] classFiles = scanner.getIncludedFiles(); |
| |
| for ( String classFile : classFiles ) |
| { |
| if ( !SCANNABLE_CLASS.matcher( classFile ).matches() ) |
| { |
| continue; |
| } |
| |
| InputStream is = new BufferedInputStream( new FileInputStream( new File( classDirectory, classFile ) ) ); |
| try |
| { |
| analyzeClassStream( mojoAnnotatedClasses, is, artifact, excludeMojo ); |
| } |
| finally |
| { |
| IOUtil.close( is ); |
| } |
| } |
| return mojoAnnotatedClasses; |
| } |
| |
| private void analyzeClassStream( Map<String, MojoAnnotatedClass> mojoAnnotatedClasses, InputStream is, |
| Artifact artifact, boolean excludeMojo ) |
| throws IOException, ExtractionException |
| { |
| MojoClassVisitor mojoClassVisitor = new MojoClassVisitor( getLogger() ); |
| |
| ClassReader rdr = new ClassReader( is ); |
| rdr.accept( mojoClassVisitor, ClassReader.SKIP_FRAMES | ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG ); |
| |
| analyzeVisitors( mojoClassVisitor ); |
| |
| MojoAnnotatedClass mojoAnnotatedClass = mojoClassVisitor.getMojoAnnotatedClass(); |
| |
| if ( excludeMojo ) |
| { |
| mojoAnnotatedClass.setMojo( null ); |
| } |
| |
| if ( mojoAnnotatedClass != null ) // see MPLUGIN-206 we can have intermediate classes without annotations |
| { |
| if ( getLogger().isDebugEnabled() && mojoAnnotatedClass.hasAnnotations() ) |
| { |
| getLogger().debug( "found MojoAnnotatedClass:" + mojoAnnotatedClass.getClassName() + ":" |
| + mojoAnnotatedClass ); |
| } |
| mojoAnnotatedClass.setArtifact( artifact ); |
| mojoAnnotatedClasses.put( mojoAnnotatedClass.getClassName(), mojoAnnotatedClass ); |
| } |
| } |
| |
| protected void populateAnnotationContent( Object content, MojoAnnotationVisitor mojoAnnotationVisitor ) |
| throws ReflectorException |
| { |
| for ( Map.Entry<String, Object> entry : mojoAnnotationVisitor.getAnnotationValues().entrySet() ) |
| { |
| reflector.invoke( content, entry.getKey(), new Object[] { entry.getValue() } ); |
| } |
| } |
| |
| protected void analyzeVisitors( MojoClassVisitor mojoClassVisitor ) |
| throws ExtractionException |
| { |
| final MojoAnnotatedClass mojoAnnotatedClass = mojoClassVisitor.getMojoAnnotatedClass(); |
| |
| try |
| { |
| // @Mojo annotation |
| MojoAnnotationVisitor mojoAnnotationVisitor = mojoClassVisitor.getAnnotationVisitor( Mojo.class ); |
| if ( mojoAnnotationVisitor != null ) |
| { |
| MojoAnnotationContent mojoAnnotationContent = new MojoAnnotationContent(); |
| populateAnnotationContent( mojoAnnotationContent, mojoAnnotationVisitor ); |
| mojoAnnotatedClass.setMojo( mojoAnnotationContent ); |
| } |
| |
| // @Execute annotation |
| mojoAnnotationVisitor = mojoClassVisitor.getAnnotationVisitor( Execute.class ); |
| if ( mojoAnnotationVisitor != null ) |
| { |
| ExecuteAnnotationContent executeAnnotationContent = new ExecuteAnnotationContent(); |
| populateAnnotationContent( executeAnnotationContent, mojoAnnotationVisitor ); |
| mojoAnnotatedClass.setExecute( executeAnnotationContent ); |
| } |
| |
| // @Parameter annotations |
| List<MojoFieldVisitor> mojoFieldVisitors = mojoClassVisitor.findFieldWithAnnotation( Parameter.class ); |
| for ( MojoFieldVisitor mojoFieldVisitor : mojoFieldVisitors ) |
| { |
| ParameterAnnotationContent parameterAnnotationContent = |
| new ParameterAnnotationContent( mojoFieldVisitor.getFieldName(), mojoFieldVisitor.getClassName() ); |
| if ( mojoFieldVisitor.getMojoAnnotationVisitor() != null ) |
| { |
| populateAnnotationContent( parameterAnnotationContent, |
| mojoFieldVisitor.getMojoAnnotationVisitor() ); |
| } |
| |
| mojoAnnotatedClass.getParameters().put( parameterAnnotationContent.getFieldName(), |
| parameterAnnotationContent ); |
| } |
| |
| // @Component annotations |
| mojoFieldVisitors = mojoClassVisitor.findFieldWithAnnotation( Component.class ); |
| for ( MojoFieldVisitor mojoFieldVisitor : mojoFieldVisitors ) |
| { |
| ComponentAnnotationContent componentAnnotationContent = |
| new ComponentAnnotationContent( mojoFieldVisitor.getFieldName() ); |
| |
| MojoAnnotationVisitor annotationVisitor = mojoFieldVisitor.getMojoAnnotationVisitor(); |
| if ( annotationVisitor != null ) |
| { |
| for ( Map.Entry<String, Object> entry : annotationVisitor.getAnnotationValues().entrySet() ) |
| { |
| String methodName = entry.getKey(); |
| if ( StringUtils.equals( "role", methodName ) ) |
| { |
| Type type = (Type) entry.getValue(); |
| componentAnnotationContent.setRoleClassName( type.getClassName() ); |
| } |
| else |
| { |
| reflector.invoke( componentAnnotationContent, entry.getKey(), |
| new Object[]{ entry.getValue() } ); |
| } |
| } |
| |
| if ( StringUtils.isEmpty( componentAnnotationContent.getRoleClassName() ) ) |
| { |
| componentAnnotationContent.setRoleClassName( mojoFieldVisitor.getClassName() ); |
| } |
| } |
| mojoAnnotatedClass.getComponents().put( componentAnnotationContent.getFieldName(), |
| componentAnnotationContent ); |
| } |
| } |
| catch ( ReflectorException e ) |
| { |
| throw new ExtractionException( e.getMessage(), e ); |
| } |
| } |
| } |
