root/releases/bedework-3.8/build/buildTools/deftasks.xml

<!-- Define a number of tasks and macros
     deftasks:  define someuseful build tasks
     projectDefs: standard project definitions
     xMsg: x=info,debug etc. For message output

     Authors: Mike Douglass   douglm rpi.edu
-->

<project name="doDeftasks" basedir="." default="">
  <macrodef name="deftasks">
    <sequential>
      <path id="build.cp">
        <fileset dir="${build.dir}">
          <include name="*.jar"/>
        </fileset>
      </path>
  
      <taskdef name="forEachApp"
               classname="org.bedework.deployment.ForEachAppTask">
        <classpath refid="build.cp"/>
      </taskdef>
      
      <taskdef name="forApp"
               classname="org.bedework.deployment.ForAppTask">
        <classpath refid="build.cp"/>
      </taskdef>

      <taskdef name="resolveFile"
               classname="org.bedework.deployment.ResolveFile">
        <classpath refid="build.cp"/>
      </taskdef>

      <taskdef name="makeLangXsl"
               classname="org.bedework.deployment.MakeLangXsl">
        <classpath refid="build.cp"/>
      </taskdef>

      <taskdef name="applicationXml"
               classname="org.bedework.deployment.ApplicationXmlTask">
        <classpath refid="build.cp"/>
      </taskdef>
    </sequential>
  </macrodef>
  
  <macrodef name="execProject">
    <attribute name="project"/>
    <attribute name="target"/>
          <sequential>
            <ant antfile="${bedework.home}/../@{project}/build.xml" 
                 inheritall="false"
                 target="@{target}" />
          </sequential>
        </macrodef>
    
  <macrodef name="projectDefs">
    <attribute name="name"/>
    <attribute name="version"/>
    <attribute name="deployment-name" default=""/>
    <attribute name="subproject" default="false"/>
    <sequential>
      <property name="project.name" value="@{name}"/>
      
      <property name="project.version" value="@{version}"/>
      
      <property name="dist.home" location="${project.home}/dist"/>
      <mkdir dir="${dist.home}" />

      <property name="lib.dir" location="${project.home}/lib"/>

      <property name="build.dir" location="${bedework.home}/build"/>

      <property name="buildjar" location="${build.dir}/buildTools/buildjar.xml"/>
      <property name="buildwar" location="${build.dir}/buildwar.xml"/>
      <property name="buildsh" location="${build.dir}/buildsh.xml"/>

      <property name="resources.dir" location="${project.home}/resources"/>

      <property name="org.bedework.libcache.dir"
                location="${bedework.home}/libcache"/>
      
      <property name="org.bedework.temp.dir"
                location="${dist.home}/temp" />

      <if>
        <istrue value="@{subproject}" />
        <then>
          <property name="source.home" location="${project.home}/src"/>
        </then>
        <else>
          <delete dir="${org.bedework.temp.dir}" />
          <mkdir dir="${org.bedework.temp.dir}" />
          
          <property name="org.bedework.deployment.name"
                    value="@{deployment-name}" />

          <deftasks/>
        </else>
      </if>

      <import file="${build.dir}/buildTools/getJar.xml"/>
      <import file="${build.dir}/buildTools/jdoc.xml"/>
    </sequential>
  </macrodef>

  <!-- =====================================================================
       Assumes projectDefs was called previously.
       ===================================================================== -->
  <macrodef name="projectInit">
    <sequential>
      <infoMsg message="* =========== Building ${project.name}" />
      
      <delete dir="${lib.dir}" />
      <mkdir dir="${lib.dir}" />

      <property name="test.data.dir"
                location="${dist.home}/test-data" />

      <property name="test.reports.dir"
                location="${dist.home}/test-reports" />

      <property name="org.bedework.empty.dir"
                location="${dist.home}/empty-dir" />
      <mkdir dir="${org.bedework.empty.dir}" />

      <fileset id="empty.fileset" dir="${org.bedework.empty.dir}"
               excludes="*" />

      <!-- ==================== Compilation Classpath ==================== -->

      <path id="compile.classpath">
        <fileset dir="${lib.dir}">
           <include name="*.jar"/>
        </fileset>
        <fileset dir="${dist.home}">
           <include name="*.jar"/>
        </fileset>
      </path>
    </sequential>
  </macrodef>

  <!-- =====================================================================
       Assumes projectDefs was called previously.
       Set things up ready for deployment
       ===================================================================== -->
  <macrodef name="deployInit">
    <attribute name="ear-name"/>
    <sequential>
      <!-- Where we put ear stuff -->
      <if>
        <isset property="org.bedework.global.build.ear" />
        <then>
          <property name="app.ear.file.name"
                    value="@{ear-name}.ear" />

          <property name="org.bedework.ear.name"
                    value="@{ear-name}" />

          <property name="org.bedework.ear.templib"
                    location="${org.bedework.temp.dir}/earlib" />

          <property name="org.bedework.ear.properties.dir"
                    location="${org.bedework.temp.dir}/ear-properties" />

          <delete dir="${org.bedework.ear.templib}" />
          <mkdir dir="${org.bedework.ear.templib}" />

          <delete dir="${org.bedework.ear.properties.dir}" />
          <mkdir dir="${org.bedework.ear.properties.dir}" />
        </then>
      </if>
      
      <property name="org.bedework.temp.shellscr.home"
                location="${org.bedework.temp.dir}/shellscr" />

      <property name="org.bedework.temp.extrajars.dir"
                location="${org.bedework.temp.dir}/extrajars" />

      <!-- Preserve extra jars for ear builds -->
      <property name="org.bedework.temp.ear.extrajars.dir"
                location="${org.bedework.temp.dir}/earextrajars" />
      
      <property name="org.bedework.global.context.roots"
                location="${org.bedework.temp.dir}/context-roots.properties" />

      <!-- ===== End of stuff in main bedework deployment build file ======   -->
      
      <!-- Clean up before we start -->
      <if>
        <isset property="org.bedework.temp.wars.home" />
        <then>    
          <delete dir="${org.bedework.temp.wars.home}" />
          <mkdir dir="${org.bedework.temp.wars.home}" />
        </then>
      </if>

      <delete dir="${org.bedework.temp.ear.extrajars.dir}" />
      <mkdir dir="${org.bedework.temp.ear.extrajars.dir}" />

      <delete dir="${org.bedework.temp.extrajars.dir}" />
      <mkdir dir="${org.bedework.temp.extrajars.dir}" />
    </sequential>
  </macrodef>
  
  <macrodef name="deployTerm">
    <sequential>
      <ant antfile="${build.dir}/../deployment/termination/webapp/build.xml" 
           target="deploy" inheritRefs="true" />
      
      <!-- Platform specific -->
      <ant antfile="${build.dir}/../deployment/termination/build.xml" 
           target="deploy" inheritRefs="true" />
    </sequential>
  </macrodef>

  <!-- =================================================================
       Standard targets for build files. Two targets (at least) need to be 
       overridden by the importing task
       
       init - carry out project specific initialisation
       build-source - builds the source to creat ejars.
       =================================================================-->
  
  <!-- Override this -->
  <target name="init" />
  
  <!-- Override this -->
  <target name="build-init" />

  <!-- Override this -->
  <target name="build-source" />
  
  <!-- Override this -->
  <target name="deploy" depends="build" />

  <!-- =================================================================
       Clean out all library files from other projects and all generated
       files in preparation for a complete rebuild.

       Needed because switching versions leaves a load of old bedework
       generated stuff in the libraries.
       ================================================================= -->
  <target name="deep-clean" depends="clean">
    <delete dir="${lib.dir}" />
  </target>

  <!-- =================================================================
       Clean all generated files
       ================================================================= -->
  <target name="clean">
    <delete dir="${dist.home}" />
  </target>

  <!-- =================================================================
       Clean and deploy in one go
       ================================================================= -->
  <target name="clean.deploy" depends="clean,deploy" />

  <!-- =================================================================
       Clean up after a build.
       ================================================================= -->
  <target name="cleanup">
    <!--
    <delete dir="${org.bedework.empty.dir}" />
    -->
  </target>

  <!-- ========================== Base build Targets ===================
       Here we have one target building the classes and interfaces that make
       up the access control suite.
       ================================================================= -->

  <target name="clean-build" depends="clean,build"
          description="Clean and compile access control classes"/>

  <target name="clean-build-all" depends="clean,build-all"
          description="Clean and compile access control classes"/>

  <target name="build" depends="init,build-source,cleanup"
          description="Compile access control classes"/>

  <target name="build-all" depends="build"
          description="Compile access control classes"/>
  
  <target name="javadoc" depends="build-init"
          description="Create Javadoc API documentation">
    <jdoc/>
  </target>
  
  <macrodef name="build-jar-stats">
    <sequential>
      <if>
        <not>
          <isset property="org.bedework.jars.built" />
        </not>
        <then>
          <echo message="No jars were checked or built" />
        </then>
        <else>
          <echo message="${org.bedework.jars.checked} jars checked: ${org.bedework.jars.built} built" />
        </else>
      </if>
    </sequential>
  </macrodef>
  
  <!-- This macro builds a single jar file. It just sets defaults for the java
       compiler then invokes it.

       This is the only place we compile files.

       On entry we require:
         jar.file              Fully specified name of destination jar file.
         base.java.sources     Defines the java source files
         base.class.patternset Defines the java class files
         base.resource.files   Defines extra resources to go in the jar

       We will copy all files defined by base.java.patternset to a temporary
       location and compile out of that into a temporary classes location.

       We do that to avoid a problematic feature of the java compilers, the
       tendency to recompile any referenced sources found on the source path.

       So, if we have all our sources under the directory "src" and compile a
       single package in that tree, all referenced classes will be compiled,
       even if they exist in a jar file on the class path.

       The other side-effect is that we might compile and include classes we
       didn't realise we were compiling.

       The downside is that we need to be very specific about the classes we
       compile for a package and we might need to put classes in
       base.java.sources which we don't want in the final jar file.

       On exit we will have created classes in the directory
          ${jar.temp.classes}
       and a jar file
          ${build.jar.file}

       Authors: Mike Douglass   douglm rpi.edu
  -->
  <macrodef name="build-jar">
    <attribute name="module-base"/>
    <attribute name="jar-file"/>
    <attribute name="jar-dependency" default=""/>
    <attribute name="generated-sources" default=""/>
    <attribute name="property-resources" default=""/>
    
    <sequential>
      <if>
        <not>
          <isset property="org.bedework.jars.built" />
        </not>
        <then>
          <var name="org.bedework.jars.built" value="0" />
          <var name="org.bedework.jars.checked" value="0" />
        </then>
      </if>
      
      <math result="org.bedework.jars.checked" 
            operand1="${org.bedework.jars.checked}" 
            operation="+" operand2="1" datatype="int"/>

      <if>
        <equals arg1="@{generated-sources}" arg2="" />
        <then>
          <fileset id="buildjar.generated.java.sources" refid="empty.fileset" />
        </then>
        <else>
          <fileset id="buildjar.generated.java.sources" dir="@{generated-sources}" >
            <include name="org/bedework/**/*.java"/>
          </fileset>
        </else>
      </if>

      <if>
        <equals arg1="@{property-resources}" arg2="" />
        <then>
          <fileset id="buildjar.resource.files" refid="empty.fileset" />
        </then>
        <else>
          <fileset id="buildjar.resource.files" dir="@{property-resources}" >
            <include name="**/*.properties"/>
          </fileset>
        </else>
      </if>

      <fileset id="buildjar.java.sources" dir="@{module-base}/src" >
        <include name="**/*.java"/>
      </fileset>

      <patternset id="base.class.patternset">
        <include name="**/*.class"/>
      </patternset>

      <if>
        <not>
          <equals arg1="@{jar-dependency}" arg2="" />
        </not>
        <then>
          <var name="build.jar.dependency" value="@{jar-dependency}" />
        </then>
      </if>
      
      <!--  =================== Compilation Control Options ===============
        These properties control option settings on the Javac compiler when it
        is invoked using the <javac> task.

        compile.debug        Should compilation include the debug option?
        compile.deprecation  Should compilation include the deprecation option?
        compile.optimize     Should compilation include the optimize option?

        Below are the defaults. They may already be set in the build properties.
      -->

      <property name="compile.debug" value="true"/>
      <property name="compile.deprecation" value="false"/>
      <property name="compile.optimize" value="true"/>
      <property name="compile.verbose" value="false"/>
      <property name="compile.listfiles" value="false"/>

      <var name="jar.temp.sources"
           value="${dist.home}/source" />
      <var name="jar.temp.classes"
           value="${dist.home}/classes" />

      <!-- ==============================================================
            See if the jar is up to date. We recompile if any of the
            source files or metainf files are newer. We also recompile if
            any jars on the package classpath are newer.
           ============================================================== -->

      <noisyMsg message="build.jar.file=@{jar-file}" />
      
      <if>
        <isset property="build.jar.dependency"/>
        <then>
          <dirname file="${build.jar.dependency}"
                   property="dependency.dirname" />
          <basename file="${build.jar.dependency}"
                    property="dependency.basename" />
          <fileset dir="${dependency.dirname}" id="dependency.fileset">
            <include name="${dependency.basename}"/>
          </fileset>
        </then>
        <else>
          <fileset refid="empty.fileset" id="dependency.fileset"/>
        </else>
      </if>      

      <!-- See if the libraries are later than any classes --> 

      <var name="org.bedework.libraries.changed" value="false" />
      
      <outofdate outputsources="org.bedework,changed.sources">
        <sourcefiles>
          <fileset dir="${lib.dir}">
             <include name="*.jar"/>
          </fileset>
          <!-- This makes almost everything rebuild all the time
               because it has the generated jars for the current package
          <path refid="compile.classpath"/> 
          -->
        </sourcefiles>
        <targetfiles>
          <pathelement path="@{jar-file}"/>
        </targetfiles>
        <sequential>
          <var name="org.bedework.libraries.changed" value="true" />
          <noisyMsg message="**** @{jar-file} needs rebuilding - libraries changed" />
        </sequential>
      </outofdate>
      
      <noisyMsg message="**** org.bedework,changed.sources = ${org.bedework,changed.sources}" />
      <noisyMsg message="**** org.bedework.libraries.changed = ${org.bedework.libraries.changed}" />

      <if>
        <and>
          <not>
            <equals arg1="${org.bedework.libraries.changed}" arg2="true" />
          </not>
          <uptodate targetfile="@{jar-file}" >
            <srcfiles refid="buildjar.java.sources" />
            <srcfiles refid="buildjar.generated.java.sources" />
            <srcfiles refid="buildjar.resource.files"/>
            <srcfiles refid="dependency.fileset"/>
          </uptodate>
        </and>
        <then>
          <noisyMsg message="**** @{jar-file} is up to date" />
        </then>
        <else>
          <noisyMsg message="**** @{jar-file} needs rebuilding" />

          <math result="org.bedework.jars.built" 
                operand1="${org.bedework.jars.built}" 
                operation="+" operand2="1" datatype="int"/>

          <!-- Delete jar file -->
          <delete file="@{jar-file}"/>

          <dirname property="build.jar.dir" file="@{jar-file}"/>

          <mkdir dir="${build.jar.dir}" />

          <!-- ==========================================================
                            Build the classes
               ========================================================== -->

          <!-- First copy the sources we are going to compile into a temp
               directory. -->
          <delete dir="${jar.temp.sources}" />
          <mkdir dir="${jar.temp.sources}" />
          
          <copy toDir="${jar.temp.sources}">
            <fileset refid="buildjar.java.sources" />
            <fileset refid="buildjar.generated.java.sources" />
            <fileset refid="buildjar.resource.files"/>
          </copy>

          <mkdir dir="${jar.temp.classes}"/>
          
          <debugMsg message="About to build jar @{jar-file}"/>
          <debugCpid idpar="compile.classpath" />

          <javac srcdir="${jar.temp.sources}"
                 destdir="${jar.temp.classes}"
                 debug="${compile.debug}"
                 verbose="${compile.verbose}"
                 listfiles="${compile.listfiles}"
                 deprecation="${compile.deprecation}"
                 optimize="${compile.optimize}">
            <classpath refid="compile.classpath"/>
            <include name="**/*.java"/>
            <compilerarg value="-nowarn" compiler="jikes" />
          </javac>

          <!-- ==========================================================
                            Build jar file
               ========================================================== -->

          <jar jarfile="@{jar-file}">
            <fileset dir="${jar.temp.classes}">
              <patternset refid="base.class.patternset"/>
            </fileset>
            <fileset refid="buildjar.resource.files"/>
          </jar>

          <!-- ==========================================================
                            Clean up
               ========================================================== -->

          <delete dir="${jar.temp.sources}" />
          <delete dir="${jar.temp.classes}"/>
        </else>
      </if>
    </sequential>
  </macrodef>
  
  <macrodef name="infoMsg">
    <attribute name="message"/>
    <sequential>
      <if>
        <not>
          <istrue value="${org.bedework.build.silent}" />
        </not>
        <then>
          <echo message="@{message}" />
        </then>
      </if>
    </sequential>
  </macrodef>
  
  <macrodef name="noisyMsg">
    <attribute name="message"/>
    <sequential>
      <if>
        <istrue value="${org.bedework.build.noisy}" />
        <then>
          <echo message="@{message}" />
        </then>
      </if>
    </sequential>
  </macrodef>
  
  <macrodef name="debugMsg">
    <attribute name="message"/>
    <sequential>
      <if>
        <istrue value="${org.bedework.build.debug}" />
        <then>
          <echo message="@{message}" />
        </then>
      </if>
    </sequential>
  </macrodef>
  
  <macrodef name="debugCpid">
    <attribute name="idpar"/>
    <sequential>
      <if>
        <istrue value="${org.bedework.build.debug}" />
        <then>
          <property name="cp" refid="@{idpar}" />
          <echo message="***************cp: ${cp}"/>
        </then>
      </if>
    </sequential>
  </macrodef>
</project>