X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=build.xml;h=0cb5cf328349fe70a1a78a25c23f1ec82628c6c4;hb=a178c6c1739363851d03935b2b6fdebea1d664b5;hp=c68923d7b5360da892b9e189f4ce63039f55198b;hpb=0ee7828e9bed6ad40415f6a7b76b1d484f985d86;p=mir.git

diff --git a/build.xml b/build.xml
index c68923d7..0cb5cf32 100755
--- a/build.xml
+++ b/build.xml
@@ -1,240 +1,269 @@
-<project name="Mir" default="compile" basedir=".">
-
-
-<!-- What this file is all about
-
-     You can use this version of build.xml to use directly with ant
-     i.e. without the build.sh script. Simply call ant and let it all
-     happen.
--->
-
-<!-- Property Definitions
-
-     Please not that only the first couple of properties have to be defined.
-     The rest, residing below the "no customization needed" line may be
-     customized if you know what you are doing. Else, leave the defaults
-     and use them to look up where ant places all the files.
-
-     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.
-
-     deploy.classes    The name of the directory that will contain
-                       the class files.
-
-     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.
-
-	java.home          The location of your Java SDK.
-
-	java.localhome     Where your local java classes and jar files
-                       are located.
-
-	tomcat.home        The location of the tomcat root directory.
-
--->
-
-  <property name="app.name"       value="Mir"/>
-  <property name="deploy.home"    value="../${app.name}"/>
-
-
-<!-- No customization required after this line -->
-
+<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
+    -        zipped version of the source tree
+    -   * 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="dist.home"      value="${deploy.home}"/>
-  <property name="deploy.webinf"  value="${deploy.home}/WEB-INF"/>
-  <property name="deploy.classes" value="${deploy.webinf}/classes"/>
-  <property name="dist.src"       value="${app.name}.jar"/>
-  <property name="dist.war"       value="${app.name}.war"/>
-  <property name="javadoc.home"   value="${deploy.home}/javadoc"/>
-  <property name="tomcat.home"    value="${env.TOMCAT_HOME}"/>
-
-  <!-- If you want to use the very good jikes compiler, uncomment this 
-  <property name="build.compiler"   value="jikes"/> -->
 
+  <property name="tomcat.home"    value="${env.TOMCAT_HOME}"/>
 
+<!--
+  <property name="compile.optimize" value="off" />
+  <property name="compile.debug" value="on" />
+  -->
 
-  <!-- Construct the classpath -->
-  <path id="project.class.path">
-    <pathelement path="${deploy.home}"/>
-    <pathelement path="${deploy.classes}"/>
-    <pathelement path="source"/>
-    <fileset dir="lib">
-      <include name="*.jar"/>
-    </fileset>
-    <pathelement path="${tomcat.home}/lib/tomcat.jar"/>
-	<fileset dir="${tomcat.home}/lib/common">
-		<include name="*.jar" />
-	</fileset>
-  </path>
-
+  <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>
 
-<!-- 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="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"/>
 
-  <target name="prepare">
-    <mkdir  dir="${deploy.home}"/>
-    <copy todir="${deploy.home}">
+    <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>
 
-    <mkdir  dir="${deploy.home}/WEB-INF"/>
-    <copy  file="etc/web.xml"          tofile="${deploy.home}/WEB-INF/web.xml"/>
-    <mkdir  dir="${deploy.classes}"/>
-    <mkdir  dir="${deploy.home}/WEB-INF/lib"/>
-    <copy todir="${deploy.home}/WEB-INF/lib">
-      <fileset dir="lib">
-        <exclude name="ant.jar"/>
-        <exclude name="xerces.jar"/>
-      </fileset>
+    <copy todir="${destination}/WEB-INF/etc">
+      <fileset dir="etc" excludes="extrasource,extralib"/>
     </copy>
-    <mkdir  dir="${javadoc.home}"/>
-    <mkdir  dir="${deploy.home}/log"/>
 
-  </target>
+    <copy todir="${destination}/WEB-INF">
+      <fileset dir="meta"/>
+    </copy>
 
+    <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.classes}"/>
-	<mkdir dir="${deploy.classes}"/>
+    <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"/>
 
-<!-- The "mrproper" target removes the entire deploy dir - including all
-	built pages and images.
--->
-
-  <target name="mrproper">
-    <delete dir="${deploy.home}"/>
-  </target>
-
-
+    <!-- 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>
 
-<!-- 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.
 
-     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.
+  <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" task depends on the "prepare" task, so the deployment
-     home directory structure will be created if needed the first time.
--->
+  <!-- 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>
 
-  <target name="compile" depends="prepare">
-	<antcall target="clean"/>
-    <javac srcdir="source" destdir="${deploy.classes}"
+  <!-- compile a debuggable version -->
+  <target name="compile-debug" depends="prepare-compilation">
+    <javac destdir="${build.classes}"
            debug="on" optimize="off" deprecation="on">
-      <classpath refid="project.class.path"/>
-	</javac>
-    <copy   todir="${deploy.classes}">
-      <fileset dir="source" includes="**/*.properties"/>
-    </copy>
-    <copy   todir="${deploy.home}">
-      <fileset dir="source" includes="**/content-types.properties"/>
-      <fileset dir="source" includes="**/server.xml"/>
-    </copy>
-    <copy   todir="${deploy.classes}/bundles">
-      <fileset dir="bundles" includes="**/*.properties"/>
-    </copy>
+      <src path="source"/>
+      <src path="etc/extrasource"/>
+      <classpath refid="project.classpath"/>
+    </javac>
   </target>
 
 
+  <!-- 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="perms">
-	<exec executable="./perms.sh"/>
+  <target name="prepare-javadoc">
+    <mkdir  dir="${build.javadoc}"/>
   </target>
 
+  <target name="prepare-distribution">
+    <mkdir  dir="${distribution.home}"/>
+    <delete dir="${build}/dist"/>
+    <mkdir  dir="${build}/dist"/>
+  </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="distribution" depends="prepare-distribution">
+    <antcall target="generate-deployment-tree">
+      <param name="destination" value="${build}/dist"/>
+    </antcall>
 
-  <target name="javadoc" depends="prepare">
-    <javadoc packagenames="mir.*, mircoders.*"
-	     sourcefiles="source/${app.name}.java,source/Open${app.name}.java"
-	     sourcepath="source"
-             destdir="${javadoc.home}">
-	  <classpath refid="project.class.path"/>
-	</javadoc>
+    <tar tarfile="${distribution.home}/mir-${version}.tar.gz" compression="gzip">
+      <tarfileset dir="${build}/binarydist" includes="**/*" />
+    </tar>
   </target>
 
+  <target name="prepare-source-distribution">
+    <mkdir  dir="${distribution.home}"/>
+  </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="all" depends="clean,prepare,compile,javadoc"/>
+  <target name="source-distribution" depends="prepare-source-distribution">
+    <zip zipfile="${distribution.home}/source.zip" >
+      <fileset dir="."
+        includes="bundles/**/*,source/**/*,etc/**/*,meta/**/*,web/**/*,templates/**/*,dbscripts/**/*,lib/**/*,doc/**/*,build.xml" />
+    </zip>
 
+  </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.66.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.
--->
-  <target name="dist" depends="prepare,compile">
-    <jar jarfile="${dist.home}/mirbase.jar"
-	 includes="mir/**"
-	 basedir="${deploy.classes}"/>
-    <jar jarfile="${dist.home}/${dist.src}"
-         basedir="./source"/>
-    <jar jarfile="${dist.home}/${dist.war}"
-         basedir="${deploy.home}"
-         excludes="${dist.war}"/>
+    <xslt basedir="doc/installation" includes="*.xml"
+          destdir="${build}/htmldocs"
+          style="${build}/xslt/html.xsl"/>
   </target>
+  
 
 </project>