X-Git-Url: http://erislabs.net/gitweb/?p=mir.git;a=blobdiff_plain;f=build.xml;h=54c96281b520dabfbe803027500b72658140f9f2;hp=2d7874cc734af48c667a6eb56482bde7ec492106;hb=HEAD;hpb=4bff8359ef95523748cf5b92f455d1bd0e5d83e5

diff --git a/build.xml b/build.xml
index 2d7874cc..54c96281 100755
--- a/build.xml
+++ b/build.xml
@@ -1,151 +1,284 @@
-<project name="Mir" default="compile" basedir=".">
-
-
-<!-- Property Definitions
-     app.name          Base name of this application, used to
-                       construct filenames and directories.
-
-     deploy.home       The name of the directory into which the
-                       deployment hierarchy will be created.
-                       Normally, this will be the name of a
-                       subdirectory under $TOMCAT_HOME/webapps.
-
-     dist.home	       The name of the base directory in which
-                       distribution files are created.
-
-     dist.src          The name of the distribution JAR file
-                       containing the application source code,
-                       to be stored in the "dist.home" directory.
-                       This filename should end with ".jar".
-
-     dist.war          The name of the Web ARchive (WAR) file
-                       containing our deployable application.
-                       This filename should end with ".war".
-
-     javadoc.home      The name of the base directory in which
-                       the JavaDoc documentation for this application
-                       is generated.
-
-     tomcat.home       The name of the base directory in which
-                       Tomcat has been installed.  This value is
-                       normally set automatically from the value
-                       of the TOMCAT_HOME environment variable.
--->
-
-  <property name="app.name"       value="Mir"/>
-  <property name="deploy.home"    value="../${app.name}"/>
-  <property name="dist.home"      value="${deploy.home}"/>
-  <property name="dist.src"       value="${app.name}.jar"/>
-  <property name="dist.war"       value="${app.name}.war"/>
-  <property name="javadoc.home"   value="${deploy.home}/javadoc"/>
-
-
-<!-- The "prepare" target is used to construct the deployment home
-     directory structure (if necessary), and to copy in static files
-     as required.  In the example below, Ant is instructed to create
-     the deployment directory, copy the contents of the "web/" source
-     hierarchy, and set up the WEB-INF subdirectory appropriately.
--->
-
-  <target name="prepare">
-    <mkdir  dir="${deploy.home}"/>
-    <copy todir="${deploy.home}">
+<project name="Mir" default="deploy" basedir=".">
+  <!--
+    - Build script for the Mir project
+    -
+    - usefull tasks are:
+    -   * compile
+    -        Creates the jars needed for a mir deployment
+    -   * deploy
+    -        Sets up a deployment directory
+    -   * binary-distribution
+    -        Sets up a distributable version of mir in the
+    -        form of a war file
+    -   * source-distribution
+    -        Sets up a distributable version of mir as a
+    -        gzipped tar version of the source tree
+    -   * full-distribution
+    -        Sets up a distributable version of mir in the
+    -        form of a gzipped tar file with the sources
+    -   * javadoc
+    -        Generates the project's javadoc
+    -->
+
+  <property name="version"        value="1.1.0rc0"/>
+
+  <property name="app.name"       value="mir"/>
+
+  <!-- -->
+  <property name="deploy.home"    value="./bin/${app.name}"/>
+
+  <!-- The distribution will be built here: -->
+  <property name="distribution.home"      value="./dist"/>
+
+
+
+  <!-- The temporary files made during the build process
+       will be created here: -->
+  <property name="build"     value="./build"/>
+  <property name="build.classes"  value="./${build}/classes"/>
+  <property name="build.jars"  value="./${build}/jars"/>
+  <property name="build.javadoc"   value="${build}/javadoc"/>
+
+  <!-- retrieve environment variables -->
+  <property environment="env"/>
+
+  <property name="tomcat.home"    value="${env.TOMCAT_HOME}"/>
+
+<!--
+  <property name="compile.optimize" value="off" />
+  <property name="compile.debug" value="on" />
+  -->
+
+  <target name="deploy" depends="compile,generate-deployment-tree" 
+      description="Sets up a deployment directory">
+  </target>
+
+  <target name="debug" depends="compile-debug,generate-deployment-tree"
+      description="Sets up a deployment directory with debug enabled">
+  </target>
+
+  <target name="generate-deployment-tree">
+    <property name="destination" value="${deploy.home}"/>
+    <mkdir  dir="${destination}"/>
+    <mkdir  dir="${destination}/WEB-INF"/>
+    <delete dir="${destination}/WEB-INF/lib"/>
+    <mkdir  dir="${destination}/WEB-INF/lib"/>
+    <mkdir  dir="${destination}/WEB-INF/log"/>
+
+    <copy todir="${destination}">
       <fileset dir="web"/>
     </copy>
-    <mkdir  dir="${deploy.home}/templates"/>
-    <copy todir="${deploy.home}/templates">
-      <fileset dir="templates"/>
-    </copy>
-    <mkdir  dir="${deploy.home}/src"/>
-    <copy todir="${deploy.home}/src">
-      <fileset dir="source"/>
+
+    <copy todir="${destination}/WEB-INF/etc">
+      <fileset dir="etc" excludes="extrasource,extralib"/>
     </copy>
 
-    <mkdir  dir="${deploy.home}/WEB-INF"/>
-    <copy  file="etc/web.xml"          tofile="${deploy.home}/WEB-INF/web.xml"/>
-    <mkdir  dir="${deploy.home}/WEB-INF/classes"/>
-    <mkdir  dir="${deploy.home}/WEB-INF/lib"/>
-    <copy todir="${deploy.home}/WEB-INF/lib">
-      <fileset dir="lib"/>
+    <copy todir="${destination}/WEB-INF">
+      <fileset dir="meta"/>
     </copy>
-    <mkdir  dir="${javadoc.home}"/>
-    <mkdir  dir="${deploy.home}/log"/>
 
-  </target>
+    <copy todir="${destination}/WEB-INF/templates">
+      <fileset dir="templates"/>
+    </copy>
 
+    <copy todir="${destination}/WEB-INF/bundles">
+      <fileset dir="bundles"/>
+    </copy>
 
-<!-- The "clean" target removes the deployment home directory structure,
-     so that the next time the "compile" target is requested, it will need
-     to compile everything from scratch.
--->
+    <copy todir="${destination}/WEB-INF" file="source/default.properties" />
 
+    <copy todir="${destination}/WEB-INF/lib">
+      <fileset dir="lib" />
+      <fileset dir="etc/extralib" />
+      <fileset dir="${build.jars}" />
+    </copy>
+  </target>
 
   <target name="clean">
-    <delete dir="${deploy.home}"/>
+    <delete dir="${build}"/>
   </target>
 
+  <!-- Construct the classpath -->
+  <path id="project.classpath">
+    <fileset dir="lib">
+      <include name="*.jar"/>
+    </fileset>
+    <fileset dir="etc/extralib">
+      <include name="*.jar"/>
+    </fileset>
+
+    <pathelement path="${tomcat.home}/lib/tomcat.jar"/>
+
+    <!-- for libs shared between tomcat and webapps (tomcat 3.3.x) -->
+    <fileset dir="${tomcat.home}">
+		  <include name="lib/common/*.jar" />
+	  </fileset>
+    <!-- for libs shared between webapps (tomcat 3.3.x) -->
+	  <fileset dir="${tomcat.home}">
+		  <include name="lib/apps/*.jar" />
+	  </fileset>
+    <!-- for libs shared between tomcat and webapps (tomcat 4.x.x) -->
+	  <fileset dir="${tomcat.home}">
+		  <include name="common/lib/*.jar" />
+	  </fileset>
+    <!-- for libs shared between webapps (tomcat 4.0.x) -->
+	  <fileset dir="${tomcat.home}">
+		  <include name="lib/*.jar" />
+	  </fileset>
+    <!-- for libs shared between webapps (tomcat 4.1.x) -->
+	  <fileset dir="${tomcat.home}">
+		  <include name="shared/lib/*.jar" />
+	  </fileset>
+
+	  <fileset dir="${tomcat.home}">
+		  <include name="common/endorsed/*.jar" />
+	  </fileset>
+  </path>
+
+
+  <target name="prepare-compilation">
+    <mkdir  dir="${build.classes}"/>
+    <mkdir  dir="${build.jars}"/>
+    <uptodate property="up.to.date" targetfile="${build.jars}/mir.jar">
+      <srcfiles dir="source" includes="**/*.java"/>
+      <srcfiles dir="lib" includes="*.jar"/>
+      <srcfiles dir="etc/extrasource" includes="**/*"/>
+      <srcfiles dir="etc/extralib" includes="*"/>
+    </uptodate>
+  </target>
 
-<!-- The "compile" target is used to compile (or recompile) the Java classes
-     that make up this web application.  The recommended source code directory
-     structure makes this very easy because the <javac> task automatically
-     works its way down a source code hierarchy and compiles any class that
-     has not yet been compiled, or where the source file is newer than the
-     class file.
+  <!-- compile target: compiles all files into the build/classes dir -->
+  <target name="compile" depends="prepare-compilation" unless="up.to.date"
+          description="Creates the jars needed for a mir deployment">
+          
+    <javac destdir="${build.classes}" debug="true" deprecation="off" source="1.3">
+      <src path="source"/>
+      <src path="etc/extrasource"/>
+      <classpath refid="project.classpath"/>
+    </javac>
+
+    <delete file="${build.jars}/mir.jar"/>
+
+    <jar
+       jarfile="${build.jars}/mir.jar">
+      <fileset dir="${build.classes}" includes="**/*.class" />
+      <manifest>
+        <attribute name="Built-By" value="${user.name}"/>
+      </manifest>
+    </jar>
+  </target>
 
-     Feel free to adjust the compilation option parameters (debug,
-     optimize, and deprecation) to suit your requirements.  It is also
-     possible to base them on properties, so that you can adjust this
-     behavior at runtime.
+  <!-- compile a debuggable version -->
+  <target name="compile-debug" depends="prepare-compilation">
+    <javac destdir="${build.classes}"
+           debug="on" optimize="off" deprecation="on">
+      <src path="source"/>
+      <src path="etc/extrasource"/>
+      <classpath refid="project.classpath"/>
+    </javac>
+  </target>
 
-     The "compile" task depends on the "prepare" task, so the deployment
-     home directory structure will be created if needed the first time.
--->
 
-  <target name="compile" depends="prepare">
-    <javac srcdir="source" destdir="${deploy.home}/WEB-INF/classes"
-           classpath="${deploy.home}/WEB-INF/classes"
-           debug="on" optimize="off" deprecation="on"/>
-    <copy   todir="${deploy.home}/WEB-INF/classes">
-      <fileset dir="source" includes="**/*.properties"/>
-    </copy>
+  <!-- build the project's javadoc -->
+  <target name="javadoc" depends="prepare-javadoc">
+    <javadoc
+        destdir="${build.javadoc}"
+        author="true"
+        version="true"
+        use="true"
+        packagenames="mir.*,mircoders.*"
+        sourcepath="source"
+        sourcefiles="source/Mir.java,source/OpenMir.java"
+        windowtitle="Mir">
+
+      <classpath refid="project.classpath"/>
+      <link href="http://java.sun.com/j2se/1.3/docs/api"/>
+    </javadoc>
   </target>
 
+  <target name="prepare-javadoc">
+    <mkdir  dir="${build.javadoc}"/>
+  </target>
 
-<!-- The "javadoc" target is used to create the Javadoc API documentation
-     for the Java classes in this web application.  It is assumed that
-     this documentation is included in the deployed application, so the
-     example below generates the Javadoc HTML files in a subdirectory under
-     the deployment home directory.  Feel free to customize the options for
-     the JavaDoc task, after consulting the Ant documentation.
--->
-
-  <target name="javadoc" depends="prepare">
-    <javadoc packagenames="mir.*, mircoders.*"
-	     sourcefiles="source/${app.name}.java,source/Open${app.name}.java"
-	     sourcepath="source"
-             destdir="${javadoc.home}"/>
+  <target name="prepare-distribution">
+    <mkdir  dir="${distribution.home}"/>
+    <delete dir="${build}/dist"/>
+    <mkdir  dir="${build}/dist"/>
   </target>
 
+  <target name="distribution" depends="prepare-distribution">
+    <antcall target="generate-deployment-tree">
+      <param name="destination" value="${build}/dist"/>
+    </antcall>
+
+    <tar tarfile="${distribution.home}/mir-${version}.tar.gz" compression="gzip">
+      <tarfileset dir="${build}/dist" includes="**/*" />
+    </tar>
+  </target>
 
-<!-- The "all" target rebuilds everything by executing the "clean"
-     target first, which forces the "compile" target to compile all
-     source code instead of just the files that have been changed.
--->
+  <target name="prepare-source-distribution">
+    <mkdir  dir="${distribution.home}"/>
+  </target>
 
-  <target name="all" depends="clean,prepare,compile,javadoc"/>
+  <target name="source-distribution" depends="prepare-source-distribution">
+    <!--<zip zipfile="${distribution.home}/mir-source-${version}.zip" >
+      <fileset dir="."
+        includes="bundles/**/*,source/**/*,etc/**/*,meta/**/*,web/**/*,templates/**/*,dbscripts/**/*,lib/**/*,doc/**/*,build.xml" />
+    </zip>-->
+    <tar tarfile="${distribution.home}/mir-source-${version}.tar.gz" compression="gzip">
+      <tarfileset dir="."
+        includes="bundles/**/*,source/**/*,etc/**/*,meta/**/*,web/**/*,templates/**/*,dbscripts/**/*,lib/**/*,doc/**/*,build.xml" />
+    </tar>
 
+  </target>
+  
+<!--  
+  
+  <target name="documentation-pdf" description="generates documentation into html form">
+      <xslt in="${temp}/docs/pdf/${document}.xml"
+            out="${temp}/docs/pdf/${document}.fo"
+            style=""/>
+
+      <java classname="org.apache.fop.apps.Fop" fork="yes">
+          <classpath>
+              <fileset dir="lib">
+                  <include name="*.jar"/>
+              </fileset>
+          </classpath>
+
+          <arg value="-fo"/>
+          <arg file="${temp}/docs/pdf/${document}.fo"/>
+          <arg file="${build}/pdfdocs/${document}.pdf"/>
+      </java>
+  </target>
+-->  
+  <target name="prepare-html">
+    <mkdir dir="${build}/xslt"/>
+ 
+    <unzip dest="${build}/xslt" src="doc/lib/docbook-xsl-1.70.1.zip"/>
+ 
+    <copy todir="${build}/xslt">
+      <fileset dir="doc/style">
+        <include name="*"/>
+      </fileset>
+    </copy>
+  </target>
+  
+  <target name="documentation-html" description="generates documentation into html form" depends="prepare-html">
+    <mkdir dir="${build}/htmldocs"/>
 
-<!-- The "dist" target builds the distribution Web ARchive (WAR) file
-     for this application, suitable for distribution to sites that wish
-     to install your application.  It also creates a JAR file containing
-     the source code for this application, if you wish to distribute
-     that separately.
--->
+    <xslt basedir="doc/installation" includes="*.xml"
+          destdir="${build}/htmldocs"
+          style="${build}/xslt/html.xsl"/>
+  </target>
 
-  <target name="dist" depends="prepare,compile">
-    <jar jarfile="${dist.home}/${dist.src}"
-         basedir="./source"/>
-    <jar jarfile="${dist.home}/${dist.war}"
-         basedir="${deploy.home}"/>
+  <target name="full-distribution" depends="prepare-distribution,deploy,source-distribution">
+  	<copy todir="${destination}/WEB-INF">
+  	      <fileset file="${distribution.home}/mir-source-${version}.tar.gz"/>
+  	    </copy>
+    <tar tarfile="${distribution.home}/mir-${version}.tar.gz" compression="gzip">
+      <tarfileset dir="bin" includes="**/*" />
+    </tar>
   </target>
-</project>
\ No newline at end of file
+
+</project>