I guess I've heard "Ant is an XML programming language" and "Ant would be fine wasn't it for all the XML" once too often. Last week I managed to free up a few hours to build a (probably completely useless) prototype to prove it doesn't have to be that way:
$ cat src/etc/examples/Simple2.java package org.example; import org.apache.ant.javafront.annotations.AntProject; import org.apache.ant.javafront.annotations.AntTarget; import org.apache.tools.ant.Project; @AntProject() public class Simple2 { private final Project p; public Simple2(Project p) { this.p = p; } @AntTarget(Name="hello", Description="says hello", Depends="nonsense") public void foo() { p.log("Hello, world!"); p.log("This is " + p.getProperty("ant.version") + " calling."); } @AntTarget public void nonsense() {} } $ ant -lib build/lib/ant-javafront-0.1.jar -f src/etc/examples/Simple2.java -projecthelp Buildfile: src/etc/examples/Simple2.java [buildfile] Compiling 1 source file to /tmp/javafront Main targets: hello says hello $ ant -lib build/lib/ant-javafront-0.1.jar -f src/etc/examples/Simple2.java hello Buildfile: src/etc/examples/Simple2.java nonsense: hello: Hello, world! This is Apache Ant version 1.7.1 compiled on June 27 2008 calling. BUILD SUCCESSFUL Total time: 0 seconds
This is stock Ant 1.7.1 (should work with Ant 1.7.0 and probably 1.6.5 as well) and Java 5 together with a custom ProjectHelper (more on this later).
The build file is a Java source file that gets compiled on demand.
Each public no-arg method that has the AntTarget
annotation becomes a target where the method's name forms the
default for the target name.
Ant provides an extension point, the ProjectHelper
class which is responsible for configuring an
Ant Project instance from a source (usually
a File).
My prototype
extends Ant's built in ProjectHelper class and
overrides a single method. The majority of that class is concerned
with compiling the "build file" and performing some reflection.
Apart from that, two
trivial annotations
and
a very
simple subclass of Ant's Target are all that it
takes to replace XML with Java source code. Replacing XML with any
custom format you can think up would be as straight forward, it's
just that nobody seems to know you can plug in your own parser -
maybe it's time for a "little known Ant extension points"
article.
My experiment doesn't do all that its XML cousin can do, in
particular it doesn't support <import>, but that
can be faked to a certain extent by making the "build file" inherit
from a base class. The other thing is automatic handling of IDs,
but that is something you'd need when using Ant tasks and should
probably go into the builder (see below). It does
support <ant> and friends as well as namespaces,
as demonstrated by an
example
of
running AntUnit
on the build file itself.
Inside your "target" you may perform any Java code as you see fit. Of course this means you'll only use the target execution engine of Ant. Reusing Ant tasks from Java might be pretty daunting, so I threw in a little Ant tag builder library based on the builder pattern and a fluent interface, not very complete and really just a teaser. For example:
$ cat src/etc/examples/Simple3.java package org.example; import org.apache.ant.javafront.annotations.AntProject; import org.apache.ant.javafront.annotations.AntTarget; import org.apache.tools.ant.Project; import org.apache.ant.javafront.builder.TagBuilder; @AntProject(Name="simple3", DefaultTarget="hello") public class Simple3 { private Project p; public void setProject(Project p) { this.p = p; } @AntTarget(Name="-setup") public void setup() { TagBuilder.forProject(p) .property().withName("world").andValue("world").execute(); } @AntTarget(Depends="-setup") public void hello() { TagBuilder.forProject(p).echo().message("Hello, ${world}!").execute(); } } $ ant -lib build/lib/ant-javafront-0.1.jar -f src/etc/examples/Simple3.java Buildfile: src/etc/examples/Simple3.java [buildfile] Compiling 1 source file to /tmp/javafront -setup: hello: [echo] Hello, world! BUILD SUCCESSFUL Total time: 0 seconds $ ant -lib build/lib/ant-javafront-0.1.jar -f src/etc/examples/Simple3.java -Dworld=reader Buildfile: src/etc/examples/Simple3.java -setup: hello: [echo] Hello, reader! BUILD SUCCESSFUL Total time: 0 seconds
or
$ cat src/etc/examples/AntUnitTest.java
package org.apache.ant.javafront.example;
import org.apache.ant.javafront.BuildFileBase;
import org.apache.ant.javafront.annotations.AntProject;
import org.apache.ant.javafront.annotations.AntTarget;
import org.apache.tools.ant.Project;
import static org.apache.ant.javafront.builder.EchoBuilder.echoMessage;
import static org.apache.ant.javafront.builder.DeleteBuilder.deleteDir;
import static org.apache.ant.javafront.builder.MkdirBuilder.mkdir;
@AntProject(Name="example using AntUnit", BaseDir="../../..",
DefaultTarget="antunit")
public class AntUnitTest extends BuildFileBase {
private static final String FILE = "build.xml";
private static final String OUTPUT = "${output}";
public AntUnitTest(Project p) {
super(p);
build().property().withName("output").andLocation("build/testoutput")
.execute();
}
@AntTarget(Description="describes this build file")
public void describe() {
echoMessage(getProject(), "${ant.version}");
echoMessage(getProject(), "Demonstrates running an AntUnit test.");
}
@AntTarget
public void setUp() {
mkdir(getProject(), OUTPUT);
}
@AntTarget
public void tearDown() {
deleteDir(getProject(), OUTPUT);
}
@AntTarget
public void testCopy() {
build().copy().withAttribute("verbose", "true")
.file(FILE).toDir(OUTPUT)
.execute();
build().tagWithNs("assertFileExists", "antlib:org.apache.ant.antunit")
.withAttribute("file", OUTPUT + "/" + FILE)
.execute();
}
@AntTarget(Description="runs the test")
public void antunit() {
build().tagWithNs("antunit", "antlib:org.apache.ant.antunit")
.withChild(build().tagWithNs("plainlistener",
"antlib:org.apache.ant.antunit"))
.withChild(build().tag("file").withAttribute("file",
"${ant.file}"))
.execute();
}
}
$ ant -lib build/lib/ant-javafront-0.1.jar -lib ../ant-core/trunk/lib/optional/ant-antunit-1.1.jar -f src/etc/examples/AntUnitTest.java
Buildfile: src\etc\examples\AntUnitTest.java
antunit:
[antunit] Build File: /home/stefan/dev/ASF/ant-javafront/src/etc/examples/AntUnitTest.java
[antunit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0,062 sec
[antunit] Target: testCopy took 0,031 sec
BUILD SUCCESSFUL
Total time: 0 seconds
$ ant -lib build/lib/ant-javafront-0.1.jar -lib ../ant/lib/optional/ant-antunit-1.1.jar\
-f src/etc/examples/AntUnitTest.java setUp testCopy tearDown
Buildfile: src/etc/examples/AntUnitTest.java
setUp:
[mkdir] Created dir: /home/stefan/dev/ASF/ant-javafront/build/testoutput
testCopy:
[copy] Copying 1 file to /home/stefan/dev/ASF/ant-javafront/build/testoutput
[copy] Copying /home/stefan/dev/ASF/ant-javafront/build.xml to /home/stefan/dev/ASF/ant-javafront/build/testoutput/build.xml
tearDown:
[delete] Deleting directory /home/stefan/dev/ASF/ant-javafront/build/testoutput
BUILD SUCCESSFUL
Total time: 0 seconds
I must admit that I don't really see that much of a point in the experiment itself, other than proving that it can be done. The files I've presented so far are longer and more verbose than their XML equivalents would have been. There may be cases where you realy want some non-declarative stuff like performing a loop, here using Java may help, something like.
$ cat src/etc/examples/EchoExamples.java package org.example; import org.apache.ant.javafront.BuildFileBase; import org.apache.ant.javafront.annotations.AntProject; import org.apache.ant.javafront.annotations.AntTarget; import org.apache.tools.ant.DirectoryScanner; import org.apache.tools.ant.Project; import org.apache.tools.ant.types.FileSet; import static org.apache.ant.javafront.builder.EchoBuilder.echoMessage; @AntProject(Description="lists all build files in the current directory", DefaultTarget="list") public class EchoExamples extends BuildFileBase { public EchoExamples(Project p) { super(p); } @AntTarget(Description="list the files in the example dir") public void list() { FileSet fs = (FileSet) build().tag("fileset") .withAttribute("dir", ".") .withAttribute("includes", "*.java") .build(); DirectoryScanner ds = fs.getDirectoryScanner(); for (String file : ds.getIncludedFiles()) { echoMessage(getProject(), "found " + file); } } } $ ant -lib build/lib/ant-javafront-0.1.jar -f src/etc/examples/EchoExamples.java Buildfile: src/etc/examples/EchoExamples.java [buildfile] Compiling 1 source file to /tmp/javafront list: [echo] found AntUnitTest.java [echo] found EchoExamples.java [echo] found Simple.java [echo] found Simple2.java [echo] found Simple3.java BUILD SUCCESSFUL Total time: 0 seconds
Right now I don't expect to put more work into the experiment. The tag builder library may be useful on its own, but what I've seen so far hasn't convinced my that Java would be a better language to describe your builds. What I have shown is that Ant doesn't need XML at all and now I feel better 8-).
path: /en/Apache/Ant | #