build.xml

<?xml version="1.0"?>
<!--

  Copyright (c) 2004-2014, PostgreSQL Global Development Group

  Build file to allow ant (http://ant.apache.org/) to be used
  to build the PostgreSQL JDBC Driver.

  This file now requires Ant 1.4.1.  2002-04-18


-->

<!DOCTYPE project [
  <!ENTITY jarfiles "postgresql.jar">
]>

<project name="postgresqlJDBC" default="all" basedir="." xmlns:artifact="antlib:org.apache.maven.artifact.ant">

  <!-- set global properties for this build -->
  <property name="srcdir"  value="." />
  <property name="jardir"  value="jars" />
  <property name="builddir" value="build" />
  <property name="package" value="org/postgresql" />
  <property name="debug" value="on" />

  <!-- default build parameters are in build.properties, these may be
       overridden by local configuration settings in build.local.properties
  -->
  <property file="build.local.properties" />
  <property file="build.properties"/>

 <!-- define artifacts' name, which follows the convention of Maven -->
  <property name="maven.jar" value="${jardir}/${maven.artifact.id}-${maven.artifact.version}.jar"/>
  <property name="maven.javadoc.jar" value="${jardir}/${maven.artifact.id}-${maven.artifact.version}-javadoc.jar"/>
  <property name="maven.sources.jar" value="${jardir}/${maven.artifact.id}-${maven.artifact.version}-sources.jar"/>

  <patternset id="jdbc.version.src.pattern">
    <!-- This is the core of the driver.  It is common for all versions. -->
    <include name="${package}/*.java" />
    <include name="${package}/core/**" />
    <include name="${package}/copy/**" />
    <include name="${package}/fastpath/**" />
    <include name="${package}/geometric/**" />
    <include name="${package}/largeobject/**" />
    <include name="${package}/util/**" />

    <!--
    Each jdbcN subpackage is used only if the driver supports *at least* that
    revision of JDBC. That is, a JDBC2 build uses only jdbc2, a JDBC3 build
    uses both jdbc2 and jdbc3, etc.

    Within those subpackages, classes beginning with "JdbcN" are assumed to be
    the concrete implementations for JDBC version N and are built only if the
    driver supports *exactly* that version. For example, jdbc2/Jdbc2Statement.java
    is built only if the driver build is a JDBC2 build.
    -->

    <!-- jdbc2 subpackage -->
    <include name="${package}/jdbc2/**"/>

    <!-- jdbc3 subpackage -->
    <include name="${package}/jdbc3/Abstract*.java"/>
    <include name="${package}/jdbc3/PSQLSavepoint.java"/>

    <include name="${package}/jdbc3/Jdbc3Array.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Blob.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3CallableStatement.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Clob.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Connection.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3DatabaseMetaData.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3PreparedStatement.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3ResultSet.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3ResultSetMetaData.java.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Statement.java" if="jdbc3"/>

    <!-- jdbc3g subpackage -->
    <include name="${package}/jdbc3g/*.java" if="jdbc3g"/>
    <exclude name="${package}/jdbc3g/Jdbc3g*.java" unless="jdbc3g"/>

    <!-- jdbc4 subpackage -->
    <include name="${package}/jdbc4/*.java" if="jdbc4any"/>
    <exclude name="${package}/jdcb4/Jdbc4*.java" unless="jdbc4any"/>

    <!-- ssl -->
    <include name="${package}/ssl/SingleCertValidatingFactory.java" if="jdbc4any"/>
    <include name="${package}/ssl/jdbc4/*.java" if="jdbc4any"/>
    <include name="${package}/ssl/jdbc3/*.java" if="jdbc3any"/>
    <include name="${package}/ssl/*.java" if="jdbc3any"/>

    <!-- gss -->
    <include name="${package}/gss/*.java"/>

    <!-- datasource stuff -->
    <include name="${package}/jdbc3/Jdbc3ConnectionPool.java" if="jdbc3any"/>
    <include name="${package}/jdbc3/Jdbc3PoolingDataSource.java" if="jdbc3any"/>
    <include name="${package}/jdbc3/Jdbc3SimpleDataSource.java" if="jdbc3any"/>

    <include name="${package}/ds/*.java"/>
    <include name="${package}/ds/common/*.java"/>
    <include name="${package}/ds/jdbc23/*.java"/>
    <include name="${package}/ds/jdbc4/*.java" if="jdbc4any"/>

    <!-- XA stuff -->
    <include name="${package}/xa/*.java"/>
    <include name="${package}/xa/jdbc3/*.java"/>
    <include name="${package}/xa/jdbc4/*.java" if="jdbc4any"/>
  </patternset>

  <artifact:dependencies pathId="dependency.classpath" useScope="test">
    <dependency groupId="junit" artifactId="junit" version="3.8.2" scope="test"/>
  </artifact:dependencies>

  <target name="check_versions">
    <condition property="jdbc2">
      <or>
        <equals arg1="${java.specification.version}" arg2="1.2"/>
        <equals arg1="${java.specification.version}" arg2="1.3"/>
      </or>
    </condition>
    <condition property="jdbc3">
        <equals arg1="${java.specification.version}" arg2="1.4"/>
    </condition>
    <condition property="jdbc3g">
	<equals arg1="${java.specification.version}" arg2="1.5"/>
    </condition>
    <condition property="jdbc4">
        <equals arg1="${java.specification.version}" arg2="1.6"/>
    </condition>
    <condition property="jdbc41">
      <or>
	<equals arg1="${java.specification.version}" arg2="1.7"/>
        <equals arg1="${java.specification.version}" arg2="1.8"/>
      </or>
    </condition>
    <condition property="jdbc4any">
      <or>
        <isset property="jdbc4" />
	<isset property="jdbc41" />
      </or>
    </condition>
    <condition property="jdbc3any">
      <or>
        <isset property="jdbc3" />
	<isset property="jdbc3g" />
      </or>
    </condition>
    <condition property="jdbc3plus">
      <or>
        <isset property="jdbc3any" />
	<isset property="jdbc4any" />
      </or>
    </condition>

    <condition property="unknownjvm">
      <not>
        <or>
          <isset property="jdbc2" />
          <isset property="jdbc3any" />
          <isset property="jdbc4any" />
        </or>
      </not>
    </condition>

    <fail if="jdbc2" message="1.4 or higher JDK is required to build the JDBC driver." />
    <fail if="unknownjvm" message="Unknown JDK version." />

    <available property="junit" classname="junit.framework.Test"/>
    <available property="junit.task" classname="org.apache.tools.ant.taskdefs.optional.junit.JUnitTask"/>

    <condition property="jdbc4tests">
      <and>
        <isset property="jdbc4any" />
        <isset property="junit" />
      </and>
    </condition>

    <condition property="jdbc41tests">
      <and>
        <isset property="jdbc41" />
        <isset property="junit" />
      </and>
    </condition>

    <condition property="jdbc.version" value="jdbc3">
      <isset property="jdbc3any" />
    </condition>

    <condition property="jdbc.version" value="jdbc4">
      <isset property="jdbc4" />
    </condition>

    <condition property="jdbc.version" value="jdbc41">
      <isset property="jdbc41" />
    </condition>

    <condition property="jdbc.version.upper" value="JDBC3">
      <isset property="jdbc3any" />
    </condition>

    <condition property="jdbc.version.upper" value="JDBC4">
      <isset property="jdbc4" />
    </condition>

    <condition property="jdbc.version.upper" value="JDBC41">
      <isset property="jdbc41" />
    </condition>
  </target>


  <!-- default target -->
  <target name="all">
    <antcall target="jar" />
  </target>


  <!-- create the jar file -->
  <target name="jar" depends="compile, artifact-version">
    <property name="artifact.jar" value="${jardir}/${artifact.version.string}.jar"/>
    <jar jarfile="${artifact.jar}">
      <fileset dir="${builddir}">
        <include name="${package}/**/*.class" />
      </fileset>

      <fileset dir="${srcdir}">
        <include name="${package}/translation/*.class" />
      </fileset>

      <metainf dir="META-INF">
      </metainf>
      <manifest>
        <attribute name="Main-Class" value="org.postgresql.util.PGJDBCMain"/>
      </manifest>
    </jar>
  </target>


  <target name="compile" depends="prepare,check_versions,driver">

    <available classname="org.postgresql.Driver" property="old.driver.present" />
    <fail message="Old driver was detected on classpath or in jre/lib/ext, please remove and try again." if="old.driver.present" />

    <javac classpath="${srcdir}" srcdir="${srcdir}" destdir="${builddir}" debug="${debug}" source="${java.specification.version}">
      <classpath refid="dependency.classpath" />
      <patternset refid="jdbc.version.src.pattern"/>
    </javac>
  </target>

  <target name="check_driver">
    <uptodate targetfile="${package}/Driver.java" property="driver.uptodate">
      <srcfiles dir="${srcdir}">
      <include name="${package}/Driver.java.in"/>
      <include name="${package}/ds/PGSimpleDataSource.java.in"/>
      <include name="${package}/ds/PGPoolingDataSource.java.in"/>
      <include name="${package}/ds/PGPooledConnection.java.in"/>
      <include name="${package}/ds/PGConnectionPoolDataSource.java.in" />
      <include name="${package}/xa/PGXADataSource.java.in" />
      <include name="build.properties"/>
      <include name="build.local.properties" />
      </srcfiles>
    </uptodate>
  </target>

  <!--
    This generates Driver.java from Driver.java.in
    It's required for importing the driver version properties
  -->
  <target name="driver" depends="prepare,check_versions,check_driver"
          unless="driver.uptodate">
    <!-- determine the edition text -->
    <condition property="edition" value="JDBC3">
        <equals arg1="${jdbc3}" arg2="true"/>
    </condition>
    <condition property="edition" value="JDBC3g">
    	<equals arg1="${jdbc3g}" arg2="true" />
    </condition>
    <condition property="edition" value="JDBC4">
	<equals arg1="${jdbc4}" arg2="true" />
    </condition>
    <condition property="edition" value="JDBC4.1">
	<equals arg1="${jdbc41}" arg2="true" />
    </condition>

    <!-- determine the connection class -->
    <condition property="connectclass" value="org.postgresql.jdbc3.Jdbc3Connection">
        <equals arg1="${jdbc3}" arg2="true"/>
    </condition>
    <condition property="connectclass" value="org.postgresql.jdbc3g.Jdbc3gConnection">
        <equals arg1="${jdbc3g}" arg2="true"/>
    </condition>
    <condition property="connectclass" value="org.postgresql.jdbc4.Jdbc4Connection">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="notimplementedexception" value="java.sql.SQLException">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="notimplementedexception" value="java.sql.SQLFeatureNotSupportedException">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="simpledsclass" value="org.postgresql.ds.jdbc23.AbstractJdbc23SimpleDataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="simpledsclass" value="org.postgresql.ds.jdbc4.AbstractJdbc4SimpleDataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="poolingdsclass" value="org.postgresql.ds.jdbc23.AbstractJdbc23PoolingDataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="poolingdsclass" value="org.postgresql.ds.jdbc4.AbstractJdbc4PoolingDataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
</condition>

    <condition property="pooledconnclass" value="org.postgresql.ds.jdbc23.AbstractJdbc23PooledConnection">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="pooledconnclass" value="org.postgresql.ds.jdbc4.AbstractJdbc4PooledConnection">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="connpooldsclass" value="org.postgresql.ds.jdbc23.AbstractJdbc23ConnectionPoolDataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="connpooldsclass" value="org.postgresql.ds.jdbc4.AbstractJdbc4ConnectionPoolDataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="xadsclass" value="org.postgresql.xa.jdbc3.AbstractJdbc3XADataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="xadsclass" value="org.postgresql.xa.jdbc4.AbstractJdbc4XADataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>
    <condition property="makesslclass" value="org.postgresql.ssl.jdbc3.AbstractJdbc3MakeSSL">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="makesslclass" value="org.postgresql.ssl.jdbc4.AbstractJdbc4MakeSSL">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>
	
    <!-- Some defaults -->
    <filter token="MAJORVERSION" value="${major}" />
    <filter token="MINORVERSION" value="${minor}" />
    <filter token="VERSION" value="PostgreSQL ${fullversion} ${edition}" />
    <filter token="JDBCCONNECTCLASS" value="${connectclass}" />
    <filter token="NOTIMPLEMENTEDEXCEPTION" value="${notimplementedexception}" />
    <filter token="XA_DS_CLASS" value="${xadsclass}" />
    <filter token="POOLING_DS_CLASS" value="${poolingdsclass}" />
    <filter token="SIMPLE_DS_CLASS" value="${simpledsclass}" />
    <filter token="POOLED_CONN_CLASS" value="${pooledconnclass}" />
    <filter token="CONN_POOL_DS_CLASS" value="${connpooldsclass}" />
    <filter token="DEF_PGPORT" value="${def_pgport}" />
    <filter token="MAKE_SSL_CLASS" value="${makesslclass}"/>

     <fail unless="major" message="'major' undefined. Please follow the directions in README."/>
     <fail unless="minor" message="'minor' undefined. Please follow the directions in README."/>
     <fail unless="fullversion" message="'fullversion' undefined. Please follow the directions in README."/>
     <fail unless="def_pgport" message="'def_pgport' undefined. Please follow the directions in README."/>
     <fail unless="enable_debug" message="'enable_debug' undefined. Please follow the directions in README."/>
 
    <!-- Put a check for the current version here -->

    <!-- now copy and filter the file -->
    <copy file="${srcdir}/${package}/Driver.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/Driver.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGPoolingDataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGPoolingDataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGSimpleDataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGSimpleDataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGPooledConnection.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGPooledConnection.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGConnectionPoolDataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGConnectionPoolDataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/xa/PGXADataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/xa/PGXADataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ssl/MakeSSL.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ssl/MakeSSL.java"
          filtering="yes" />

  <echo message="Configured build for the ${edition} edition driver." />
  </target>


  <!-- Prepares the build directory -->
  <target name="prepare">
    <!-- use the enable_debug option from configure -->
    <condition property="debug" value="on">
      <and>
        <equals arg1="${enable_debug}" arg2="yes" />
      </and>
    </condition>
    <mkdir dir="${builddir}" />
    <mkdir dir="${jardir}" />
  </target>


  <!-- This target removes any class files from the build directory -->
  <target name="clean">
    <delete quiet="true" dir="${builddir}" />
    <delete quiet="true" dir="${jardir}" />
    <delete quiet="true" file="${srcdir}/${package}/Driver.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGPoolingDataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGSimpleDataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGPooledConnection.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGConnectionPoolDataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/xa/PGXADataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/ssl/MakeSSL.java" />
  </target>

  <!-- This compiles and executes the JUnit tests -->

  <!-- defaults for the tests - override these if required -->
  <property name="server" value="localhost" />
  <property name="port" value="${def_pgport}" />
  <property name="database" value="test" />
  <property name="username" value="test" />
  <!-- Password must be something.  Doesn't matter if trust is used! -->
  <property name="password" value="test" />
	
  <property name="privilegedUser" value="postgres"/>	
  <!-- Password must be something.  Doesn't matter if trust is used! -->
  <property name="privilegedPassword" value=""/>	
	
  <property name="preparethreshold" value="5" />
  <property name="loglevel" value="0" />
  <property name="protocolVersion" value="0" />
  <property name="ssltest.properties" value="ssltest.properties" />

  <!-- The tests now build to a separate directory and jarfile from the
       driver build, to ensure we're really testing against the jar we just
       built, and not whatever happens to be in builddir. -->

  <!-- This compiles and builds the test jarfile. -->  
  <target name="testjar" depends="jar">
    <mkdir dir="${builddir}/tests"/>
    <javac srcdir="${srcdir}" destdir="${builddir}/tests" debug="${debug}" source="${java.specification.version}">
      <classpath refid="dependency.classpath" />
      <include name="${package}/test/**" />

      <exclude name="${package}/test/jdbc4/**" unless="jdbc4tests" />
      <exclude name="${package}/test/jdbc4/jdbc41/**" unless="jdbc41tests" />
      <exclude name="${package}/test/ssl/**" unless="jdbc4tests" />

      <classpath>
        <pathelement location="${artifact.jar}"/>
      </classpath>
    </javac>
    <jar jarfile="${jardir}/postgresql-tests.jar" basedir="${builddir}/tests"/>
  </target>
    
  <!-- This actually runs the tests -->
  <target name="runtest" depends="testjar">
    <fail message="Your version of ant doesn't seem to have the junit task available.  I looked for org.apache.tools.ant.taskdefs.optional.junit.JUnitTask, but I couldn't find it." unless="junit.task" />

    <delete file="postgresql-jdbc-tests.debug.txt"/>

    <property name="testResultsDir" value="${builddir}/testresults" />
    <mkdir dir="${testResultsDir}" />
 
    <junit>
      <formatter type="brief" usefile="false"/>
      <formatter type="xml" usefile="true" />

      <sysproperty key="server" value="${server}" />
      <sysproperty key="port" value="${port}" />
      <sysproperty key="database" value="${database}" />
      <sysproperty key="username" value="${username}" />
      <sysproperty key="password" value="${password}" />
      <sysproperty key="privilegedUser" value="${privilegedUser}"/>	
      <sysproperty key="privilegedPassword" value="${privilegedPassword}"/>	
      <sysproperty key="preparethreshold" value="${preparethreshold}" />
      <sysproperty key="loglevel" value="${loglevel}" />
      <sysproperty key="protocolVersion" value="${protocolVersion}" />
      <sysproperty key="ssltest.properties" value="${ssltest.properties}" />

      <classpath refid="dependency.classpath" />
      <classpath>
        <pathelement location="${artifact.jar}" />
        <pathelement location="${jardir}/postgresql-tests.jar" />
        <pathelement path="${java.class.path}" />
      </classpath>
      <test name="org.postgresql.test.jdbc2.Jdbc2TestSuite" outfile="${testResultsDir}/jdbc2"/>
      <test name="org.postgresql.test.jdbc2.optional.OptionalTestSuite" outfile="${testResultsDir}/jdbc2optional"/>
      <test name="org.postgresql.test.jdbc3.Jdbc3TestSuite" outfile="${testResultsDir}/jdbc3"/>
      <test name="org.postgresql.test.xa.XATestSuite" outfile="${testResultsDir}/xa"/>
      <test name="org.postgresql.test.extensions.ExtensionsSuite" outfile="${testResultsDir}/extensions"/>
      <test name="org.postgresql.test.jdbc4.Jdbc4TestSuite" if="jdbc4tests" outfile="${testResultsDir}/jdbc4"/>
      <test name="org.postgresql.test.jdbc4.jdbc41.Jdbc41TestSuite" if="jdbc41tests" outfile="${testResultsDir}/jdbc41"/>
      <test name="org.postgresql.test.ssl.SslTestSuite" if="jdbc4tests" outfile="${testResultsDir}/ssl"/>
      <test name="org.postgresql.test.ssl.SingleCertValidatingFactoryTest" if="jdbc4tests" outfile="${testResultsDir}/scsf-ssl"/>
    </junit>
  </target>
  
  <!-- Build and run the tests. -->
  <target name="test" depends="testjar,runtest"/>

  <!-- Build public javadoc -->
  <target name="publicapi" depends="compile">
    <mkdir dir="${builddir}/publicapi" />
    <javadoc destdir="${builddir}/publicapi" charset="utf-8">
      <classpath>
        <pathelement path="${builddir}" />
        <pathelement path="${java.class.path}" />
      </classpath>
      <fileset dir="${srcdir}/${package}">
        <include name="copy/*.java" />
        <include name="geometric/*.java" />
        <include name="largeobject/*.java" />
        <include name="fastpath/*.java" />
        <include name="PG*.java" />
        <include name="util/PGobject.java" />
        <include name="util/PGmoney.java" />
        <include name="util/PGInterval.java" />
        <include name="util/ServerErrorMessage.java" />
        <include name="ssl/WrappedFactory.java" />
        <include name="ssl/NonValidatingFactory.java" />
        <include name="ssl/SingleCertValidatingFactory.java" />
        <include name="ds/PG*.java" />
        <include name="ds/common/BaseDataSource.java" />
        <include name="xa/PGXADataSource.java" />
      </fileset>
    </javadoc>
  </target>

  <!-- Build driver-internal javadoc. NB: needs Ant 1.6 & JDK 1.4 for 'breakiterator'. -->
  <target name="privateapi" depends="compile">
    <javadoc destdir="${builddir}/privateapi" breakiterator="yes" charset="utf-8">
      <classpath>
        <pathelement path="${builddir}" />
        <pathelement path="${java.class.path}" />
      </classpath>
      <fileset dir="${srcdir}/${package}">
        <include name="**/*.java"/>
	<exclude name="jdbc3/Jdbc3*.java" unless="jdbc3" />
	<exclude name="jdbc3g/Jdbc3g*.java" unless="jdbc3g" />
	<exclude name="jdbc4/*.java" unless="jdbc4any" />
	<exclude name="ds/jdbc4/*.java" unless="jdbc4any" />
        <exclude name="test/**/*.java"/>
      </fileset>
    </javadoc>
  </target>

  <!-- Build the documentation -->
  <target name="doc" depends="prepare">
   <mkdir dir="${builddir}/doc"/>
   <xslt basedir="doc" destdir="${builddir}/doc" includes="*.xml" force="yes" style="${docbook.stylesheet}">
     <param name="base.dir" expression="${builddir}/doc/"/>
     <param name="use.id.as.filename" expression="1" />
   </xslt>
  </target>

  <!-- Blah. Can't reference an external XML catalog until Ant 1.6.
       So instead we copy the contents of ${docbook.dtd}/catalog.xml
       here, in the form that Ant's xmlcatalog element wants. -->
  <xmlcatalog id="docbook-catalog">  
    <dtd publicId="-//OASIS//DTD DocBook XML V4.2//EN"
      location="${docbook.dtd}/docbookx.dtd"/>
    <entity publicId="-//OASIS//DTD DocBook CALS Table Model V4.2//EN"
      location="${docbook.dtd}/calstblx.dtd"/>
    <entity publicId="-//OASIS//DTD XML Exchange Table Model 19990315//EN"
      location="${docbook.dtd}/soextblx.dtd"/>
    <entity publicId="-//OASIS//ELEMENTS DocBook Information Pool V4.2//EN"
      location="${docbook.dtd}/dbpoolx.mod"/>    
    <entity publicId="-//OASIS//ELEMENTS DocBook Document Hierarchy V4.2//EN"
      location="${docbook.dtd}/dbhierx.mod"/>    
    <entity publicId="-//OASIS//ENTITIES DocBook Additional General Entities V4.2//EN"
      location="${docbook.dtd}/dbgenent.mod"/>    
    <entity publicId="-//OASIS//ENTITIES DocBook Notations V4.2//EN"
      location="${docbook.dtd}/dbnotnx.mod"/>
    <entity publicId="-//OASIS//ENTITIES DocBook Character Entities V4.2//EN"
      location="${docbook.dtd}/dbcentx.mod"/>
  </xmlcatalog>

  <!-- Validate but don't process the documentation.
       This target expects the DocBook XML DTDs, available at
       http://www.docbook.org/xml/4.2/docbook-xml-4.2.zip, to be
       present in ${docbook.dtd}. If they're not present, they will
       be fetched on each validation from www.oasis-open.org.

       Note that if the DTD fetch fails, validation fails with a fairly
       useless error message. Run ant with -verbose to get a more useful
       error. You'll need to set the java properties http.proxyHost and
       http.proxyPort if you need to go via a proxy to fetch the DTDs.
  -->
       
  <target name="validate-doc" depends="prepare">
    <xmlvalidate warn="true">
      <fileset dir="doc" includes="*.xml"/>
      <xmlcatalog refid="docbook-catalog"/>
    </xmlvalidate>
  </target>

  <target name="artifact-version" description="Sets the version string for the jar artifact">
    <property name="artifact.version.string" value="${maven.artifact.id}-${maven.artifact.version}.${jdbc.version}" />
    <echo message="Artifact version string: ${artifact.version.string}" />
  </target>

  <target name="snapshot-version" description="Sets the version string to a snapshot version">
    <property name="maven.artifact.version.string" value="${maven.artifact.version}-${jdbc.version}-SNAPSHOT" />
    <echo message="Maven version string: ${maven.artifact.version.string}" />
  </target>

  <target name="release-version" description="Sets the version string to a release version">
    <property name="maven.artifact.version.string" value="${maven.artifact.version}-${jdbc.version}" />
    <echo message="Maven version string: ${maven.artifact.version.string}" />
  </target>

  <target name="prepare-pom" depends="prepare,check_versions" description="Filters the pom depending on the jdbc version being built">
    <mkdir dir="${builddir}/pom"/>
    <!-- Copy the templated pom.xml with version info -->
    <filter token="maven.group.id" value="${maven.group.id}"/>
    <filter token="maven.artifact.id" value="${maven.artifact.id}"/>
    <filter token="maven.artifact.version.string" value="${maven.artifact.version.string}"/>
    <filter token="maven.artifact.description" value="${maven.artifact.description}"/>
    <filter token="jdbc.version.upper" value="${jdbc.version.upper}"/>
    <copy todir="${builddir}/pom" filtering="true" file="src/pom/pom.xml"/>
  </target>

  <target name="snapshot" depends="maven-jar,snapshot-version,prepare-pom" description="deploy snapshot version to Maven snapshot repository">
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-deploy-plugin:2.6:deploy-file"/>
      <artifact:arg value="-Durl=${maven.snapshots.repository.url}"/>
      <artifact:arg value="-DrepositoryId=${maven.snapshots.repository.id}"/>
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml"/>
      <artifact:arg value="-Dfile=${maven.jar}"/>
    </artifact:mvn>
  </target>

  <!-- before this, update project version (both build.xml and pom.xml) from SNAPSHOT to RELEASE -->
  <target name="release" depends="maven-jar,release-version,prepare-pom" description="deploy release version to Maven staging repository">
    <!-- sign and deploy the main artifact -->
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.4:sign-and-deploy-file" />
      <artifact:arg value="-Durl=${maven.staging.repository.url}" />
      <artifact:arg value="-DrepositoryId=${maven.staging.repository.id}" />
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml" />
      <artifact:arg value="-Dfile=${maven.jar}" />
      <artifact:arg value="-Pgpg" />
    </artifact:mvn>

    <!-- sign and deploy the sources artifact -->
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.4:sign-and-deploy-file" />
      <artifact:arg value="-Durl=${maven.staging.repository.url}" />
      <artifact:arg value="-DrepositoryId=${maven.staging.repository.id}" />
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml" />
      <artifact:arg value="-Dfile=${maven.sources.jar}" />
      <artifact:arg value="-Dclassifier=sources" />
      <artifact:arg value="-Pgpg" />
    </artifact:mvn>

    <!-- sign and deploy the javadoc artifact -->
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.4:sign-and-deploy-file" />
      <artifact:arg value="-Durl=${maven.staging.repository.url}" />
      <artifact:arg value="-DrepositoryId=${maven.staging.repository.id}" />
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml" />
      <artifact:arg value="-Dfile=${maven.javadoc.jar}" />
      <artifact:arg value="-Dclassifier=javadoc" />
      <artifact:arg value="-Pgpg" />
    </artifact:mvn>
  </target>

  <!-- create jar files for distribution to maven central -->
  <target name="maven-jar" depends="jar, publicapi">
    <!-- Copy the built jar into a maven compatible name -->
    <copy file="${artifact.jar}" tofile="${maven.jar}"/>
    <!-- Create a jar of the javadoc public api -->
    <jar jarfile="${maven.javadoc.jar}">
      <fileset dir="${builddir}/publicapi">
        <include name="**/*"/>
      </fileset>
    </jar>
    <!-- Create a jar of the source code -->
    <jar jarfile="${maven.sources.jar}">
      <fileset dir="${srcdir}">
        <patternset refid="jdbc.version.src.pattern"/>
        <include name="META-INF/**/*"/>
      </fileset>
    </jar>
  </target>

</project>