Building HttpComponents Core 
============================

(1) Requisites
--------------
HttpCore utilizes Maven 2 as a distribution management and packaging tool.
Version 2.1.0 or above is required, which requires JDK 1.4 or later. However, 
it is recommended that you use Maven 2.2.1 or later, which requires JDK 1.5+. 
JDK 1.5 also required in order to compile some modules (such as NIO extensions).

Maven installation and configuration instructions can be found here:

http://maven.apache.org/run-maven/index.html

(2) Executing test cases

Execute the following command in order to compile and test the components

mvn test [-P java-1.3|java-1.4]

The profile java-1.3 ensures that the tests are run with JVM 1.3, similarly for java-1.4.
These profiles require the appropriate environment variables to have been set up,
see pom.xml comments for details.

(3) Building packages 

Execute the following command in order to build the JAR packages

mvn package [-P java-1.3|java-1.4]


The resultant packages can be found in the target folders of their respective modules

httpcore/target/httpcore-<VERSION>.jar
httpcore-nio/target/httpcore-nio-<VERSION>.jar
httpcore-osgi/target/org.apache.httpcomponents.httpcore_<VERSION>.jar

where <VERSION> is the release version

(4) Building documentation 

Execute the following command in order to generate javadoc:

mvn javadoc:aggregate

Execute the following command in order to generate the tutorial in html and pdf formats

mvn docbkx:generate-pdf docbkx:generate-html

(5) Building distribution assemblies 

Execute the following command in order to build the distribution assemblies

mvn package assembly:assembly

(6) Fix EOL in source files

Fix the archive files so the source files have the correct EOL settings:

mvn antrun:run

(7) Building project web site 

Execute the following command in order to generate the project web site:

mvn site -Dmaven.clover.licenseLocation=<path>/clover.license

where <path> is a full path to Clover license file

ASF committers can obtain a copy of Clover license donated to the ASF from the SVN repository
at the following location:

https://svn.apache.org/repos/private/committers/donated-licenses/clover

