<!--
  Copyright 2002,2004 The Apache Software Foundation.
  
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
       http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->

<project default="jar" xmlns:j="jelly:core" xmlns:maven="jelly:maven" xmlns:util="jelly:util">

  <!-- ================================================================== -->
  <!-- START : C O M M O N S - B U I L D                                  -->
  <!-- ================================================================== -->
  <!-- Required: Look and Feel for documentation within distributions     -->
  <!-- ================================================================== -->
  <postGoal name="xdoc:copy-resources">  
    <copy todir="${basedir}/target/docs/style/" failonerror="false">
      <fileset dir="${basedir}/../commons-build/xdocs/style">
          <include name='**/*'/>
          <exclude name='**/CVS/**'/>
      </fileset>
    </copy>
  </postGoal>
  <!-- ================================================================== -->
  <!-- END: C O M M O N S - B U I L D                                     -->
  <!-- ================================================================== -->

  <!-- create the lib and bin directories in the binary distro -->
  <preGoal name="dist:build">
    <echo>About to create lib and bin directories in ${maven.dist.assembly.dir}</echo>

    <mkdir dir="${maven.dist.assembly.dir}/bin"/>
    <mkdir dir="${maven.dist.assembly.dir}/lib"/>
    <mkdir dir="${maven.dist.assembly.dir}/custom"/>

    <copy todir="${maven.dist.assembly.dir}/bin">
      <fileset dir="src/bin"/>
    </copy>

    <chmod file="${maven.dist.assembly.dir}/bin/jelly" perm="ugo+rx" />

    <j:forEach var="dep" items="${pom.dependencies}">
      <j:choose>
        <j:when test="${dep.id == 'forehead'}">
          <copy tofile="${maven.dist.assembly.dir}/lib/forehead.jar"
              file="${maven.repo.local}/${dep.artifactDirectory}/${dep.type}s/${dep.artifact}"/>
        </j:when>
        <j:otherwise>
          <copy todir="${maven.dist.assembly.dir}/lib"
              file="${maven.repo.local}/${dep.artifactDirectory}/${dep.type}s/${dep.artifact}"/>
        </j:otherwise>
      </j:choose>
    </j:forEach>

    <!-- put a copy of Jelly's jar there too -->
    <copy todir="${maven.dist.assembly.dir}/lib"
            file="${maven.build.dir}/${maven.final.name}.jar"/>
  </preGoal>

  <!-- TAG LIBS BUILD -->
  <goal 
    name="tags:build"
    description="Build each tag into an installable jar">

    <maven:reactor
      basedir="jelly-tags"
      includes="*/project.xml"
      goals="clean,jar:install"
      banner="Building tag"
      ignoreFailures="false"/>
  </goal>

  <!-- TAG DOCUMENTATION -->
  <goal 
    name="tags:doc"
    description="Build the documentation for each tag library">

    <j:set var="maven.jellydoc.packages" value="org.apache.commons.jelly.*"/>
    
    <maven:reactor
      basedir="jelly-tags"
      includes="*/project.xml"
      goals="jellydoc,xdoc"
      banner="Building tag"
      ignoreFailures="false"/>
  </goal>

  <!-- Do the same goal on all Tag Libs -->
  <goal 
    name="tags:do"
    description="Do a specific goal on each taglib">

    <maven:reactor
      basedir="jelly-tags"
      includes="*/project.xml"
      goals="${goal}"
      banner="Building tag"
      ignoreFailures="false"/>
  </goal>


  <!-- ===================================================================== -->
  <!--                      D I S T : I N S T A L L                          -->
  <!-- ===================================================================== -->
  <!-- This installs Jelly on your system. With an installed Jelly, you'll   -->
  <!-- be able to run Jelly scripts from wherever your are, using :          -->
  <!-- "jelly <script> <outputfile>".                                        -->
  <!-- The installation dir is set in the project.properties file, under the -->
  <!-- name "maven.dist.install.dir", which defaults to "/usr/local/jelly"   -->
  <!-- (yep, that's a Linux path :). Please override it to suit your needs   -->
  <!-- ===================================================================== -->

  <goal name="dist:install"
            description="Installs Jelly on your system."
            prereqs="dist:build">

    <echo>
      +-------------------------------------------------------+
      | I N S T A L L I N G   J E L L Y                       |
      | to ${maven.dist.install.dir}                          |
      +-------------------------------------------------------+
    </echo>
    <mkdir dir="${maven.dist.install.dir}"/>

    <copy todir="${maven.dist.install.dir}">
      <fileset dir="${maven.dist.assembly.dir}"/>
    </copy>

    <chmod file="${maven.dist.install.dir}/bin/jelly" perm="ugo+rx" />

    <echo>
      * ===================================================== *
      *                    W A R N I N G                      *
      * ===================================================== *
      * Jelly is now almost installed on your system !        *
      * Next, you must set JELLY_HOME to point to             *
      * "${maven.dist.install.dir}", and add JELLY_HOME/bin   *
      * to your PATH.                                         *
      *                                                       *
      * Then, you will be able to run Jelly scripts using the *
      * command : "jelly script outputfile".                  *
      *                                                       *
      * Enjoy !                                               *
      *                                                       *
      * p.s. if ${maven.dist.install.dir} isn't where you'd   *
      * like Jelly installed, please set a property called    *
      * maven.dist.install.dir to the appropriate directory   *
      * ===================================================== *
    </echo>
  </goal>


  <!-- ===================================================================== -->
  <!-- GENERATE THE TAG-LIBRARY LIST                       -->
  <!-- ===================================================================== -->
  <preGoal name="xdoc:transform">
      
    <!-- can't pass anything into the jellydoc doclet so its hard coded to target -->      
    <mkdir dir="target"/>
          
    <mkdir dir="${maven.gen.docs}/libs/"/>
    <j:file name="${maven.gen.docs}/libs/index.xml"
      prettyPrint="true">
      <document>
        <properties>
          <title>Jelly Libraries</title>
          <author email="dion@multitask.com.au">dIon Gillard</author>
        </properties>
        <body>
          <section name="Jelly Libraries">
            <p>
              The following libraries are available for Jelly as part of the standard distribution.
              Other libraries are maintained elsewhere - please see the 
              <a href="../poweredby.html">powered by</a> page for more details.
            </p>
            <ul>
              <fileScanner var="pluginProjects">
                <fileset dir="${basedir}">
                  <include name="jelly-tags/*/project.xml" />
                </fileset>
             </fileScanner>
             <j:forEach items="${pluginProjects.iterator()}" var="plugin">
               <j:set var="pluginName" value="${plugin.parentFile.name}" />
               <li>
                 <a href="./${pluginName}/index.html">${pluginName}</a> :
                 <a href="./${pluginName}/tags.html">tags</a> 
               </li>
             </j:forEach>
            </ul>
          </section>
        </body>
      </document>
    </j:file>

    <!-- now lets implement the jellydoc for the core package -->    
    <j:set var="maven.jellydoc.packages" value="org.apache.commons.jelly.tags.core.*"/>
    <attainGoal name="jellydoc"/>
  </preGoal>

  <preGoal name="xdoc">

    <j:if test="${empty(mainSiteOnly)}">
      <!--        
      This runs out of memory - have a feeling its the velocity & xdoc plugin
      -->
      <!-- <maven:reactor
        basedir="${basedir}"
        includes="jelly-tags/*/project.xml"
        goals="site"
        banner="Generating site for"
        ignoreFailures="false"
      />-->
      <!-- PL: instead... invoke maven from the command-line directly for
       each directory in jelly-tags. -->
      <attainGoal name="tags:build-site-individually"/>
        
      <!-- then copy all the results to docs/libs -->
      <j:if test="${context.getVariable('maven.docs.dest') == null}">
        <j:set var="maven.docs.dest" value="target/docs"/>
      </j:if>
    
      <!-- create the parent directory for the docs -->
      <mkdir dir="${maven.docs.dest}/libs" />
    
      <!-- copy them all to ${maven.docs.dest}/libs/${plugin.id}/ -->
      <j:forEach items="${pluginProjects.iterator()}" var="plugin">
        <j:set var="pluginName" value="${plugin.parentFile.name}" />
        <mkdir dir="${maven.docs.dest}/libs/${pluginName}/" />
        <copy toDir="${maven.docs.dest}/libs/${pluginName}/">
          <fileset dir="jelly-tags/${pluginName}/target/docs/">
            <include name="**" />
          </fileset>
        </copy>
      </j:forEach>
    </j:if>
  </preGoal>

  <goal name="tags:build-site-individually">

    <fileScanner var="taglibProjects">
      <fileset dir="${basedir}">
        <include name="jelly-tags/*/project.xml" />
      </fileset>
    </fileScanner>
            
    <j:choose>
      <j:when test="${systemScope['os.name'].startsWith('Windows')}">
        <j:set var="mavenCmd" value="${maven.home}/bin/maven.bat"/>
      </j:when>
      <j:otherwise>
        <j:set var="mavenCmd" value="${maven.home}/bin/maven"/>
      </j:otherwise>
    </j:choose>
        
    <j:forEach items="${taglibProjects.iterator()}" var="taglib">
      <j:set var="tlName" value="${taglib.parentFile.name}" />
      <echo>Processing tag-library ${tlName}.</echo>
      <j:set var="dir" value="${basedir}/jelly-tags/${tlName}"/>
      <j:set var="testVar" value="siteIsBuilt${tlName}"/>
      <uptodate property="${testVar}">
        <srcfiles dir="${dir}" excludes="target/**/*"/>
        <mapper type="merge" to="${dir}/target/docs/index.html"/>
      </uptodate>
      <echo>Tag-library ${tlname}'s site is up-to-date ? "${context.getVariable(testVar)}"</echo>
      <j:if test="${!context.getVariable(testVar)}">
        <echo>Building tag-library ${tlname}'s site.</echo>

        <exec executable="${mavenCmd}" failonerror="true" dir="${dir}">
          <arg value="site"/>
        </exec>
      </j:if>
    </j:forEach>
        
  </goal>


  <!-- demo programs -->

  <!-- a sample of using the command line interface to invoke Jelly -->
  <goal name="demo:cmdline" prereqs="create-classpath"
    description="Demonstrates how to use the command line interface to Jelly">
    <java classname="org.apache.commons.jelly.Jelly" fork="yes">
      <classpath refid="test.classpath"/>
      <arg value="src/test/org/apache/commons/jelly/testCmdLineOptions.jelly"/>
      <arg value="-a"/>
      <arg value="valueOfA"/>
      <arg value="-b"/>
      <arg value="valueOfB"/>
      <arg value="-c"/>
      <arg value="valueOfC"/>
      <arg value="-Dtestsysprop=valueOfTestSystemProp"/>
    </java>
  </goal>


  <goal name="test:benchmark" prereqs="create-classpath"
    description="A simple bit of Jelly script used as a benchmark to guage performance">
    <java classname="org.apache.commons.jelly.Jelly" fork="yes">
      <classpath refid="test.classpath"/>
      <arg value="src/test/org/apache/commons/jelly/benchmark/benchmark.jelly"/>
    </java>
  </goal>

  <goal name="demo:embed" prereqs="create-classpath"
    description="A sample Swing app which lets you build a personalized homepage, and uses Jelly as a templating engine">
    <java classname="org.apache.commons.jelly.demos.HomepageBuilder" fork="yes">
      <classpath refid="test.classpath"/>
    </java>
  </goal>

  <goal name="demo:async"
    description="An example of using asynchronous invocation of goals">

    <j:thread>
      <attainGoal name="demo:asyncOtherThread"/>
    </j:thread>

    <echo>XXXX</echo>
  </goal>

  <goal name="demo:asyncOtherThread"
    description="A private target invoked by the async demo">
    <echo>YYYY</echo>
  </goal>


  <!-- define the classpath used to run examples -->
  <goal name="create-classpath" prereqs="java:compile,test:compile">
    <path id="test.classpath">
      <pathelement path="${maven.build.dest}"/>
      <pathelement path="target/classes"/>
      <pathelement path="target/test-classes"/>
      <path refid="maven.dependency.classpath"/>
    </path>
  </goal>
    
    
  <goal name="clean-build">
    <attainGoal name="clean"/>
    <attainGoal name="jar:install-snapshot"/>
    ${systemScope.put('goal','clean,jar:install-snapshot')}
    <attainGoal name="multiproject:goal"/>
  </goal>
  
  <goal name="pack-fat-jar" prereqs=""
            description="Creates a jar with all the dependencies of jelly and the taglibs indicated in ${tagLibs}.">
      <!-- variables: 
        - tagLibs: a comma-separated list of taglib-names (without the "jelly:")
        - doBuildAll: a boolean that says wether we invoke build (of jelly, and the taglibs)
           When true, invokes jar:install-snapshot on jelly and each taglib included
        - fatJarName: the location of the fat-jar collected
        -->
      <!-- this goal isn't really much tested yet but could be the key
        to get a better packaging -->
        
      <property name="tagLibs" value="ant,bean,beanshell,betwixt,define,dynabean,fmt,html,http,interaction,junit,jsl,log,swing,threads,util,validate,velocity,xml,xmlunit"/>
      <!-- arbitrary set of taglibs with dependencies that should have no problems -->
      <property name="doBuildAll" value="false"/>
      <property name="fatJarPath" value="${maven.build.dir}/fatjelly.jar"/>
      <property name="classpathFile" value="${maven.build.dir}/classpath-with-deps.txt"/>
        
      <!-- if we need to build, we need to build first jelly -->
      <j:if test="${doBuildAll}"><attainGoal name="jar:install-snapshot"/></j:if>
      <j:new var="jellyTaglibNames" className="java.util.HashSet"/>
      <j:set var="taglibs_projects" value=""/>
      <util:tokenize delim="," var="tagLibnames">${tagLibs}</util:tokenize>
      <j:forEach var="tlName" items="${tagLibnames}">
        <echo>Considering taglib tlName "${tlName}".</echo>
        <j:if test="${'core' ne tlName}">
          <j:if test="${taglibs_projects.length() > 0}"><j:set var="taglibs_projects" trim="false">${taglibs_projects},</j:set></j:if>
          <j:set var="taglibs_projects">${taglibs_projects}jelly-tags/${tlName}/project.xml</j:set>
          ${jellyTaglibNames.add(tlName)}
        </j:if>
      </j:forEach> 
    
      <!-- collect all dependencies in a set -->
      <j:new var="deps" className="java.util.HashSet"/>

      <j:choose>
        <j:when test="${doBuildAll}">
          <maven:reactor basedir="." 
                         postProcessing="true"
                         goals="jar:install-snapshot"
                         includes="${taglibs_projects}" 
                         ignoreFailures="false"/>
        </j:when>
        <j:otherwise>
              <maven:reactor basedir="." postProcessing="true"
                  includes="${taglibs_projects}" ignoreFailures="false"/>
        </j:otherwise>
      </j:choose>
        
      <j:forEach var="reactorProject" items="${reactorProjects}">
        <j:forEach var="dep" items="${reactorProject.dependencies}">${deps.add(dep)}</j:forEach>
      </j:forEach>
      <j:forEach var="tl" items="${jellyTaglibNames}">
        <j:new var="tlD" className="org.apache.maven.project.Dependency"/>
        ${tlD.setGroupId("commons-jelly")}
        <j:set var="artId" value="commons-jelly-tags-${tl}"/>
        ${tlD.setArtifactId(artId)}
        ${tlD.setType("jar")}
        ${tlD.setVersion("SNAPSHOT")}
        ${deps.add(tlD)}
      </j:forEach>
  
      <!-- <maven:reactor
           basedir="."
           postProcessing="true"
           includes="project.xml"
           ignoreFailures="false">
           </maven:reactor>
        <j:forEach var="reactorProject" items="${reactorProjects}">
          <j:forEach var="dep" items="${reactorProject.dependencies}">${deps.add(dep)}</j:forEach>
        </j:forEach> -->


      <j:if test="${'' ne classpathFile}">    
        <j:file name="${classpathFile}" omitXmlDeclaration="true"><j:forEach items="${deps}" trim="true" var="dep">${maven.repo.local}/${dep.groupId}/${dep.type}s/${dep.artifactId}-${dep.version}.${dep.type}${path.separator}</j:forEach></j:file>
      </j:if>
    
      <!-- merging it all -->
      <j:if test="${'' ne fatJarPath}">
        <jar destfile="${fatJarPath}" update="yes">
          <manifest><attribute name="Main-Class" value="org.apache.commons.jelly.Jelly"/></manifest>
          <j:forEach var="dep" items="${deps}">
            <zipfileset src="${maven.repo.local}/${dep.groupId}/${dep.type}s/${dep.artifact}" />
            <echo>Adding jar ${maven.repo.local}/${dep.groupId}/${dep.type}s/${dep.artifact}.</echo>
          </j:forEach>
        </jar>
      </j:if>
            
    </goal>
</project>