<!--
 -
 - Licensed to the Apache Software Foundation (ASF) under one
 - or more contributor license agreements.  See the NOTICE file
 - distributed with this work for additional information
 - regarding copyright ownership.  The ASF licenses this file
 - to you 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 name="Qpid JCA" default="build">

  <property name="module.depends" value="common client"/>
  <property name="module.name" value="jca"/>
  <!-- Hack to make the renamed module jars available on the module test classpath -->
  <property name="module.test.depends" value="ra ra/tests"/>

  <!-- Import common.xml to make the properties it defines available before importing module.xml -->
  <import file="../common.xml"/>

  <!-- Override the standard output jar names before importing module.xml, to produce
       artifacts that use ra in the name instead of jca like the module should -->
  <property name="module.test.jar" value="${build.lib}/${project.name}-ra-tests-${project.version}.jar"/>
  <property name="module.jar" value="${build.lib}/${project.name}-ra-${project.version}.jar"/>
  <property name="module.source.jar" value="${build.lib}/${project.name}-ra-${project.version}-sources.jar"/>

  <import file="../module.xml"/>

  <property name="module.rar" value="${build.lib}/${project.name}-ra-${project.version}.rar"/>
  <property name="rar.resources" value="rar/src/main/resources"/>

  <target name="rar" depends="jar" description="creates a rar file containing the module jar, client jars, etc">
    <jar destfile="${module.rar}">
      <fileset dir="${rar.resources}">
        <include name="**/*.xml"/>
      </fileset>
      <fileset dir="${build.lib}">
        <include name="${project.name}-ra-${project.version}.jar"/>
        <include name="${project.name}-client-${project.version}.jar"/>
        <include name="${project.name}-common-${project.version}.jar"/>
      </fileset>
    </jar>
  </target>

  <!-- Create properties file for examples -->
  <target name="example-properties-file">
    <copy file="example/build-properties.xml.temp" tofile="example/build-properties.xml">
      <filterset>
        <filter token="project.version" value="${project.version}"/>
      </filterset>
    </copy>
  </target>

  <!-- Copy jars for standalone examples -->
  <target name="example-jars">
    <mkdir dir="example/lib"/>
    <copy todir="example/lib">
      <fileset dir="${build.lib}">
        <include name="${project.name}-ra-${project.version}.jar"/>
        <include name="${project.name}-client-${project.version}.jar"/>
        <include name="${project.name}-common-${project.version}.jar"/>
      </fileset>
    </copy>
  </target>

  <target name="examples" depends="example-properties-file, example-jars"/>

  <target name="postbuild" depends="rar, examples"/>

  <!-- Override module.xml 'libs' target to avoid copying the jar files dependencies
       into the 'build/lib' dir, since they will be supplied by the app server -->
  <target name="libs"/>
</project>
