<project name="common">
  <!-- it's okay for this not to exist, but it gives a place to store
       "your" property settings, if any, persistently.  For example, you
       might use it to set gwt.junit.testcase.includes to a narrower subset
       of test cases to exercise. -->
  <property file="local.ant.properties" />

  <!-- gwt.build.iscasesensitivefs is true if the filesystem of the
    build machine is case-sensitive, false otherwise.  Update with
    new lines for any supported platforms with case-insensitive
    filesystems
  -->
  <condition property="gwt.build.iscasesensitivefs" else="false">
    <not>
      <or>
        <os family="windows"/>
      </or>
    </not>
  </condition>

  <property name="test.ant.file" location="${gwt.root}/${project.tail}/build.xml" />
  <condition property="project.valid">
    <equals arg1="${ant.file}" arg2="${test.ant.file}"
      casesensitive="${gwt.build.iscasesensitivefs}"/>
  </condition>
  <fail unless="project.valid" message="This build file is in an inconsistent state (${ant.file} != ${test.ant.file})." />

  <!-- Global Properties -->
  <property environment="env" />
  <condition property="gwt.version" value="${env.GWT_VERSION}" else="0.0.0">
    <isset property="env.GWT_VERSION" />
  </condition>
  <condition property="gwt.tools.check" value="${env.GWT_TOOLS}" else="${gwt.root}/../tools">
    <isset property="env.GWT_TOOLS" />
  </condition>
  <property name="gwt.tools" location="${gwt.tools.check}" />
  <property name="gwt.tools.lib" location="${gwt.tools}/lib" />
  <property name="gwt.tools.antlib" location="${gwt.tools}/antlib" />
  <property name="gwt.tools.redist" location="${gwt.tools}/redist" />
  <property name="gwt.build" location="${gwt.root}/build" />
  <property name="gwt.build.out" location="${gwt.build}/out" />
  <property name="gwt.build.lib" location="${gwt.build}/lib" />
  <property name="gwt.build.jni" location="${gwt.build}/jni" />
  <property name="gwt.build.staging" location="${gwt.build}/staging" />
  <property name="gwt.build.dist" location="${gwt.build}/dist" />
  <!-- gwt.threadsPerProcessor supercedes gwt.threadCount unless set to 0 --> 
  <property name="gwt.threadsPerProcessor" value="1" />
  <property name="gwt.threadCount" value="1" />
  <property name="project.build" location="${gwt.build.out}/${project.tail}" />
  <property name="project.lib" location="${gwt.build.lib}/gwt-${ant.project.name}.jar" />
  <property name="project.jni" location="${gwt.build}/${project.tail}" />
  <property name="javac.out" location="${project.build}/bin" />
  <property name="javac.junit.out" location="${project.build}/bin-test" />
  <property name="javac.emma.out" location="${project.build}/bin-emma" />
  <property name="javac.debug" value="true" />
  <property name="javac.debuglevel" value="lines,vars,source" />
  <property name="javac.encoding" value="utf-8" />
  <property name="javac.source" value="1.5" />
  <property name="javac.target" value="1.5" />
  <property name="javac.nowarn" value="true" />
  <property name="junit.out" location="${project.build}/test" />
  <property name="emma.dir" value="${gwt.tools.redist}/emma" />
  <property name="emma.filter.exclude" value="" />
  
  <!-- Sanity check -->
  <available file="${gwt.tools}" type="dir" property="gwt.tools.exists" />
  <fail unless="gwt.tools.exists" message="Cannot find '${gwt.tools}' tools directory; perhaps you should define the GWT_TOOLS environment variable" />

  <!-- Platform identification -->
  <condition property="build.host.islinux">
    <and>
      <os family="unix" />
      <not>
        <contains string="${os.name}" substring="mac" casesensitive="false" />
      </not>
    </and>
  </condition>
  <condition property="build.host.platform" value="linux">
    <isset property="build.host.islinux" />
  </condition>

  <condition property="build.host.ismac">
    <and>
      <os family="unix" />
      <contains string="${os.name}" substring="mac" casesensitive="false" />
    </and>
  </condition>
  <condition property="build.host.platform" value="mac">
    <isset property="build.host.ismac" />
  </condition>

  <condition property="build.host.iswindows">
    <os family="windows" />
  </condition>
  <condition property="build.host.platform" value="windows">
    <isset property="build.host.iswindows" />
  </condition>
  <fail unless="build.host.platform" message="Building on ${os.name} is not supported" />

  <!-- JUnit support -->
  <property name="gwt.dev.staging.jar" location="${gwt.build.staging}/gwt-${gwt.version}/gwt-dev.jar" />
  <property name="gwt.junit.port" value="8888" />
  <property name="gwt.junit.testcase.includes" value="**/*Suite.class"/>

  <!-- Shared class paths -->
  <path id="project.classpath.class">
    <pathelement location="${javac.out}" />
  </path>
  <path id="project.classpath.src">
    <pathelement location="${gwt.root}/${project.tail}/src" />
  </path>

  <!-- Pulls in tasks defined in ant-contrib, i.e. foreach -->
  <taskdef resource="net/sf/antcontrib/antlib.xml">
    <classpath>
      <pathelement location="${gwt.tools.antlib}/ant-contrib-1.0b3.jar" />
    </classpath>
  </taskdef>

  <!-- Global Custom Tasks -->
  <presetdef name="gwt.ant">
    <ant inheritall="false" target="${target}">
      <propertyset>
        <propertyref name="gwt.version" />
        <propertyref name="gwt.junit.port" />
        <propertyref name="gwt.remote.browsers" />
        <propertyref name="emma.enabled" />
        <propertyref name="emma.compiled" />
      </propertyset>
    </ant>
  </presetdef>

  <presetdef name="gwt.javac">
    <javac srcdir="src" destdir="${javac.out}" debug="${javac.debug}" debuglevel="${javac.debuglevel}" source="${javac.source}" target="${javac.target}" nowarn="${javac.nowarn}" encoding="${javac.encoding}" />
  </presetdef>

  <macrodef name="gwt.jar">
    <attribute name="destfile" default="${project.lib}"/>
    <attribute name="duplicate" default="fail"/>
    <attribute name="update" default="true"/>
    <element name="jarcontents" implicit="true"/>
    <sequential>
      <taskdef name="jar.bydate"
          classname="com.google.gwt.ant.taskdefs.LatestTimeJar"
          classpath="${gwt.build.lib}/ant-gwt.jar" />

      <jar.bydate destfile="@{destfile}" duplicate="@{duplicate}" filesonly="false"
          index="true" update="@{update}">
        <jarcontents/>
      </jar.bydate>
    </sequential>
  </macrodef>

  <macrodef name="gwt.junit">
    <!-- TODO: Because dev has core, oophm splits, the "common pattern" here doesn't work
         for it (and we use extraclasspaths entries instead).  Once we lose SWT, we can
         consolidate dev/core and dev/oophm, and that can instead more to the normal
         pattern.  Note also special casing regarding (dev/) core/test. -->
    <attribute name="test.args" default="" />
    <attribute name="test.out" default="" />
    <attribute name="test.reports" default="@{test.out}/reports" />
    <attribute name="test.emma.coverage" default="@{test.out}/emma-coverage" />
    <attribute name="test.cases" default="" />
    <attribute name="test.name" default="" />
    <attribute name="haltonfailure" default="true" />
    <element name="extraclasspaths" optional="true" />
    <sequential>
      <taskdef name="junit" classname="org.apache.tools.ant.taskdefs.optional.junit.JUnitTask">
        <classpath>
          <pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
          <pathelement location="${gwt.tools.antlib}/ant-junit-1.6.5.jar" />
          <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
        </classpath>
      </taskdef>

      <echo message="Writing test results to @{test.reports} for @{test.cases}" />
      <mkdir dir="@{test.reports}" />

      <antcall target="-create.emma.coverage.if.enabled">
    	  <param name="test.emma.coverage" value="@{test.emma.coverage}"/>
      </antcall>
      <condition property="emma.lib" value="${emma.dir}/emma-2.0.5312-patched.jar" else="">
        <isset property="emma.enabled" />
      </condition>

      <junit dir="@{test.out}" fork="yes" printsummary="yes"
             failureproperty="junit.failure" tempdir="@{test.out}">
        <jvmarg line="-Xmx768m" />
        <jvmarg value="-Demma.coverage.out.file=@{test.emma.coverage}/coverage.emma" />
        <jvmarg value="-Demma.coverage.out.merge=true" />
        <sysproperty key="gwt.args" value="@{test.args}" />
        <sysproperty key="java.awt.headless" value="true" />
        <classpath>
          <path refid="project.classpath.src" />
          <pathelement location="${gwt.root}/${project.tail}/super" />
          <pathelement location="${gwt.root}/${project.tail}/test" />
          <!-- TODO: this is here because e.g. ClassPathEntryTest otherwise fails,
               expecting the src entry (core/test) to be earlier than the bin entry
               (${javac.junit.out}). -->
          <pathelement location="${gwt.root}/${project.tail}/core/test" />
          <pathelement location="${javac.junit.out}" />
          <!-- javac.emma.out is empty unless emma is enabled. -->
          <pathelement location="${javac.emma.out}" />
          <path refid="project.classpath.class" />
          <pathelement location="${emma.lib}" />
          <pathelement location="${gwt.dev.staging.jar}" />
          <pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
          <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
          <pathelement location="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" />
          <pathelement location="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" />
          <extraclasspaths />
        </classpath>

        <formatter type="plain" />
        <formatter type="xml" />

        <batchtest todir="@{test.reports}">
          <fileset refid="@{test.cases}" />
        </batchtest>
      </junit>

      <emma enabled="${emma.enabled}">
        <report sourcepath="${project.classpath.src}">
          <fileset file="${javac.emma.out}/metadata.emma" />
          <fileset dir="@{test.emma.coverage}">
            <include name="*.emma" />
          </fileset>
          <txt outfile="@{test.emma.coverage}/coverage.txt" />
          <html outfile="@{test.emma.coverage}/coverage.html" />
          <xml outfile="@{test.emma.coverage}/coverage.xml" />
        </report>
      </emma>

      <condition property="junit.stop.build" value="true"> 
        <and>
          <istrue value="@{haltonfailure}"/>
          <isset property="junit.failure"/>
        </and>
      </condition>
      <fail
          message="One or more junit tests failed for target: @{test.name} @{test.args}"
          if="junit.stop.build" />
    </sequential>
  </macrodef>

  <macrodef name="gwt.tgz.cat">
    <attribute name="destfile" />
    <attribute name="compression" default="gzip" />
    <element name="tar.elements" implicit="true" optional="true" />
    <sequential>
      <taskdef name="tar.cat" classname="com.google.gwt.ant.taskdefs.TarCat" classpath="${gwt.build.lib}/ant-gwt.jar" />
      <tar.cat destfile="@{destfile}" compression="@{compression}" longfile="gnu">
        <tar.elements />
      </tar.cat>
    </sequential>
  </macrodef>

  <macrodef name="gwt.getsvninfo" description="Identifies the SVN info of a workspace">
    <sequential>
      <taskdef name="svninfo"
         classname="com.google.gwt.ant.taskdefs.SvnInfo"
         classpath="${gwt.build.lib}/ant-gwt.jar" />
      <svninfo directory="${gwt.root}" outputproperty="gwt.svnrev"
          outputfileproperty="gwt.svnrev.filename" />
      <!-- Generally, filtering requires a sentinel file so that changes to svn rev will
         be noticed as invalidating the previously-generated filter output.  This property
         names where such a sentinel lives; it is tested with <available/> and created
         with <touch/> -->
      <mkdir dir="${project.build}/sentinels" /> 
      <property name="filter.sentinel" 
          location="${project.build}/sentinels/gwt-${gwt.version}-svn-${gwt.svnrev.filename}" /> 
    </sequential>
  </macrodef>
  
  <macrodef name="gwt.revfilter" description="Filters files for versioning">
    <attribute name="todir" description="Destination for the filtered copy"/>
    
    <element name="src.fileset" implicit="true" 
      description="Source for the filtered copy"/>
    <sequential>
      <!-- These files must be filtered for versioning -->
      <echo message="Branding as GWT version ${gwt.version}, SVN rev ${gwt.svnrev}"/>
      <mkdir dir="@{todir}" />
      <copy todir="@{todir}" overwrite="true">
        <src.fileset/>
        <filterset>
          <filter token="GWT_VERSION" value="${gwt.version}" />
          <filter token="GWT_SVNREV" value="${gwt.svnrev}" />
        </filterset>
      </copy>
    </sequential>
  </macrodef>

  <macrodef name="gwt.timer">
    <attribute name="name"/>
    <element name="timer.elements" implicit="true" optional="false"/>
    <sequential>
      <taskdef name="timer" 
        classname="com.google.gwt.ant.taskdefs.Timer"
        classpath="${gwt.build.lib}/ant-gwt.jar" />
      <timer name="@{name}">
        <timer.elements/>
      </timer>
    </sequential>
  </macrodef>

  <macrodef name="gwt.checkstyle">
    <attribute name="outputdirectory" default="${project.build}"/>
    <element name="sourcepath" implicit="yes" optional="true" />
    <sequential>
      <taskdef resource="checkstyletask.properties" classpath="${gwt.tools.antlib}/checkstyle-all-4.2.jar;${gwt.build.lib}/gwt-customchecks.jar" />
      <mkdir dir="@{outputdirectory}"/>
      <checkstyle config="${gwt.root}/eclipse/settings/code-style/gwt-checkstyle.xml" maxErrors="0" failOnViolation="false" failureProperty="gwt.checkstyle.failed">
        <formatter type="xml" toFile="@{outputdirectory}/checkstyle_log.xml"/>
        <property key="checkstyle.header.file" file="${gwt.root}/eclipse/settings/code-style/google.header" />
        <sourcepath />
      </checkstyle>
      <fail message="Checkstyle errors exist, and are reported at @{outputdirectory}/checkstyle_log.xml" if="gwt.checkstyle.failed" />
    </sequential>
  </macrodef>

  <macrodef name="gwt.checkstyle.tests">
    <attribute name="outputdirectory" default="${project.build}"/>
    <element name="sourcepath" implicit="yes" optional="true" />
    <sequential>
      <taskdef resource="checkstyletask.properties" classpath="${gwt.tools.antlib}/checkstyle-all-4.2.jar;${gwt.build.lib}/gwt-customchecks.jar" />
      <mkdir dir="@{outputdirectory}"/>
      <checkstyle config="${gwt.root}/eclipse/settings/code-style/gwt-checkstyle-tests.xml" maxErrors="0" failOnViolation="false" failureProperty="gwt.checkstyle-tests.failed">
        <formatter type="xml" toFile="@{outputdirectory}/checkstyle_tests_log.xml"/>
        <property key="checkstyle.header.file" file="${gwt.root}/eclipse/settings/code-style/google.header" />
        <sourcepath />
      </checkstyle>
      <fail message="Checkstyle errors exist in tests, and are reported at @{outputdirectory}/checkstyle_tests_log.xml" if="gwt.checkstyle-tests.failed" />
    </sequential>
  </macrodef>

  <macrodef name="property.ensure">
    <attribute name="name" />
    <attribute name="location" />
    <attribute name="message" default="Cannot find dependency ${@{name}}" />
    <attribute name="unless" default="__nonexistent_property__" />
    <sequential>
      <property name="@{name}" location="@{location}" />
      <condition property="@{name}.exists">
        <or>
          <available file="${@{name}}" />
          <isset property="@{unless}" />
        </or>
      </condition>
      <fail unless="@{name}.exists" message="@{message}" />
    </sequential>
  </macrodef>

  <!-- Targets for emma support.  To run tests with emma enabled, use 
       ant <test-target> -Demma.enabled=true -->
  <path id="emma.taskdef.lib">
    <pathelement location="${emma.dir}/emma-2.0.5312-patched.jar" />
    <pathelement location="${emma.dir}/emma_ant-2.0.5312.jar" />
  </path>

  <taskdef resource="emma_ant.properties" classpathref="emma.taskdef.lib" />

  <!-- Instruments emma classes -->
  <target name="compile.emma.if.enabled" unless="emma.compiled">
    <delete dir="${javac.emma.out}" />
    <property name="emma.compiled" value="true" />
    <antcall target="-compile.emma.if.enabled" />
  </target>

  <!-- Instruments emma classes -->
  <target name="-compile.emma.if.enabled" if="emma.enabled">
    <mkdir dir="${javac.emma.out}" />
    <path id="emma.classpath">
      <pathelement location="${javac.out}" />
    </path>
    <emma enabled="${emma.enabled}" >
      <instr instrpathref="emma.classpath" destdir="${javac.emma.out}" metadatafile="${javac.emma.out}/metadata.emma" merge="false">
        <filter includes="com.google.*" />
        <filter excludes="${emma.filter.exclude}" />
      </instr>
    </emma>
  </target>

  <!-- Create the emma coverage directory -->
  <target name="-create.emma.coverage.if.enabled" if="emma.enabled">
    <delete dir="${test.emma.coverage}" />
    <mkdir dir="${test.emma.coverage}" />
  </target>

  <!-- Default implementations of the required targets; projects should
  override the ones that matter -->
  <target name="all" depends="verify" />
  <target name="verify" depends="checkstyle, test"
      description="Runs tests and checkstyle static analysis" />
  <target name="checkstyle" />
  <target name="test" depends="build" />
  <target name="build" />

  <target name="clean">
    <delete dir="${project.build}" />
  </target>

</project>