<!--
	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>
	<groupId>org.apache.uima</groupId>
	<artifactId>RegularExpressionAnnotator</artifactId>
	<packaging>jar</packaging>
	<version>2.3.0-incubating</version> <!-- this comment is a flag for changeVersion -->
	<name>Apache UIMA RegularExpressionAnnotator</name>
    
  <parent>
    <groupId>org.apache.uima</groupId>
    <artifactId>SandboxDistr-pearBuilder</artifactId>
    <version>2.3.0-incubating</version> <!-- this comment is a flag for changeVersion -->
    <relativePath>../SandboxDistr/pear-builder-pom</relativePath>
  </parent>
  
	<dependencies>
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-test-util</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.uima</groupId>
			<artifactId>uimaj-component-test-util</artifactId>
		</dependency>
		<!--dependency>
			<groupId>local.xmlbeans.dependency</groupId>
			<artifactId>generated-xmltypes</artifactId>
			<version>1.0</version>
			<scope>system</scope>
			<systemPath>${basedir}/lib/regex_annot_xml_types.jar</systemPath>
		</dependency-->
    
    <dependency>
      <groupId>org.apache.xmlbeans</groupId>
      <artifactId>xmlbeans</artifactId>
      <version>2.4.0</version>
      <exclusions>
        <exclusion> <!-- licensing issues, use geronimo instead -->
          <groupId>stax</groupId>
          <artifactId>stax-api</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.apache.geronimo.specs</groupId>
      <artifactId>geronimo-stax-api_1.0_spec</artifactId>
      <version>1.0.1</version>
    </dependency>
    
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.3.2</version>
      <scope>test</scope>
    </dependency>
	</dependencies>
  
	<build>
		<finalName>uima-an-regex</finalName>
     
		<plugins>
      
      <!-- generate XML parser from .xsd file -->
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>xmlbeans-maven-plugin</artifactId>
        <version>2.3.3</version>
        <executions>
          <execution>
            <goals><goal>xmlbeans</goal></goals>
            <configuration>
              <schemaDirectory>resources</schemaDirectory>
            </configuration>        
          </execution>
        </executions>
      </plugin>
      
      <!-- build pear plugin, most settings inherited from parent POM -->      
      <plugin>
        <groupId>org.apache.uima</groupId>
        <artifactId>PearPackagingMavenPlugin</artifactId>
        <executions><execution>
          <id>buildPear</id>
          <configuration>
            <mainComponentDesc>desc/RegExAnnotator.xml</mainComponentDesc> 
          </configuration>
        </execution></executions>
      </plugin>              
      
      <!-- Release Audit Tool checks -->
      <plugin>
        <groupId>org.apache.rat</groupId>
        <artifactId>apache-rat-plugin</artifactId>
        <executions>
          <execution>
            <id>default-cli</id>
            <configuration>
              <excludes>
                <exclude>docs/html/images/*.svg</exclude> <!-- generated image files for docbook -->
                <exclude>src/test/resources/*/*Ref.txt</exclude>
                <exclude>src/test/resources/conceptSyntax/syntaxCheckRefOutput.txt</exclude>
                <exclude>src/test/resources/setFeatureValues/featureValuesRef?.txt</exclude>
              </excludes>
            </configuration>
          </execution>
        </executions>
      </plugin>
      
 			<!--plugin>
				<groupId>org.apache.uima</groupId>
		  	<artifactId>PearPackagingMavenPlugin</artifactId>
				<extensions>true</extensions>
				<executions>
					<execution>
						<phase>package</phase>
						<configuration>
						  <classpath>$main_root/lib/jsr173_1.0_api.jar;$main_root/lib/regex_annot_xml_types.jar;$main_root/lib/xbean.jar</classpath>
						  <mainComponentDesc>desc/RegExAnnotator.xml</mainComponentDesc>
						  <componentId>RegExAnnotator</componentId>
						  <datapath>$main_root/resources</datapath>
						</configuration>
						<goals>
							<goal>package</goal>
						</goals>
					</execution>	
				</executions>
			</plugin-->
		</plugins>
	</build>
</project>
