build.xml

<project default="build" basedir=".">

    <property environment="env"/>

    <!-- Source, JUnit test code and jar library locations. -->
    <property name="src" location="src"/>
    <property name="test" location="test"/>
    <property name="lib" location="lib"/>

    <!-- Location to check for local copy of beast2 repository -->
    <property name="local-beast-source-root" location="../beast2"/>
    <property name="local-beastfx-source-root" location="../BeastFX"/>

    <!-- BEAST 2 currently uses Java 1.8 -->
    <property name="sourceVersion" value="1.8"/>
    <property name="targetVersion" value="1.8"/>

    <!-- Directories necessary for all BEAST 2 packages -->
    <property name="doc" location="doc"/>
    <property name="examples" location="examples"/>
    <property name="scripts" location="scripts"/>
    <property name="fxtemplates" location="fxtemplates"/>

    <!-- BEAST branch and version to build against
         (only different for version tags because of
         a Github peculiarity) -->
    <property name="beast-branch" value="master"/>
    <property name="beast-version" value="master"/>
    <property name="beastfx-branch" value="master"/>
    <property name="beastfx-version" value="master"/>

    <!-- Names of temporary build/test directories -->
    <property name="build" location="build"/>
    <property name="build-beast" location="build-beast"/>
    <property name="build-beastfx" location="build-beastfx"/>
    <property name="beast-source-root" location="beast-source"/>
    <property name="beastfx-source-root" location="beastfx-source"/>
    <property name="build-test" location="build-test"/>
    <property name="test-reports" location="test-reports"/>
    <property name="dist" location="dist"/>
    <property name="pack" location="${dist}/package"/>

    <!-- Prepare for compilation -->
    <target name="init">

        <available file="version.xml" property="versionAvailable"/>
        <fail unless="versionAvailable">
            ** Required file version.xml does not exist. **
            If this is a new project, run "ant skeleton" from
            the command line to create the files required for
            your BEAST 2 package.
        </fail>

        <!-- Read package name and version from xml file -->
        <xmlproperty file="version.xml" prefix="fromVersionFile" />
        <property name="projName" value="${fromVersionFile.package(name)}" />
        <property name="projVersion" value="${fromVersionFile.package(version)}" />

        <mkdir dir="${build}"/>
        <mkdir dir="${dist}"/>

    </target>

    <!-- Get beast -->

    <target name="find-beast" depends="init">
        <available file="${local-beast-source-root}" property="localBeastAvailable"/>
    </target>

    <target name="get-remote-beast" depends="find-beast" unless="localBeastAvailable">
        <echo>No local copy of the beast2 source found at ${local-beast-source-root}.</echo>
        <echo>Compiling against version ${beast-version} from GitHub.</echo>

        <mkdir dir="beast-archive"/>

        <get src="https://github.com/CompEvol/beast2/archive/${beast-branch}.zip"
             dest="beast-archive/beast.zip"/>
        <unzip src="beast-archive/beast.zip" dest="beast-archive"/>

        <copy todir="${beast-source-root}">
              <fileset dir="beast-archive/beast2-${beast-version}" includes="**/*.*"/>
        </copy>

        <delete dir="beast-archive"/>
    </target>

    <target name="get-local-beast" depends="find-beast" if="localBeastAvailable">
        <echo>Compiling against beast2 source found at ${local-beast-source-root}.</echo>

        <copy todir="${beast-source-root}">
          <fileset dir="${local-beast-source-root}" includes="**/*.*"/>
        </copy>
    </target>

    <target name="build-beast" depends="get-local-beast,get-remote-beast">
      <mkdir dir="${build-beast}"/>
      <javac
          srcdir="${beast-source-root}/src"
          destdir="${build-beast}"
          source="${sourceVersion}"
          target="${targetVersion}"
          encoding="UTF-8"
          includeantruntime="false"
          fork="yes">
        <classpath>
          <pathelement path="${classpath}"/>
          <fileset dir="${beast-source-root}/lib" includes="**/*.jar"/>
        </classpath>
      </javac>
      <javac
          srcdir="${beast-source-root}/test"
          destdir="${build-beast}"
          source="${sourceVersion}"
          target="${targetVersion}"
          encoding="UTF-8"
          includeantruntime="false"
          fork="yes">
        <classpath>
          <pathelement path="${classpath}"/>
          <fileset dir="${beast-source-root}/lib" includes="**/*.jar"/>
        </classpath>
      </javac>

    </target>


    <target name="find-beastfx" depends="init">
        <available file="${local-beastfx-source-root}" property="localBeastFXAvailable"/>
    </target>

    <target name="get-local-beastfx" depends="find-beastfx" if="localBeastFXAvailable">
        <echo>Compiling against BeastFX source found at ${local-beastfx-source-root}.</echo>

        <copy todir="${beastfx-source-root}">
          <fileset dir="${local-beastfx-source-root}" includes="**/*.*"/>
        </copy>
    </target>

    <target name="get-remote-beastfx" depends="find-beastfx" unless="localBeastFXAvailable">
        <echo>No local copy of the BeastFX source found at ${local-beastfx-source-root}.</echo>
        <echo>Compiling against version ${beast-version} from GitHub.</echo>

        <mkdir dir="beastfx-archive"/>

        <get src="https://github.com/CompEvol/BeastFX/archive/refs/heads/${beastfx-branch}.zip"
             dest="beastfx-archive/beast.zip"/>
        <unzip src="beastfx-archive/beast.zip" dest="beastfx-archive"/>

        <copy todir="${beastfx-source-root}">
              <fileset dir="beastfx-archive/BeastFX-${beastfx-version}" includes="**/*.*"/>
        </copy>

        <delete dir="beastfx-archive"/>
    </target>

    <target name="build-beastfx" depends="get-local-beastfx,get-remote-beastfx">
      <mkdir dir="${build-beastfx}"/>
        <javac
            srcdir="${beastfx-source-root}/src"
            destdir="${build-beastfx}"
            source="${sourceVersion}"
            target="${targetVersion}"
            includeantruntime="false"
            encoding="UTF-8"
            fork="yes">
            <classpath>
                <pathelement path="${classpath}"/>
                <fileset dir="${beastfx-source-root}/locallib" includes="**/*.jar"/>
                <fileset dir="${env.JAVA_FX_HOME}" includes="**/*.jar"/>
                <fileset dir="${beast-source-root}/lib" includes="**/*.jar"/>
                <pathelement path="${build-beast}"/>
            </classpath>
        </javac>
    </target>

<!--    <target name="install-dependencies" depends="build-beast">-->
<!--      <mkdir dir="deps"/>-->
<!--      <java fork="true" classname="beast.pkgmgmt.PackageManager">-->
<!--        <jvmarg line="-Dbeast.user.package.dir=./deps"/>-->
<!--        <arg line="-add feast"/>-->
<!--        <classpath>-->
<!--          <pathelement path="${build-beast}"/>-->
<!--        </classpath>-->
<!--      </java>-->
<!--    </target>-->

    <!-- Compile -->
<!--    <target name="compile" depends="build-beast,build-beastfx,install-dependencies">-->
    <target name="compile" depends="build-beast,build-beastfx">

      <javac target="${targetVersion}" source="${sourceVersion}"
             srcdir="${src}" destdir="${build}"
             includeantruntime="false" fork="yes" encoding="UTF-8">
            <classpath>
                <pathelement path="${classpath}"/>
                <fileset dir="${lib}" includes="**/*.jar"/>
                <fileset dir="${beast-source-root}/lib" includes="**/*.jar"/>
                <pathelement path="${build-beast}"/>
                <fileset dir="${beastfx-source-root}/locallib" includes="**/*.jar"/>
                <pathelement path="${build-beastfx}"/>
                <fileset dir="${env.JAVA_FX_HOME}" includes="**/*.jar"/>
<!--                <fileset dir="deps/feast" includes="**/*.jar"/>-->
            </classpath>
        </javac>
    </target>

    <target name="copy-resources" depends="compile">
        <copy todir="${build}">
            <fileset dir="${src}"
                     includes="**/*.png" />
        </copy>
    </target>

    <!-- Prepare for unit test compilation -->
    <target name="init-test" depends="init">
        <mkdir dir="${build-test}"/>
        <mkdir dir="${test-reports}"/>
    </target>

    <!-- Compile unit tests -->
    <target name="compile-test" depends="init-test,compile,copy-resources">
      <javac target="${targetVersion}" source="${sourceVersion}"
             srcdir="${test}" destdir="${build-test}"
             includeantruntime="false" fork="yes">
            <classpath>
                <pathelement path="${classpath}"/>
                <pathelement path="${build}" />
                <fileset dir="${lib}" includes="**/*.jar"/>
                <fileset dir="${beast-source-root}/lib" includes="**/*.jar"/>
                <pathelement path="${build-beast}"/>
            </classpath>
        </javac>
    </target>


    <!-- Run unit tests -->
    <target name="test" depends="compile-test">
      <junit printsummary="yes" failureproperty="testFailed" showoutput="true"
             maxmemory="4G">
            <classpath>
                <pathelement path="${classpath}"/>
                <pathelement path="${build}" />
                <pathelement path="${build-test}" />
                <fileset dir="${lib}" includes="**/*.jar"/>
                <fileset dir="${beast-source-root}/lib" includes="**/*.jar"/>
                <pathelement path="${build-beast}" />
            </classpath>
            <batchtest fork="true" todir="${test-reports}">
                <fileset dir="${test}">
                    <include name="**/*Test.java"/>
                </fileset>
                <formatter type="plain"/>
                <formatter type="plain" usefile="false"/> <!-- to screen -->
            </batchtest>
        </junit>

        <fail if="testFailed" status="1" message="Unit test failed."/>
    </target>


    <!-- Create BEAST 2 package -->
    <target name="build" depends="compile,copy-resources">
        <property name="fullName" value="${projName}.v${projVersion}"/>

        <mkdir dir="${pack}"/>
        <mkdir dir="${pack}/examples"/>
        <mkdir dir="${pack}/scripts"/>
        <mkdir dir="${pack}/fxtemplates"/>
        <mkdir dir="${pack}/lib"/>
        <mkdir dir="${pack}/doc"/>

        <jar jarfile="${pack}/${fullName}.src.jar" basedir="${src}" />

        <mkdir dir="${lib}" />
        <copy todir="${pack}/lib">
            <fileset dir="${lib}" includes="*.jar" />
        </copy>
        <jar jarfile="${pack}/lib/${fullName}.jar" basedir="${build}" />

        <copy file="README.md" tofile="${pack}/README" />
        <copy file="COPYING" todir="${pack}" />
        <copy todir="${pack}">
            <fileset dir="${lib}" includes="LICENSE*" />
        </copy>

        <mkdir dir="${examples}" />
        <copy todir="${pack}/examples">
            <fileset dir="${examples}" includes="**/*.xml" />
            <fileset dir="${examples}" includes="**/*.fasta" />
            <fileset dir="${examples}" includes="**/*.fna" />
            <fileset dir="${examples}" includes="**/*.nexus" />
            <fileset dir="${examples}" includes="**/*.txt" />
        </copy>

        <mkdir dir="${scripts}" />
        <copy todir="${pack}/scripts">
            <fileset dir="${scripts}" includes="**/*" />
        </copy>


        <mkdir dir="${fxtemplates}" />
        <copy todir="${pack}/fxtemplates">
            <fileset dir="${fxtemplates}" includes="*.xml" />
        </copy>

        <mkdir dir="${doc}" />
        <copy todir="${pack}/doc">
            <fileset dir="${doc}" includes="*.tex,*.doc,*.lyx,*.txt"/>
        </copy>

        <copy file="version.xml" todir="${pack}" />

        <zip destfile="${dist}/${fullName}.zip" basedir="${pack}" />

        <delete dir="${pack}"/>

        <echo/>
        <echo/>
        <echo>** Package ${dist}/${fullName}.zip created successfuly! **</echo>
    </target>


    <!-- Revert to pristine state. -->
    <target name="clean">
        <delete dir="${build}" />
        <delete dir="${build-beast}" />
        <delete dir="${build-beastfx}" />
        <delete dir="${beast-source-root}" />
        <delete dir="${beastfx-source-root}" />
        <delete dir="${dist}" />
        <delete dir="${build-test}" />
        <delete dir="${test-reports}" />
        <delete dir="deps" />
    </target>


    <!-- Create skeleton package layout in current directory -->
    <target name="skeleton">

        <fail>
            <condition>
                <or>
                    <resourcecount when="gt" count="1">
                        <fileset dir="${basedir}"/>
                    </resourcecount>
                    <resourcecount when="gt" count="1">
                        <dirset dir="${basedir}"/>
                    </resourcecount>
                </or>
            </condition>

            ** This directory contains files besides the build script. **
            You should run "ant skeleton" in a directory containing only the build script.
        </fail>

        <echo>===============================</echo>
        <echo>Create skeleton BEAST 2 package</echo>
        <echo>===============================</echo>
        <echo/>
        <echo>First, we need some information...</echo>
        <echo/>

        <basename property="defaultProjName" file="${basedir}"/>

        <input addproperty="projName" defaultvalue="${defaultProjName}">Enter package name</input>
        <input addproperty="license" defaultvalue="gpl3" validargs="gpl3,lgpl3,lgpl2.1,apache2">Select open source software license</input>
        <input addproperty="projVersion" defaultvalue="1.0.0">Enter package version</input>
        <input addproperty="beastVersionReq" defaultvalue="2.1.0">Enter minimum required BEAST 2 version</input>

        <echo>Assembling files and directory structure...</echo>

        <echo file="version.xml">&lt;addon name="${projName}" version="${projVersion}"&gt;
            &lt;depends on="beast2" atleast="${beastVersionReq}"/&gt;

            &lt;!-- Add other dependencies as necessary. --&gt;
            &lt;/addon&gt;
        </echo>

        <echo file="README.md" message="README for my package.${line.separator}"/>

        <condition property="licenseURL" value="https://www.gnu.org/licenses/gpl-3.0.txt">
            <equals arg1="${license}" arg2="gpl3"/>
        </condition>
        <condition property="licenseURL" value="https://www.gnu.org/licenses/lgpl-3.0.txt">
            <equals arg1="${license}" arg2="lgpl3"/>
        </condition>
        <condition property="licenseURL" value="https://www.gnu.org/licenses/lgpl-2.1.txt">
            <equals arg1="${license}" arg2="lgpl2.1"/>
        </condition>
        <condition property="licenseURL" value="http://www.apache.org/licenses/LICENSE-2.0.txt">
            <equals arg1="${license}" arg2="apache2"/>
        </condition>

        <get src="${licenseURL}" dest="COPYING"/>

        <mkdir dir="${src}"/>
        <mkdir dir="${test}"/>
        <mkdir dir="${lib}"/>
        <mkdir dir="${examples}"/>
        <mkdir dir="${fxtemplates}"/>
        <mkdir dir="${doc}"/>

        <echo/>
        <echo>Done.</echo>
        <echo/>
        <echo>The directory structure is as follows:</echo>
        <echo>${src} - your java source goes here</echo>
        <echo>${test} - your junit tests go here (You _are_ going to write those, aren't you!)</echo>
        <echo>${doc} - your documentation goes here</echo>
        <echo>${examples} - your example XML scripts go here</echo>
        <echo>${fxtemplates} - your BEAUti fxtemplates go here</echo>
        <echo/>
        <echo>To build your package, just type "ant" at the command line.</echo>
        <echo/>
        <echo>To run unit tests, type "ant test".</echo>
        <echo/>
        <echo>That's it!  Happy coding!</echo>

    </target>

</project>