build.xml

<project name="mimprint" default="build">

    <target name="init">
        <property file="local.properties"/>
        <property file="build.properties"/>
        <property file="VERSION"/>

        <property name="rel.subdir" value="${version.name}-${version.numberU}"/>
        <property name="rel.dir" value="${release.dir}/${rel.subdir}" />
        <property name="rel.jar" value="${rel.subdir}.jar" />

        <property name="relbin.files"
            value="README README.html VERSION LICENSE COPYRIGHT HISTORY \
		    mim mim.bat"/>
	<property name="jarinst.files"
		value="${src.dir}/jarinst/*.c ${src.dir}/jarinst/*.ini
			${src.dir}/jarinst/*.inf ${src.dir}/jarinst/*.bat"/>

	<property name="log4j.dir"
		value="${net.dir}/log4j"/>
	<property name="log4j.jar"
		value="${log4j.dir}/log4j-${log4j.version}.jar"/>

	<property name="jshortcut.dir"
		value="${net.dir}/jshortcut/v${jshortcut.version}"/>
	<property name="jshortcut.jar" value="${jshortcut.dir}/jshortcut.jar"/>
	<property name="jshortcut.dll" value="${jshortcut.dir}/jshortcut.dll"/>

        <property name="junit.dir"
                 value="${net.dir}/junit${junit.version}"/>
        <property name="junit.jar" value="${junit.dir}/junit.jar"/>

        <property name="hansel.dir"
                 value="${net.dir}/hansel-${hansel.version}"/>
        <property name="hansel.jar" value="${hansel.dir}/lib/hansel.jar"/>
        <property name="hansel-bcel.jar" value="${hansel.dir}/lib/bcel.jar"/>

        <property name="scala.dir"
                value="${net.dir}/scala/scala-current"/>
        <property name="scala.compiler.jar"
                value="${scala.dir}/lib/scala-compiler.jar"/>
        <property name="scala.library.jar"
                value="${scala.dir}/lib/scala-library.jar"/>

        <property name="scalatest.version" value="1.0"/>
        <property name="scalatest.dir"
                value="${net.dir}/scala/scalatest-${scalatest.version}"/>
        <property name="scalatest.jar"
                value="${scalatest.dir}/scalatest-${scalatest.version}.jar"/>

        <!-- Unit testing, things you might want to change -->
        <property name="test.coverage" value=""/>
        <property name="test.headlessarg" value="-Djava.awt.headless=true"/>
        <property name="test.includes" value="**/Test*.java"/>
        <property name="test.jvmarg" value=""/>

        <!-- You should not have to change these values -->
        <property name="testsrc.dir" value="testsrc"/>
        <property name="testobj.dir" value="${build.dir}/testobj"/>
        <property name="test.results.dir" value="${build.dir}/test/results"/>
        <property name="test.reports.dir" value="${build.dir}/test/reports"/>
        <property name="test.jar" value="${build.dir}/test.jar"/>
        <property name="testresources.properties"
            value="${testobj.dir}/net/jimmc/racer/TestResources.properties"/>

        <!-- The classpath for compiling our java classes. -->
        <path id="compile.classpath">
            <pathelement location="${class.dir}"/>
	    <pathelement location="${jshortcut.jar}"/>
        </path>

        <!-- The classpath for compiling our scala classes. -->
        <path id="scala.classpath">
            <pathelement location="${scala.compiler.jar}"/>
            <pathelement location="${scala.library.jar}"/>
            <pathelement location="${class.dir}"/>
	    <pathelement location="${log4j.jar}"/>
        </path>

	<!-- The classpath for compiling our test java classes -->
	<path id="testcompile.classpath">
	    <path refid="compile.classpath"/>
            <path refid="scala.classpath"/>
            <pathelement location="${scalatest.jar}"/>
	    <pathelement location="${testobj.dir}"/>
	    <pathelement location="${junit.jar}"/>
	    <pathelement location="${hansel.jar}"/>
	    <pathelement location="${hansel-bcel.jar}"/>
	</path>

        <!-- The classpath for running our tests -->
        <path id="test.classpath">
            <path refid="compile.classpath"/>
            <path refid="scala.classpath"/>
            <pathelement location="${scalatest.jar}"/>
            <pathelement location="${testobj.dir}"/>
            <pathelement location="${junit.jar}"/>
            <pathelement location="${hansel.jar}"/>
            <pathelement location="${hansel-bcel.jar}"/>
        </path>

        <!-- The classpath for creating our scaladoc docs. -->
	<path id="scaladoc.classpath">
            <pathelement location="${scala.library.jar}"/>
	    <path refid="compile.classpath"/>
	</path>

        <!-- Define the scalac task -->
        <taskdef resource="scala/tools/ant/antlib.xml">
            <classpath refid="scala.classpath"/>
        </taskdef>

    </target>

    <target name="mkdirs" depends="init">
        <mkdir dir="${build.dir}"/>
        <mkdir dir="${class.dir}"/>
        <mkdir dir="${release.dir}"/>
        <mkdir dir="${testobj.dir}"/>
    </target>

    <target name="build" depends="jar"/>

    <target name="compile" depends="javac,scalac"/>

    <target name="javac" depends="init,mkdirs">
        <javac
            srcdir="${src.dir}"
            destdir="${class.dir}"
            debug="${javac.debug}"
            classpathref="compile.classpath"
            source="1.4"
        >
            <include name="**/*.java"/>
	    <exclude name="**/*.old/**/*.java"/>
        </javac>
    </target>

    <macrodef name="base-scalac">
        <!-- fsc task is same as scalac, but uses cached "fast scala compiler" -->
        <!-- To clear out the compiler cache, run "fsc -reset" -->
        <attribute name="m.cp.name" default="scala.classpath"/>
        <attribute name="m.src.dir" default="${src.dir}"/>
        <attribute name="m.class.dir" default="${class.dir}"/>
        <sequential>
            <scalac
                 srcdir="@{m.src.dir}"
                 destdir="@{m.class.dir}"
                 addparams="-g:vars"
                 classpathref="@{m.cp.name}"
                 force="changed"
                 deprecation="on"
            >
                <include name="**/*.scala"/>
                <exclude name="**/*.old/**/*.scala"/>
            </scalac>
        </sequential>
    </macrodef>

    <target name="scalac" depends="init,mkdirs,javac">
        <base-scalac/>
    </target>

    <!-- Compile the test classes -->
    <target name="testcompile" depends="testjavac,testscalac"
    		description="Compile all unit test java classes"/>

    <!-- Compile the test java classes -->
    <target name="testjavac" depends="init,mkdirs"
    		description="Compile all unit test java classes">
        <javac
	    srcdir="${testsrc.dir}"
	    destdir="${testobj.dir}" 
	    debug="${javac.debug}"
	    classpathref="testcompile.classpath"
	    source="1.4"
	>
	    <include name="**/*.java"/>
	    <exclude name="**/*.old/**/*.java"/>
	</javac>
    </target>

    <target name="testscalac" depends="init,build"
            description="Compile the scala test files">
        <base-scalac
            m.cp.name="testcompile.classpath"
            m.src.dir="${testsrc.dir}"
            m.class.dir="${testobj.dir}" />
    </target>

    <!-- Create the default properties file from all of the props files -->
    <target name="properties-default"
	    depends="init,check-properties-default,concat-properties-default"/>

    <!-- See if the properties file is up to date -->
    <target name="check-properties-default">
        <uptodate property="properties-default-uptodate"
		targetfile="${resources.properties}"
        >
	    <srcfiles dir="${src.dir}"
		    includes="**/*.props"
		    excludes="**/*_*.props"
	    />
	    <srcfiles dir="${src.dir}"
		    includes="net/jimmc/catprops/*.java"
	    />
	    <srcfiles dir="." includes="build.xml" />
	</uptodate>
    </target>

    <!-- Create the properties file if it is not up to date. -->
    <target name="concat-properties-default"
    		unless="properties-default-uptodate">
	<path id="prop-file-path">
	    <fileset dir="${src.dir}">
	    	<include name="**/*.props"/>
	    	<exclude name="**/*_*.props"/>
	    </fileset>
	</path>
	<property name="prop-files" refid="prop-file-path"/>
	<java	classname="net/jimmc/catprops/CatProps"
		classpath="${class.dir}"
		output="${resources.properties}.tmp"
		fork="true"
		failonerror="true"
	>
	    <arg value="-sourcepath"/>
	    <arg line="${prop-files}"/>
	</java>
	<!-- Now that the props have been collected, replace the VERSION
	     and VDATE strings. -->
	<copy file="${resources.properties}.tmp"
		tofile="${resources.properties}">
	    <filterset begintoken="%" endtoken="%">
	        <filter token="VERSION" value="v${version.number}"/>
	        <filter token="VDATE" value="${version.date}"/>
	    </filterset>
	</copy>
	<delete file="${resources.properties}.tmp"/>
    </target>

    <!-- Create the test properties file from all of the test props files -->
    <target name="testproperties"
	    depends="init,check-testproperties,concat-testproperties"/>

    <!-- See if the test properties file is up to date -->
    <target name="check-testproperties">
        <uptodate property="testproperties-uptodate"
		targetfile="${testresources.properties}"
        >
	    <srcfiles dir="${testsrc.dir}" includes="**/*.props"/>
	</uptodate>
    </target>

    <!-- Create the test properties file if it is not up to date. -->
    <target name="concat-testproperties" unless="testproperties-uptodate">
    	<echo message="A test echo"/>
<!--
    	<echo destfile="${testobj.dir}/props.header" message="#Auto-generated"/>
	<echo destfile="${testobj.dir}/props.header">
#This file is automatically created from the *.props files
#in various source directories.
</echo>
-->
	<mkdir dir="${testobj.dir}/net/jimmc/racer"/>
        <concat
		destfile="${testresources.properties}.tmp"
	>
	    <filelist dir="${testobj.dir}" files="props.header"/>
	    <fileset dir="${testsrc.dir}">
	    	<include name="**/*.props"/>
	    	<exclude name="**/*.old/**/*.props"/>
	    </fileset>
	    <!-- TBD - would be nice if we could get separators between
	      the files, like we had from the Makefile -->
	</concat>
	<!-- Now that the props have been collected, replace the VERSION
	     and VDATE strings. -->
	<copy file="${testresources.properties}.tmp"
		tofile="${testresources.properties}">
	    <filterset begintoken="%" endtoken="%">
	        <filter token="VERSION" value="v${versionNumber}"/>
	        <filter token="VDATE" value="${versionDate}"/>
	    </filterset>
	</copy>
    </target>

    <target name="jar" depends="compile,properties-default"
            description="Build the application">
        <!-- Start by creating the jar file with all our classes. -->
        <jar
            jarfile="${mimprint.jar}"
            basedir="${class.dir}"
        >
            <manifest>
                <attribute name="Main-class" value="${main.class}"/>
		<attribute name="Class-Path"
			value="jRegistryKey.jar jshortcut.jar"/>
            </manifest>
        </jar>
        <!-- Now add the image files from the source directory. -->
        <zip
            destfile="${mimprint.jar}"
            basedir="${src.dir}"
            update="true"
            includes="**/*.gif **/*.png"
        />
    </target>

    <!-- Make the jar file with the test classes -->
    <target name="testjar" depends="testcompile,testproperties"
    		description="Create the test.jar file">
        <jar
	    jarfile="${test.jar}"
	    basedir="${testobj.dir}"
	/>
    </target>

    <target name="test" depends="testinit,testjava,testscala"
    		description="Run the unit tests"/>

    <target name="testinit" depends="jar,testjar">
        <delete dir="${test.results.dir}"/>
        <delete dir="${test.reports.dir}"/>
        <mkdir dir="${test.results.dir}"/>
        <mkdir dir="${test.reports.dir}"/>
    </target>

    <target name="testjava" depends="testinit">
	<junit	printsummary="true"
		errorProperty="test.failed"
		failureProperty="test.failed"
                fork="yes">
            <!-- Add JVM args to run with debugger enabled -->
            <jvmarg value="-Xdebug"/>
            <jvmarg value="-Xnoagent"/>
            <jvmarg line="-Djava.compiler=NONE ${test.jvmarg} ${test.headlessarg}"/>
                <!-- we would put test.jvmarg and test.headlessarg
                     each in its own jvmarg, but we want
                     to be able to set them to blank, which doesn't work
                     properly when each is its own arg. -->
	    <formatter type="plain"/>
	    <formatter type="xml"/>
	    <classpath refid="test.classpath"/>
	    <sysproperty key="JR_TEST_COVERAGE"
	    	value="${test.coverage}"/>
	    <batchtest todir="${test.results.dir}">
	        <fileset dir="${testsrc.dir}">
		    <include name="${test.includes}"/>
		</fileset>
	    </batchtest>
        </junit>

<!-- junitreport seems to be broken, so skip it...
	<junitreport todir="${test.reports.dir}">
	    <fileset dir="${test.results.dir}">
	        <include name="TEST-*.xml"/>
	    </fileset>
	    <report format="frames" todir="${test.reports.dir}"/>
	</junitreport>
-->

	<fail message="Test failures, see ${test.reports.dir}"
		if="test.failed"/>
    </target>

    <target name="testscala" depends="testinit">
        <pathconvert property="runscalatest.classpath"
                refid="test.classpath" pathsep=":"/>
        <property name="test.main.class" value="org.scalatest.tools.Runner"/>
        <echo>scala -classpath ${runscalatest.classpath} ${test.main.class} -p ${testobj.dir} -o</echo>
        <exec
                executable="scala"
                failonerror="true"
        >
            <arg line="-classpath ${runscalatest.classpath}"/>
            <arg line="${test.main.class}"/>
            <arg line="-p ${testobj.dir}"/>
            <arg line="-o"/>
        </exec>
    </target>

    <target name="testdebug" description="Run unit tests with suspend for debug">
        <property name="test.debugjvmarg"
                value="-Xrunjdwp:transport=dt_socket,address=2000,server=y,suspend=y"/>
        <antcall target="test">
	    <param name="test.jvmarg" value="${test.debugjvmarg}"/>
	</antcall>
    </target>

    <target name="clean" depends="init"
            description="Remove all generated files">
        <delete dir="${build.dir}"/>
        <delete file="${mimprint.jar}"/>
    </target>

    <!-- Make the documentation -->
    <target name="doc" depends="apidoc"
    		description="Compile all the documentation"/>

    <target name="apidoc" depends="init"
    		description="Create the scaladoc documentation">
        <uptodate targetfile="${apidoc.dir}/index.html"
		property="apidoc-uptodate">
	    <srcfiles dir="${src.dir}"
	    	includes="**/*.scala"
		excludes="**/*.old/**/*.scala"/>
	</uptodate>
	<antcall target="create-apidoc"/>
    </target>

    <target name="create-apidoc" depends="init" unless="apidoc-uptodate">
        <mkdir dir="${apidoc.dir}"/>
	<scaladoc
		srcdir="${src.dir}"
		destdir="${apidoc.dir}"
		classpathref="scaladoc.classpath"
	>
            <include name="**/*.scala"/>
            <exclude name="**/*.old/**/*.scala"/>
	</scaladoc>
    </target>

    <target name="coverage" description="Run unit tests with coverage">
        <antcall target="test">
            <param name="test.coverage" value="1"/>
        </antcall>
    </target>

    <target name="all" depends="jar,doc,test"
    		description="Build all files and run all tests for release"/>

    <target name="arch" depends="init"
    		description="Copy the reljar and README files to the Arch dir">
	<property name="arch.version.dir"
		value="${arch.dir}/v${version.number}"/>
        <mkdir dir="${arch.version.dir}"/>
        <copy file="${rel.jar}"
		tofile="${arch.version.dir}/${rel.jar}"
		preservelastmodified="true"/>
        <copy file="README.html"
		tofile="${arch.version.dir}/README-${version.numberU}.html"
		preservelastmodified="true"/>
        <chmod dir="${arch.version.dir}" includes="*" perm="-w"/>
    </target>

    <target name="gittag" depends="init"
    		description="Tag all files in git for the current release">
	<echo message="Tagging files as ${version.name}-${version.number}"/>
        <exec executable="git" failonerror="true" >
            <arg line="tag -a -m 'Auto-tag version ${version.number}' ${version.name}-${version.number}"/>
        </exec>
    </target>

    <target name="rel" depends="relbin,relsrc,relapidoc"
    		description="Create the release directory"/>

    <target name="relbin" depends="init">
        <mkdir dir="${rel.dir}"/>
	<copy todir="${rel.dir}" flatten="true" preservelastmodified="true">
	    <fileset dir="." includes="${relbin.files}"/>
	</copy>
        <chmod dir="${rel.dir}" includes="mim" perm="+x"/>
	<copy todir="${rel.dir}" file="${mimprint.jar}"
		preservelastmodified="true"/>
	<copy todir="${rel.dir}" file="${jshortcut.jar}"
		preservelastmodified="true"/>
	<copy todir="${rel.dir}" file="${jshortcut.dll}"
		preservelastmodified="true"/>
        <!-- Don't copy in the api doc, we deliver it in apidoc.zip ...
	<copy todir="${rel.dir}/doc/api" preservelastmodified="true">
	    <fileset dir="${apidoc.dir}" includes="*"/>
	</copy>
        -->
	<copy todir="${rel.dir}/templates" preservelastmodified="true">
	    <fileset dir="${templates.dir}" includes="**/*.mpr"/>
	</copy>
    </target>

    <target name="relsrc" depends="init">
        <property name="relsrc.includes"
                  value="README.build build.xml build.properties
			${jarinst.files}
			${src.dir}/**/*.java
			${src.dir}/**/*.scala
                        ${src.dir}/**/*.props
			${src.dir}/**/*.html
                        ${src.dir}/**/*.mf" />
        <zip basedir="." destfile="${rel.dir}/src.zip"
		includes="${relsrc.includes}"
		excludes="**/*.old/**/*.*"
	/>
    </target>

    <target name="relapidoc" depends="init">
        <zip basedir="." destfile="${rel.dir}/apidoc.zip"
		includes="${apidoc.dir}/**/*"
	/>
    </target>

    <!-- Make the release jar file from the release directory -->
    <target name="reljar" depends="init"
	    description=
	        "Create the distributable jar file from the release directory">
	<!-- Start by creating a jar file with the release directory files -->
        <jar basedir="${release.dir}" jarfile="${rel.jar}"
                includes="${rel.subdir}/**">
	    <manifest>
	        <attribute name="Main-class"
                        value="net.jimmc.selfunzip.ZipSelfExtractor"/>
	    </manifest>
	</jar>
        <zip basedir="${class.dir}" destfile="${rel.jar}"
		includes="net/jimmc/selfunzip/ZipSelfExtractor*.class"
		update="true"
	/>
	<!-- Add the shortcut class for installing on windows. -->
        <zip destfile="${rel.jar}" update="true">
	    <zipfileset src="${jshortcut.jar}"
		    includes="net/jimmc/jshortcut/JShellLink.class"/>
	</zip>
    </target>

</project>