ant-dev mailing list archives

Hi,
yesterday I finally got around to cleaning up Myrmidon so that it is
representative of where I think Ant2 should go. It does not yet cover a whole
range of things because no one has made up their minds on how we should
implement them ;) However with a few exceptions I think it is mostly
representative of what we have discussed.
Some of the features that it implements
* aspects (currently are possible to do everything discussed)
* ClassLoader protection between different libraries
* Type librarys (ie can store tasks, mappers, listeners, builders, datatypes
etc)
* Dry Runs (ie just print out what you would execute rather than executing
it). This needs a few mods to work a-ok but is simple to fix
* Incremental mode (or shell mode). Can load JVM up once and re-run over same
build file. (Much faster as no JVM startup cost).
* TaskModel/TaskProxy/TaskConfiguration system where tasks are interpreted
when executed thus making system fully dynamic
* Clean separation between Project/Targets/Tasks.
* Workspace model which contains set of runtime data about execution of set
of projects. (ie Centralized Properties/Aspects/Listeners/Registry/etc).
* Pluggable builders so that you can build projects from what ever whacky
input format you come up with. Includes a basic builder that reads in XML
(like Ant1) and another builder that will process it through XSL
transformation.
* Project specific TypeManager and Global TypeManager. (So you can register
some types/tasks/mappers/etc globally and some only in a particular project).
* Transparent addition of new types
* Pluggable converter system
* Cross project DAGs (via projectref)
* preloaded type librarys (via import)
* Well defined Task API
* Support for many Ant1 tasks
Things it doesn't do;
* Task framework (ie ClassPath object, FileSet object etc). It has a few
placeholder classes or basic "framework" components like COndition but this
has been left largely undone. This will probably be the largest part of Ant2.
* Implement any tasks other than core features.
* Implement any particular property policy. (ie are properties immutable? Are
they dynamic? Are they scoped ? etc). Mainly as no one has decided on
strategy yet ;)
* Allow sharing of classloaders between Type libraries (unless installed
system-wide).
* Separate engine specific ClassLoader from task ClassLoader (ie still can
only use 1 global XML parser).
* have a GUI or anyother type of frontend.
Any ways I am looking for constructive feedback on any bit of it ;)
Theres still heaps to do - I think the Task framework part is going to be
faaaaaaaaar larger a job than we thought it would be ;) But the basic outline
is there. About half the ugly bits left in the code are marker by comments
(usually prefixed with something like HACK/TODO/FIXME/UGLY etc) but if you
find anything else lacking I would be interested in hearing about it ;)
Cheers,
Pete
*-----------------------------------------------------*
| "Faced with the choice between changing one's mind, |
| and proving that there is no need to do so - almost |
| everyone gets busy on the proof." |
| - John Kenneth Galbraith |
*-----------------------------------------------------*