DefaultArchetypeCataloger.groovy

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
    }
}