@@ -54,86 +54,47 @@
package org.apache.tools.ant.taskdefs; package org.apache.tools.ant.taskdefs;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.util.FileUtils;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.myrmidon.interfaces.executor.Executor;
import org.apache.myrmidon.interfaces.executor.ExecutionFrame;
import org.apache.myrmidon.api.TaskException;
import java.io.File; import java.io.File;
import java.util.Vector ;
import java.util.Iterator ;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.tools.ant.util.FileUtils;
/** /**
* Call Ant in a sub-project.
*
* <pre>
* <target name="foo" depends="init">
* <ant antfile="build.xml" target="bar" >
* <property name="property1" value="aaaaa" />
* <property name="foo" value="baz" />
* </ant></SPAN>
* </target></SPAN>
*
* <target name="bar" depends="init">
* <echo message="prop is ${property1} ${foo}" />
* </target>
* </pre>
*
* Ant1Compat version of <ant>, which delegates to the Myrmidon version.
* *
* @author costin@dnt.ro * @author costin@dnt.ro
* @author <a href="mailto:darrell@apache.org">Darrell DeBoer</a> * @author <a href="mailto:darrell@apache.org">Darrell DeBoer</a>
*/ */
public class Ant extends Task {
public class Ant
extends AbstractAnt1AntTask
{
/** the basedir where is executed the build file */ /** the basedir where is executed the build file */
private File dir = null; private File dir = null;
/** the build.xml file (can be absolute) in this case dir will be ignored */ /** the build.xml file (can be absolute) in this case dir will be ignored */
private String antFile = null; private String antFile = null;
/** the target to call if any */
private String target = null;
/** the output */ /** the output */
private String output = null; private String output = null;
/** should we inherit properties from the parent ? */
private boolean inheritAll = true;
/** should we inherit references from the parent ? */ /** should we inherit references from the parent ? */
private boolean inheritRefs = false; private boolean inheritRefs = false;
/** the properties to pass to the new project */
private Vector properties = new Vector();
/** the references to pass to the new project */
private Vector references = new Vector();
/**
* If true, inherit all properties from parent Project
* If false, inherit only userProperties and those defined
* inside the ant call itself
*/
public void setInheritAll(boolean value) {
inheritAll = value;
}
/** /**
* If true, inherit all references from parent Project * If true, inherit all references from parent Project
* If false, inherit only those defined * If false, inherit only those defined
* inside the ant call itself * inside the ant call itself
*/ */
public void setInheritRefs(boolean value) {
public void setInheritRefs( boolean value )
{
inheritRefs = value; inheritRefs = value;
} }
/** /**
* ... * ...
*/ */
public void setDir(File d) {
public void setDir( File d )
{
this.dir = d; this.dir = d;
} }
@@ -142,159 +103,50 @@ public class Ant extends Task {
* If it is absolute, <tt>dir</tt> will be ignored, if it is * If it is absolute, <tt>dir</tt> will be ignored, if it is
* relative it will be resolved relative to <tt>dir</tt>. * relative it will be resolved relative to <tt>dir</tt>.
*/ */
public void setAntfile(String s) {
public void setAntfile( String s )
{
// @note: it is a string and not a file to handle relative/absolute // @note: it is a string and not a file to handle relative/absolute
// otherwise a relative file will be resolved based on the current // otherwise a relative file will be resolved based on the current
// basedir. // basedir.
this.antFile = s; this.antFile = s;
} }
/**
* set the target to execute. If none is defined it will
* execute the default target of the build file
*/
public void setTarget(String s) {
this.target = s;
}
public void setOutput(String s) {
public void setOutput( String s )
{
this.output = s; this.output = s;
} }
/** create a property to pass to the new project as a 'user property' */ /** create a property to pass to the new project as a 'user property' */
public Property createProperty() {
Property p = new Property(true);
properties.addElement( p );
return p;
}
/**
* create a reference element that identifies a data type that
* should be carried over to the new project.
*/
public void addReference(Reference r) {
references.addElement(r);
}
/**
* Helper class that implements the nested <reference>
* element of <ant> and <antcall>.
*/
public static class Reference
extends org.apache.tools.ant.types.Reference {
public Reference() {super();}
private String targetid=null;
public void setToRefid(String targetid) { this.targetid=targetid; }
public String getToRefid() { return targetid; }
public Property createProperty()
{
return doCreateProperty();
} }
/** /**
* Called by the project to let the task do its work. This method may be
* called more than once, if the task is invoked more than once.
* For example,
* if target1 and target2 both depend on target3, then running
* "ant target1 target2" will run all tasks in target3 twice.
*
* @exception BuildException if something goes wrong with the build
* Construct a TaskModel for the Myrmidon <ant> task, and configure it
* with sub-class specific values (antfile).
* @return the TaskModel
*/ */
public void execute() throws BuildException
{
Object ant1project = unsetProject();
try
{
Configuration antConfig = buildAntTaskConfiguration();
executeTask( antConfig );
}
finally
{
resetProject( ant1project );
}
}
private void executeTask( Configuration antConfig )
{
try
{
Executor executor = (Executor) m_context.getService( Executor.class );
ExecutionFrame frame =
(ExecutionFrame) m_context.getService( ExecutionFrame.class );
executor.execute( antConfig, frame );
}
catch( TaskException e )
{
throw new BuildException( e );
}
}
private Configuration buildAntTaskConfiguration()
protected DefaultConfiguration buildTaskModel()
{ {
DefaultConfiguration antConfig = new DefaultConfiguration( "ant", "" ); DefaultConfiguration antConfig = new DefaultConfiguration( "ant", "" );
antConfig.setAttribute( "inherit-all", String.valueOf( inheritAll ) );
// Ignore inheritRefs for now ( inheritAll == inheritRefs )
if ( target != null )
{
antConfig.setAttribute( "target", target );
}
// Get the "file" value. // Get the "file" value.
if (antFile == null) {
if( antFile == null )
{
antFile = "build.xml"; antFile = "build.xml";
} }
if ( dir == null )
if( dir == null )
{ {
dir = project.getBaseDir(); dir = project.getBaseDir();
} }
File file = FileUtils.newFileUtils().resolveFile(dir, antFile);
File file = FileUtils.newFileUtils().resolveFile( dir, antFile );
antFile = file.getAbsolutePath(); antFile = file.getAbsolutePath();
antConfig.setAttribute( "file", antFile ); antConfig.setAttribute( "file", antFile );
// Add all of the properties.
Iterator iter = properties.iterator();
while( iter.hasNext() )
{
DefaultConfiguration param = new DefaultConfiguration( "param", "" );
Property property = (Property)iter.next();
param.setAttribute( "name", property.getName() );
param.setAttribute( "value", property.getValue() );
antConfig.addChild( param );
}
return antConfig; return antConfig;
} }
private void resetProject( Object ant1project ) throws BuildException
{
try
{
m_context.setProperty( "ant1.project", ant1project );
}
catch( TaskException e )
{
throw new BuildException( e );
}
}
private Object unsetProject() throws BuildException
{
Object ant1project = null;
try
{
ant1project = m_context.getProperty( "ant1.project" );
m_context.setProperty( "ant1.project", null );
}
catch( TaskException e )
{
throw new BuildException( e );
}
return ant1project;
}
} }
Darrell DeBoer