net.flexmojos.oss.generator.SimpleGeneratorMojo Maven / Gradle / Ivy
The newest version!
/**
* Flexmojos is a set of maven goals to allow maven users to compile, optimize and test Flex SWF, Flex SWC, Air SWF and Air SWC.
* Copyright (C) 2008-2012 Marvin Froeder
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see extraOptions;
/**
* Templates used by the generator implementation, check generator docs to see which Templates can be used. Example:
*
*
* <templates>
* <base-enum-template>your-template</base-enum-template>
* </templates>
*
*
* @parameter
*/
private Map templates;
/**
* A '=' separated list of Strings, format: packageToTranslate=packageToReplace
*
* @parameter
*/
private String[] translators;
public void execute()
throws MojoExecutionException
{
setUp();
GeneratorLogger logger = new MavenGeneratorLogger( getLog() );
GenerationRequest request = new GenerationRequest();
request.setClasses( getFilesToGenerator() );
request.setClassLoader( this.initializeClassLoader() );
request.setExtraOptions( extraOptions );
request.setPersistentOutputFolder( outputDirectory );
request.setTemplates( templates );
request.setTransientOutputFolder( baseOutputDirectory );
request.setTranslators( translators );
request.setLogger( logger );
ClassLoader cl = currentThread().getContextClassLoader();
try
{
currentThread().setContextClassLoader( request.getClassLoader() );
Generator generator = generatorFactory.getGenerator( generatorToUse );
generator.generate( request );
}
catch ( GenerationException e )
{
throw new MojoExecutionException( e.getMessage(), e );
}
finally
{
currentThread().setContextClassLoader( cl );
}
}
private void setUp()
throws MojoExecutionException
{
if ( includeJavaClasses == null )
{
includeJavaClasses = new String[] { "*" };
}
if ( !outputDirectory.exists() )
{
outputDirectory.mkdirs();
}
String outputPath = outputDirectory.getAbsolutePath();
if ( !project.getCompileSourceRoots().contains( outputPath ) )
{
project.addCompileSourceRoot( outputPath );
}
if ( !baseOutputDirectory.exists() )
{
baseOutputDirectory.mkdirs();
}
String baseOutputPath = baseOutputDirectory.getAbsolutePath();
if ( !project.getCompileSourceRoots().contains( baseOutputPath ) )
{
project.addCompileSourceRoot( baseOutputPath );
}
if ( translators == null )
{
translators = new String[0];
}
}
private final Map getFilesToGenerator()
throws MojoExecutionException
{
List classpaths = getDirectDependencies();
Map classes = new HashMap();
for ( String fileName : classpaths )
{
File file = new File( fileName ).getAbsoluteFile();
if ( file.isDirectory() )
{
DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir( file );
ds.setIncludes( new String[] { "**/*.class" } );
ds.scan();
for ( String classFileName : ds.getIncludedFiles() )
{
String className = classFileName.replace( File.separatorChar, '.' );
className = className.substring( 0, className.length() - 6 );
if ( matchWildCard( className, includeJavaClasses )
&& !matchWildCard( className, excludeJavaClasses ) )
{
classes.put( className, new File( file, classFileName ) );
}
}
}
else
{
try
{
JarInputStream jar = new JarInputStream( new FileInputStream( file ) );
JarEntry jarEntry;
while ( true )
{
jarEntry = jar.getNextJarEntry();
if ( jarEntry == null )
{
break;
}
String className = jarEntry.getName();
if ( jarEntry.isDirectory() || !className.endsWith( ".class" ) )
{
continue;
}
className = className.replace( '/', '.' );
className = className.substring( 0, className.length() - 6 );
if ( matchWildCard( className, includeJavaClasses )
&& !matchWildCard( className, excludeJavaClasses ) )
{
classes.put( className, file );
}
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error on classes resolve", e );
}
}
}
return classes;
}
private boolean matchWildCard( String className, String... wildCards )
{
if ( wildCards == null )
{
return false;
}
for ( String wildCard : wildCards )
{
if ( className.equals( wildCard ) )
{
return true;
}
if ( SelectorUtils.matchPath( wildCard, className ) )
{
return true;
}
}
return false;
}
private ClassLoader initializeClassLoader()
throws MojoExecutionException
{
List classpaths = getClasspath();
try
{
List classpathsUrls = new ArrayList();
// add all the jars to the new child realm
for ( String path : classpaths )
{
URL url = new File( path ).toURI().toURL();
classpathsUrls.add( url );
}
return new URLClassLoader( classpathsUrls.toArray( new URL[0] ), currentThread().getContextClassLoader() );
}
catch ( MalformedURLException e )
{
throw new MojoExecutionException( "Unable to get dependency URL", e );
}
}
private List getClasspath()
throws MojoExecutionException
{
List classpaths;
try
{
classpaths = project.getCompileClasspathElements();
classpaths.remove( project.getBuild().getOutputDirectory() );
}
catch ( DependencyResolutionRequiredException e )
{
throw new MojoExecutionException( "Failed to find dependencies", e );
}
return classpaths;
}
private List getDirectDependencies()
throws MojoExecutionException
{
List classpaths = new ArrayList();
Set artifacts = project.getDependencyArtifacts();
for ( Artifact artifact : artifacts )
{
if ( "jar".equals( artifact.getType() ) || "maven-plugin".equals( artifact.getType() ) )
{
classpaths.add( artifact.getFile().getAbsolutePath() );
}
}
return classpaths;
}
}