0.4.1:2013-01-25

0.4.0:2013-01-21

Moved to GitHub!

Add Parameter Passing to Xnt

Combined Build Modules ((N)Ant and make all live in
xnt.build.make)

Add Compiler Wrappers (gcc/g++ and javac)

Testing

I don’t test everything as well as maybe I would like and, of course,
some better integration tests would help. But one area that is
seriously lacking testing are the Windows builds. I don’t have the
best access to a Windows box and so I may not notice a potentially
huge bug for some time.

Motivation

When writing something such as a build tool, there is always the
question: “why?”. Why write yet another build tool?

Well, there are several reasons that are the backing motivation:

First, developing a variety of software, using one and only one build
tool for every project is nearly (if not entirely) impossible. There
is a desire to have a consistent build step and process when testing
and deploying. Given the environment in which the code is written is
heterogeneous, having one uniform build tool that wraps itself around
the other ones (and has the ability to expand to new ones) is ideal.

Second, short of dropping into the language the build tool was
written in, expanding some build steps is very difficult (or at least
can be). Further there can be complicated build targets that require
some interesting and potentially involved (smelly) procedures to be
accomplished, that may or may not be easy to describe in the build
file or in the native language. Therefore, having a wrapping build
framework/ tool that is written in an easy to read and write
language, such as Python, these complicated steps can depend less on
some funky new build library (further adding to the dependency tree)
and can become just implementation details (assuming, of course, you
buy into Xnt first).

Last, and most certainly the least, I wanted to explore the idea. I
wanted to write something that made me think about solving some of
the problems challenged by such a tool.

What Xnt Is NOT

Calling Xnt simply a build tool is (grossly?) misleading. Xnt is not
really a build tool in the traditional sense. Like stated above, it
is more a wrapper around existing build tools. I didn’t want to
replace what some of these tools already do really well (e.g. being
able to describe how to compile an entire large Java program in
several lines of code using Ant).

What Xnt IS

Xnt is a wrapping build tool, intended to be used with a multitude of
sub-build tools, even in the same project. Regardless of the language
the project is written in, Xnt should be able to suite your needs. If
your language’s build tool is unable to do something concisely or
cleanly, Python should help. [There could be more here… I can’t
think of it though.]

Installing and Setting Up Xnt

Using Xnt is fairly simple. All you will need to do is install it,
create a build.py file for your project, and invoke it just like
any other build tool you have used before (e.g. $ xnt {target}).

Dependencies

There are a few required and optional dependencies to install and run
Xnt. Namely, reference the following list:

setuptools

Ant (Optional)

CVS (Optional)

Git (Optional)

LaTeX (Optional)

Make (Optional)

Mercurial (Optional)

NAnt (Optional)

For developers, there are a few more dependencies.

sphinx

pylint

Source Install

To install from source, you can download the source tarball or zip
file (from either Downloads or Xnt), unpack it into a
temporary directory and then, from a shell or command prompt, run:

$ python[2] setup.py install [--user]

PyPi/ Pip

To install from PyPi, you will need pip. Once you have pip,
you may only run:

$ pip[2] install Xnt [--user]

Linux/ Unix

If you install using the --user option in either source or PyPi
installs you may need to add ~/.local/bin/ to your PATH
environment variable.

Otherwise, you shall need do nothing more.

Windows

If on Windows, after installing you will need edit your PATH
environment variable to include the <python_install_dir>\Scripts
folder. After which, you will be all set to use Xnt.

As you can see, it really just is a Python script. There really isn’t
anything really special happening. We just import some of the Xnt
modules, and define some targets. When you call xnt, it will be
loading this script and call the target specified by {target} or,
if you don’t specify one, it will call the target named default.