src/main/java/org/apache/maven/artifact/ant/Mvn.java

package org.apache.maven.artifact.ant;

/*
 * 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.regex.Pattern;

import org.apache.maven.model.Dependency;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.taskdefs.Java;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Environment.Variable;

/**
 * Ant task to execute a maven build.
 * 
 * @author pgier
 *
 */
public class Mvn
    extends Java
{

    public final String BATCH_MODE = "-B";
    
    private File pom;
    
    private File mavenHome;
    
    private final String DEFAULT_MAVEN_VERSION = "2.0.10";
    
    private String mavenVersion = DEFAULT_MAVEN_VERSION;
    
    private boolean batchMode = true;
    
    private LocalRepository localRepository;
    
    public void execute()
        throws BuildException
    {
        if ( batchMode )
        {
            this.createArg().setValue( BATCH_MODE );
        }
        
        if ( pom != null )
        {
            createArg().setValue( "-f" + pom.getAbsolutePath() );
        }
        
        if ( localRepository != null )
        {
            this.createJvmarg().setValue( "-Dmaven.repo.local=" + localRepository.getPath().getAbsolutePath() );
        }
        
        if ( mavenHome == null )
        {
            Pattern oldMaven = Pattern.compile("(2\\.0)|(2\\.0-.*)|(2\\.0\\.[1-9])");
            if ( oldMaven.matcher( getMavenVersion() ).matches() )
            {
                throw new BuildException( "The requested Maven version '" + getMavenVersion() + "' is prior to " +
                                          "version '2.0.10'. In order to launch the requested version you need to " +
                                          "use a local Maven installation and point to that installation with the " +
                                          "mavenHome attribute." );
            }
            downloadAndConfigureMaven();
        }
        else
        {
            setupLocalMaven();
        }
        
        super.execute();
    }
    
    private void downloadAndConfigureMaven()
    {
        Dependency apacheMaven = new Dependency();
        apacheMaven.setGroupId( "org.apache.maven" );
        apacheMaven.setArtifactId( "apache-maven" );
        apacheMaven.setVersion( getMavenVersion() );
        apacheMaven.setType( "pom" );
        
        DependenciesTask depsTask = new DependenciesTask();
        depsTask.addLocalRepository( getLocalRepository() );
        depsTask.setProject( getProject() );
        depsTask.setPathId( "apache-maven-dependencies" );
        depsTask.addDependency( apacheMaven );
        depsTask.setType( "pom,jar" );
        depsTask.setPathType( "jar" );

        depsTask.execute();
        
        this.setClasspath( (Path) getProject().getReference( "apache-maven-dependencies" ) );
        
        this.setClassname( "org.apache.maven.cli.MavenCli" );
    }
    
    private void setupLocalMaven()
    {
        // Set the required properties
        Variable classworldsConfProp = new Variable();
        classworldsConfProp.setKey( "classworlds.conf" );
        File classworldsPath = new File( mavenHome, "bin/m2.conf" );
        classworldsConfProp.setValue( classworldsPath.getAbsolutePath() );
        this.addSysproperty( classworldsConfProp );
        
        Variable mavenHomeProp = new Variable();
        mavenHomeProp.setKey( "maven.home" );
        mavenHomeProp.setValue( mavenHome.getAbsolutePath() );
        this.addSysproperty( mavenHomeProp );
        
        // Set the boot classpath
        FileSet bootDir = new FileSet();
        bootDir.setDir( new File ( mavenHome, "boot" ) );
        bootDir.setIncludes( "*.jar" );
        
        Path mavenClasspath = new Path( getProject() );
        mavenClasspath.addFileset( bootDir );
        
        this.setClasspath( mavenClasspath );
        
        this.setClassname( "org.codehaus.classworlds.Launcher" );
    }

    public void setPom( File pom )
    {
        this.pom = pom;
    }

    public File getPom()
    {
        return pom;
    }

    public void setMavenHome( File mavenHome )
    {
        this.mavenHome = mavenHome;
    }

    public File getMavenHome()
    {
        return mavenHome;
    }

    public void setBatchMode( boolean batchMode )
    {
        this.batchMode = batchMode;
    }

    public boolean isBatchMode()
    {
        return batchMode;
    }

    public void addLocalRepository( LocalRepository localRepository )
    {
        this.localRepository = localRepository;
    }

    public LocalRepository getLocalRepository()
    {
        return localRepository;
    }

    public void setMavenVersion( String mavenVersion )
    {
        this.mavenVersion = mavenVersion;
    }

    public String getMavenVersion()
    {
        return mavenVersion;
    }

}