| package org.apache.maven.archetype.generator |
| import org.apache.maven.archetype.ArchetypeGenerationRequest |
| import org.apache.maven.archetype.artifact.ArchetypeArtifactManager |
| import org.codehaus.plexus.logging.AbstractLogEnabled |
| import groovy.text.SimpleTemplateEngine |
| import org.apache.maven.archetype.file.ArchetypeFileResolver |
| import groovy.xml.StreamingMarkupBuilder |
| import groovy.xml.StreamingSAXBuilder |
| import groovy.xml.MarkupBuilder |
| import org.apache.maven.archetype.pom.PomManager |
| import org.apache.maven.model.Model |
| import org.apache.maven.model.Parent |
| import org.gparallelizer.Asynchronizer |
| import org.apache.velocity.runtime.log.LogChute |
| import org.apache.velocity.runtime.RuntimeServices |
| import org.apache.velocity.app.VelocityEngine |
| import org.apache.velocity.VelocityContext |
| |
| /** |
| * |
| * @author raphaelpieroni |
| */ |
| abstract class AbstractFilesetArchetypeGenerator |
| extends AbstractLogEnabled |
| implements FilesetArchetypeGenerator, LogChute { |
| |
| /** @plexus.requirement */ |
| ArchetypeArtifactManager archetypeArtifactManager |
| /** @plexus.requirement */ |
| ArchetypeFileResolver archetypeFileResolver |
| /** @plexus.requirement */ |
| PomManager pomManager |
| |
| def templateEngine = new SimpleTemplateEngine() |
| |
| void generateProject( ArchetypeGenerationRequest request ){ |
| def archetypeDescriptor = loadArchetypeDescriptor( request.archetypeFile ) |
| def archetypeResources = archetypeArtifactManager.getFilesetArchetypeResources( request.archetypeFile ) |
| def archetypeZipFile = archetypeArtifactManager.getArchetypeZipFile( request.archetypeFile ) |
| def velocity = getVelocityEngine( request.archetypeFile ) |
| def basedirPom = new File( request.outputDirectory, 'pom.xml' ) |
| def filterProperties = prepareFilterProperties( request ) |
| |
| logger.error"RESOURCES${archetypeResources}" |
| logger.error"this=${this.dump()}" |
| if( !archetypeDescriptor.@partial.toBoolean() ) { |
| logger.info "Processing complete archetype: ${archetypeDescriptor.@name}" |
| def projectOutputDirectory = new File( request.outputDirectory, filterProperties.artifactId ) |
| |
| if( new File( projectOutputDirectory, 'pom.xml' ).exists() ) throw new Exception( "A project already exists in ${projectOutputDirectory}" ) |
| |
| def processRequest = [moduleOffset:'', |
| zipModuleOffset:'', |
| archetypeDescriptor:archetypeDescriptor, |
| filterProperties:filterProperties, |
| archetypeResources:archetypeResources, |
| archetypeZipFile:archetypeZipFile, |
| outputDirectory:projectOutputDirectory, |
| updirPom:basedirPom, |
| archetypes:request.archetypes, |
| velocity:velocity |
| ] |
| processProject processRequest |
| } else { |
| logger.error "Processing partial archetype: ${archetypeDescriptor.@name} in ${request.outputDirectory}" |
| |
| if( !basedirPom.exists() ) throw new Exception( "No project to modify in ${request.outputDirectory}" ) |
| |
| def processRequest = [moduleOffset:'', |
| zipModuleOffset:'', |
| archetypeDescriptor:archetypeDescriptor, |
| filterProperties:filterProperties, |
| archetypeResources:archetypeResources, |
| archetypeZipFile:archetypeZipFile, |
| outputDirectory:request.outputDirectory, |
| archetypes:request.archetypes, |
| velocity:velocity |
| ] |
| processPartialProject processRequest |
| |
| } |
| } |
| |
| abstract def loadArchetypeDescriptor( File archetypeFile ) |
| |
| def getVelocityEngine( File jarFile ){ |
| def engine = new VelocityEngine() |
| engine.setProperty VelocityEngine.RUNTIME_LOG_LOGSYSTEM, this |
| engine.setProperty VelocityEngine.RESOURCE_LOADER, 'jar' |
| engine.setProperty 'jar.resource.loader.class', 'org.apache.velocity.runtime.resource.loader.JarResourceLoader' |
| engine.setProperty 'jar.resource.loader.path', "jar:file:${jarFile.path}".toString() |
| engine.init() |
| return engine |
| } |
| void init(RuntimeServices rsvc) {/*println"init ${rsvc}"*/} |
| void log(int level, String message) {/*println"log ${level} ${message}"*/} |
| void log(int level, String message, Throwable t) {/*println "log ${level} ${message} ${t}"*/} |
| boolean isLevelEnabled(int level) {/*println"isLevelEnabled ${level}";*/ return false } |
| |
| |
| def prepareFilterProperties( request ) { |
| logger.error"props ${request.generationFilterProperties}" |
| def filters = request.generationFilterProperties |
| if( !filters.rootArtifactId ) { |
| filters.rootArtifactId = filters.artifactId |
| } |
| filters.upArtifactId = filters.artifactId |
| filters.'package' = filters.packageName |
| |
| return filters |
| } |
| |
| def processPartialProject( processRequest ) { |
| def pom = mergePom( processRequest ) |
| processFilesets processRequest |
| processModules processRequest, pom |
| } |
| |
| def processProject( processRequest ) { |
| processRequest.outputDirectory.mkdirs() |
| def pom = processPom( processRequest ) |
| processFilesets processRequest |
| processModules processRequest, pom |
| } |
| def processModules( processRequest, pom ) { |
| def moduleOffset = processRequest.moduleOffset |
| def zipModuleOffset = processRequest.zipModuleOffset |
| def outputDirectory = processRequest.outputDirectory |
| def filterProperties = processRequest.filterProperties |
| def upArtifactId = processRequest.filterProperties.artifactId |
| processRequest.archetypeDescriptor.modules.module.each { module -> |
| // println"${Thread.currentThread().name} ${module?.dump()}" |
| def artifactId = getOutputName( module.@artifactId.text(), processRequest.filterProperties ) |
| def moduleRequest = processRequest.clone() |
| moduleRequest.moduleOffset = "${moduleOffset ? moduleOffset + '/' : ''}${artifactId}" |
| moduleRequest.zipModuleOffset = "${zipModuleOffset ? zipModuleOffset + '/' : ''}${module.@artifactId.text()}" |
| moduleRequest.outputDirectory = new File( outputDirectory, artifactId ) |
| moduleRequest.archetypeDescriptor = module |
| moduleRequest.updirPom = pom |
| // println"${Thread.currentThread().name} artifactId ${artifactId}" |
| // println"${Thread.currentThread().name} moduleRequest.moduleOffset ${moduleRequest.moduleOffset}" |
| // println"${Thread.currentThread().name} moduleRequest.outputDirectory ${moduleRequest.outputDirectory}" |
| |
| def moduleFilter = filterProperties.clone() |
| moduleFilter.upArtifactId = upArtifactId |
| moduleFilter.artifactId = artifactId |
| moduleRequest.filterProperties = moduleFilter |
| |
| if(!module.@nested.toBoolean()){ |
| logger.warn "Processing module ${module.@artifactId.text()} in ${moduleRequest.outputDirectory}" |
| processProject moduleRequest |
| } else { |
| def archetype = processRequest.archetypes."${module.@archetypeGroupId.toString()}:${module.@archetypeArtifactId.toString()}:${module.@archetypeVersion.toString()}" |
| |
| logger.warn"Processing nested archetype ${module.@archetypeArtifactId.toString()} in ${outputDirectory}" |
| def request = new ArchetypeGenerationRequest() |
| request.archetypes = moduleRequest.archetypes |
| request.archetypeFile = archetype.file |
| request.outputDirectory = outputDirectory |
| moduleRequest.filterProperties.remove 'upArtifactId' |
| moduleRequest.filterProperties.remove 'rootArtifactId' |
| request.generationFilterProperties = moduleRequest.filterProperties |
| // request.archetypes = moduleRequest.archetypes |
| // request.archetypes = moduleRequest.archetypes |
| // request.archetypes = moduleRequest.archetypes |
| archetype.generator.generateProject request |
| } |
| } |
| } |
| |
| def mergePom( processRequest ) { |
| def pomFile = new File( processRequest.outputDirectory, 'pom.xml' ) |
| Model initialModel = pomManager.loadModel( pomFile ) |
| |
| StringWriter writer = new StringWriter() |
| processRequest.velocity.mergeTemplate( archetypeFileResolver.getResourcePath( processRequest.zipModuleOffset, '', 'pom.xml' ), new VelocityContext( processRequest.filterProperties ), writer ) |
| def slurpedPom = new XmlSlurper().parseText( writer.toString() ) |
| //logger.error "${Thread.currentThread().name} INITIAL POM ${pomFile}" |
| def pomBuilder = new StreamingMarkupBuilder().bind { |
| mkp.xmlDeclaration() |
| mkp.declareNamespace '':'http://maven.apache.org/POM/4.0.0' |
| mkp.yield slurpedPom |
| } |
| Model newModel = pomManager.loadModel( pomBuilder.toString() ) |
| |
| pomManager.writeModel pomFile, pomManager.mergeModel( initialModel, newModel ) |
| |
| return pomFile |
| } |
| |
| def processPom( processRequest ) { |
| |
| def pomFile = new File( processRequest.outputDirectory, 'pom.xml' ) |
| //logger.error "${Thread.currentThread().name} Processing POM ${pomFile}" |
| pomFile.parentFile.mkdirs() |
| pomFile.withWriter { |
| it.write archetypeFileResolver.getFile( |
| processRequest.zipModuleOffset, '', 'pom.xml', processRequest.archetypeZipFile |
| ).newReader().text |
| } |
| |
| // def initialPomFile = archetypeFileResolver.getFile( |
| // processRequest.zipModuleOffset, '', 'pom.xml', processRequest.archetypeZipFile |
| // ).newReader() |
| // def filteredPom = templateEngine.createTemplate( initialPomFile ). |
| // make( processRequest.filterProperties ) |
| StringWriter writer = new StringWriter() |
| processRequest.velocity.mergeTemplate( archetypeFileResolver.getResourcePath( processRequest.zipModuleOffset, '', 'pom.xml' ), new VelocityContext( processRequest.filterProperties ), writer ) |
| def slurpedPom = new XmlSlurper().parseText( writer.toString() ) |
| //logger.error "${Thread.currentThread().name} INITIAL POM ${pomFile}" |
| def pomBuilder = new StreamingMarkupBuilder().bind { |
| mkp.xmlDeclaration() |
| mkp.declareNamespace '':'http://maven.apache.org/POM/4.0.0' |
| mkp.yield slurpedPom |
| } |
| Model newModel = pomManager.loadModel( pomBuilder.toString() ) |
| |
| if( processRequest.updirPom?.exists() ) { |
| Model parentModel = pomManager.loadModel( processRequest.updirPom ) |
| if( !newModel.parent ) { |
| newModel.parent = new Parent() |
| newModel.parent.groupId = parentModel.groupId |
| newModel.parent.artifactId = parentModel.artifactId |
| newModel.parent.version = parentModel.version |
| } |
| //logger.error "MODULES=${parentModel.modules}" |
| if( !parentModel.modules.contains(newModel.artifactId) ) { |
| parentModel.modules << newModel.artifactId |
| pomManager.writeModel processRequest.updirPom, parentModel |
| } |
| } |
| |
| pomManager.writeModel pomFile, newModel |
| |
| return pomFile |
| } |
| |
| |
| def processFilesets( processRequest ) { |
| |
| //logger.error "archetypeDescriptor ${processRequest.archetypeDescriptor.fileSets.dump()}" |
| //logger.error "archetypeDescriptor ${processRequest.archetypeDescriptor.fileSets.fileSet.dump()}" |
| |
| // Asynchronizer.withAsynchronizer { |
| processRequest.archetypeDescriptor.fileSets.fileSet.each/*Async*/ { fileset -> |
| //println"A" |
| //logger.error"Thread ${Thread.currentThread().name}" |
| // logger.error"A${fileset.@filtered.toBoolean()}" |
| // logger.error"B${fileset.@packaged.toBoolean()}" |
| // logger.error"C${fileset.directory}" |
| // logger.error"D${fileset.includes.include.dump()}" |
| |
| def filesetResources = archetypeFileResolver.getFiles( |
| processRequest.zipModuleOffset, fileset, processRequest.archetypeResources ) |
| //println"B" |
| //logger.error "FILESET== ${filesetResources}" |
| |
| def filesetRequest = processRequest.clone() |
| filesetRequest.filesetResources = filesetResources |
| filesetRequest.packaged = fileset.@packaged.toBoolean() |
| filesetRequest.filesetDirectory = fileset.directory.text().toString() |
| filesetRequest.engine = fileset.@engine?.toString() |
| |
| //println"C" |
| if( fileset.@filtered.toBoolean() ) |
| processFileset filesetRequest |
| else |
| copyFileset filesetRequest |
| } |
| // } |
| } |
| |
| def processFileset( filesetRequest ) { |
| |
| println"\n\n\n\n\nD" |
| logger.error "Processing Fileset ${filesetRequest.filesetDirectory}" |
| // Asynchronizer.withAsynchronizer { |
| VelocityContext context |
| if( 'velocity' == filesetRequest.engine ) context = new VelocityContext( filesetRequest.filterProperties ) |
| |
| filesetRequest.filesetResources.each { resource -> |
| println"E ${resource}" |
| def resourceFile = archetypeFileResolver.getFile( |
| filesetRequest.zipModuleOffset, filesetRequest.filesetDirectory, resource, filesetRequest.archetypeZipFile |
| ).newReader() |
| def text |
| if( 'groovy' == filesetRequest.engine ) { |
| text = templateEngine.createTemplate( resourceFile ).make( filesetRequest.filterProperties ) |
| println"F" |
| } else { |
| StringWriter writer = new StringWriter() |
| filesetRequest.velocity.mergeTemplate( archetypeFileResolver.getResourcePath( filesetRequest.zipModuleOffset, filesetRequest.filesetDirectory, resource ), context, writer ) |
| text = writer.toString() |
| println"G" |
| } |
| logger.error "RESULT=\n${text}" |
| def path = getPath( filesetRequest.moduleOffset, |
| filesetRequest.filesetDirectory, |
| filesetRequest.packaged, |
| filesetRequest.filterProperties, |
| resource ) |
| def outName = getOutputName( path, filesetRequest.filterProperties ) |
| //templateEngine.createTemplate( path ).make( filesetRequest.filterProperties ) |
| def outputFile = new File( filesetRequest.outputDirectory, outName.toString() ) |
| logger.error "outputFile=${outputFile}" |
| outputFile.parentFile.mkdirs() |
| outputFile.withWriter { |
| it.write text |
| } |
| // } |
| } |
| println"I" |
| } |
| |
| def copyFileset( filesetRequest ) { |
| |
| //logger.error "Processing Fileset ${filesetRequest.filesetDirectory}" |
| // Asynchronizer.withAsynchronizer { |
| filesetRequest.filesetResources.each { resource -> |
| def resourceFile = archetypeFileResolver.getFile( |
| filesetRequest.zipModuleOffset, filesetRequest.filesetDirectory, resource, filesetRequest.archetypeZipFile ) |
| def path = getPath( filesetRequest.moduleOffset, |
| filesetRequest.filesetDirectory, |
| filesetRequest.packaged, |
| filesetRequest.filterProperties, |
| resource ) |
| def outName = getOutputName( path, filesetRequest.filterProperties ) |
| //templateEngine.createTemplate( path ).make( filesetRequest.filterProperties ) |
| def outputFile = new File( filesetRequest.outputDirectory, outName.toString() ) |
| // logger.error "outputFile=${outputFile}" |
| outputFile.parentFile.mkdirs() |
| outputFile.withOutputStream { |
| it << resourceFile |
| } |
| } |
| // } |
| } |
| |
| def getPath( moduleOffset, filesetDirectory, packaged, filterProperties, resource ) { |
| def offset = moduleOffset ? moduleOffset + '/' : '' |
| def packageName = packaged ? filterProperties.packageName.replace( '.', '/' ) + '/' : '' |
| return "${offset}${filesetDirectory}/${packageName}${resource}" |
| } |
| |
| |
| def getOutputName( path, filterProperties ) { |
| def outputName = path.toString() |
| def log = "${Thread.currentThread().name} ${outputName}" |
| filterProperties.each { key, value -> |
| outputName = outputName.replaceAll( /\$\{${key}}/, value.toString() ) |
| log+= " (${key}=${value.toString()})-> ${outputName}" |
| } |
| // println "${log} = ${outputName}" |
| return outputName |
| } |
| |
| |
| } |
| |
