<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License. You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied. See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Developing Apache Rampart</title>
</head>
<body lang="en" xml:lang="en">
<h1>Developing Apache Rampart</h1>
<p>This document provides information on how to use SVN to get an
SVN checkout/update, make commits to the repository, etc., in the
process of contributing to Apache projects (specifically Apache Rampart).
Instructions on configuring IDEs for development and using Maven to
build the project is also included here.</p>
<h2>Content</h2>
<ul>
<li><a href="#svn">Working with Subversion (SVN)</a></li>
<li><a href="#checkout">Checkout Rampart from Subversion</a></li>
<li><a href="#maven">Installing Maven 2</a></li>
<li><a href="#ide">Configuring your IDE</a></li>
</ul>
<a name="svn" id="svn"></a>
<h2>Working with Subversion (SVN)</h2>
<p>The Rampart development team uses Subversion (SVN) for source
control. Subversion is a compelling replacement for CVS, developed
under the auspices of the Tigris community and licensed under an
Apache compatible license. To learn more about Subversion or to
download the latest distribution, visit the <a href=
"http:///subversion.tigris.org" target="_blank">Subversion project
site</a>. If you are looking for guidance on setting up and
installing Subversion, please read the ASF <a href=
"http://www.apache.org/dev/version-control.html" target=
"_blank">Source Code Repositories page</a>.</p>
<a name="checkout" id="checkout"></a>
<h2>Checkout Axis2 from Subversion</h2>
<p>To check out the latest version of Rampart from the Foundation's
Subversion repository, you must use one of the following URLs
depending on your level of access to the Rampart source code:</p>
<ul>
<li><b>If you are not a committer:</b> <a href=
"http://svn.apache.org/repos/asf/axis/axis2/java/rampart/trunk"
target=
"_blank">http://svn.apache.org/repos/asf/axis/axis2/java/rampart/trunk</a></li>
<li><b>If you are a committer:</b> <a href=
"https://svn.apache.org/repos/asf/axis/axis2/java/rampart/trunk"
target=
"_blank">https://svn.apache.org/repos/asf/axis/axis2/java/rampart/trunk</a></li>
</ul>
If you are a committer, make sure that you have selected an
svnpasswd. To do this, you must log into svn.apache.org. For more
information, please read the ASF <a href=
"http://www.apache.org/dev/version-control.html" target=
"_blank">Source Code Repositories page</a>.
<p>Once you have successfully installed Subversion, you can check
out Rampart trunk by following these steps:</p>
<ol type="1">
<li>Run <strong>svn co &lt;repository URL&gt; rampart</strong> where
the repository URL is one of the URLs from the previous list.</li>
<li>This step will check out the latest version of the Rampart Java
codebase to a directory named "rampart". The second parameter to the
<strong>svn co</strong> selects a directory to create on your local
machine. If you want to checkout Rampart to a different directory,
feel free to change rampart to any other directory name.</li>
<li>To update your working copy to the latest version from the
repository, execute the <strong>svn update</strong> command.</li>
<li>If you would like to submit a patch, you can execute
<strong>svn diff</strong> to create a unified diff for submission
to the Rampart JIRA issue tracker.</li>
</ol>
<a name="maven" id="maven"></a>
<h2>Installing Maven 2</h2>
<p>Rampart's build is based on Maven 2. Maven is a build system that
allows for the reuse of common build projects across multiple
projects. For information about obtaining, installing, and
configuring Maven 2, please see the <a href=
"http://maven.apache.org" target="_blank">Maven project page</a>.
To use Maven to build the Axis2 project, Please install <a href="http://maven.apache.org/download.html" target=
"_blank">Maven2</a> and follow instructions here -  <a href="maven-help.html">Quick Guide to Maven for Axis 2.0</a></p>.
<a name="ide" id="ide"></a>
<h2>Configuring your IDE</h2>
<p>The Rampart development team uses a variety of development tools
from vi to emacs to eclipse to Intellij/IDEA. The following section
is not an endorsement of a specific set of tools, it is simply
meant as a pointer to ease the process of getting started with
Rampart development.</p>
<ul>
<li><strong>Intellij IDEA</strong> - type <strong>mvn
idea:idea</strong>. Generates the necessary IDEA .ipr, .iml
and .iws project files</li>
<li><strong>Eclipse</strong>- type <strong>mvn eclipse:eclipse</strong>. Then in Eclipse, setup a Classpath Variable
for MAVEN_REPO, and select File &gt; Import &gt; Existing Projects
into Workspace &gt; Select root directory. Selecting the root of
the Rampart source discovers all the modules and allows them to be
imported as individual projects at once.</li>
</ul>
</body>
</html>
