[ajdt-dev] Vancouver Plug-in Structure

["Adrian Colyer" <adrian_colyer@xxxxxxxxxx>]

(Caution - looks scary on first read).


Here's the results of a brainstorm Andy
& I did on the plugin structure to use for the Vancouver development
stream. It's heavily based on the JDT plugin structure (I recommend we
copy JDT architecture wherever we can, which will make things easier both
for ourselves and for future developers who want to work with our code
or APIs).


AspectJ artefacts packaged for consumption
in Eclipse IDE:

org.aspectj.ajde  
(aspectjrt.jar, aspectjtools.jar) -
this is a library plugin. It would be nice not to have it at all, and put
these jars directly in ajdt.core, but we can't because we need to control
the visibility of the AspectJ compiler versions of the JDT compiler classes.
We could consider building this plugin as part of the AspectJ project build.

org.aspectj.ajde.doc
This provides the User Guide, Programming
Guide etc. for AspectJ (note that I've split this out from it's current
location in ajdt.ui). Ideally produced as an output of the AspectJ build
so that we keep the documentation up-to-date (current process is by-hand,
difficult, and error-prone).

org.aspectj.ajde.source
Could consider creating a source plugin
(would certainly aid us in debugging, if no-one else). Would also ideally
be produced as part of the AspectJ build.


AJDT plugins:

org.eclipse.ajdt.core
Mirrors the jdt.core plugin. Contains
the key class AspectJCore, and provides access to the AspectJ Model. Manages
all the AspectJ projects in the workspace.

org.eclipse.ajdt.core.tests
Following the JDT example of putting
tests into a separate plugin. This has packaging and dependency management
advantages. A possible consequence : it may be harder to have aspects in
the test plugin that advise classes in the tested plugin. Shared source
folders should be able to handle this to a first approximation.

org.eclipse.ajdt.ui
The user interface components of AJDT.
Mimics jdt.ui. 

org.eclipse.ajdt.ui.tests
The test cases for the UI plugin (to
the greatest extent that it is possible to test)

org.eclipse.ajdt.doc
The AJDT User Guide, plus in-time a
programming guide for extending AJDT and working with AspectJ projects

org.eclipse.contributions.crossreference
This is the cross-reference view. It
has been deliberately designed to be generally usable and extendable outside
of just AJDT, so we put it in a contributions package. Shipped as part
of AJDT.

org.eclipse.contribtutions.crossreference.tests
The tests for the cross-reference.

org.eclipse.contributions.vis
This is the generic visualizer. It has
been deliberately designed to be generally usable and extendable outside
of just AJDT, so we put it in a contributions package. Shipped as part
of AJDT.

org.eclipse.contributions.vis.tests
The tests for the visualizer.

org.eclipse.ajdt.debug.ui
The AspectJ debugging user-interface.
Mimics jdt.debug.ui.

org.eclipse.ajdt.debug.ui.tests
Tests for the debug ui plugin.

org.eclipse.ajdt.source
A source plugin for all of the AJDT



We may not need this next set, but if
we end up having to write these functions, this is where they'll go:

org.eclipse.ajdt.debug
org.eclipse.ajdt.debug.test
org.eclipse.ajdt.launching
org.eclipse.ajdt.launching.test

Feature and Update Site

To pull all this together we have our
feature plugin:

org.eclipse.aspectj
The feature plugin for adding AspectJ
support into Eclipse.

And we have the feature and update site
projects:
org.eclipse.aspectj.feature,
org.eclipse.aspectj.updatesite

Seeing this number of plugins and projects
is a striking statement of how far AJDT has come (and will go) from it's
humble beginnings. Although the list looks daunting, it should actually
help us by providing a good degree of modularity in the system from the
get-go.

-- Adrian
Adrian_Colyer@xxxxxxxxxx