build.xml

<?xml version="1.0" encoding="UTF-8"?>
<project basedir="." name="HsgProject" default="all" xmlns:if="ant:if" xmlns:unless="ant:unless" xmlns:xdb="http://exist-db.org/ant">
    <property file="build/local.build.properties"/>
    <property file="build/build.properties"/>

    <property name="repos" value="repos"/>
    <property name="libs" value="lib"/>
    <property name="build" value="build"/>

    <property name="build-env" value=""/>

    <!-- use "xars" unless called with a "repo-name" property -->
    <condition property="xars" value="${repo-name}" else="xars">
        <isset property="repo-name"/>
    </condition>
    <property name="instance.tempColl" value="hsg-temp"/>
    <property name="instance.tempPath" value="/db/${instance.tempColl}"/>
    <property name="local.instance.temp" value="${local.instance.uri}${instance.tempPath}"/>
    <property name="production.instance.temp" value="${production.instance.uri}${instance.tempPath}"/>

    <taskdef resource="net/sf/antcontrib/antcontrib.properties" classpath="build/lib/ant-contrib-1.0b3.jar"/>

    <target name="all" depends="ping-localhost,ping-public-repo,clean,update,build,deploy"
            description="Clean, update, build, and deploy all packages (assumes 'setup' has already been run)"/>

    <condition property="git.private.include">
        <istrue value="${git.private.include}"/>
    </condition>

    <target name="clone-private-repos" if="${git.private.include}"
            description="Clone private packages">
        <echo message="Cloning private packages into ${repos}..."/>
        <foreach list="${git.private.repo-names}" delimiter="," parallel="false" target="git.clone.private" param="repo-name"/>
    </target>

    <target name="check-if-repo-exists">
        <condition property="repo-exists" value="true" else="false">
            <available file="${repos}/${repo-name}" type="dir"/>
        </condition>

        <echo if:true="${repo-exists}" message="If you need to re-clone this repo, please delete ${repos}/${repo-name} and try again."/>

        <!-- let the command git.clone only fail on error, if the to-be-cloned repo is not yet existing, e.g. on an initial setup -->
        <condition property="fail-on-error" value="false" else="true">
            <istrue value="${repo-exists}"/>
        </condition>
    </target>

    <target name="git.clone.private" depends="check-if-repo-exists">
        <antcall target="git.clone">
            <param name="local-repo-name" value="${repo-name}"/>
            <param name="origin" value="${git.private.remotes.origin.org}/${repo-name}.git"/>
            <param name="upstream" value="${git.private.remotes.upstream.org}/${repo-name}.git"/>
        </antcall>
    </target>

    <target name="clone-public-repos">
        <echo message="Cloning required packages into ${repos}..."
              description="Clone public packages"/>
        <foreach list="${git.public.repo-names}" delimiter="," parallel="false" target="git.clone.public" param="repo-name"/>

        <!-- TODO(AR) these should likely move to HistoryAtState -->
        <foreach list="${git.joewiz.repo-names}" delimiter="," parallel="false" target="git.clone.joewiz" param="repo-name"/>
    </target>

    <target name="git.clone.public" depends="check-if-repo-exists">
        <antcall target="git.clone">
            <param name="local-repo-name" value="${repo-name}"/>
            <param name="origin" value="${git.public.remotes.origin.org}/${repo-name}.git"/>
            <param name="upstream" value="${git.public.remotes.upstream.org}/${repo-name}.git"/>
        </antcall>
    </target>

    <!-- TODO(AR) these should likely move to HistoryAtState -->
    <target name="git.clone.joewiz"  depends="check-if-repo-exists">
        <antcall target="git.clone">
            <param name="local-repo-name" value="${repo-name}"/>
            <param name="origin" value="${git.joewiz.remotes.origin.org}/${repo-name}.git"/>
            <param name="upstream" value="${git.joewiz.remotes.upstream.org}/${repo-name}.git"/>
        </antcall>
    </target>

    <target name="setup" depends="prepare,upgrade-local-build-properties,mvn-copy-dependencies,clone-public-repos,clone-private-repos"
            description="Clone required repositories">
        <echo message="Completed cloning of repositories..."/>
    </target>

    <target name="build" depends="prepare" description="Build all packages">
        <iterate target="build-xar"/>
    </target>

    <target name="deploy" description="Deploy all packages"
            depends="ping-localhost,ping-public-repo,deploy.init,deploy.install-packages-from-public-repo,deploy.upload,deploy.deploy,deploy.cleanup"/>

    <target name="deploy-one" description="Deploy one package"
            depends="ping-localhost,ping-public-repo,deploy.init,deploy.upload-one,deploy.deploy-xar,deploy.cleanup"/>

    <target name="prepare">
        <mkdir dir="${libs}"/>
        <mkdir dir="${xars}"/>
        <mkdir dir="${repos}"/>
    </target>

    <target name="mvn-copy-dependencies" depends="prepare">
        <delete>
            <fileset dir="${libs}">
                <include name="*.jar"/>
            </fileset>
        </delete>
        <exec executable="${mvn}" dir=".">
            <arg line="dependency:copy-dependencies -DoutputDirectory=${libs}" />
        </exec>
    </target>

    <target name="update">
        <echo message="-------------------------------------"/>
        <echo message="Pulling updates for all repositories"/>
        <echo message="-------------------------------------"/>

        <antcall target="update-public-repos"/>
        <antcall target="update-private-repos"/>
    </target>

    <target name="update-private-repos" if="${git.private.include}"
            description="Update private packages">
        <echo message="Cloning private packages into ${repos}..."/>
        <foreach list="${git.private.repo-names}" delimiter="," parallel="false" target="git.pull-path" param="repo-name"/>
    </target>

    <target name="update-public-repos">
        <echo message="Updating required packages into ${repos}..."
              description="Update public packages"/>
        <foreach list="${git.public.repo-names}" delimiter="," parallel="false" target="git.pull-path" param="repo-name"/>

        <!-- TODO(AR) these should likely move to HistoryAtState -->
        <foreach list="${git.joewiz.repo-names}" delimiter="," parallel="false" target="git.pull-path" param="repo-name"/>
    </target>

    <target name="git.pull-path">
        <antcall target="git.pull">
            <param name="local-repo-path" value="${repos}/${repo-name}"/>
        </antcall>
    </target>

    <target name="update-one">
        <antcall target="git.pull">
            <param name="local-repo-path" value="${repos}/${repo-name}"/>
        </antcall>
    </target>

    <target name="deploy.init">
        <path id="exist.classpath">
            <fileset dir="${libs}">
                <include name="*.jar"/>
            </fileset>
        </path>

        <typedef resource="org/exist/ant/antlib.xml" uri="http://exist-db.org/ant">
            <classpath refid="exist.classpath"/>
        </typedef>
        <typedef resource="net/sf/antcontrib/antlib.xml">
            <classpath refid="exist.classpath"/>
        </typedef>
    </target>

    <target name="deploy.upload">
        <echo message="Uploading packages ..."/>
        <xdb:store uri="${local.instance.temp}" user="${local.instance.user}"
                   password="${local.instance.password}" createcollection="true">
            <fileset dir="${xars}">
                <include name="*.xar"/>
            </fileset>
        </xdb:store>
    </target>

    <target name="deploy.upload-to-production">
        <echo message="Uploading packages ..."/>
        <xdb:store uri="${production.instance.temp}" user="${production.instance.user}"
                   password="${production.instance.password}" createcollection="true">
            <fileset dir="${xars}">
                <include name="*.xar"/>
            </fileset>
        </xdb:store>
    </target>

    <target name="deploy.upload-one" depends="deploy.get-xar-filename">
        <echo message="Uploading package ${repo-name} ..."/>
        <xdb:store uri="${local.instance.temp}" user="${local.instance.user}"
                   password="${local.instance.password}" createcollection="true"
                   srcfile="${repos}/${repo-name}/${build}/${xar}"/>
    </target>

    <target name="deploy.deploy">
        <echo message="Installing packages ..."/>
        <iterate-xars target="deploy.deploy-xar"/>
    </target>

    <target name="deploy.install-packages-from-public-repo">
        <echo message="Installing packages from public repo..."/>
        <xdb:create uri="${local.instance.uri}/db" user="${local.instance.user}"
                    password="${local.instance.password}" collection="${instance.tempColl}"/>
        <echo message="Installing Shared Resources..."/>
        <xdb:xquery uri="${local.instance.temp}" user="${local.instance.user}"
                    password="${local.instance.password}"
                    query="repo:install-and-deploy('http://exist-db.org/apps/shared', '${eXist.public-repo.lookup}')"/>
        <echo message="Installing TEI Publisher Libraries..."/>
        <xdb:xquery uri="${local.instance.temp}" user="${local.instance.user}"
                    password="${local.instance.password}"
                    query="repo:install-and-deploy('http://existsolutions.com/apps/tei-publisher-lib', '${eXist.public-repo.lookup}')"
        />
        <echo message="Installing Crypto Module..."/>
        <xdb:xquery uri="${local.instance.temp}" user="${local.instance.user}"
                    password="${local.instance.password}"
                    query="repo:install-and-deploy('http://expath.org/ns/crypto', '${eXist.public-repo.lookup}')"/>
        <echo message="Installing SAML Module..."/>
        <xdb:xquery uri="${local.instance.temp}" user="${local.instance.user}"
                    password="${local.instance.password}"
                    query="repo:install-and-deploy('http://exist-db.org/xquery/exsaml', '${eXist.public-repo.lookup}')"/>
        <!-- NOTE: Messaging and Replication app is needed on production system in ApacheMQ environment,
            but without ApacheMQ listening, deploying an app that registers the replication trigger will fail. -->
        <!--
        <echo message="Installing Messaging and Replication..."/>
        <xdb:xquery uri="${local.instance.temp}" user="${local.instance.user}" password="${local.instance.password}"
            query="repo:install-and-deploy('http://exist-db.org/messaging-replication', '${eXist.public-repo.lookup}')"/>
        -->
    </target>

    <target name="deploy.get-xar-filename" unless="xar">
        <path id="xar-path-ref">
            <fileset dir="${repos}/${repo-name}/${build}">
                <include name="*.xar"/>
            </fileset>
        </path>
        <property name="xar-path" refid="xar-path-ref"/>
        <basename property="xar" file="${xar-path}"/>
    </target>

    <target name="deploy.deploy-xar" depends="deploy.get-xar-filename">
        <echo message="Deploying xar ${xar}"/>
        <xdb:xquery uri="${local.instance.temp}" user="${local.instance.user}"
                    password="${local.instance.password}" queryFile="${build}/deploy.xql"
                    outputproperty="deploy.output">
            <variable name="temp" value="${instance.tempPath}"/>
            <variable name="xar" value="${xar}"/>
            <variable name="repo" value="${eXist.public-repo.lookup}"/>
        </xdb:xquery>
        <echo message="${deploy.output}"/>
    </target>

    <target name="deploy.cleanup">
        <echo message="Removing temporary collection ..."/>
        <xdb:remove uri="${local.instance.temp}" user="${local.instance.user}"
                    password="${local.instance.password}" collection="${instance.tempPath}"/>
    </target>

    <target name="clean" description="Call clean on all package dirs; remove built xars">
        <delete>
            <fileset dir="${xars}">
                <include name="*.xar"/>
            </fileset>
        </delete>
        <subant target="clean" failonerror="false">
            <fileset dir=".">
                <include name="${repos}/*/build.xml"/>
            </fileset>
        </subant>
    </target>

    <target name="clean-all" depends="clean"
            description="Clean everything, including checked out repos, downloaded libs, and built xars">
        <delete dir="${libs}" failonerror="false"/>
        <delete dir="${repos}" failonerror="false"/>
        <delete dir="${xars}" failonerror="false"/>
    </target>

    <!-- Called on each directory in repos to build it -->
    <target name="build-xar">
        <echo message="Building ${dir}"/>
        <echo message="Validating well-formedness of XML files in ${dir}"/>
        <xmlvalidate lenient="true">
            <fileset dir="${dir}" includes="**/**.xml,**/**.xconf" excludes="node_modules/**"/>
        </xmlvalidate>
        <subant target="xar${build-env}">
            <!-- set version for repos deployed to localhost during development, since CI sets versions at time of release -->
            <property name="app.version" value="0.0.0-development"/>
            <fileset dir="${dir}">
                <include name="build.xml"/>
            </fileset>
        </subant>
        <copy todir="xars/" failonerror="false">
            <fileset dir="${dir}/build">
                <include name="*.xar"/>
            </fileset>
        </copy>
        <delete dir="${dir}" includes="*.xar"/>
    </target>

    <target name="git.pull">
        <echo message="Updating ${local-repo-path}..."/>
        <exec executable="${git}" dir="${local-repo-path}" failonerror="true">
            <arg line="pull"/>
            <arg line="--recurse-submodules"/>
        </exec>
        <exec executable="${git}" dir="${local-repo-path}" failonerror="true">
            <arg line="submodule"/>
            <arg line="update"/>
            <arg line="--recursive"/>
        </exec>
    </target>

    <!-- Iterate through directory of repos and call target for each -->
    <scriptdef name="iterate" language="javascript">
        <attribute name="target"/>
        <![CDATA[
            repos = project.getProperty("repos");

            fs = project.createDataType("fileset");
            fs.setDir(new java.io.File(repos));
            fs.setIncludes("*/build.xml");

            ds = fs.getDirectoryScanner(project);
            descriptors = ds.getIncludedFiles();

            var basedir = fs.getDir(project);

            for (i=0; i < descriptors.length; i++) {
              var descriptor = new java.io.File(basedir, descriptors[i]);
              var dir = descriptor.getParent();

              // create and use a Task via Ant API
              antc = project.createTask("antcall");
              var prop = antc.createParam();
              prop.setName("dir");
              prop.setValue(dir);

              antc.setTarget(attributes.get("target"));
              antc.perform();
            }
        ]]>
    </scriptdef>

    <!-- Iterate through directory of xars and call target for each xar -->
    <scriptdef name="iterate-xars" language="javascript">
        <attribute name="target"/>
        <![CDATA[
            xarsDir = project.getProperty("xars");

            fs = project.createDataType("fileset");
            fs.setDir(new java.io.File(xarsDir));
            fs.setIncludes("*.xar");

            ds = fs.getDirectoryScanner(project);
            xars = ds.getIncludedFiles();

            var basedir = fs.getDir(project);

            for (i=0; i < xars.length; i++) {
              // create and use a Task via Ant API
              antc = project.createTask("antcall");
              var prop = antc.createParam();
              prop.setName("xar");
              prop.setValue(xars[i]);

              antc.setTarget(attributes.get("target"));
              antc.perform();
            }
        ]]>
    </scriptdef>

    <target name="git.clone">
        <echo message="Cloning ${origin}..."/>
        <exec executable="${git}" outputproperty="git.output" dir="${repos}" failonerror="${fail-on-error}">
            <arg line="clone"/>
            <arg line="--depth 1"/>
            <arg line="${origin}"/>
            <arg line="${local-repo-name}"/>
        </exec>
        <echo message="${git.output}"/>

        <condition property="set-upstream">
            <not>
                <equals arg1="${origin}" arg2="${upstream}"/>
            </not>
        </condition>

        <echo if:true="${set-upstream}" message="Configuring upstream: ${upstream}..."/>

        <exec if:true="${set-upstream}" executable="${git}" dir="${repos}/${local-repo-name}" failonerror="${fail-on-error}">
            <arg line="remote"/>
            <arg line="add"/>
            <arg line="upstream"/>
            <arg line="${upstream}"/>
        </exec>

        <exec if:true="${set-upstream}" executable="${git}" dir="${repos}/${local-repo-name}" failonerror="${fail-on-error}">
            <arg line="fetch"/>
            <arg line="upstream"/>
        </exec>

    </target>

    <target name="test">
        <ant antfile="${repos}/hsg-test/build.xml" target="test" useNativeBasedir="true"/>
    </target>

    <!-- ================================================= -->
    <!-- Targets for uploading files from oXygen to the db -->
    <!-- ================================================= -->

    <condition property="is-xml">
        <contains string="${file-name}" substring=".xml"/>
    </condition>

    <target name="validate-if-xml" if="${is-xml}">
        <xmlvalidate file="${directory}/${file-name}" lenient="true" failonerror="true"/>
    </target>

    <target name="upload-file-to-localhost"
            description="Upload a file from an hsg-project repo to eXist-db on localhost"
            depends="deploy.init,validate-if-xml,ping-localhost">
        <property name="directory" value="${directory}"/>
        <property name="file-name" value="${file-name}"/>
        <property name="file-path" value="${directory}/${file-name}"/>
        <echo message="Uploading ${file-name} from ${directory} to eXist-db localhost"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <fileset file="${file-path}" id="file"/>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <condition property="is-hsg-project-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/"/>
        </condition>
        <fail message="ERROR: The directory ${directory} is not an hsg-project repo"
              unless="${is-hsg-project-repo}"/>
        <condition property="is-hsg-staging-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/hsg-staging"/>
        </condition>
        <propertyregex property="target-collection" input="${file-path.unix}"
                       regexp=".*?/hsg-project/${repos}/(hsg-staging/)?(.*)" select="/db/apps/\2"
                       defaultvalue="Error" override="true"/>
        <property name="target-xmldb-collection-uri"
                  value="${local.instance.uri}${target-collection}"/>
        <xdb:store user="${local.instance.user}" password="${local.instance.password}"
                   uri="${target-xmldb-collection-uri}" createcollection="true" createsubcollections="true">
            <fileset refid="file"/>
        </xdb:store>
    </target>

    <target name="upload-file-to-production"
            description="Upload a file from an hsg-project repo to eXist-db on history.state.gov"
            depends="deploy.init,validate-if-xml,ping-production">
        <property name="directory" value="${directory}"/>
        <property name="file-name" value="${file-name}"/>
        <property name="file-path" value="${directory}/${file-name}"/>
        <echo
                message="Uploading ${file-name} from ${directory} to eXist-db on history.state.gov"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <fileset file="${file-path}" id="file"/>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <condition property="is-hsg-project-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/"/>
        </condition>
        <fail message="ERROR: The directory ${directory} is not an hsg-project repo"
              unless="${is-hsg-project-repo}"/>
        <condition property="is-hsg-staging-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/hsg-staging"/>
        </condition>
        <fail
                message="ERROR: The directory ${directory} is part of the hsg-staging repo and cannot be uploaded to the production server"
                if="${is-hsg-staging-repo}"/>
        <propertyregex property="target-collection" input="${file-path.unix}"
                       regexp=".*?/hsg-project/${repos}/(.*)" select="/db/apps/\1" defaultvalue="Error"
                       override="true"/>
        <property name="target-xmldb-collection-uri"
                  value="${production.instance.uri}${target-collection}"/>
        <xdb:store user="${production.instance.user}" password="${production.instance.password}"
                   uri="${target-xmldb-collection-uri}" ssl="true" createcollection="true"
                   createsubcollections="true">
            <fileset refid="file"/>
        </xdb:store>
    </target>

    <target name="delete-file-from-localhost"
            description="Delete a file from an hsg-project repo from eXist-db on localhost"
            depends="deploy.init">
        <property name="directory" value="${directory}"/>
        <property name="file-name" value="${file-name}"/>
        <property name="file-path" value="${directory}/${file-name}"/>
        <echo message="Deleting ${file-name} from ${directory} on eXist-db localhost"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <fileset file="${file-path}" id="file"/>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <condition property="is-hsg-project-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/"/>
        </condition>
        <fail message="ERROR: The directory ${directory} is not an hsg-project repo"
              unless="${is-hsg-project-repo}"/>
        <propertyregex property="target-collection" input="${file-path.unix}"
                       regexp=".*?/hsg-project/${repos}/(hsg-staging/)?(.*)" select="/db/apps/\2"
                       defaultvalue="Error" override="true"/>
        <property name="target-xmldb-collection-uri"
                  value="${local.instance.uri}${target-collection}"/>
        <xdb:remove user="${local.instance.user}" password="${local.instance.password}"
                    uri="${target-xmldb-collection-uri}" resource="${file-name}"/>
    </target>

    <target name="delete-file-from-production"
            description="Delete a file from an hsg-project repo from eXist-db on history.state.gov"
            depends="deploy.init">
        <property name="directory" value="${directory}"/>
        <property name="file-name" value="${file-name}"/>
        <property name="file-path" value="${directory}/${file-name}"/>
        <echo message="Deleting ${file-name} from ${directory} on eXist-db localhost"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <fileset file="${file-path}" id="file"/>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <condition property="is-hsg-project-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/"/>
        </condition>
        <fail message="ERROR: The directory ${directory} is not an hsg-project repo"
              unless="${is-hsg-project-repo}"/>
        <condition property="is-hsg-staging-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/hsg-staging"/>
        </condition>
        <fail
                message="ERROR: The directory ${directory} is part of the hsg-staging repo and cannot be uploaded to the production server"
                if="${is-hsg-staging-repo}"/>
        <propertyregex property="target-collection" input="${file-path.unix}"
                       regexp=".*?/hsg-project/repos/(.*)" select="/db/apps/\1" defaultvalue="Error"
                       override="true"/>
        <property name="target-xmldb-collection-uri"
                  value="${production.instance.uri}${target-collection}"/>
        <xdb:remove user="${production.instance.user}" password="${production.instance.password}"
                    uri="${target-xmldb-collection-uri}" resource="${file-name}" ssl="true"/>
    </target>

    <target name="update-repo"
            description="Pull updates for the parent repo of a file (from an hsg-project repo)"
            depends="deploy.init">
        <property name="directory" value="${directory}"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <condition property="is-hsg-project-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/"/>
        </condition>
        <fail message="ERROR: The directory ${directory} is not an hsg-project repo"
              unless="${is-hsg-project-repo}"/>
        <propertyregex property="repo-name" input="${file-path.unix}"
                       regexp=".*/hsg-project/${repos}/([^/]+)" select="\1" defaultvalue="Error" override="true"/>
        <antcall target="git.pull">
            <param name="local-repo-path" value="${repos}/${repo-name}"/>
        </antcall>
    </target>

    <target name="update-hsg-project" description="Updates the hsg-project repo">
        <echo message="------------------------------------"/>
        <echo message="Pulling updates for hsg-project repo"/>
        <echo message="------------------------------------"/>
        <exec executable="${git}" dir=".">
            <arg line="checkout"/>
            <arg line="HEAD"/>
            <arg line="hsg-project.xpr"/>
        </exec>
        <exec executable="${git}" dir=".">
            <arg line="pull"/>
        </exec>
    </target>

    <target name="deploy-repo-to-localhost"
            description="Packages and deploys the parent repo of a file (from an hsg-project repo) to eXist-db on localhost"
            depends="deploy.init">
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <condition property="is-hsg-project-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/"/>
        </condition>
        <fail message="ERROR: The directory ${directory} is not an hsg-project repo"
              unless="${is-hsg-project-repo}"/>
        <condition property="is-hsg-staging-repo">
            <contains string="${file-path.unix}" substring="/hsg-project/${repos}/hsg-staging"/>
        </condition>
        <fail
                message="ERROR: The directory ${directory} is part of the hsg-staging repo and cannot be deployed"
                if="${is-hsg-staging-repo}"/>
        <propertyregex property="repo-name" input="${file-path.unix}"
                       regexp=".*/hsg-project/${repos}/([^/]+)" select="\1" defaultvalue="Error"
                       override="true"/>
        <echo>Validating well-formedness of XML files in ${repo-name}</echo>
        <xmlvalidate lenient="true">
            <fileset dir="${repos}/${repo-name}" includes="**/**.xml,**/**.xconf" excludes="node_modules/**"/>
        </xmlvalidate>
        <subant>
            <!-- set version for repos deployed to localhost during development, since CI sets versions at time of release -->
            <property name="app.version" value="0.0.0-development"/>
            <fileset dir="${repos}/${repo-name}">
                <include name="build.xml"/>
            </fileset>
        </subant>
        <antcall target="deploy.upload-one"/>
        <antcall target="deploy.deploy-xar"/>
        <antcall target="deploy.cleanup"/>
    </target>

    <target name="open-repo-in-github-desktop"
            description="Opens an hsg-project repo in oXygen XML Editor" depends="deploy.init">
        <property name="directory" value="${directory}"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <propertyregex property="repo-basepath" input="${file-path.unix}"
                       regexp="(.*?/hsg-project/${repos}/[^/]*)" select="\1" defaultvalue="ERROR" override=""/>
        <fail message="ERROR: The directory ${file-path.unix} is not an hsg-project repo">
            <condition>
                <equals arg1="${repo-basepath}" arg2="ERROR"/>
            </condition>
        </fail>
        <exec executable="${github}" dir="${repo-basepath}">
            <arg line="."/>
        </exec>
    </target>

    <target name="open-repo-in-vscode" description="Opens an hsg-project repo in Visual Studio Code"
            depends="deploy.init">
        <property name="directory" value="${directory}"/>
        <path id="parent-dir">
            <pathelement path="${directory}"/>
        </path>
        <pathconvert targetos="unix" property="file-path.unix" refid="parent-dir">
            <map from="c:" to=""/>
        </pathconvert>
        <propertyregex property="repo-basepath" input="${file-path.unix}"
                       regexp="(.*?/hsg-project/${repos}/[^/]*)" select="\1" defaultvalue="ERROR" override=""/>
        <fail message="ERROR: The directory ${file-path.unix} is not an hsg-project repo">
            <condition>
                <equals arg1="${repo-basepath}" arg2="ERROR"/>
            </condition>
        </fail>
        <propertyregex property="repo" input="${file-path.unix}"
                       regexp=".*?/hsg-project/${repos}/([^/]*)" select="\1" override=""/>
        <copy file="${build}/vscode-existdb_tmpl.json" tofile="${repo-basepath}/.existdb.json"
              overwrite="yes"/>
        <replace file="${repo-basepath}/.existdb.json" token="@@@" value="${repo}"/>
        <exec executable="${vscode}" dir="${repo-basepath}">
            <arg line="."/>
        </exec>
    </target>

    <target name="ping-localhost">
        <condition property="exist-running">
            <http requestmethod="HEAD" url="http://localhost:8080/exist/apps/dashboard/index.html"/>
        </condition>
        <fail unless="${exist-running}" message="eXist is not running. Please start eXist and try again."/>
    </target>

    <target name="ping-production">
        <condition property="exist-running">
            <http requestmethod="GET" url="${production.instance.http}/test"/>
        </condition>
        <fail unless="${exist-running}" message="The production server cannot be reached. Please confirm you are connected to the internet and try again."/>
    </target>

    <target name="ping-public-repo">
        <condition property="public-repo-accessible">
            <http requestmethod="GET" url="${eXist.public-repo}" />
        </condition>
        <fail unless="${public-repo-accessible}" message="The package repository at ${eXist.public-repo} cannot be reached. Please confirm you are connected to the internet and try again."/>
    </target>

    <!-- =================================================================== -->
    <!-- Wipe eXist-db database; perform only with eXist-db shut down        -->
    <!-- =================================================================== -->
    <target name="wipe-exist-data" description="Wipe eXist data">
        <condition property="exist-running">
            <http requestmethod="GET" url="http://localhost:8080/exist"/>
        </condition>
        <fail if="${exist-running}"
              message="eXist is still running. Please shut down eXist and try again."/>
        <condition property="eXist.data-exists">
            <available file="${eXist.data}"/>
        </condition>
        <fail unless="${eXist.data-exists}" message="No eXist data was found in ${eXist.data}. This probably indicates you have just installed eXist. It could also indicate you have not run the steps required to prepare hsg-project's settings to find your eXist installation, so please consult the hsg-project setup documentation."/>
        <echo message="-------------------------"/>
        <echo message="Wiping eXist data"/>
        <echo message="-------------------------"/>
        <delete dir="${eXist.data}"/>
    </target>

    <target name="wipe-exist-data-with-confirmation" description="Wipe eXist data">
        <property name="are-you-sure" value="${are-you-sure}"/>
        <condition property="proceed">
            <equals arg1="${are-you-sure}" arg2="true"/>
        </condition>
        <fail unless="${proceed}"
              message="Halted 'Wipe eXist database' thanks to your selection of 'No'."/>
        <antcall target="wipe-exist-data"/>
    </target>

    <target name="create-new-local-build-properties"
            description="Create a new local copy of build.properties, overwriting any existing copy">
        <copy file="${build}/build.properties" tofile="${build}/local.build.properties" overwrite="yes"/>
    </target>

    <target name="check-local-build-properties"
            description="Check to make sure a local copy of build.properties is available" unless="exists-local-build-properties">
        <copy file="${build}/build.properties" tofile="${build}/local.build.properties"/>
    </target>

    <condition property="exists-local-build-properties">
        <available file="${build}/local.build.properties"/>
    </condition>

    <!-- 
        Set properties for the macOS-based hsg development environment, which uses Homebrew to install dependencies
    
        According to Homebrew's documentation, Homebrew's pre-built binary packages are installed in the following locations:
        - /usr/local for macOS Intel
        - /opt/homebrew for Apple Silicon
        @see https://docs.brew.sh/FAQ#why-should-i-install-homebrew-in-the-default-location
        
        For macOS, we set the $homebrew-prefix property to the appropriate location. 
        For other platforms, we will assume that the binaries are on the PATH and set $homebrew-prefix to an empty string.
    -->
    <condition property="homebrew-prefix" value="/usr/local/bin/">
        <os family="mac" arch="x86_64"/>
    </condition>
    <condition property="homebrew-prefix" value="/opt/homebrew/bin/">
        <os family="mac" arch="aarch64"/>
    </condition>
    <condition property="homebrew-prefix" value="">
        <not>
            <os family="mac"/>
        </not>
    </condition>
    <condition property="exist-home" value="/Applications/eXist-db.app">
        <os family="mac"/>
    </condition>
    <condition property="exist-data" value="${user.home}/Library/Application Support/org.exist">
        <os family="mac"/>
    </condition>

    <target name="upgrade-local-build-properties"
            description="Upgrade local.build.properties file to latest build.properties while preserving passwords" depends="check-local-build-properties">
        <echo message="------------------------------------------------------------"/>
        <echo message="Upgrading local.build.properties file (preserving passwords)"/>
        <echo message="------------------------------------------------------------"/>
        <propertyfile file="${build}/local.build.properties" comment="Updated with latest hsg-project settings">
            <entry key="eXist.data" value="${exist-data}"/>
            <entry key="eXist.home" value="${exist-home}"/>
            <entry key="git" value="${homebrew-prefix}git"/>
            <entry key="github" value="${homebrew-prefix}github"/>
            <entry key="mvn" value="${homebrew-prefix}mvn"/>
            <entry key="vscode" value="${homebrew-prefix}code"/>
            <entry key="local.instance.password" value="${local.instance.password}"/>
            <entry key="production.instance.user" value="${production.instance.user}"/>
            <entry key="production.instance.password" value="${production.instance.password}"/>
            <entry key="git.private.include" value="${git.private.include}"/>
        </propertyfile>
    </target>

    <target name="store-production-password"
            description="Store production password in local.build.properties" depends="check-local-build-properties">
        <property name="password" value="${password}"/>
        <propertyfile file="${build}/local.build.properties" comment="Updated with production.instance.password">
            <entry key="production.instance.password" value="${password}"/>
        </propertyfile>
    </target>

    <target name="apply-hsg-project-customizations-to-exist"
            description="Apply hsg-project customizations to eXist"
            depends="upgrade-local-build-properties,prepare-exist-configuration"/>

    <target name="prepare-exist-configuration" depends="back-up-exist-configuration-file">
        <echo message="-------------------------------------------------------"/>
        <echo message="Applying hsg customizations to eXist configuration file"/>
        <echo message="-------------------------------------------------------"/>
        <xslt in="${eXist.home}/Contents/Resources/etc/conf-orig.xml" style="${build}/configure-exist.xsl" out="${eXist.home}/Contents/Resources/etc/conf.xml" processor="trax">
            <factory name="net.sf.saxon.TransformerFactoryImpl"/>
            <classpath>
                <fileset dir="${eXist.home}/Contents/Java">
                    <include name="Saxon*.jar"/>
                </fileset>
            </classpath>
            <param name="target" type="STRING" expression="development"/>
        </xslt>
        <copy file="${build}/webdav.properties" todir="${eXist.home}/Contents/Resources/etc/" overwrite="true"/>
    </target>
    <target name="back-up-exist-configuration-file" unless="exist-configuration-backup-exists">
        <copy file="${eXist.home}/Contents/Resources/etc/conf.xml" tofile="${eXist.home}/Contents/Resources/etc/conf-orig.xml"/>
    </target>
    <condition property="exist-configuration-backup-exists">
        <available file="${eXist.home}/Contents/Resources/etc/conf-orig.xml"/>
    </condition>
    
    <target name="update-homebrew">
        <property environment="env"/>
        <echo message="-----------------"/>
        <echo message="Updating Homebrew"/>
        <echo message="-----------------"/>
        <echo message="--------"/>
        <echo message="brew tap"/>
        <echo message="--------"/>
        <exec executable="/usr/local/bin/brew" dir=".">
            <arg line="tap"/>
        </exec>
        <echo message="-----------"/>
        <echo message="brew update"/>
        <echo message="-----------"/>
        <exec executable="/usr/local/bin/brew" dir=".">
            <arg line="update"/>
        </exec>
        <echo message="------------"/>
        <echo message="brew upgrade"/>
        <echo message="------------"/>
        <exec executable="/usr/local/bin/brew" dir=".">
            <arg line="upgrade"/>
        </exec>
        <echo message="------------"/>
        <echo message="brew cleanup"/>
        <echo message="------------"/>
        <exec executable="/usr/local/bin/brew" dir=".">
            <arg line="cleanup"/>
        </exec>
        <echo message="-----------"/>
        <echo message="brew doctor"/>
        <echo message="-----------"/>
        <exec executable="/usr/local/bin/brew" dir="." searchpath="true">
            <!-- assume path is set correctly, since our hsg-project setup directions will have us set this up correctly; see https://docs.brew.sh/FAQ.html#my-mac-apps-dont-find-usrlocalbin-utilities -->
            <env key="PATH" value="/usr/local/bin:${env.PATH}"/>
            <arg line="doctor"/>
        </exec>
        <echo message="--------------------"/>
        <echo message="brew list --versions"/>
        <echo message="--------------------"/>
        <exec executable="/usr/local/bin/brew" dir=".">
            <arg line="list"/>
            <arg line="--versions"/>
        </exec>
        <echo message="----------------------------"/>
        <echo message="brew list --casks --versions"/>
        <echo message="----------------------------"/>
        <exec executable="/usr/local/bin/brew" dir=".">
            <arg line="list"/>
            <arg line="--casks"/>
            <arg line="--versions"/>
        </exec>
    </target>

    <target name="troubleshoot" description="Generate a troubleshooting report">
        <condition property="local.build.properties.exists">
            <available file="build/local.build.properties" />
        </condition>
        <echo message="----------------------"/>
        <echo message="Troubleshooting report"/>
        <echo message="----------------------"/>
        <echo message="Username: ${user.name}"/>
        <echo message="Operating system: ${os.name} ${os.version}"/>
        <antcall target="hardware-info"/>
        <antcall target="disk-free-space-check"/>
        <antcall target="software-update-check"/>
        <antcall target="update-hsg-project"/>
        <antcall target="update"/>
        <antcall target="repo-status"/>
        <antcall target="update-homebrew"/>
        <antcall target="show-app-versions"/>
        <antcall target="exist-environment"/>
        <echo message="----------------------------------------------------------------------------------------------"/>
        <echo message="Please copy and paste the entire report (starting with 'Troubleshooting report') into an email"/>
        <echo message="----------------------------------------------------------------------------------------------"/>
    </target>

    <target name="exist-environment">
        <echo message="-----------------"/>
        <echo message="eXist environment"/>
        <echo message="-----------------"/>
        <echo message="Java: ${java.version}"/>
        <echo message="Java home: ${java.home}"/>
        <echo message="local.build.properties file found: ${local.build.properties.exists}"/>
        <echo message="eXist.data: ${eXist.data}"/>
        <echo message="eXist.home: ${eXist.home}"/>
    </target>

    <target name="hardware-info">
        <echo message="--------------------"/>
        <echo message="Hardware information"/>
        <echo message="--------------------"/>
        <exec executable="system_profiler">
            <arg line="SPHardwareDataType"/>
        </exec>
    </target>

    <target name="show-app-versions">
        <echo message="--------------------------"/>
        <echo message="Versions of installed apps"/>
        <echo message="--------------------------"/>
        <exec executable="mdls" dir="." outputproperty="exist.version">
            <arg line="-raw"/>
            <arg line="-name"/>
            <arg line="kMDItemVersion"/>
            <arg line="'/Applications/eXist-db.app'"/>
        </exec>
        <exec executable="mdls" dir="." outputproperty="github.version">
            <arg line="-raw"/>
            <arg line="-name"/>
            <arg line="kMDItemVersion"/>
            <arg line="'/Applications/GitHub Desktop.app'"/>
        </exec>
        <exec executable="mdls" dir="." outputproperty="oxygen.version">
            <arg line="-raw"/>
            <arg line="-name"/>
            <arg line="kMDItemVersion"/>
            <arg line="'/Applications/Oxygen XML Editor/Oxygen XML Editor.app'"/>
        </exec>
        <echo message="eXist v${exist.version}"/>
        <echo message="GitHub Desktop v${github.version}"/>
        <echo message="oXygen XML Editor v${oxygen.version}"/>
    </target>

    <target name="repo-status">
        <iterate target="git.rev-parse"/>
    </target>

    <target name="git.rev-parse">
        <echo message="${dir}"/>
        <exec executable="${git}" dir="${dir}" outputproperty="git.current-commit">
            <arg line="rev-parse"/>
            <arg line="--short"/>
            <arg line="HEAD"/>
        </exec>
        <echo message="Head: ${git.current-commit}"/>
        <echo message="Status"/>
        <exec executable="${git}" dir="${dir}">
            <arg line="status"/>
        </exec>
    </target>

    <target name="software-update-check">
        <echo message="---------------------------"/>
        <echo message="Checking for system updates"/>
        <echo message="---------------------------"/>
        <echo message="(This may take several minutes.)"/>
        <exec executable="softwareupdate">
            <arg line="-l"/>
        </exec>
    </target>

    <target name="disk-free-space-check">
        <echo message="---------------------------"/>
        <echo message="Checking free space on disk"/>
        <echo message="---------------------------"/>
        <exec executable="df">
            <arg line="-h"/>
        </exec>
    </target>
</project>