<?xml version="1.0" encoding="UTF-8"?>
<!--
   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 xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
  
  <parent>
    <groupId>org.apache.uima</groupId>
    <artifactId>uimaj-parent</artifactId>
    <version>2.4.1-SNAPSHOT</version>
    <relativePath>../uimaj-parent/pom.xml</relativePath>
  </parent>
  
	<artifactId>uimaj-tools</artifactId>
	<packaging>jar</packaging>
	<version>2.4.1-SNAPSHOT</version>
	<name>Apache UIMA Base: ${project.artifactId}: Tools</name>
  <description>Tooling supporting UIMA use</description>
  <url>${uimaWebsiteUrl}</url>
  
  <!-- Special inheritance note
       even though the <scm> element that follows is exactly the 
       same as those in super poms, it cannot be inherited because 
       there is some special code that computes the connection elements
       from the chain of parent poms, if this is omitted. 
       
       Keeping this a bit factored allows cutting/pasting the <scm>
       element, and just changing the following two properties -->  
  <scm>
    <connection>
      scm:svn:http://svn.apache.org/repos/asf/uima/uimaj/trunk/uimaj-tools
    </connection>
    <developerConnection>
      scm:svn:https://svn.apache.org/repos/asf/uima/uimaj/trunk/uimaj-tools
    </developerConnection>
    <url>
      http://svn.apache.org/viewvc/uima/uimaj/trunk/uimaj-tools
    </url>
  </scm>
  
  <properties>
    <uimaScmProject>${project.artifactId}</uimaScmProject>
    <postNoticeText>${ibmNoticeText}</postNoticeText>
  </properties>
  
	<dependencies>
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-core</artifactId>
			<version>${project.parent.version}</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-cpe</artifactId>
			<version>${project.parent.version}</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-document-annotation</artifactId>
			<version>${project.parent.version}</version>
			<scope>compile</scope>
		</dependency>	    
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-test-util</artifactId>
			<version>${project.parent.version}</version>
			<scope>test</scope>
		</dependency>    
	</dependencies>
	<build>
		<finalName>uima-tools</finalName>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>        
      </resource>
    </resources>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.rat</groupId>
          <artifactId>apache-rat-plugin</artifactId>
          <executions>
            <execution>
              <id>default-cli</id>
              <configuration>
                <excludes>
                  <exclude>release.properties</exclude> <!-- release generated artifact -->
                  <exclude>src/main/resources/org/apache/uima/tools/migration/*</exclude> <!-- data for migration code -->
                  <exclude>src/main/resources/org/apache/uima/tools/util/gui/about.txt</exclude>
                  <exclude>src/test/resources/pearTests/pearMergerTests/*.pear</exclude> <!-- test data -->
                </excludes>              
              </configuration>
            </execution>
          </executions>
        </plugin>      
      </plugins>
    </pluginManagement>
    
	</build>	
</project>