<?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.taverna</groupId>
		<artifactId>apache-taverna-parent</artifactId>
		<version>3-incubating-SNAPSHOT</version>
	</parent>
	<groupId>org.apache.taverna.language</groupId>
	<artifactId>apache-taverna-language</artifactId>
	<version>0.15.2-incubating-SNAPSHOT</version>
	<packaging>pom</packaging>

	<name>Apache Taverna Language APIs (Scufl2, Databundle)</name>
	<description>Taverna Language API for workflow definitions (SCUFL2)
		and workflow inputs/outputs/run (DataBundle).
	</description>

	<build>
		<plugins>
			<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-javadoc-plugin</artifactId>
    <executions>
        <execution>
            <id>attach-javadocs</id>
            <goals>
                <goal>jar</goal>
            </goals>
            <configuration>
                <additionalparam>-Xdoclint:none</additionalparam>
            </configuration>
        </execution>
    </executions>
</plugin>
			<plugin>
				<groupId>org.apache.rat</groupId>
				<artifactId>apache-rat-plugin</artifactId>
				<configuration>
					<useDefaultExcludes>true</useDefaultExcludes>
					<excludes>
            <!--Just a META-INF file -->
            <exclude>DEPENDENCIES</exclude>
						<!-- Following excludes needed for taverna-scufl2-rdf,
						taverna-scufl2-integration-tests and taverna-scufl2-validation-integration
						subfolders that should be modules but are not. -->
						<exclude>**/.classpath</exclude>
						<exclude>**/.project</exclude>
						<exclude>**/.settings/</exclude>
						<exclude>**/target/</exclude>
						<!-- Text and Markdown files are typically used only for documentation 
							purposes and license declarations are usually spurious in these files since 
							often they will refer to the LICENSE/NOTICE for users to find the actual 
							licenses -->
						<exclude>**/*.md</exclude>
						<!-- META-INF services files can include comments but a license header 
							would be unecessarily clutter so we exclude these -->
						<exclude>**/META-INF/services/*</exclude>
						<!-- No headers in JSON which haven't got comments ... -->
						<exclude>**/*.json</exclude>
						<!-- Really a binary format, but must look like text -->
						<exclude>**/mimetype</exclude>
						<!-- Effectively a binary format -->
						<exclude>**/*.url</exclude>
						<!-- Cannot contain comments; content must match program output. -->
						<exclude>/src/test/resources/org/apache/taverna/scufl2/api/io/HelloWorld.txt</exclude>
						<exclude>/src/test/resources/as.txt</exclude>
						<!-- Expanded data bundle. Generated. -->
						<exclude>/src/test/resources/full-example/ebi-wfrun-2013-05-31/</exclude>

            <!-- Test COMBINE archives. Skeleton only (files empty) -->
            <exclude>/src/test/resources/combine/aslanidi_purkinje_model_skeleton.zip</exclude>
            <exclude>/src/test/resources/combine/Boris-skeleton.omex</exclude>
            <exclude>/src/test/resources/combine/DirectoryMadnessZipped-skeleton.omex</exclude>
            <exclude>/src/test/resources/combine/DirectoryMadness-skeleton.omex</exclude>

            <!-- Our own test documents - contains LICENSE -->
            <exclude>src/test/resources/document.odt</exclude>
            <exclude>src/test/resources/workflowrun.bundle.zip</exclude>

           <!-- Created by Maven Shade plugin -->
           <exclude>dependency-reduced-pom.xml</exclude>

            <!-- 
                 Below exclusions are for 
                 externally sourced/derived files 
                 that must be acknowledged in 
                 NOTICE (and/or */src/*/resources/META-INF/NOTICE)
            -->

            <!-- W3C license -->
						<exclude>**/xml.xsd</exclude>
						<exclude>**/xenc-schema.xsd</exclude>
						<exclude>**/xmldsig-core-schema.xsd</exclude>
            <exclude>**/prov-o.rdf</exclude>
            <exclude>**/prov-o.ttl</exclude>
            <exclude>**/prov-aq.rdf</exclude>
            <!-- W3C Community license -->
            <!-- FOAF, Creative Commons Attribution 1.0 -->
            <exclude>**/oa.rdf</exclude>
						<exclude>**/foaf.rdf</exclude>
            <!-- Research Object Model, Creative Commons Attribution 3.0 -->
						<exclude>**/roterms.ttl</exclude>
            <exclude>**/wf4ever.ttl</exclude>
            <exclude>**/wfdesc.ttl</exclude>
            <exclude>**/wfprov.ttl</exclude>

            <!-- Dublin Core, Creative Commons Attribution 3.0 -->
            <exclude>**/dcam.owl</exclude>
            <exclude>**/dcterms_od.owl</exclude>

					</excludes>
				</configuration>
			</plugin>
		
			<!--
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>license-maven-plugin</artifactId>
				<version>1.7</version>
				<executions>
					<execution>
						<id>add-licenses</id>
						<phase>generate-sources</phase>
						<goals>
							<goal>aggregate-add-third-party</goal>
						</goals>
						<configuration>
							<excludedGroups>.*(mygrid|taverna).*</excludedGroups>
							<useMissingFile>true</useMissingFile>
							<missingFile>src/license/THIRD-PARTY.properties</missingFile>
							<licenseMerges>
								<licenseMerge>The Apache Software License, Version 2.0|Apache 2|Apache License|Apache License, Version 2.0|Apache Public License 2.0|Apache License Version 2.0|Apache Software License 2.0|Apache Software License - Version 2.0</licenseMerge>
								<licenseMerge>The BSD License|BSD|BSD License|BSD-style license|BSD style|Aduna BSD license|Aduna BSD-style license</licenseMerge>
								<licenseMerge>MIT License|The MIT License|MIT license</licenseMerge>
								<licenseMerge>GNU Lesser General Public License|GNU LESSER GENERAL PUBLIC LICENSE|GNU Library or Lesser General Public License|LGPL</licenseMerge>
								<licenseMerge>Common Development and Distribution License (CDDL) v1.0|CDDL 1.1|COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0</licenseMerge>
								<licenseMerge>Eclipse Public License, Version 1.0|Eclipse Public License</licenseMerge>
							</licenseMerges>
						</configuration>
					</execution>
				</executions>
			</plugin>
			-->
		</plugins>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId>org.jvnet.jaxb2.maven2</groupId>
					<artifactId>maven-jaxb2-plugin</artifactId>
					<configuration>
						<enableIntrospection>true</enableIntrospection>
						<specVersion>2.2</specVersion>
						<schemaDirectory>src/main/xsd</schemaDirectory>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
	<scm>
		<connection>scm:git:https://git-wip-us.apache.org/repos/asf/incubator-taverna-language.git</connection>
		<developerConnection>scm:git:https://git-wip-us.apache.org/repos/asf/incubator-taverna-language.git</developerConnection>
		<url>https://github.com/apache/incubator-taverna-language</url>
		<tag>HEAD</tag>
	</scm>

  <repositories>
    <repository>
      <id>apache.snapshots</id>
      <name>Apache Snapshot Repository</name>
      <url>https://repository.apache.org/snapshots</url>
      <releases>
        <enabled>false</enabled>
      </releases>
    </repository>
	</repositories>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>com.fasterxml.jackson.core</groupId>
				<artifactId>jackson-core</artifactId>
				<version>${jackson.version}</version>
			</dependency>
			<dependency>
				<groupId>com.fasterxml.jackson.core</groupId>
				<artifactId>jackson-databind</artifactId>
				<version>${jackson.version}</version>
			</dependency>
			<dependency>
				<groupId>com.fasterxml.jackson.module</groupId>
				<artifactId>jackson-module-jsonSchema</artifactId>
				<version>${jackson.version}</version>
			</dependency>
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>${junit.version}</version>
				<scope>test</scope>
			</dependency>
			<dependency>
				<groupId>commons-io</groupId>
				<artifactId>commons-io</artifactId>
				<version>${commons.io.version}</version>
			</dependency>
			<dependency>
				<groupId>org.jdom</groupId>
				<artifactId>com.springsource.org.jdom</artifactId>
				<version>${jdom.version}</version>
				<type>jar</type>
			</dependency>
			<dependency>
				<groupId>com.sun.xml.bind</groupId>
				<artifactId>jaxb-impl</artifactId>
				<version>${jaxb.version}</version>
				<type>jar</type>
				<optional>true</optional>
			</dependency>
			<dependency>
				<groupId>org.jaxen</groupId>
				<artifactId>com.springsource.org.jaxen</artifactId>
				<!-- Was 1.1.4. as "1.1.3 has missing dependencies" but 1.1.1 appears to work fine -->
				<version>${jaxen.version}</version>
				<type>jar</type>
			</dependency>
			<dependency>
				<groupId>commons-beanutils</groupId>
				<artifactId>commons-beanutils</artifactId>
				<version>${commons.beanutils.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>
<dependencies>
  <!-- Common dependencies on jena-osgi, which requires some
additional dependencies to be a happy OSGi bundle -->

	<dependency>
		<groupId>org.apache.jena</groupId>
		<artifactId>jena-osgi</artifactId>
		<version>${jena.version}</version>
	</dependency>
    <dependency>
      <groupId>org.apache.servicemix.bundles</groupId>
      <artifactId>org.apache.servicemix.bundles.xerces</artifactId>
      <version>${servicemix.xerces.version}</version>
    </dependency>
        <!-- JENA-1178 workaround: Upgrade jsonlld-java -->
    <dependency>
      <groupId>com.github.jsonld-java</groupId>
      <artifactId>jsonld-java</artifactId>
      <version>${jsonldjava.version}</version>
     </dependency>
    <!-- Needed by Jena -->
    <dependency>
      <groupId>com.github.andrewoma.dexx</groupId>
      <artifactId>collection</artifactId>
      <version>${dexx.collection.version}</version>
    </dependency>

</dependencies>

	<modules>
    <module>taverna-baclava-language</module>
    <module>taverna-databundle</module>
    <module>taverna-robundle</module>
    <module>taverna-scufl2-annotation</module>
    <module>taverna-scufl2-api</module>
    <module>taverna-scufl2-examples</module>
    <module>taverna-scufl2-integration-tests</module>
    <module>taverna-scufl2-schemas</module>
    <module>taverna-scufl2-scufl</module>
    <module>taverna-scufl2-t2flow</module>
    <module>taverna-scufl2-ucfpackage</module>
    <module>taverna-scufl2-wfbundle</module>
    <module>taverna-tavlang-tool</module>
    <module>taverna-scufl2-wfdesc</module>
	</modules>
</project>
