For those not familiar with Phantom, this is a build system written in C# and Boo.

• Binaries
• Documentation
• Source

This release includes:

NAnt Integration

You can now execute NAnt tasks from within Phantom build scripts. In order for this to work, you’ll need to drop Phantom.Integration.Nant.dll and NAnt.Core.dll into the same directory as Phantom.exe. Once in place, you can import the NAnt tasks. This example executes the ‘echo’ task which is part of NAnt.Core.dll:

import tasks from NAnt.Core
target default:
   echo(message : "Hello from NAnt!")

Runnables

With v0.1 of Phantom, a lot of options were passed to helper methods via Hashes. For example, if you wanted tell msbuild to compile a project with a particular configuration and verbosity, you’d have to do the following:

msbuild("foo.sln", { "configuration": "release", "verbosity": "normal" })

With Phantom 0.2, most of these methods have been converted to classes that define regular properties. You can use Boo’s object initializer syntax they can still be declared on one line:

msbuild(file: "foo.sln", configuration: "release", verbosity: "normal")

This is called a ‘runnable’ as the msbuild class implements the IRunnable interface. When Phantom sees an instance of an IRunnable type being created, it will automatically call the ‘Run’ method (in this case, to kick off MSbuild). This syntax is equivalent to the following:

m = msbuild()
m.file = "foo.sln"
m.configuration = "release"
m.verbosity = "normal"
m.Run()

Runnables can also be used inside a with block:

with msbuild():
  .file = "foo.sln"
  .verbosity = "normal"
  .configuration = "release"

…and the ‘Run’ method will automatically be called at the end of the block. This is particularly useful if you have lots of properties that you want to set that cannot all fit on one line.

Improved FileList support

The 0.1 version of FileLists were rather limited. With 0.2 they now support exclusion patterns as well as recursively copying subdirectories:

with FileList("path/to/bin/debug"):
  .Include("**/*")
  .ForEach def(file):
    file.CopyToDirectory("directoryToPackage")

NCover Integration

Phantom 0.2 now includes runnables for executing NCover and NCoverExplorer. At present, these only work with the free Community Edition of NCover.

If you are unfamiliar with Phantom, check out my previous post.

• Binaries
• Documentation
• Source

Phantom is still very much in its initial stages. There are quite a lot of features still missing, but I now consider it stable enough to be usable.

To avoid confusion, I have renamed my Spectre to ‘Phantom’. The updated source can be found on GitHub.

*Update 2* The syntax used in this post is out of date and will not work with Phantom v0.2 or later. Please check out the Phantom Documentation to see the updated syntax.

I’ve recently been reading Ayende’s excellent book Building Domain Specific Languages in Boo and wanted to try out the techniques I’ve been learning on a real project. As such, I’ve created a Boo-based build system called ‘Phantom‘.

Why a build system?

In the past I’ve tended to use NAnt for building my projects, but I’ve never really liked the XML-driven build files. I much prefer the approach taken by tools such as Rake that allow you to configure your build through code.

While it is possible to use Rake with .NET projects (for example, Fluent NHibernate uses Rake), it requires that you have Ruby, Gems and Rake installed in order to use it. One thing that I really like about NAnt is that I can store it alongside my code inside my source control repository. This way, when someone checks out the source code they can run the build without having to install any additional tools.

Like Rake, Phantom is completely code-driven and like Nant, it is completely standalone with no installation required.

How does a Phantom build script differ from a NAnt script?

Here is a typical NAnt build script that declares three targets: ‘default’, ‘compile’ and ‘test’. The ‘default’ target depends on both ‘compile’ and ‘test’. ‘Compile’ will build a project using MSBuild and ‘test’ will run the project’s unit tests:

<project xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd" name="MyProject" default="default">
	<target name="default" depends="compile test" />
	<target name="compile" description="Compiles the project">
		<msbuild project="path\to\myproject.sln" target="Build">
			<property name="configuration" value="release" />
		</msbuild>
	</target>
	<target name="test" description="Runs tests">
		<nunit2 failonerror="true" verbose="true">
			<formatter type="Plain" />
			<test assemblyname="path\to\mytestassembly.dll" />
		</nunit2>
	</target>
</project>

Here is the same script using Phantom:

target default, (compile, test):
   pass
 
desc "Compiles the project"
target compile:
   msbuild("path/to/myproject.sln", { @configuration: 'release' })
 
desc "Runs tests"
target test:
  nunit("path/to/testassembly.dll")

Note that the syntax is very similar to Rake. To run this script you would save it as ‘default.boo’ and then run ‘Phantom.exe’ in the same directory. Much like Rake, you can run phantom -t to get a list of targets in the current project:

Phantom v0.1.0.0
Copyright (c) Jeremy Skinner 2009 (http://www.jeremyskinner.co.uk)

http://github.com/JeremySkinner/Phantom

Targets in build.boo:
compile          Compiles the solution
default
package          Creates zip package
test             Executes tests

Utility functions

At the moment, Phantom only has a small number of utility functions. Currently these are:

• msbuild(project, options) – executes msbuild against a project/solution file.
• nunit(assemblies, options) – executes nunit-console.exe against a collection of test assemblies.
• exec(command, args) – executes an arbitrary program.
• env(variable) – gets an environment variable.

These are in addition to Boo’s built-in functions. I plan to add more over time.

Does the world really need another build system?

Probably not. This more an exercise for me in learning how to build DSLs with Boo and Rhino DSL than anything else. Nevertheless, I plan to use it with a couple of real projects. If anyone else decides to use it, please let me know!

Where’s the source?

You can grab the source from GitHub and run Build.bat in order to compile the latest binaries.