<?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>taverna-parent</artifactId>
		<version>1-incubating-SNAPSHOT</version>
	</parent>
	<groupId>org.apache.taverna.language</groupId>
	<artifactId>taverna-language</artifactId>
	<version>0.15.0-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.rat</groupId>
				<artifactId>apache-rat-plugin</artifactId>
				<executions>
					<execution>
						<id>rat-checks</id>
						<phase>verify</phase>
						<goals>
							<goal>check</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<useDefaultExcludes>true</useDefaultExcludes>
					<excludes>
						<!-- 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>
						<!-- The following schemas are W3C; automatic retrieval during build is 
							blocked by their administrative processes, yet they are explicitly
							standardised documents intended for wide use. Their licenses should
							be standard W3C ones, but that's never stated explicitly by the W3C.
							"Thanks!" -->
						<exclude>**/xml.xsd</exclude>
						<exclude>**/xenc-schema.xsd</exclude>
						<exclude>**/xmldsig-core-schema.xsd</exclude>
						<!-- This refers to the FOAF spec, which is available online at
							http://xmlns.com/foaf/spec/ and which uses the CC-BY-SA 1.0
							license. The RDF downloadable from the site, of which this is a copy,
							has no copyright statement at all in it. -->
						<exclude>**/foaf.rdf</exclude>
						<!-- The following contain a mix of licenses. PROBLEM! -->
						<exclude>/src/main/resources/ontologies/*.owl</exclude>
						<exclude>/src/main/resources/ontologies/*.rdf</exclude>
						<exclude>/src/main/resources/org/purl/wf4ever/wfdesc/roterms.ttl</exclude>
						<exclude>/src/main/resources/org/purl/wf4ever/wfdesc/wf4ever.ttl</exclude>
						<exclude>/src/main/resources/org/purl/wf4ever/wfdesc/wfdesc.ttl</exclude>
						<exclude>/src/main/resources/org/purl/wf4ever/wfdesc/wfprov.ttl</exclude>
						<exclude>/src/main/resources/org/w3/prov-o.ttl</exclude>
						<!-- Various files used for testing and test support only. -->
						<!-- THESE SUPPORT COMMENTS with # --><!--taverna-integration-test-->
						<exclude>/src/test/resources/t172starterpacklist</exclude>
						<exclude>/src/test/resources/t230starterpacklist</exclude>
						<!-- THESE ARE XML AND SUPPORT COMMENTS -->
						<exclude>/src/test/resources/annotation_with_backslash.t2flow</exclude>
						<exclude>/src/test/resources/beanshell-deps.t2flow</exclude>
						<exclude>/src/test/resources/component_simple.t2flow</exclude>
						<exclude>/src/test/resources/dataflow_link_then_merge.t2flow</exclude>
						<exclude>/src/test/resources/dispatchlayers-xsd.t2flow</exclude>
						<exclude>/src/test/resources/dispatchlayers.t2flow</exclude>
						<exclude>/src/test/resources/fasta_and_pscan.t2flow</exclude>
						<exclude>/src/test/resources/fasta_pscan_and_dbfetch.t2flow</exclude>
						<exclude>/src/test/resources/interaction-with-strange-loop.t2flow</exclude>
						<exclude>/src/test/resources/interaction_multiple_choice.t2flow</exclude>
						<exclude>/src/test/resources/interaction_simple_tell.t2flow</exclude>
						<exclude>/src/test/resources/iterationstrategies.t2flow</exclude><!-- TOM -->
						<exclude>/src/test/resources/merge_fun.t2flow</exclude>
						<exclude>/src/test/resources/merge_then_dataflow_link.t2flow</exclude>
						<exclude>/src/test/resources/missing_merge.t2flow</exclude>
						<exclude>/src/test/resources/missing_produced_by_941.t2flow</exclude>
						<exclude>/src/test/resources/rest-2-2.t2flow</exclude>
						<exclude>/src/test/resources/rshell-2-2.t2flow</exclude>
						<exclude>/src/test/resources/simple_fasta.t2flow</exclude>
						<exclude>/src/test/resources/sleepers.t2flow</exclude>
						<exclude>/src/test/resources/apiconsumer.t2flow</exclude>
						<exclude>/src/test/resources/rest.t2flow</exclude>
						<exclude>/src/test/resources/valid_component_imagemagickconvert.t2flow</exclude>
						<exclude>/src/test/resources/enm-v21.t2flow</exclude>
						<exclude>/src/test/resources/helloworld.wfdesc.ttl</exclude>
						<exclude>/src/test/resources/localdependency.t2flow</exclude>
						<exclude>/src/test/resources/nested.t2flow</exclude>
						<exclude>/src/test/resources/rdf-in-example-annotation.t2flow</exclude>
						<exclude>/src/test/resources/workflow10.xml</exclude>
						<exclude>/src/test/resources/full-example/ebi_interproscan_newservices_900329.t2flow</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>
					</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>
					<version>0.12.3</version>
					<configuration>
						<enableIntrospection>true</enableIntrospection>
						<specVersion>2.2</specVersion>
						<schemaDirectory>src/main/xsd</schemaDirectory>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
<!-- TODO: Update -->
	<scm>
		<!-- TODO: Replace with git.apache.org details :
		<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://git-wip-us.apache.org/repos/asf/incubator-taverna-language.git</url>
		-->
		<connection>scm:git:https://github.com/taverna-incubator/incubator-taverna-language.git</connection>
		<developerConnection>scm:git:git@github.com:taverna-incubator/incubator-taverna-language.git</developerConnection>
		<url>https://github.com/taverna-incubator/incubator-taverna-language</url>
		<tag>HEAD</tag>
	</scm>

	<repositories>
		<!--
		<repository>
			<id>com.springsource.repository.bundles.release</id>
			<name>SpringSource Enterprise Bundle Repository - SpringSource Bundle Releases</name>
			<url>http://repository.springsource.com/maven/bundles/release</url>
			<releases />
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
		<repository>
			<id>com.springsource.repository.bundles.external</id>
			<name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>
			<url>http://repository.springsource.com/maven/bundles/external</url>
			<releases />
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
		-->

<!-- TODO: Remove myGrid repositories -->
		<repository>
			<id>taverna-incubating</id>
			<name>Apache Taverna incubating Repository</name>
			<url>http://repository.mygrid.org.uk/artifactory/incubator-snapshot-local/</url>
			<releases>
				<enabled>false</enabled>
			</releases>
			<snapshots />
		</repository>
		<repository>
<!-- TODO: Use Apache snapshot repo instead -->
			<id>taverna-incubating-release</id>
			<name>Taverna incubating test release</name>
			<url>http://repository.mygrid.org.uk/artifactory/incubator-release-test/</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</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>
	<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-scufl2-wfdesc</module>
	</modules>
</project>
