build.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- ===================================================================== -->
<!--  File:       build.xml                                                -->
<!--  Author:     Jeni Tennison                                            -->
<!--  Tags:                                                                -->
<!--    Copyright (c) 2008, 2010 Jeni Tennison (see end of file.)          -->
<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->


<project name="xspec" default="xspec" xmlns:if="ant:if" xmlns:unless="ant:unless">
  <description><![CDATA[
    Usage:
    
      * Command-line
          https://github.com/xspec/xspec/wiki/Running-with-Ant
          
      * Oxygen XSLT transformation scenario
          https://github.com/xspec/xspec/wiki/Running-with-Oxygen
  ]]></description>

  <!-- "xspec.project.dir" property: Documented in Wiki. DO NOT RENAME.
    Directory where XSpec repository is cloned. -->
  <dirname property="xspec.project.dir" file="${ant.file.xspec}" />

  <!-- "xspec.properties" property: Documented. DO NOT RENAME.
    Absolute or relative path of Ant properties file -->
  <property name="xspec.properties" location="${xspec.project.dir}/xspec.properties" />
  <property file="${xspec.properties}" />

  <!-- "xspec.xml" property: Documented in Wiki. DO NOT RENAME.
    No default value. This property is always provided by the user.
    This property name is vague. Use the alias property "xspec.xspecfile.original" for internal use. -->

  <!-- "saxon.custom.options" property: Documented in Wiki. DO NOT RENAME.
    Optional command-line arguments passed to Saxon when running the tests.
    For example, -warnings:recover -strip:none -opt:10 -dtd:off -l:off -versionmsg:off -expand:on
    -outval:fatal -val:lax
    No default value. This property is occasionally provided by the user. -->

  <!-- "catalog" property: Documented in Wiki. DO NOT RENAME.
    File path (not URL) of XML catalog file -->

  <!-- File path of the original XSpec file specified by the user -->
  <property name="xspec.xspecfile.original" value="${xspec.xml}" />

  <!-- Directory of the original XSpec file -->
  <dirname property="xspec.xspecfile.dir" file="${xspec.xspecfile.original}" />

  <!-- File name (with extension) of the original XSpec file -->
  <basename property="xspec.xspecfile.name" file="${xspec.xspecfile.original}" />

  <!-- File name (without extension) of the original XSpec file -->
  <basename property="xspec.xspecfile.name.without.xml"
            file="${xspec.xspecfile.name}"
            suffix=".xml" />
  <basename property="xspec.xspecfile.name.without.ext"
            file="${xspec.xspecfile.name.without.xml}"
            suffix=".xspec" />

  <!-- "xspec.dir" property: Documented in Wiki. DO NOT RENAME.
    This property name is vague. Use the alias property "xspec.output.dir" for internal use. -->
  <property name="xspec.dir" value="${xspec.xspecfile.dir}/xspec" />

  <!-- Directory where various output files are created -->
  <property name="xspec.output.dir" value="${xspec.dir}" />

  <!-- Whether to create the coverage report or not -->
  <property name="xspec.coverage.enabled" value="false" />

  <!-- Whether to create the JUnit report or not -->
  <property name="xspec.junit.enabled" value="false" />

  <!-- File path of the XML report file -->
  <property name="xspec.result.xml"
            value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-result.xml" />

  <!-- File path of the coverage XML file -->
  <property name="xspec.coverage.xml"
            value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-coverage.xml" />

  <!-- "xspec.result.html" property: Documented in Wiki. DO NOT RENAME.
    File path of the test result HTML file -->
  <property name="xspec.result.html"
            value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-result.html" />

  <!-- "xspec.coverage.html" property: Documented in Wiki. DO NOT RENAME.
    File path of the coverage report HTML file -->
  <property name="xspec.coverage.html"
             value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-coverage.html" />

  <!-- File path of the JUnit report file -->
  <property name="xspec.result.junit"
            value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-junit.xml" />

  <!-- "clean.output.dir" property: Documented in Wiki. DO NOT RENAME.
    Controls whether to delete the output files -->
  <property name="clean.output.dir" value="false" />

  <!-- File path of XSLT file for formatting the test result HTML file -->
  <property name="xspec.html.reporter.xsl"
            value="${xspec.project.dir}/src/reporter/format-xspec-report.xsl" />

  <!-- File path of XSLT file for formatting the coverage report HTML file -->
  <property name="xspec.coverage.reporter.xsl"
            value="${xspec.project.dir}/src/reporter/coverage-report.xsl" />

  <!-- File path of XSLT file for formatting the JUnit report file -->
  <property name="xspec.junit.reporter.xsl"
            value="${xspec.project.dir}/src/reporter/junit-report.xsl" />

  <!-- "test.type" property: Documented in Wiki. DO NOT RENAME.
    Specifies XSLT, XQuery or Schematron -->
  <property name="test.type" value="t" />

  <!-- Properties indicating whether the test type is a specific type -->
  <condition property="xspec.is.schematron" else="false">
    <equals arg1="${test.type}" arg2="s" />
  </condition>
  <condition property="xspec.is.xquery" else="false">
    <equals arg1="${test.type}" arg2="q" />
  </condition>
  <condition property="xspec.is.xslt" else="false">
    <equals arg1="${test.type}" arg2="t" />
  </condition>

  <!-- "xspec.fail" property: Documented in Wiki. DO NOT RENAME.
    Controls whether to make the build fail when one or more tests failed -->
  <property name="xspec.fail" value="true" />

  <!-- File path of the XSpec file after preprocessing.
    XSLT and XQuery: This property is just the alias of the original XSpec file.
    Schematron: This file is created while preprocessing at preprocess-schematron-xspec and deleted by cleanup. -->
  <condition property="xspec.xspecfile.preprocessed"
             value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-sch-preprocessed.xspec"
             else="${xspec.xspecfile.original}">
    <istrue value="${xspec.is.schematron}" />
  </condition>

  <!-- Catalog URL.
    To work around a Saxon bug, it must be URL: https://saxonica.plan.io/issues/3025#note-8
    To debug catalog resolution, -Dsaxon.custom.options=-t would help.
    Oxygen 20 default transformation scenario sets catalog even when file does not exist. Hence
    validate=false. -->
  <makeurl property="xspec.catalog.url" file="${catalog}" validate="false" if:set="catalog" />

  <!-- File path of the compiled XSLT/XQuery file that finally runs the tests -->
  <property name="xspec.compiled.runner.without.ext" 
            value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}" />
  <condition property="xspec.compiled.runner"
             value="${xspec.compiled.runner.without.ext}.xq"
             else="${xspec.compiled.runner.without.ext}.xsl">
    <istrue value="${xspec.is.xquery}" />
  </condition>

  <!-- Converts URL to file path -->
  <scriptdef name="makepath" language="javascript" src="${xspec.project.dir}/src/ant/make-path.js">
    <attribute name="url" />
    <attribute name="property" />
  </scriptdef>

  <!-- Performs XSLT using Saxon with common parameters including catalog -->
  <macrodef name="saxon-xslt">
    <attribute name="in" />
    <attribute name="out" />
    <attribute name="style" />

    <element name="factory-elements" optional="true" />
    <element name="xslt-elements" optional="true" />

    <sequential>
      <xslt in="@{in}" out="@{out}" style="@{style}" force="true">
        <factory name="net.sf.saxon.TransformerFactoryImpl">
          <factory-elements />

          <!-- For debugging -->
          <!--<attribute name="http://saxon.sf.net/feature/timing"
                     value="true"/>-->
        </factory>

        <xmlcatalog if:set="catalog">
          <catalogpath>
            <pathelement location="${catalog}" />
          </catalogpath>
        </xmlcatalog>

        <xslt-elements />
      </xslt>
    </sequential>
  </macrodef>

  <!-- Transforms the input XML using the given XSLT and loads the output XML as Ant properties -->
  <macrodef name="xml-to-properties">
    <attribute name="in" />
    <attribute name="style" />

    <sequential>
      <!-- <tempfile deleteonexit=false> accumulates temp files. <tempfile deleteonexit=true> makes
        debugging a bit harder. Hence a fixed path. -->
      <property name="xspec.xml-to-properties.temp"
                value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}_xml-to-properties.xml" />

      <saxon-xslt in="@{in}"
                  out="${xspec.xml-to-properties.temp}"
                  style="${xspec.project.dir}/src/ant/@{style}" />

      <xmlproperty file="${xspec.xml-to-properties.temp}" />
    </sequential>
  </macrodef>

  <!-- Prepares the environment before compilation -->
  <target name="init">
    <condition property="xspec.coverage.dispchar" value="c" else="">
      <istrue value="${xspec.coverage.enabled}" />
    </condition>
    <echo message="Testing ${xspec.xspecfile.name} [${test.type}${xspec.coverage.dispchar}]" />

    <!-- Verify "test.type" -->
    <fail message="Invalid test.type: '${test.type}'">
      <condition>
        <and>
          <isfalse value="${xspec.is.schematron}" />
          <isfalse value="${xspec.is.xquery}" />
          <isfalse value="${xspec.is.xslt}" />
        </and>
      </condition>
    </fail>

    <!-- Verify "xspec.coverage.enabled" -->
    <fail message="Coverage is supported only for XSLT">
      <condition>
        <and>
          <istrue value="${xspec.coverage.enabled}" />
          <isfalse value="${xspec.is.xslt}" />
        </and>
      </condition>
    </fail>

    <!-- Verify .xspec file existence, to avoid creating a useless output directory -->
    <available property="xspec.xspecfile.is.available"
               file="${xspec.xspecfile.original}" type="file" />
    <fail message="XSpec file not found: '${xspec.xspecfile.original}'"
          unless="xspec.xspecfile.is.available" />

    <!-- Create the output directory.
      Need to retry, for the creation may fail temporarily while running the build repeatedly
      with clean.output.dir=true. -->
    <retry retrycount="2" retrydelay="1000">
      <mkdir dir="${xspec.output.dir}" />
    </retry>
  </target>

  <!-- Gets the file path (not URL) of the Schematron file -->
  <target name="locate-schematron-file" if="${xspec.is.schematron}">
    <xml-to-properties in="${xspec.xspecfile.original}" style="locate-schematron.xsl" />
    <makepath property="xspec.schematron.file" url="${xspec.schematron.uri}" />
    <echo message="Path of Schematron file: ${xspec.schematron.file}"
          level="info" />
  </target>

  <!-- Sets up the preprocessors for Schematron -->
  <target name="setup-schematron-preprocessor" if="${xspec.is.schematron}">
    <!-- "xspec.schematron.preprocessor.step1" property: Documented in Wiki. DO NOT RENAME.
      File path of the Step 1 preprocessor XSLT file -->
    <property name="xspec.schematron.preprocessor.step1"
              value="${xspec.project.dir}/src/schematron/iso-schematron/iso_dsdl_include.xsl" />

    <!-- "xspec.schematron.preprocessor.step2" property: Documented in Wiki. DO NOT RENAME.
      File path of the Step 2 preprocessor XSLT file -->
    <property name="xspec.schematron.preprocessor.step2"
              value="${xspec.project.dir}/src/schematron/iso-schematron/iso_abstract_expand.xsl" />

    <!-- For Step 3: Wrap the actual preprocessor in order to inject parameters -->

    <!-- File path of a temporary XSLT file which imports the actual preprocessor -->
    <property name="xspec.schematron.preprocessor.step3.wrapper"
              value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-sch-step3-wrapper.xsl" />

    <!-- "xspec.schematron.preprocessor.step3" property: Documented in Wiki. DO NOT RENAME.
      File path of the actual Step 3 preprocessor XSLT file -->
    <!-- "xspec.schematron.preprocessor.step3.url" property:
      URL of the actual preprocessor -->
    <makeurl property="xspec.schematron.preprocessor.step3.url"
             file="${xspec.schematron.preprocessor.step3}"
             if:set="xspec.schematron.preprocessor.step3" />

    <!-- Generate the wrapper of the actual preprocessor -->
    <saxon-xslt in="${xspec.xspecfile.original}"
                out="${xspec.schematron.preprocessor.step3.wrapper}"
                style="${xspec.project.dir}/src/schematron/generate-step3-wrapper.xsl">
      <xslt-elements>
        <param name="ACTUAL-PREPROCESSOR-URI" expression="${xspec.schematron.preprocessor.step3.url}"
               if="xspec.schematron.preprocessor.step3.url" />
      </xslt-elements>
    </saxon-xslt>
  </target>

  <!-- Converts Schematron into XSLT -->
  <target name="preprocess-schematron-xslt"
          depends="locate-schematron-file, setup-schematron-preprocessor"
          if="${xspec.is.schematron}">
    <!-- Location of the temporary files -->
    <property name="xspec.schematron.preprocessed.step1"
              value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-step1.sch" />
    <property name="xspec.schematron.preprocessed.step2"
              value="${xspec.output.dir}/${xspec.xspecfile.name.without.ext}-step2.sch" />

    <!-- Location of the preprocessed Schematron XSLT file.
      Since the original Schematron file may reference other files at relative paths,
      the preprocessed XSLT file needs to go in the same folder as the original Schematron file.
      This file is created at "STEP 3" and deleted by cleanup. -->
    <property name="xspec.schematron.preprocessed.xsl.file"
              value="${xspec.schematron.file}-preprocessed.xsl" />

    <echo message="STEP 1: Include modules"
          level="info" />
    <saxon-xslt in="${xspec.schematron.file}"
                out="${xspec.schematron.preprocessed.step1}"
                style="${xspec.schematron.preprocessor.step1}" />

    <echo message="STEP 2: Expand abstracts"
          level="info" />
    <saxon-xslt in="${xspec.schematron.preprocessed.step1}"
                out="${xspec.schematron.preprocessed.step2}"
                style="${xspec.schematron.preprocessor.step2}" />

    <echo message="STEP 3: Convert Schematron to XSLT"
          level="info" />
    <saxon-xslt in="${xspec.schematron.preprocessed.step2}"
                out="${xspec.schematron.preprocessed.xsl.file}"
                style="${xspec.schematron.preprocessor.step3.wrapper}" />
  </target>

  <!-- Converts Schematron XSpec into XSLT XSpec -->
  <target name="preprocess-schematron-xspec"
          depends="preprocess-schematron-xslt"
          if="${xspec.is.schematron}">
    <makeurl property="xspec.schematron.preprocessed.xsl.url"
             file="${xspec.schematron.preprocessed.xsl.file}" />

    <saxon-xslt in="${xspec.xspecfile.original}"
                out="${xspec.xspecfile.preprocessed}"
                style="${xspec.project.dir}/src/schematron/schut-to-xspec.xsl">
      <xslt-elements>
        <param name="stylesheet-uri" expression="${xspec.schematron.preprocessed.xsl.url}" />
      </xslt-elements>
    </saxon-xslt>
  </target>

  <!-- Compiles the XSpec file into the test runner file written in XSLT or XQuery -->
  <target name="compile" depends="init, preprocess-schematron-xspec">
    <condition property="xspec.compiler.xsl"
               value="generate-query-tests.xsl"
               else="generate-xspec-tests.xsl">
      <istrue value="${xspec.is.xquery}" />
    </condition>

    <echo message="Compiling Tests..."
          level="info" />
    <saxon-xslt in="${xspec.xspecfile.preprocessed}"
                out="${xspec.compiled.runner}"
                style="${xspec.project.dir}/src/compiler/${xspec.compiler.xsl}" />
  </target>

  <!-- Runs the compiled XSpec for XQuery -->
  <target name="run-xquery-test" depends="compile" if="${xspec.is.xquery}">
    <echo message="Running XQuery Tests..."
          level="info" />

    <java classname="net.sf.saxon.Query" fork="true" failonerror="true">
      <!-- Saxon should be included in the classpath -->
      <classpath>
        <pathelement path="${java.class.path}" />
      </classpath>

      <arg line="${saxon.custom.options}" if:set="saxon.custom.options" />
      <arg value="-catalog:${xspec.catalog.url}" if:set="catalog" />
      <arg value="-o:${xspec.result.xml}" />
      <arg value="-q:${xspec.compiled.runner}" />
    </java>
  </target>

  <!-- Runs the compiled XSpec for XSLT -->
  <target name="run-xslt-test" depends="compile" unless="${xspec.is.xquery}">
    <echo message="Running XSLT Tests..."
          level="info" />

    <!-- Absolute path for code coverage, with '/' and '\' adapted to
      the current platform -->
    <property name="xspec.coverage.xml.absolute"
              location="${xspec.coverage.xml}"
              if:true="${xspec.coverage.enabled}" />

    <echo message="Collecting test coverage data..."
          level="info"
          if:true="${xspec.coverage.enabled}" />

    <!-- Can't specify saxon.custom.options with <xslt> task so have to
      fall back to running Saxon as Java app. -->
    <java classname="net.sf.saxon.Transform" fork="true" failonerror="true">
      <!-- Saxon should be included in the classpath -->
      <classpath>
        <pathelement path="${java.class.path}" />
        <pathelement location="${xspec.project.dir}/java" if:true="${xspec.coverage.enabled}" />
      </classpath>

      <!-- System property for code coverage -->
      <sysproperty key="xspec.coverage.xml"
                   value="${xspec.coverage.xml.absolute}"
                   if:true="${xspec.coverage.enabled}" />

      <arg line="${saxon.custom.options}" if:set="saxon.custom.options" />
      <arg value="-catalog:${xspec.catalog.url}" if:set="catalog" />
      <arg value="-it:{http://www.jenitennison.com/xslt/xspec}main" />
      <arg value="-ext:on" />
      <arg value="-o:${xspec.result.xml}" />
      <arg value="-xsl:${xspec.compiled.runner}" />
      <arg value="-T:com.jenitennison.xslt.tests.XSLTCoverageTraceListener"
           if:true="${xspec.coverage.enabled}" />
    </java>
  </target>

  <!-- Report: Test result HTML -->
  <target name="report-html"
          depends="run-xquery-test, run-xslt-test">

    <makeurl property="xspec.result.html.css.url"
             file="${xspec.result.html.css}"
             if:set="xspec.result.html.css" />

    <saxon-xslt in="${xspec.result.xml}"
                out="${xspec.result.html}"
                style="${xspec.html.reporter.xsl}">
      <factory-elements>
        <attribute name="http://saxon.sf.net/feature/allow-external-functions"
                   value="true"/>
      </factory-elements>
      <xslt-elements>
        <param name="inline-css" expression="true" />
        <param name="report-css-uri" expression="${xspec.result.html.css.url}"
               if="xspec.result.html.css.url" />
      </xslt-elements>
    </saxon-xslt>
  </target>

  <!-- Report: Coverage HTML -->
  <target name="report-coverage"
          depends="run-xslt-test"
          if="${xspec.coverage.enabled}">

    <!-- Absolute file path of the original XSpec file -->
    <property name="xspec.xspecfile.absolute" location="${xspec.xspecfile.original}" />

    <makeurl property="xspec.coverage.html.css.url"
             file="${xspec.coverage.html.css}"
             if:set="xspec.coverage.html.css" />

    <saxon-xslt in="${xspec.coverage.xml}"
                out="${xspec.coverage.html}"
                style="${xspec.coverage.reporter.xsl}">
      <factory-elements>
        <attribute name="http://saxon.sf.net/feature/linenumbering"
                   value="true"/>
      </factory-elements>
      <xslt-elements>
        <param name="tests" expression="${xspec.xspecfile.absolute}" />
        <param name="inline-css" expression="true" />
        <param name="report-css-uri" expression="${xspec.coverage.html.css.url}"
               if="xspec.coverage.html.css.url" />
      </xslt-elements>
    </saxon-xslt>
  </target>

  <!-- Report: JUnit -->
  <target name="report-junit"
          depends="run-xquery-test, run-xslt-test"
          if="${xspec.junit.enabled}">
    <saxon-xslt in="${xspec.result.xml}"
                out="${xspec.result.junit}"
                style="${xspec.junit.reporter.xsl}" />
  </target>

  <!-- Main target -->
  <target name="xspec"
          description="Generates the result of XSpec tests"
          depends="report-html, report-coverage, report-junit">
    <antcall target="fail" />
    <antcall target="cleanup" />
  </target>

  <!-- Makes the build fail, unless otherwise specified -->
  <target name="fail" if="${xspec.fail}">
    <xml-to-properties in="${xspec.result.xml}" style="find-test-failure.xsl" />
    <fail message="XSpec tests failed. See ${xspec.result.html} for a report.">
      <condition>
        <not>
          <istrue value="${xspec.passed}" />
        </not>
      </condition>
    </fail>
  </target>

  <!-- Cleans up the output files, if required-->
  <target name="cleanup" if="${clean.output.dir}">
    <echo message="Clean up"
          level="info" />

    <!-- Need to retry, for someone may still hold a file, which tends to happen on AppVeyor. -->
    <retry retrycount="1" retrydelay="1000">
      <delete dir="${xspec.output.dir}" />
    </retry>

    <delete file="${xspec.schematron.preprocessed.xsl.file}" />
  </target>

</project>


<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
<!-- DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT.             -->
<!--                                                                       -->
<!-- Copyright (c) 2008, 2010 Jeni Tennison                                -->
<!--                                                                       -->
<!-- The contents of this file are subject to the MIT License (see the URI -->
<!-- http://www.opensource.org/licenses/mit-license.php for details).      -->
<!--                                                                       -->
<!-- Permission is hereby granted, free of charge, to any person obtaining -->
<!-- a copy of this software and associated documentation files (the       -->
<!-- "Software"), to deal in the Software without restriction, including   -->
<!-- without limitation the rights to use, copy, modify, merge, publish,   -->
<!-- distribute, sublicense, and/or sell copies of the Software, and to    -->
<!-- permit persons to whom the Software is furnished to do so, subject to -->
<!-- the following conditions:                                             -->
<!--                                                                       -->
<!-- The above copyright notice and this permission notice shall be        -->
<!-- included in all copies or substantial portions of the Software.       -->
<!--                                                                       -->
<!-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       -->
<!-- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    -->
<!-- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.-->
<!-- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  -->
<!-- CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  -->
<!-- TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     -->
<!-- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                -->
<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->