blob: 0615d1faed9b06850342f676ddf68f938936c230 [file] [log] [blame]
package org.apache.maven.archetype.catalog
import org.codehaus.plexus.logging.AbstractLogEnabled
import org.apache.maven.archetype.artifact.ArchetypeArtifactManager
/**
*
* @author raphaelpieroni
* @plexus.component
*/
class DefaultArchetypeCataloger
extends AbstractLogEnabled
implements ArchetypeCataloger {
/** @plexus.requirement */
private ArchetypeArtifactManager artifactManager
def loadCatalog( String catalogName ) {
def catalog
switch( catalogName ) {
case "internal":
logger.info "Using internal catalog"
catalog = this.class.classLoader.getResourceAsStream( "archetype-catalog.xml" )
break
case "local":
logger.info "Using default local catalog"
catalog = new File( System.getProperty( "user.home" ), ".m2/archetype-catalog.xml" )
break
case "remote":
logger.info "Using default remote catalog"
catalog = "http://repo1.maven.org/maven2/archetype-catalog.xml"
break
case ~"file://.*":
logger.info "Using local catalog $catalogName"
break
case ~"https?://.*":
logger.info "Using remote catalog $catalogName"
catalog = catalogName
break
default: return null
}
if( !catalog ) {
logger.warn "Catalog $catalogName not found"
return null
}
try {
return new XmlSlurper().parse( catalog )
} catch( e ) {
logger.warn "Can not read catalog $catalogName: $e.message"
return
}
}
def archetypeRecursivelyExists( archetype, archetypeDefinitions, localRepository, repositories ) {
def archetypeFile
try {
archetypeFile = artifactManager.getArchetypeFile(
archetype.groupId, archetype.artifactId, archetype.version,
localRepository, repositories )
} catch( e ) {
logger.warn "Archetype ${archetype} not found", e
return false
}
if( artifactManager.isLegacyArchetype( archetypeFile ) ) {
return true
} else {
def recursivelyExists = true
getNestedArchetypes( archetypeFile, archetypeDefinitions, localRepository, repositories ).each { nestedArchetype ->
recursivelyExists = recursivelyExists &&
archetypeRecursivelyExists( nestedArchetype, archetypeDefinitions, localRepository, repositories )
}
return recursivelyExists
}
}
def getNestedArchetypes( archetypeFile, archetypeDefinitions, localRepository, repositories ) {
logger.debug "Searching for nested archetype of ${archetypeFile}"
def descriptor = new XmlSlurper().parse( artifactManager.getFilesetArchetypeDescriptor( archetypeFile ) )
def nestedArchetypes = []
descriptor.modules.module.each {
if( it.@nested.toBoolean() ) {
logger.debug "Module ${it.@artifactId.toString()} is a nested archetype"
nestedArchetypes.add toDefinition( it )
} else {
logger.debug "Module ${it.@artifactId.toString()} is a regular module"
getInnerArchetypes it, archetypeDefinitions, nestedArchetypes, localRepository, repositories
}
}
return nestedArchetypes
}
void getInnerArchetypes( module, archetypes, nestedArchetypes, localRepository, repositories ) {
module.modules.module.each {
if( it.@nested.toBoolean() ) {
logger.debug "Module ${it.@artifactId.toString()} is a nested archetype"
nestedArchetypes.add toDefinition( it )
} else {
logger.debug "Module ${it.@artifactId.toString()} is a regular module"
getInnerArchetypes it, archetypes, nestedArchetypes, localRepository, repositories
}
}
}
def getArchetypesByCatalog( catalogs ) {
if( !catalogs ) return null
def archetypes = [:]
catalogs.split( "," ).each { catalogName ->
def catalog = loadCatalog( catalogName )
if( !catalog ) {
logger.error "Unknown catalog $catalog"
return null
}
catalog.archetypes.archetype.each{
def archetype = [
catalog:catalogName,
groupId:it.groupId.text().toString(),
artifactId:it.artifactId.text().toString(),
version:it.version.text().toString(),
description:it.description.text().toString(),
repository:it.repository.text().toString()]
if( !archetype.repository && (catalogName =~ "(file|https?)://.*" ) ) archetype.repository = catalogName - "archetype-catalog.xml"
archetypes["${archetype.groupId}:${archetype.artifactId}:${archetype.version}".toString()] = archetype
}
}
return archetypes
}
def toDefinition( module ) {
[groupId:module.@archetypeGroupId.text().toString(),
artifactId:module.@archetypeArtifactId.text().toString(),
version:module.@archetypeVersion.text().toString()]
}
def searchArchetype( definition, archetypeCatalogs ) {
def archetype
archetypeCatalogs.each { key, value ->
if( !archetype &&
definition['groupId'] == value['groupId'] &&
definition['artifactId'] == value['artifactId'] &&
(definition['version'] ? definition['version'] == value['version'] : true) ) {
archetype = value
}
}
if( !archetype ) {
log.warn "Archetype ${definition} not found in any catalog"
}
return archetype
}
}