AbstractInvokerMojo.java

package com.soebes.maven.plugins.iterator;

/*
 * 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.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.invoker.DefaultInvocationRequest;
import org.apache.maven.shared.invoker.InvocationRequest;

/**
 * @author Karl-Heinz Marbaise <a href="mailto:khmarbaise@apache.org">khmarbaise@apache.org</a>
 */
public abstract class AbstractInvokerMojo
    extends AbstractIteratorMojo
{

    /**
     * The list of goals which will be called during each invocation of Maven. TODO: Change the name, cause we are
     * calling life cycle phases instead of goal but we can if we like things like site:site ?
     */
    @Parameter
    private List<String> goals = Collections.singletonList( "clean" );

    /**
     * This will set <code>--batch-mode</code>
     */
    @Parameter( defaultValue = "false" )
    private boolean interactive;

    /**
     * This will <code>--also-make</code>
     */
    @Parameter( defaultValue = "false" )
    private boolean alsoMake;

    /**
     * This will activate <code>--also-make-dependents</code>
     */
    @Parameter( defaultValue = "false" )
    private boolean alsoMakeDependents;

    /**
     * Sets the path to the base directory of the POM for the Maven invocation. If {@link #getPomFile()} does not return
     * <code>null</code>, this setting only affects the working directory for the Maven invocation. Here you can use the
     * placeholder like: EXAMPLE
     */
    @Parameter
    private File baseDirectory;

    /**
     * <code>-Ddebug=true</code>
     */
    @Parameter( defaultValue = "false" )
    private boolean debug;

    /**
     * The valid values are {@link InvocationRequest#REACTOR_FAIL_AT_END}, {@link InvocationRequest#REACTOR_FAIL_FAST},
     * {@link InvocationRequest#REACTOR_FAIL_NEVER}.
     * 
     * @see {@link InvocationRequest#REACTOR_FAIL_AT_END}, {@link InvocationRequest#REACTOR_FAIL_FAST},
     *      {@link InvocationRequest#REACTOR_FAIL_NEVER}
     * @FIXME: Check if we need to create a setter which checks the valid values
     */
    @Parameter( defaultValue = InvocationRequest.REACTOR_FAIL_FAST )
    private String failureBehaviour;

    /**
     * Sets the checksum mode of the Maven invocation. Equivalent of {@code -c} or {@code --lax-checksums}, {@code -C}
     * or {@code --strict-checksums}
     * 
     * @param globalChecksumPolicy The checksum mode, must be one of {@link InvocationRequest#CHECKSUM_POLICY_WARN} and
     *            {@link InvocationRequest#CHECKSUM_POLICY_FAIL}.
     */
    @Parameter( defaultValue = InvocationRequest.CHECKSUM_POLICY_WARN )
    private String globalChecksumPolicy;

    /**
     * The path to the global settings for the Maven invocation or <code>null</code> to load the global settings from
     * the default location.
     */
    @Parameter
    private File globalSettingsFile;

    /**
     * If <code>null</code> the default location from <code>settings.xml</code> will be used.
     */
    @Parameter
    private File localRepositoryDirectory;

    /**
     * If <code>null</code>.
     */
    @Parameter
    private String mavenOpts;

    /**
     * If true <code>--no-plugin-updates</code> will be used.
     */
    @Parameter
    private boolean nonPluginUpdates;

    /**
     * <code>true</code> Maven will be executed in off-line mode ( <code>--offline</code>).
     */
    @Parameter
    private boolean offline;

    /**
     * The list of profiles.
     */
    @Parameter
    private List<String> profiles;

    /**
     * Sets the reactor project list. Equivalent of {@code -pl} or {@code --projects} projects the reactor project list
     */
    @Parameter
    private List<String> projects;

    /**
     * Sets the system properties for the Maven invocation, may be <code>null</code> if not set.
     */
    @Parameter
    private Properties properties;

    /**
     * Sets the recursion behavior of a reactor invocation. <em>Inverse</em> equivalent of {@code -N} and
     * {@code --non-recursive}
     */
    @Parameter( defaultValue = "false" )
    private boolean recursive;

    /**
     * Specify the reactor project to resume from.
     */
    @Parameter
    private String resumeFrom;

    /**
     * Indicates whether the environment variables of the current process should be propagated to the Maven invocation.
     * By default, the current environment variables are inherited by the new Maven invocation.
     */
    @Parameter( defaultValue = "true" )
    private boolean shellEnvironmentInherited;

    /**
     * Gets the exception output mode of the Maven invocation. By default, Maven will not print stack traces of build
     * exceptions.
     */
    @Parameter( defaultValue = "false" )
    private boolean showErrors;

    /**
     * The show version behaviour {@code -V} option.
     */
    @Parameter( defaultValue = "false" )
    private boolean showVersion;

    /**
     * {@code -T} option of Maven.
     */
    @Parameter
    protected String threads;

    /**
     * Set the path to the custom toolchains file
     */
    @Parameter
    private File toolchains;

    /**
     * Indicates whether Maven should enforce an update check for plugins and snapshots. By default, no update check is
     * performed {@code --update-snapshots}.
     */
    @Parameter( defaultValue = "false" )
    private boolean updateSnapshots;

    /**
     * Sets the path to the user settings for the Maven invocation.
     */
    @Parameter
    private File userSettings;
        
    private File getBaseDirectoryAfterPlaceHolderIsReplaced( String currentValue )
    {
        File baseDir = getBaseDirectory();
        if ( baseDir != null && baseDir.toString().contains( getPlaceHolder() ) )
        {
            baseDir = new File( baseDir.toString().replaceAll( getPlaceHolder(), currentValue ) );
        }
        return baseDir;
    }

    private List<String> replacePlaceholderInElements( String currentValue, List<String> goals )
    {
        List<String> result = new ArrayList<String>();
        for ( String string : goals )
        {
            if ( string.contains( getPlaceHolder() ) )
            {
                result.add( string.replaceAll( getPlaceHolder(), currentValue ) );
            }
            else
            {
                result.add( string );
            }
        }
        return result;
    }

    private List<String> getGoalsAfterPlaceHolderIsReplaced( String currentValue )
    {
        List<String> goals = getGoals();
        if ( goals == null )
        {
            return null;
        }

        List<String> result = replacePlaceholderInElements( currentValue, goals );
        return result;
    }

    private List<String> getProfilesAfterPlaceHolderIsReplaced( String currentValue )
    {
        List<String> profiles = getProfiles();
        if ( profiles == null )
        {
            return null;
        }

        List<String> result = replacePlaceholderInElements( currentValue, profiles );
        return result;
    }

    private List<String> getProjectsAfterPlaceHolderIsReplaced( String currentValue )
    {
        List<String> projects = getProjects();
        if ( projects == null )
        {
            return null;
        }

        List<String> result = replacePlaceholderInElements( currentValue, projects );
        return result;
    }

    protected InvocationRequest createAndConfigureAnInvocationRequest( ItemWithProperties currentValue )
    {
        InvocationRequest request = new DefaultInvocationRequest();

        request.setAlsoMake( isAlsoMake() );
        request.setAlsoMakeDependents( isAlsoMakeDependents() );
        request.setDebug( isDebug() );
        request.setFailureBehavior( getFailureBehaviour() );
        request.setGlobalChecksumPolicy( getGlobalChecksumPolicy() );
        request.setGlobalSettingsFile( getGlobalSettingsFile() );
        request.setInteractive( isInteractive() );

        request.setLocalRepositoryDirectory( getLocalRepositoryDirectory() );
        request.setMavenOpts( getMavenOpts() );
        request.setNonPluginUpdates( isNonPluginUpdates() );
        request.setOffline( isOffline() );

//        request.setProperties( properties )
//        ;
        // @TODO: Think about it.
        // request.setPomFile(pomFile);
        // @TODO: Think about it.
        // request.setPomFileName(pomFilename);

        // The following parameter do make sense to use a placeholder
        // base directory
        // cd @item@
        // mvn clean package
        request.setBaseDirectory( getBaseDirectoryAfterPlaceHolderIsReplaced( currentValue.getName() ) );
        // goals:
        // mvn plugin-name:@item@
        //
        request.setGoals( getGoalsAfterPlaceHolderIsReplaced( currentValue.getName() ) );
        // Profiles:
        // mvn -Pxyz-@item@ clean package
        // mvn -P@item@
        request.setProfiles( getProfilesAfterPlaceHolderIsReplaced( currentValue.getName() ) );
        // Projects:
        // mvn -pl xyz-@item@ clean package
        request.setProjects( getProjectsAfterPlaceHolderIsReplaced( currentValue.getName() ) );

        Properties props = getMergedProperties(currentValue );
        request.setProperties( props );

        request.setRecursive( isRecursive() );
        request.setResumeFrom( getResumeFrom() );
        request.setShellEnvironmentInherited( isShellEnvironmentInherited() );
        request.setShowErrors( isShowErrors() );
        request.setShowVersion( isShowVersion() );
        request.setThreads( getThreads() );
        request.setToolchainsFile( getToolchains() );
        request.setUpdateSnapshots( isUpdateSnapshots() );
        request.setUserSettingsFile( getUserSettings() );
        
        return request;
    }

    private Properties getMergedProperties( ItemWithProperties item ) 
    {
        Properties props = new Properties();
        if ( getMavenProject().getProperties() != null ) 
        {
            props.putAll( getMavenProject().getProperties() );
        }
        
        if ( getProperties() != null ) 
        {
            props.putAll( getProperties() );
        }
        
        if ( item.getProperties() != null ) 
        {
            props.putAll( item.getProperties() );
        }
        
        for ( Map.Entry<Object, Object> property : props.entrySet() ) 
        {
            String key = (String) property.getKey();
            String systemPropertyValue = System.getProperty( key );

            if ( systemPropertyValue != null ) 
            {
                props.put( key, systemPropertyValue );
            }
        }
        
        return props;
    }

    public List<String> getGoals()
    {
        return goals;
    }

    public boolean isInteractive()
    {
        return interactive;
    }

    public void setInteractive( boolean interactive )
    {
        this.interactive = interactive;
    }

    public boolean isAlsoMake()
    {
        return alsoMake;
    }

    public void setAlsoMake( boolean alsoMake )
    {
        this.alsoMake = alsoMake;
    }

    public boolean isAlsoMakeDependents()
    {
        return alsoMakeDependents;
    }

    public void setAlsoMakeDependents( boolean alsoMakeDependents )
    {
        this.alsoMakeDependents = alsoMakeDependents;
    }

    public File getBaseDirectory()
    {
        return baseDirectory;
    }

    public void setBaseDirectory( File baseDirectory )
    {
        this.baseDirectory = baseDirectory;
    }

    public boolean isDebug()
    {
        return debug;
    }

    public void setDebug( boolean debug )
    {
        this.debug = debug;
    }

    public String getFailureBehaviour()
    {
        return failureBehaviour;
    }

    public void setFailureBehaviour( String failureBehaviour )
    {
        this.failureBehaviour = failureBehaviour;
    }

    public String getGlobalChecksumPolicy()
    {
        return globalChecksumPolicy;
    }

    public void setGlobalChecksumPolicy( String globalChecksumPolicy )
    {
        this.globalChecksumPolicy = globalChecksumPolicy;
    }

    public File getGlobalSettingsFile()
    {
        return globalSettingsFile;
    }

    public void setGlobalSettingsFile( File globalSettingsFile )
    {
        this.globalSettingsFile = globalSettingsFile;
    }

    public File getLocalRepositoryDirectory()
    {
        return localRepositoryDirectory;
    }

    public void setLocalRepositoryDirectory( File localRepositoryDirectory )
    {
        this.localRepositoryDirectory = localRepositoryDirectory;
    }

    public String getMavenOpts()
    {
        return mavenOpts;
    }

    public void setMavenOpts( String mavenOpts )
    {
        this.mavenOpts = mavenOpts;
    }

    public boolean isNonPluginUpdates()
    {
        return nonPluginUpdates;
    }

    public void setNonPluginUpdates( boolean nonPluginUpdates )
    {
        this.nonPluginUpdates = nonPluginUpdates;
    }

    public boolean isOffline()
    {
        return offline;
    }

    public void setOffline( boolean offline )
    {
        this.offline = offline;
    }

    public List<String> getProfiles()
    {
        return profiles;
    }

    public void setProfiles( List<String> profiles )
    {
        this.profiles = profiles;
    }

    public List<String> getProjects()
    {
        return projects;
    }

    public void setProjects( List<String> projects )
    {
        this.projects = projects;
    }

    public Properties getProperties()
    {
        return properties;
    }

    public void setProperties( Properties properties )
    {
        this.properties = properties;
    }

    public boolean isRecursive()
    {
        return recursive;
    }

    public void setRecursive( boolean recursive )
    {
        this.recursive = recursive;
    }

    public String getResumeFrom()
    {
        return resumeFrom;
    }

    public void setResumeFrom( String resumeFrom )
    {
        this.resumeFrom = resumeFrom;
    }

    public boolean isShellEnvironmentInherited()
    {
        return shellEnvironmentInherited;
    }

    public void setShellEnvironmentInherited( boolean shellEnvironmentInherited )
    {
        this.shellEnvironmentInherited = shellEnvironmentInherited;
    }

    public boolean isShowErrors()
    {
        return showErrors;
    }

    public void setShowErrors( boolean showErrors )
    {
        this.showErrors = showErrors;
    }

    public boolean isShowVersion()
    {
        return showVersion;
    }

    public void setShowVersion( boolean showVersion )
    {
        this.showVersion = showVersion;
    }

    public String getThreads()
    {
        return threads;
    }

    public File getToolchains()
    {
        return toolchains;
    }

    public void setToolchains( File toolchains )
    {
        this.toolchains = toolchains;
    }

    public boolean isUpdateSnapshots()
    {
        return updateSnapshots;
    }

    public void setUpdateSnapshots( boolean updateSnapshots )
    {
        this.updateSnapshots = updateSnapshots;
    }

    public File getUserSettings()
    {
        return userSettings;
    }

    public void setUserSettings( File userSettings )
    {
        this.userSettings = userSettings;
    }

    public void setGoals( List<String> goals )
    {
        this.goals = goals;
    }

}