Building from SVN

The Wicket projects are built using a multi-module build as proposed by the Maven project.
We use Maven to build our projects and distributions. To be able to build Wicket directly
from subversion, you will need an understanding of Maven.

For more information on the project structure, please read the 'Better Builds With Maven'
book which has a detailed description on how to structure a maintainable, enterprise ready
build. The book is available for free from the Mergere website.

When you build from SVN you will need to check out a whole branch, because our project depend
on one another. For Wicket 1.x you will need to check out:

svn co https://svn.apache.org/repos/asf/incubator/wicket/branches/wicket-1.x

This will give you a directory structure like the following directory tree:

• wicket-parent/
• wicket/
• wicket-extensions/
• wicket-examples/
• wicket-spring/
• wicket-spring-annot/
• wicket-auth-roles/

In this document we focus at the Wicket parent project, which enforces default settings for
all Wicket projects such as plug-in settings, versioning of the Wicket projects, managing the
various dependencies and more.

The artifacts in this project are there only for having a consistent build. This project
doesn't have sources for itself.

Building Wicket 1.x

The build has two parts: a Java 1.4 part for the projects that are Java 1.4 based and
a Java 5 part, specific for the projects that are Java 5 based.

Here's a list of the Java 1.4 based projects:

• wicket
• wicket-extensions
• wicket-examples
• wicket-quickstart
• wicket-spring
• wicket-spring-examples
• wicket-portlet-examples

Here's a list of the Java 5 based projects:

• wicket-jmx
• wicket-auth-roles
• wicket-auth-roles-examples
• wicket-spring-annot
• wicket-spring-annot-examples

To build the projects, make sure you have downloaded and installed all projects in one
directory structure, each project a subdirectory next to one another. If you want to get it
all in one sweep, then use subversion to checkout the whole project structure in one go.

svn co https://svn.apache.org/repos/asf/incubator/wicket/releases/<VERSION>

substituting the <VERSION> part with "wicket-X.Y.Z", where X, Y and Z are the major, minor and
bugfix version. So for Wicket-1.2.4 you would check out:

svn co https://svn.apache.org/repos/asf/incubator/wicket/releases/wicket-1.2.4

The development version of wicket 1.x can be found in branch wicket-1.x, and
the latest and greatest development version (currently Wicket 2.x) can be found in trunk.
The branches 1.0.x, 1.1.x and 1.2.x are for versions that are no longer actively
developed, but which may in exception cases receive bug fixes.

Stage one:
mvn -Pjdk1.4 install

Stage two (if you're running JDK 5):
mvn -Pjdk1.5 install

You may need to run with -Dmaven.test.skip=true if you have failing unit tests (this obviously
shouldn't be the case for a release build).

The following commands are useful:

You can just run the install target, as Maven will build the previous stages automatically.

Building Wicket 2.x

Wicket 2.x development is done in the trunk of our subversion repository. Wicket 2.x will
also only run on JDK 1.5 or newer. Therefore building Wicket 2.x is easier than building Wicket 1.x.

Getting the latest and greatest for Wicket 2.x development is as easy as:

svn co https://svn.apache.org/repos/asf/incubator/wicket/trunk

then change the directory to the wicket-parent subdirectory and run:

mvn install

As this is our main development you might/will encounter failing unit tests. These can be skipped using:

mvn -Dmaven.test.skip=true install

Of course, all limits are off then and your mileage may vary if you use such a built jar.

Using your own built artifacts

Now you have built your own fresh Wicket jar you must be anxious to use it. This is now as simple as adding
a snapshot dependency on the specific Wicket version. So in your pom.xml you can use:

<dependency>
    <groupId>org.apache.wicket</groupId>
    <artifactId>wicket</artifactId>
    <version>1.3-incubating-SNAPSHOT</version>
    <scope>compile</scope>
</dependency>

And adding this to your Eclipse or NetBeans project classpath is then as simple as:

• mvn eclipse:eclipse or
• mvn netbeans:netbeans

Maven will then add all the necessary JAR files to the project's classpath.

One thing you need to make sure is that you have set the M2_REPO classpath variable in
Eclipse (or a similar construct in Netbeans), and point it to your local repository, typically found in
C:\Documents and Settings\username\.m2\repo or (for unix buffs) ~/.m2/repo