maven-archetype-plugin/src/main/java/org/apache/maven/archetype/ui/creation/DefaultArchetypeCreationConfigurator.java

package org.apache.maven.archetype.ui.creation;

/*
 * 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.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import org.apache.maven.archetype.common.ArchetypeFilesResolver;
import org.apache.maven.archetype.common.Constants;
import org.apache.maven.archetype.exception.ArchetypeNotConfigured;
import org.apache.maven.archetype.exception.ArchetypeNotDefined;
import org.apache.maven.archetype.exception.TemplateCreationException;
import org.apache.maven.archetype.ui.ArchetypeConfiguration;
import org.apache.maven.archetype.ui.ArchetypeDefinition;
import org.apache.maven.archetype.ui.ArchetypeFactory;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.components.interactivity.PrompterException;
import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.util.StringUtils;

@Component( role = ArchetypeCreationConfigurator.class, hint = "default" )
public class DefaultArchetypeCreationConfigurator
    extends AbstractLogEnabled
    implements ArchetypeCreationConfigurator
{
    @Requirement
    private ArchetypeCreationQueryer archetypeCreationQueryer;

    @Requirement
    private ArchetypeFactory archetypeFactory;

    @Requirement
    private ArchetypeFilesResolver archetypeFilesResolver;

    @Override
    public Properties configureArchetypeCreation( MavenProject project, Boolean interactiveMode,
                                                  Properties commandLineProperties, File propertyFile,
                                                  List<String> languages )
        throws IOException, ArchetypeNotDefined, ArchetypeNotConfigured, PrompterException, TemplateCreationException
    {
        Properties properties = initialiseArchetypeProperties( commandLineProperties, propertyFile );

        ArchetypeDefinition archetypeDefinition = archetypeFactory.createArchetypeDefinition( properties );

        if ( !archetypeDefinition.isDefined() )
        {
            archetypeDefinition = defineDefaultArchetype( project, properties );
        }

        ArchetypeConfiguration archetypeConfiguration =
            archetypeFactory.createArchetypeConfiguration( project, archetypeDefinition, properties );

        String resolvedPackage = archetypeFilesResolver.resolvePackage( project.getBasedir(), languages );

        if ( !archetypeConfiguration.isConfigured() )
        {
            archetypeConfiguration =
                defineDefaultConfiguration( project, archetypeDefinition, resolvedPackage, properties );
        }

        if ( interactiveMode.booleanValue() )
        {
            getLogger().debug( "Entering interactive mode" );

            boolean confirmed = false;
            while ( !confirmed )
            {
                if ( !archetypeDefinition.isDefined() )// <editor-fold text="...">
                {
                    getLogger().debug( "Archetype is yet not defined" );
                    if ( !archetypeDefinition.isGroupDefined() )
                    {
                        getLogger().debug( "Asking for archetype's groupId" );
                        archetypeDefinition.setGroupId( archetypeCreationQueryer.getArchetypeGroupId( project.getGroupId() ) );
                    }
                    if ( !archetypeDefinition.isArtifactDefined() )
                    {
                        getLogger().debug( "Asking for archetype's artifactId" );
                        archetypeDefinition.setArtifactId( archetypeCreationQueryer.getArchetypeArtifactId( project.getArtifactId()
                            + Constants.ARCHETYPE_SUFFIX ) );
                    }
                    if ( !archetypeDefinition.isVersionDefined() )
                    {
                        getLogger().debug( "Asking for archetype's version" );
                        archetypeDefinition.setVersion( archetypeCreationQueryer.getArchetypeVersion( project.getVersion() ) );
                    }

                    archetypeFactory.updateArchetypeConfiguration( archetypeConfiguration, archetypeDefinition );
                } // </editor-fold>

                if ( !archetypeConfiguration.isConfigured() )// <editor-fold text="...">
                {
                    getLogger().debug( "Archetype is not yet configured" );
                    if ( !archetypeConfiguration.isConfigured( Constants.GROUP_ID ) )
                    {
                        getLogger().debug( "Asking for project's groupId" );
                        archetypeConfiguration.setProperty(
                                                            Constants.GROUP_ID,
                                                            archetypeCreationQueryer.getGroupId( archetypeConfiguration.getDefaultValue( Constants.GROUP_ID ) ) );
                    }
                    if ( !archetypeConfiguration.isConfigured( Constants.ARTIFACT_ID ) )
                    {
                        getLogger().debug( "Asking for project's artifactId" );
                        archetypeConfiguration.setProperty(
                                                            Constants.ARTIFACT_ID,
                                                            archetypeCreationQueryer.getArtifactId( archetypeConfiguration.getDefaultValue( Constants.ARTIFACT_ID ) ) );
                    }
                    if ( !archetypeConfiguration.isConfigured( Constants.VERSION ) )
                    {
                        getLogger().debug( "Asking for project's version" );
                        archetypeConfiguration.setProperty(
                                                            Constants.VERSION,
                                                            archetypeCreationQueryer.getVersion( archetypeConfiguration.getDefaultValue( Constants.VERSION ) ) );
                    }
                    if ( !archetypeConfiguration.isConfigured( Constants.PACKAGE ) )
                    {
                        getLogger().debug( "Asking for project's package" );
                        archetypeConfiguration.setProperty(
                                                            Constants.PACKAGE,
                                                            archetypeCreationQueryer.getPackage( StringUtils.isEmpty( resolvedPackage ) ? archetypeConfiguration.getDefaultValue( Constants.PACKAGE )
                                                                            : resolvedPackage ) );
                    }
                } // </editor-fold>

                boolean stopAddingProperties = false;
                while ( !stopAddingProperties )
                {
                    getLogger().debug( "Asking for another required property" );
                    stopAddingProperties = !archetypeCreationQueryer.askAddAnotherProperty();

                    if ( !stopAddingProperties )
                    {
                        getLogger().debug( "Asking for required property key" );

                        String propertyKey = archetypeCreationQueryer.askNewPropertyKey();
                        getLogger().debug( "Asking for required property value" );

                        String replacementValue =
                            archetypeCreationQueryer.askReplacementValue(
                                                                          propertyKey,
                                                                          archetypeConfiguration.getDefaultValue( propertyKey ) );
                        archetypeConfiguration.setDefaultProperty( propertyKey, replacementValue );
                        archetypeConfiguration.setProperty( propertyKey, replacementValue );
                    }
                }

                getLogger().debug( "Asking for configuration confirmation" );
                if ( archetypeCreationQueryer.confirmConfiguration( archetypeConfiguration ) )
                {
                    confirmed = true;
                }
                else
                {
                    getLogger().debug( "Reseting archetype's definition and configuration" );
                    archetypeConfiguration.reset();
                    archetypeDefinition.reset();
                }
            } // end while
        }
        else
        {
            getLogger().debug( "Entering batch mode" );
            if ( !archetypeDefinition.isDefined() )
            {
                throw new ArchetypeNotDefined( "The archetype is not defined" );
            }
            else if ( !archetypeConfiguration.isConfigured() )
            {
                throw new ArchetypeNotConfigured( "The archetype is not configured", null );
            }
        } // end if

        return archetypeConfiguration.toProperties();
    }

    private ArchetypeDefinition defineDefaultArchetype( MavenProject project, Properties properties )
    {
        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARCHETYPE_GROUP_ID ) ) )
        {
            properties.setProperty( Constants.ARCHETYPE_GROUP_ID, project.getGroupId() );
        }
        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARCHETYPE_ARTIFACT_ID ) ) )
        {
            properties.setProperty( Constants.ARCHETYPE_ARTIFACT_ID, project.getArtifactId()
                + Constants.ARCHETYPE_SUFFIX );
        }
        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARCHETYPE_VERSION ) ) )
        {
            properties.setProperty( Constants.ARCHETYPE_VERSION, project.getVersion() );
        }

        return archetypeFactory.createArchetypeDefinition( properties );
    }

    private ArchetypeConfiguration defineDefaultConfiguration( MavenProject project,
                                                               ArchetypeDefinition archetypeDefinition,
                                                               String resolvedPackage, Properties properties )
    {
        if ( StringUtils.isEmpty( properties.getProperty( Constants.GROUP_ID ) ) )
        {
            getLogger().info( "Setting default groupId: " + project.getGroupId() );
            properties.setProperty( Constants.GROUP_ID, project.getGroupId() );
        }

        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARTIFACT_ID ) ) )
        {
            getLogger().info( "Setting default artifactId: " + project.getArtifactId() );
            properties.setProperty( Constants.ARTIFACT_ID, project.getArtifactId() );
        }

        if ( StringUtils.isEmpty( properties.getProperty( Constants.VERSION ) ) )
        {
            getLogger().info( "Setting default version: " + project.getVersion() );
            properties.setProperty( Constants.VERSION, project.getVersion() );
        }

        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARCHETYPE_GROUP_ID ) ) )
        {
            getLogger().info( "Setting default archetype's groupId: " + project.getGroupId() );
            properties.setProperty( Constants.ARCHETYPE_GROUP_ID, project.getGroupId() );
        }

        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARCHETYPE_ARTIFACT_ID ) ) )
        {
            getLogger().info( "Setting default archetype's artifactId: " + project.getArtifactId() );
            properties.setProperty( Constants.ARCHETYPE_ARTIFACT_ID, project.getArtifactId()
                + Constants.ARCHETYPE_SUFFIX );
        }

        if ( StringUtils.isEmpty( properties.getProperty( Constants.ARCHETYPE_VERSION ) ) )
        {
            getLogger().info( "Setting default archetype's version: " + project.getVersion() );
            properties.setProperty( Constants.ARCHETYPE_VERSION, project.getVersion() );
        }

        if ( StringUtils.isEmpty( properties.getProperty( Constants.PACKAGE /*, properties.getProperty ( Constants.PACKAGE_NAME ) */ ) ) )
        {
            if ( StringUtils.isEmpty( resolvedPackage ) )
            {
                resolvedPackage = project.getGroupId();
            }
            getLogger().info( "Setting default package: " + resolvedPackage );
            /* properties.setProperty ( Constants.PACKAGE_NAME, resolvedPackage ); */
            properties.setProperty( Constants.PACKAGE, resolvedPackage );
        }

        return archetypeFactory.createArchetypeConfiguration( project, archetypeDefinition, properties );
    }

    public void readProperties( Properties properties, File propertyFile )
        throws IOException
    {
        getLogger().debug( "Reading property file " + propertyFile );

        try ( InputStream is = new FileInputStream( propertyFile ) ) 
        {
            properties.load( is );

            getLogger().debug( "Read " + properties.size() + " properties" );
        }
    }

    public void writeProperties( Properties properties, File propertyFile )
        throws IOException
    {
        Properties storedProperties = new Properties();
        try
        {
            readProperties( storedProperties, propertyFile );
        }
        catch ( FileNotFoundException ex )
        {
            getLogger().debug( "Property file not found. Creating a new one" );
        }

        getLogger().debug( "Adding " + properties.size() + " properties" );

        Iterator<?> propertiesIterator = properties.keySet().iterator();
        while ( propertiesIterator.hasNext() )
        {
            String propertyKey = (String) propertiesIterator.next();
            storedProperties.setProperty( propertyKey, properties.getProperty( propertyKey ) );
        }

        try ( OutputStream os = new FileOutputStream( propertyFile ) )
        {
            storedProperties.store( os, "" );

            getLogger().debug( "Stored " + storedProperties.size() + " properties" );
        }
    }

    private Properties initialiseArchetypeProperties( Properties commandLineProperties, File propertyFile )
        throws IOException
    {
        Properties properties = new Properties();

        if ( propertyFile != null )
        {
            try
            {
                readProperties( properties, propertyFile );
            }
            catch ( FileNotFoundException ex )
            {
                getLogger().debug( "archetype.properties does not exist" );
            }
        }

        return properties;
    }

}