Description

<dependency>
    <groupId>org.scijava</groupId>
    <artifactId>pom-scijava-base</artifactId>
    <version>4.0.0</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.scijava</groupId>
	<artifactId>pom-scijava-base</artifactId>
	<version>4.0.0</version>
	<packaging>pom</packaging>

	<name>SciJava Base POM</name>
	<description>This POM is a base which SciJava-based projects can extend to inherit helpful build configuration. It ensures that projects all use a compatible build environment, including versions of Maven plugins and Java itself. It does _not_ provide any dependency version management; see org.scijava:pom-scijava for that.</description>
	<url>http://www.scijava.org/</url>
	<inceptionYear>2016</inceptionYear>
	<organization>
		<name>SciJava</name>
		<url>http://www.scijava.org/</url>
	</organization>
	<licenses>
		<license>
			<name>CC0 1.0 Universal License</name>
			<url>http://creativecommons.org/publicdomain/zero/1.0/</url>
			<distribution>repo</distribution>
		</license>
	</licenses>

	<developers>
		<developer>
			<id>ctrueden</id>
			<name>Curtis Rueden</name>
			<url>http://imagej.net/User:Rueden</url>
			<roles>
				<role>founder</role>
				<role>lead</role>
				<role>developer</role>
				<role>debugger</role>
				<role>reviewer</role>
				<role>support</role>
				<role>maintainer</role>
			</roles>
		</developer>
	</developers>
	<contributors>
		<contributor>
			<name>Mark Hiner</name>
			<url>http://imagej.net/User:Hinerm</url>
			<properties><id>hinerm</id></properties>
		</contributor>
		<contributor>
			<name>Johannes Schindelin</name>
			<url>http://imagej.net/User:Schindelin</url>
			<properties><id>dscho</id></properties>
		</contributor>
		<contributor>
			<name>Barry DeZonia</name>
			<url>http://imagej.net/User:Bdezonia</url>
			<properties><id>bdezonia</id></properties>
		</contributor>
		<contributor>
			<name>Jean-Yves Tinevez</name>
			<url>http://imagej.net/User:JeanYvesTinevez</url>
			<properties><id>tinevez</id></properties>
		</contributor>
		<contributor>
			<name>Lorenzo Scianatico</name>
			<url>http://imagej.net/User:LoreScianatico</url>
			<properties><id>LoreScianatico</id></properties>
		</contributor>
	</contributors>

	<mailingLists>
		<mailingList>
			<name>SciJava</name>
			<subscribe>https://groups.google.com/group/scijava</subscribe>
			<unsubscribe>https://groups.google.com/group/scijava</unsubscribe>
			<post>scijava@googlegroups.com</post>
			<archive>https://groups.google.com/group/scijava</archive>
		</mailingList>
	</mailingLists>

	<scm>
		<connection>scm:git:git://github.com/scijava/pom-scijava-base</connection>
		<developerConnection>scm:git:git@github.com:scijava/pom-scijava-base</developerConnection>
		<tag>pom-scijava-base-4.0.0</tag>
		<url>https://github.com/scijava/pom-scijava-base</url>
	</scm>
	<issueManagement>
		<system>GitHub Issues</system>
		<url>https://github.com/scijava/pom-scijava-base/issues</url>
	</issueManagement>
	<ciManagement>
		<system>Travis CI</system>
		<url>https://travis-ci.org/scijava/pom-scijava-base</url>
	</ciManagement>

	<properties>
		<!-- Project configuration -->

		<!--
		The main class of the project. Used in several ways:
		* Set as the Main-Class attribute of the JAR manifest.
		* dist profile: main class for the JavaFX launchers.
		* exec profile: main class to execute.
		* jdb profile: main class when launching jdb.
		-->
		<main-class />

		<!-- Package-Name attribute of the JAR artifact. -->
		<package-name />

		<!-- Premain-Class attribute of the JAR artifact. -->
		<premain-class />

		<!--
		The License which license-maven-plugin will use to populate.
		See: license:update-file-header, license:update-project-license
		-->
		<license.licenseName>N/A</license.licenseName>

		<!-- Project blurb to use in license headers atop each file. -->
		<license.projectName>${project.description}</license.projectName>

		<!-- Copyright owners to use in license headers atop each file. -->
		<license.copyrightOwners>N/A</license.copyrightOwners>

		<!-- Extra maven-surefire-plugin args. -->
		<argLine />

		<!-- Extra maven-surefile-plugin args used with debug-port profile. -->
		<argLineDebug />

		<!-- Classes the enforcer allows to be duplicated on the classpath. -->
		<allowedDuplicateClasses />

		<!-- Target version of the Java platform. -->
		<scijava.jvm.version>1.8</scijava.jvm.version>
		<scijava.jvm.test.version>${scijava.jvm.version}</scijava.jvm.test.version>
		<!-- NB: 1.8.0_101 is needed for SciJava Maven repository HTTPS support. -->
		<scijava.jvm.build.version>[1.8.0-101,1.8.9999]</scijava.jvm.build.version>

		<!-- Minimum required Maven version to build the project. -->
		<scijava.mvn.version>3.3.9</scijava.mvn.version>

		<!-- List of groupIds for which build reproducibility is enforced. -->
		<scijava.groupIds>org.scijava,net.imagej,net.imglib2,io.scif,sc.fiji</scijava.groupIds>

		<!--
		List of valid developer and contributor roles.
		See: http://imagej.net/Team
		-->
		<scijava.team.roles>founder,lead,developer,debugger,reviewer,support,maintainer</scijava.team.roles>

		<!-- Additional configuration -->

		<!-- NB: Avoid platform encoding warning when copying resources. -->
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

		<!-- NB: Specify formatting of the maven.build.timestamp property. -->
		<maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ssZ</maven.build.timestamp.format>

		<!-- NB: Deploy to OSS Sonatype repository by default when releasing. -->
		<releaseProfiles>sonatype-oss-release</releaseProfiles>

		<!-- Plugin versions -->

		<!-- Core Maven plugins -->
		<maven-assembly-plugin.version>3.1.0</maven-assembly-plugin.version>
		<maven-clean-plugin.version>3.1.0</maven-clean-plugin.version>
		<maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>
		<maven-dependency-plugin.version>3.1.1</maven-dependency-plugin.version>
		<maven-deploy-plugin.version>2.8.2</maven-deploy-plugin.version>
		<maven-enforcer-plugin.version>1.4.1</maven-enforcer-plugin.version>
		<maven-failsafe-plugin.version>2.21.0</maven-failsafe-plugin.version>
		<maven-jar-plugin.version>2.6</maven-jar-plugin.version>
		<maven-install-plugin.version>2.5.2</maven-install-plugin.version>
		<maven-invoker-plugin.version>3.1.0</maven-invoker-plugin.version>
		<maven-gpg-plugin.version>1.6</maven-gpg-plugin.version>
		<maven-javadoc-plugin.version>3.0.1</maven-javadoc-plugin.version>
		<maven-plugin-plugin.version>3.5.2</maven-plugin-plugin.version>
		<maven-release-plugin.version>2.5.3</maven-release-plugin.version>
		<maven-resources-plugin.version>3.1.0</maven-resources-plugin.version>
		<maven-site-plugin.version>3.7.1</maven-site-plugin.version>
		<maven-source-plugin.version>3.0.1</maven-source-plugin.version>
		<maven-surefire-plugin.version>2.21.0</maven-surefire-plugin.version>

		<!-- Third party Maven plugins -->
		<build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
		<buildnumber-maven-plugin.version>1.4</buildnumber-maven-plugin.version>
		<exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
		<license-maven-plugin.version>1.16</license-maven-plugin.version>
		<versions-maven-plugin.version>2.5</versions-maven-plugin.version>
		<maven-graph-plugin.version>1.39</maven-graph-plugin.version>
		<javafx-maven-plugin.version>8.8.3</javafx-maven-plugin.version>
		<nar-maven-plugin.version>3.5.2</nar-maven-plugin.version>
		<scijava-maven-plugin.version>1.0.0</scijava-maven-plugin.version>
		<imagej-maven-plugin.version>0.7.0</imagej-maven-plugin.version>
		<groovy-maven-plugin.version>1.5</groovy-maven-plugin.version>
		<nexus-staging-maven-plugin.version>1.6.8</nexus-staging-maven-plugin.version>

		<!-- Plugin dependencies -->
		<extra-enforcer-rules.version>1.0-beta-7</extra-enforcer-rules.version>
		<velocity.version>1.7</velocity.version>

		<!-- Build extensions -->
		<wagon-webdav-jackrabbit.version>1.0</wagon-webdav-jackrabbit.version>
	</properties>

	<build>
		<!-- It is nice for "mvn" with no arguments to do something reasonable. -->
		<defaultGoal>install</defaultGoal>
		<pluginManagement>
			<plugins>
				<plugin>
					<artifactId>maven-assembly-plugin</artifactId>
					<version>${maven-assembly-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-clean-plugin</artifactId>
					<version>${maven-clean-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>${maven-compiler-plugin.version}</version>
					<configuration>
						<source>${scijava.jvm.version}</source>
						<target>${scijava.jvm.version}</target>
						<testSource>${scijava.jvm.test.version}</testSource>
						<testTarget>${scijava.jvm.test.version}</testTarget>
						<!-- Workaround for a bug in maven-compiler-plugin.
						See https://issues.apache.org/jira/browse/MCOMPILER-209 -->
						<useIncrementalCompilation>false</useIncrementalCompilation>
					</configuration>
				</plugin>

				<plugin>
					<artifactId>maven-dependency-plugin</artifactId>
					<version>${maven-dependency-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-deploy-plugin</artifactId>
					<version>${maven-deploy-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-enforcer-plugin</artifactId>
					<version>${maven-enforcer-plugin.version}</version>
					<dependencies>
						<dependency>
							<groupId>org.codehaus.mojo</groupId>
							<artifactId>extra-enforcer-rules</artifactId>
							<version>${extra-enforcer-rules.version}</version>
						</dependency>
						<dependency>
							<groupId>org.scijava</groupId>
							<artifactId>scijava-maven-plugin</artifactId>
							<version>${scijava-maven-plugin.version}</version>
						</dependency>
					</dependencies>
				</plugin>

				<plugin>
					<artifactId>maven-failsafe-plugin</artifactId>
					<version>${maven-failsafe-plugin.version}</version>
					<executions>
						<execution>
							<goals>
								<goal>integration-test</goal>
								<goal>verify</goal>
							</goals>
						</execution>
					</executions>
				</plugin>

				<plugin>
					<artifactId>maven-gpg-plugin</artifactId>
					<version>${maven-gpg-plugin.version}</version>
					<executions>
						<execution>
							<id>sign-artifacts</id>
							<phase>verify</phase>
							<goals>
								<goal>sign</goal>
							</goals>
						</execution>
					</executions>
					<configuration>
						<useAgent>true</useAgent>
					</configuration>
				</plugin>

				<plugin>
					<artifactId>maven-install-plugin</artifactId>
					<version>${maven-install-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-jar-plugin</artifactId>
					<!--
					NB: This is not the latest version of maven-jar-plugin.
					However, the latest version triggers an M2E bug which
					results in an unavoidable POM warning in Eclipse. See:

					https://github.com/tesla/m2eclipse-mavenarchiver/issues/8

					To avoid this problem, we use an earlier working version.
					-->
					<version>${maven-jar-plugin.version}</version>
					<!-- Always add classpath to JAR manifests. -->
					<configuration>
						<archive>
							<manifest>
								<addClasspath>true</addClasspath>
								<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
								<addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
								<mainClass>${main-class}</mainClass>
								<packageName>${package-name}</packageName>
							</manifest>
							<manifestEntries>
								<Premain-Class>${premain-class}</Premain-Class>
								<!-- Add SCM revision from buildnumber plugin, if available. -->
								<Implementation-Build>${buildNumber}</Implementation-Build>
								<!-- Add a formatted timestamp for the build. -->
								<Implementation-Date>${maven.build.timestamp}</Implementation-Date>
							</manifestEntries>
						</archive>
						<skipIfEmpty>true</skipIfEmpty>
					</configuration>
					<executions>
						<execution>
							<goals>
								<goal>test-jar</goal>
							</goals>
						</execution>
					</executions>
				</plugin>

				<plugin>
					<artifactId>maven-javadoc-plugin</artifactId>
					<!--
					NB: The same version declaration and configuration block also appears
					in the <reporting> section, and must be kept in sync.
					-->
					<version>${maven-javadoc-plugin.version}</version>
					<configuration>
						<maxmemory>1024m</maxmemory>
						<!--
						Workaround for javadoc bug when classes in the default
						package access classes from non-default packages. See:
						http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5101868
						-->
						<use>false</use>
						<links>
							<!-- Core Java. -->
							<link>http://javadoc.scijava.org/Java/</link>
							<!-- SciJava and related projects and forks. -->
							<link>http://javadoc.scijava.org/SciJava/</link>
							<link>http://javadoc.scijava.org/Alida/</link>
							<link>http://javadoc.scijava.org/Bio-Formats/</link>
							<link>http://javadoc.scijava.org/Fiji/</link>
							<link>http://javadoc.scijava.org/Icy/</link>
							<link>http://javadoc.scijava.org/ImageJ/</link>
							<link>http://javadoc.scijava.org/ImageJ1/</link>
							<link>http://javadoc.scijava.org/ImgLib2/</link>
							<link>http://javadoc.scijava.org/Java3D/</link>
							<link>http://javadoc.scijava.org/KNIME/</link>
							<link>http://javadoc.scijava.org/LOCI/</link>
							<link>http://javadoc.scijava.org/MiToBo/</link>
							<link>http://javadoc.scijava.org/Micro-Manager-Core/</link>
							<link>http://javadoc.scijava.org/Micro-Manager-Studio/</link>
							<link>http://javadoc.scijava.org/MorphoLibJ/</link>
							<link>http://javadoc.scijava.org/OMERO/</link>
							<link>http://javadoc.scijava.org/SCIFIO/</link>
							<link>http://javadoc.scijava.org/SLIM-Curve/</link>
							<!-- Third party projects. -->
							<link>http://javadoc.scijava.org/Apache-Commons-IO/</link>
							<link>http://javadoc.scijava.org/Apache-Commons-Lang/</link>
							<link>http://javadoc.scijava.org/Apache-Commons-Math/</link>
							<link>http://javadoc.scijava.org/Apache-Commons-Text/</link>
							<link>http://javadoc.scijava.org/Eclipse/</link>
							<link>http://javadoc.scijava.org/Guava/</link>
							<link>http://javadoc.scijava.org/JAMA/</link>
							<link>http://javadoc.scijava.org/JFreeChart/</link>
							<link>http://javadoc.scijava.org/JGraphT/</link>
							<link>http://javadoc.scijava.org/JHotDraw/</link>
							<link>http://javadoc.scijava.org/Javassist/</link>
							<link>http://javadoc.scijava.org/MigLayout/</link>
							<link>http://javadoc.scijava.org/NetBeans/</link>
							<link>http://javadoc.scijava.org/Pivot/</link>
							<link>http://javadoc.scijava.org/VisAD/</link>
							<link>http://javadoc.scijava.org/Weka/</link>
							<link>http://javadoc.scijava.org/ojAlgo/</link>
						</links>
					</configuration>
				</plugin>

				<plugin>
					<artifactId>maven-plugin-plugin</artifactId>
					<version>${maven-plugin-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-release-plugin</artifactId>
					<version>${maven-release-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-resources-plugin</artifactId>
					<version>${maven-resources-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-site-plugin</artifactId>
					<version>${maven-site-plugin.version}</version>
				</plugin>

				<plugin>
					<artifactId>maven-source-plugin</artifactId>
					<version>${maven-source-plugin.version}</version>
					<!-- Build source artifact in addition to main artifact. -->
					<executions>
						<execution>
							<id>attach-sources</id>
							<goals>
								<!--
								NB: We use jar rather than jar-no-fork to avoid a bug where
								the -sources JAR gets generated and deployed twice. See:
								https://issues.apache.org/jira/browse/MNG-5939
								-->
								<goal>jar</goal>
							</goals>
						</execution>
					</executions>
				</plugin>

				<plugin>
					<artifactId>maven-surefire-plugin</artifactId>
					<version>${maven-surefire-plugin.version}</version>
					<!--
					Make sure that:
					A) unit tests run with sufficient RAM allocated;
					B) unit tests do not pop a Java dock icon on OS X;
					C) additional args can be given via argLine property;

					Sometimes, one needs to pass JVM options to the JVM
					running the unit tests, such as -verbose:class or
					-Djava.awt.headless=true.

					Unfortunately, maven-surefire does not expose a
					command-line interface to do so, therefore let's
					simulate it by re-using the property 'argLine' to
					specify those options.
					-->
					<configuration>
						<argLine>-Xms512m -Xmx512m -Dapple.awt.UIElement="true" ${argLine} ${argLineDebug}</argLine>
					</configuration>
				</plugin>

				<!--
				Build Helper Maven plugin -
				http://www.mojohaus.org/build-helper-maven-plugin/
				-->
				<plugin>
					<groupId>org.codehaus.mojo</groupId>
					<artifactId>build-helper-maven-plugin</artifactId>
					<version>${build-helper-maven-plugin.version}</version>
					<executions>
						<!--
						Create a version string which conforms to Java packaging requirements.
						https://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html#wp89936

						In particular, the standard Java packaging tool will fail unless the
						version string conforms to Java packaging rules. Further reading:
						https://docs.oracle.com/javase/8/docs/technotes/guides/deploy/packaging.html#
						-->
						<execution>
							<id>sanitize-version</id>
							<goals>
								<goal>regex-property</goal>
							</goals>
							<configuration>
								<name>sanitizedVersion</name>
								<value>${project.version}</value>
								<regex>^([0-9]+)\.([0-9]+)\.([0-9]+).*$</regex>
								<replacement>$1.$2.$3</replacement>
								<failIfNoMatch>false</failIfNoMatch>
							</configuration>
						</execution>
					</executions>
				</plugin>

				<!--
				Build Number Maven plugin -
				http://www.mojohaus.org/buildnumber-maven-plugin/
				This plugin embeds a build number in the JAR manifest.
				-->
				<plugin>
					<groupId>org.codehaus.mojo</groupId>
					<artifactId>buildnumber-maven-plugin</artifactId>
					<version>${buildnumber-maven-plugin.version}</version>
					<!-- Record SCM revision in manifest. -->
					<executions>
						<execution>
							<phase>validate</phase>
							<goals>
								<goal>create</goal>
							</goals>
						</execution>
					</executions>
					<configuration>
						<getRevisionOnlyOnce>true</getRevisionOnlyOnce>
						<revisionOnScmFailure>UNKNOWN</revisionOnScmFailure>
					</configuration>
				</plugin>

				<!-- Exec Maven plugin -
				http://www.mojohaus.org/exec-maven-plugin/
				This plugin launches a Java class using Maven. -->
				<plugin>
					<groupId>org.codehaus.mojo</groupId>
					<artifactId>exec-maven-plugin</artifactId>
					<version>${exec-maven-plugin.version}</version>
				</plugin>

				<!--
				License Maven plugin -
				http://www.mojohaus.org/license-maven-plugin/
				This plugin manages project licenses and source file headers.
				-->
				<plugin>
					<groupId>org.codehaus.mojo</groupId>
					<artifactId>license-maven-plugin</artifactId>
					<version>${license-maven-plugin.version}</version>
					<configuration>
						<addJavaLicenseAfterPackage>false</addJavaLicenseAfterPackage>
						<canUpdateDescription>true</canUpdateDescription>
						<canUpdateCopyright>true</canUpdateCopyright>
						<extraExtensions>
							<bsh>java</bsh>
							<config>properties</config>
							<ijm>java</ijm>
						</extraExtensions>
					</configuration>
				</plugin>

				<!--
				Versions Maven plugin -
				http://www.mojohaus.org/versions-maven-plugin/
				Check for new plugin versions using
				"mvn versions:display-plugin-updates"
				-->
				<plugin>
					<groupId>org.codehaus.mojo</groupId>
					<artifactId>versions-maven-plugin</artifactId>
					<version>${versions-maven-plugin.version}</version>
				</plugin>

				<!--
				Maven Graph Plugin -
				http://mvnplugins.fusesource.org/maven/1.10/maven-graph-plugin/
				Generate a dependency graph using "mvn graph:reactor"
				-->
				<plugin>
					<groupId>org.fusesource.mvnplugins</groupId>
					<artifactId>maven-graph-plugin</artifactId>
					<version>${maven-graph-plugin.version}</version>
					<configuration>
						<hideScopes>provided,runtime,system,test</hideScopes>
						<hideTransitive>true</hideTransitive>
						<label>Dependency Graph for ${project.name}</label>
						<target>${project.build.directory}/dependency-graph.dot</target>
					</configuration>
				</plugin>

				<!--
				JavaFX Maven plugin -
				https://github.com/javafx-maven-plugin/javafx-maven-plugin
				Generate platform-specific application bundles using "mvn jfx:native"
				-->
				<plugin>
					<groupId>com.zenjava</groupId>
					<artifactId>javafx-maven-plugin</artifactId>
					<version>${javafx-maven-plugin.version}</version>
					<configuration>
						<appName>${project.name}</appName>
						<identifier>${project.name}</identifier>
						<jfxMainAppJarName>${project.name}.jar</jfxMainAppJarName>
						<mainClass>${main-class}</mainClass>
						<nativeReleaseVersion>${sanitizedVersion}</nativeReleaseVersion>
						<verbose>true</verbose>
					</configuration>
				</plugin>

				<!-- NAR Maven plugin - https://github.com/maven-nar/nar-maven-plugin -->
				<plugin>
					<groupId>com.github.maven-nar</groupId>
					<artifactId>nar-maven-plugin</artifactId>
					<version>${nar-maven-plugin.version}</version>
				</plugin>

				<!-- SciJava Maven plugin - https://github.com/scijava/scijava-maven-plugin -->
				<plugin>
					<groupId>org.scijava</groupId>
					<artifactId>scijava-maven-plugin</artifactId>
					<version>${scijava-maven-plugin.version}</version>
					<executions>
						<execution>
							<id>set-rootdir</id>
							<phase>validate</phase>
							<goals>
								<goal>set-rootdir</goal>
							</goals>
						</execution>
					</executions>
				</plugin>
			</plugins>
		</pluginManagement>
		<plugins>
			<!-- Check desired rules during maven lifecycle. -->
			<plugin>
				<artifactId>maven-enforcer-plugin</artifactId>
				<executions>
					<execution>
						<id>enforce-rules</id>
						<goals>
							<goal>enforce</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<rules>
						<!--
						Standard Rules
						http://maven.apache.org/enforcer/enforcer-rules/
						-->
						<requireMavenVersion>
							<version>${scijava.mvn.version}</version>
						</requireMavenVersion>
						<requirePluginVersions>
							<message>Plugins need to be versioned!</message>
						</requirePluginVersions>
						<requireJavaVersion>
							<version>${scijava.jvm.build.version}</version>
						</requireJavaVersion>

						<!--
						Extra Enforcer Rules
						org.codehaus.mojo:extra-enforcer-rules
						http://www.mojohaus.org/extra-enforcer-rules/
						-->

						<!--
						Ensure no two dependencies ship the same class.
						Otherwise, much havoc may be wreaked at runtime.
						-->
						<banDuplicateClasses>
							<message>No Duplicate Classes Allowed!
- For duplicate transitive dependencies, add dependency exclusions.
- For duplications between direct dependencies, resolve or add
  ignored classes to this rule's configuration.</message>
							<findAllDuplicates>true</findAllDuplicates>
							<ignoreClasses>${allowedDuplicateClasses}</ignoreClasses>
						</banDuplicateClasses>

						<!--
						Require developers and contributors to use SciJava team roles.
						See: http://imagej.net/Team
						-->
						<requireDeveloperRoles>
							<validRoles>${scijava.team.roles}</validRoles>
						</requireDeveloperRoles>
						<requireContributorRoles>
							<validRoles>${scijava.team.roles}</validRoles>
						</requireContributorRoles>

						<!--
						Fail if a dependency requires a too-new version of Java.
						-->
						<enforceBytecodeVersion>
							<maxJdkVersion>${scijava.jvm.version}</maxJdkVersion>
							<excludes>
								<exclude>com.headius:invokebinder</exclude>
								<exclude>com.sun:tools</exclude>
							</excludes>
							<ignoreClasses>
								<ignoreClass>module-info</ignoreClass>
							</ignoreClasses>
							<ignoredScopes>
								<ignoredScope>test</ignoredScope>
							</ignoredScopes>
						</enforceBytecodeVersion>

						<!--
						Do not allow circular dependencies.
						Mostly impossible anyway, but... just in case.
						-->
						<banCircularDependencies />

						<!--
						SciJava Maven Plugin
						org.scijava:scijava-maven-plugin
						https://github.com/scijava/scijava-maven-plugin
						-->

						<!-- Require inheriting POMs to populate key elements. -->
						<requireElements implementation="org.scijava.maven.plugin.enforcer.RequireElements">
							<elements>
								<element>name</element>
								<element>description</element>
								<element>url</element>
								<element>inceptionYear</element>
								<element>organization</element>
								<element>licenses</element>
								<element>developers</element>
								<element>contributors</element>
								<element>mailingLists</element>
								<element>scm</element>
								<element>issueManagement</element>
								<element>ciManagement</element>
								<element>properties//license.licenseName</element>
								<element>properties//license.copyrightOwners</element>
							</elements>
						</requireElements>

						<!--
						Require builds to be reproducible.
						This means no snapshot dependencies!
						-->
						<requireReproducibleBuilds implementation="org.scijava.maven.plugin.enforcer.RequireReproducibleBuilds">
							<groupIds>${scijava.groupIds}</groupIds>
						</requireReproducibleBuilds>
					</rules>
				</configuration>
			</plugin>

			<plugin>
				<artifactId>maven-failsafe-plugin</artifactId>
			</plugin>

			<!-- Create -sources.jar when building. -->
			<plugin>
				<artifactId>maven-source-plugin</artifactId>
			</plugin>

			<plugin>
				<artifactId>maven-surefire-plugin</artifactId>
			</plugin>

			<!-- Generate a package-friendly version property. -->
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>build-helper-maven-plugin</artifactId>
			</plugin>

			<!-- Add Implementation-Build entry to JAR manifest. -->
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>buildnumber-maven-plugin</artifactId>
			</plugin>

			<!-- Enable 'graph:' goals. -->
			<plugin>
				<groupId>org.fusesource.mvnplugins</groupId>
				<artifactId>maven-graph-plugin</artifactId>
			</plugin>

			<!--
			Enable copying the artifacts and dependencies by setting
			the 'imagej.app.directory' property to a valid directory.
			-->
			<plugin>
				<groupId>net.imagej</groupId>
				<artifactId>imagej-maven-plugin</artifactId>
				<version>${imagej-maven-plugin.version}</version>
				<configuration>
					<deleteOtherVersions>true</deleteOtherVersions>
				</configuration>
				<executions>
					<execution>
						<id>copy-jars</id>
						<phase>install</phase>
						<goals>
							<goal>copy-jars</goal>
						</goals>
					</execution>
				</executions>
			</plugin>

			<!-- Enable 'jfx:' goals. -->
			<plugin>
				<groupId>com.zenjava</groupId>
				<artifactId>javafx-maven-plugin</artifactId>
			</plugin>

			<!-- Enable 'nar:' goals. -->
			<plugin>
				<groupId>com.github.maven-nar</groupId>
				<artifactId>nar-maven-plugin</artifactId>
			</plugin>

			<!-- Enable 'scijava:' goals. -->
			<plugin>
				<groupId>org.scijava</groupId>
				<artifactId>scijava-maven-plugin</artifactId>
			</plugin>
		</plugins>
		<!--
		We use wagon-webdav-jackrabbit 1.0 for deploys, since it is
		compatible with both Maven 2.2.x and Maven 3.x cross-platform.
		-->
		<extensions>
			<extension>
				<groupId>org.apache.maven.wagon</groupId>
				<artifactId>wagon-webdav-jackrabbit</artifactId>
				<version>${wagon-webdav-jackrabbit.version}</version>
			</extension>
		</extensions>
	</build>

	<reporting>
		<plugins>
			<!-- Generate javadocs as part of site generation. -->
			<plugin>
				<artifactId>maven-javadoc-plugin</artifactId>
				<!--
				NB: The following version declaration and configuration block are fully
				replicated from the pluginManagement section. This is necessary because
				many versions of maven-site-plugin (including 3.3) do not respect the
				pluginManagement values.
				See: https://issues.apache.org/jira/browse/MSITE-443
				While the maven-site-plugin documentation states that it "search[es]
				the same groupId/artifactId in the build.pluginManagement.plugins
				section", this claim unfortunately does not seem to reflect reality.
				-->
				<version>${maven-javadoc-plugin.version}</version>
				<configuration>
					<maxmemory>1024m</maxmemory>
					<!--
					Workaround for javadoc bug when classes in the default
					package access classes from non-default packages.
					See: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5101868
					-->
					<use>false</use>
					<links>
						<!-- Core Java. -->
						<link>http://javadoc.scijava.org/Java/</link>
						<!-- SciJava and related projects and forks. -->
						<link>http://javadoc.scijava.org/SciJava/</link>
						<link>http://javadoc.scijava.org/Alida/</link>
						<link>http://javadoc.scijava.org/Bio-Formats/</link>
						<link>http://javadoc.scijava.org/Fiji/</link>
						<link>http://javadoc.scijava.org/Icy/</link>
						<link>http://javadoc.scijava.org/ImageJ/</link>
						<link>http://javadoc.scijava.org/ImageJ1/</link>
						<link>http://javadoc.scijava.org/ImgLib2/</link>
						<link>http://javadoc.scijava.org/Java3D/</link>
						<link>http://javadoc.scijava.org/KNIME/</link>
						<link>http://javadoc.scijava.org/LOCI/</link>
						<link>http://javadoc.scijava.org/MiToBo/</link>
						<link>http://javadoc.scijava.org/Micro-Manager-Core/</link>
						<link>http://javadoc.scijava.org/Micro-Manager-Studio/</link>
						<link>http://javadoc.scijava.org/MorphoLibJ/</link>
						<link>http://javadoc.scijava.org/OMERO/</link>
						<link>http://javadoc.scijava.org/SCIFIO/</link>
						<link>http://javadoc.scijava.org/SLIM-Curve/</link>
						<!-- Third party projects. -->
						<link>http://javadoc.scijava.org/Apache-Commons-IO/</link>
						<link>http://javadoc.scijava.org/Apache-Commons-Lang/</link>
						<link>http://javadoc.scijava.org/Apache-Commons-Math/</link>
						<link>http://javadoc.scijava.org/Apache-Commons-Text/</link>
						<link>http://javadoc.scijava.org/Eclipse/</link>
						<link>http://javadoc.scijava.org/Guava/</link>
						<link>http://javadoc.scijava.org/JAMA/</link>
						<link>http://javadoc.scijava.org/JFreeChart/</link>
						<link>http://javadoc.scijava.org/JGraphT/</link>
						<link>http://javadoc.scijava.org/JHotDraw/</link>
						<link>http://javadoc.scijava.org/Javassist/</link>
						<link>http://javadoc.scijava.org/MigLayout/</link>
						<link>http://javadoc.scijava.org/NetBeans/</link>
						<link>http://javadoc.scijava.org/Pivot/</link>
						<link>http://javadoc.scijava.org/VisAD/</link>
						<link>http://javadoc.scijava.org/Weka/</link>
						<link>http://javadoc.scijava.org/ojAlgo/</link>
					</links>
				</configuration>
			</plugin>
		</plugins>
	</reporting>

	<profiles>
		<!--
		The groovy-code-generation profile provides a uniform way to generate
		sources from templates using Groovy. Apache Velocity, a powerful templating
		engine, is automatically available for use from Groovy. For an example of
		use, see the ImageJ Ops project: https://github.com/imagej/imagej-ops
		-->
		<profile>
			<id>groovy-code-generation</id>
			<activation>
				<file>
					<!-- NB: No property, because profile activation is too early. -->
					<exists>${basedir}/src/main/groovy/generate.groovy</exists>
				</file>
			</activation>
			<build>
				<plugins>
					<plugin>
						<groupId>org.codehaus.mojo</groupId>
						<artifactId>build-helper-maven-plugin</artifactId>
						<executions>
							<!-- Add generated code, including tests, to the build. -->
							<execution>
								<id>add-source</id>
								<phase>generate-sources</phase>
								<goals>
									<goal>add-source</goal>
								</goals>
								<configuration>
									<sources>
										<source>${project.build.directory}/generated-sources/from-template/</source>
									</sources>
								</configuration>
							</execution>
							<execution>
								<id>add-test-source</id>
								<phase>generate-test-sources</phase>
								<goals>
									<goal>add-test-source</goal>
								</goals>
								<configuration>
									<sources>
										<source>${project.build.directory}/generated-test-sources/from-template/</source>
									</sources>
								</configuration>
							</execution>
						</executions>
					</plugin>

						<!-- Groovy Maven plugin -
						http://www.mojohaus.org/groovy-maven-plugin/
						This plugin offers execution of Groovy scripts as part of the build.
						SciJava uses it for automatic code generation with Apache Velocity. -->
						<plugin>
							<groupId>org.codehaus.mojo</groupId>
							<artifactId>groovy-maven-plugin</artifactId>
							<version>${groovy-maven-plugin.version}</version>
							<dependencies>
								<dependency>
									<groupId>org.apache.velocity</groupId>
									<artifactId>velocity</artifactId>
									<version>${velocity.version}</version>
								</dependency>
							</dependencies>
							<executions>
								<execution>
									<id>generate-sources</id>
									<phase>generate-sources</phase>
									<goals>
										<goal>execute</goal>
									</goals>
									<configuration>
										<properties>
											<templateDirectory>${basedir}/src/main/templates</templateDirectory>
											<outputDirectory>${project.build.directory}/generated-sources/from-template</outputDirectory>
										</properties>
										<source>${basedir}/src/main/groovy/generate.groovy</source>
									</configuration>
								</execution>
								<execution>
									<id>generate-test-sources</id>
									<phase>generate-test-sources</phase>
									<goals>
										<goal>execute</goal>
									</goals>
									<configuration>
										<properties>
											<templateDirectory>${basedir}/src/test/templates</templateDirectory>
											<outputDirectory>${project.build.directory}/generated-test-sources/from-template</outputDirectory>
										</properties>
										<source>${basedir}/src/main/groovy/generate.groovy</source>
									</configuration>
								</execution>
							</executions>
						</plugin>

					</plugins>
				</build>
		</profile>

		<!--
		The jigsaw profile enables support for Java 9 modularization, while
		simultaneously allowing the component to continue targeting an earlier
		version of the JVM as the minimum.

		When a src/main/java/module-info.java is present, compilation proceeds in
		two steps: 1) all code including module-info.java is compiled with Java 9;
		and then 2) the project is recompiled sans module-info.java to target the
		desired bytecode version.

		This profile was adapted from the following article:
		https://maven.apache.org/plugins/maven-compiler-plugin/examples/module-info.html
		-->
		<profile>
			<id>jigsaw</id>
			<activation>
				<file>
					<!-- NB: No property, because profile activation is too early. -->
					<exists>${basedir}/src/main/java/module-info.java</exists>
				</file>
			</activation>
			<build>
				<plugins>
					<plugin>
						<artifactId>maven-compiler-plugin</artifactId>
						<executions>
							<execution>
								<id>default-compile</id>
								<configuration>
									<!-- NB: Compile everything with Java 9, for correctness. -->
									<release>9</release>
								</configuration>
							</execution>
							<execution>
								<id>base-compile</id>
								<goals>
									<goal>compile</goal>
								</goals>
								<!-- NB: Recompile minus module-info.java for the target VM. -->
								<configuration>
									<!--
									Workaround for a bug in maven-compiler-plugin.
									(Naively, it seems like this flag's behavior is reversed.)
									See https://issues.apache.org/jira/browse/MCOMPILER-209
									-->
									<useIncrementalCompilation>true</useIncrementalCompilation>
									<excludes>
										<exclude>module-info.java</exclude>
									</excludes>
								</configuration>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		The kotlin profile enables support for Kotlin projects, and mixed
		Kotlin-Java projects. It turns on automatically when a src/main/kotlin
		folder is present in the project.
		-->
		<profile>
			<id>kotlin</id>
			<activation>
				<file>
					<!-- NB: No property, because profile activation is too early. -->
					<exists>${basedir}/src/main/kotlin</exists>
				</file>
			</activation>
			<properties>
				<kotlin.compiler.incremental>true</kotlin.compiler.incremental>
				<kotlin.compiler.jvmTarget>${scijava.jvm.version}</kotlin.compiler.jvmTarget>
				<kotlin.version>1.2.50</kotlin.version>
				<kotlin-maven-plugin.version>${kotlin.version}</kotlin-maven-plugin.version>
				<dokka-maven-plugin.version>0.9.16</dokka-maven-plugin.version>
			</properties>
			<dependencies>
				<dependency>
					<groupId>org.jetbrains.kotlin</groupId>
					<artifactId>kotlin-stdlib-jdk8</artifactId>
					<version>${kotlin.version}</version>
				</dependency>
			</dependencies>
			<build>
				<plugins>
					<plugin>
						<groupId>org.codehaus.mojo</groupId>
						<artifactId>build-helper-maven-plugin</artifactId>
						<executions>
							<execution>
								<id>add-source</id>
								<phase>generate-sources</phase>
								<goals>
									<goal>add-source</goal>
								</goals>
								<configuration>
									<sources>
										<source>${project.basedir}/src/main/kotlin</source>
									</sources>
								</configuration>
							</execution>
							<execution>
								<id>add-test-source</id>
								<phase>generate-sources</phase>
								<goals>
									<goal>add-test-source</goal>
								</goals>
								<configuration>
									<sources>
										<source>${project.basedir}/src/test/kotlin</source>
									</sources>
								</configuration>
							</execution>
						</executions>
					</plugin>
					<plugin>
						<groupId>org.jetbrains.kotlin</groupId>
						<artifactId>kotlin-maven-plugin</artifactId>
						<version>${kotlin-maven-plugin.version}</version>
						<executions>
							<execution>
								<id>kapt</id>
								<goals>
									<goal>kapt</goal>
								</goals>
								<configuration>
									<sourceDirs>
										<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
									</sourceDirs>
								</configuration>
							</execution>
							<execution>
								<id>compile</id>
								<goals> <goal>compile</goal> </goals>
								<configuration>
									<sourceDirs>
										<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
										<sourceDir>${project.basedir}/src/main/java</sourceDir>
									</sourceDirs>
								</configuration>
							</execution>
							<execution>
								<id>test-compile</id>
								<goals> <goal>test-compile</goal> </goals>
								<configuration>
									<sourceDirs>
										<sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
										<sourceDir>${project.basedir}/src/test/java</sourceDir>
									</sourceDirs>
								</configuration>
							</execution>
						</executions>
					</plugin>
					<plugin>
						<artifactId>maven-compiler-plugin</artifactId>
						<executions>
							<!-- Replace default-compile as it is treated specially. -->
							<execution>
								<id>default-compile</id>
								<phase>none</phase>
							</execution>
							<!-- Replace default-testCompile as it is treated specially. -->
							<execution>
								<id>default-testCompile</id>
								<phase>none</phase>
							</execution>
							<execution>
								<id>java-compile</id>
								<phase>compile</phase>
								<goals>
									<goal>compile</goal>
								</goals>
							</execution>
							<execution>
								<id>java-test-compile</id>
								<phase>test-compile</phase>
								<goals>
									<goal>testCompile</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
					<plugin>
						<groupId>org.jetbrains.dokka</groupId>
						<artifactId>dokka-maven-plugin</artifactId>
						<version>${dokka-maven-plugin.version}</version>
						<executions>
							<execution>
								<phase>pre-site</phase>
								<goals>
									<goal>dokka</goal>
									<goal>javadoc</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
			<pluginRepositories>
				<!-- NB: for dokka-maven-plugin -->
				<pluginRepository>
					<id>jcenter</id>
					<name>JCenter</name>
					<url>https://jcenter.bintray.com/</url>
				</pluginRepository>
			</pluginRepositories>
		</profile>

		<!--
		The exec profile provides an easy way to execute a defined ${main-class}
		for manual testing purposes. It is declared in a profile to avoid clashing
		with other potential uses of exec-maven-plugin during the main build.
		-->
		<profile>
			<id>exec</id>
			<build>
				<plugins>
					<plugin>
						<groupId>org.codehaus.mojo</groupId>
						<artifactId>exec-maven-plugin</artifactId>
						<configuration>
							<executable>java</executable>
							<arguments>
								<argument>-classpath</argument>
								<classpath />
								<argument>${main-class}</argument>
							</arguments>
						</configuration>
						<executions>
							<execution>
								<phase>test</phase>
								<goals>
									<goal>exec</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		The dist profile augments the package phase to produce self-contained
		Java application bundles, using the standard Java packaging mechanism.
		Exactly which bundles are produced depends on the underlying platform
		configuration. But this configuration will always produce two sets of
		bundles: one with JRE included (in target/jfx/native) and
		another without a bundled JRE (in target/jfx/native-nojre).
		-->
		<profile>
			<id>dist</id>
			<build>
				<plugins>
					<plugin>
						<groupId>com.zenjava</groupId>
						<artifactId>javafx-maven-plugin</artifactId>
						<executions>
							<execution>
								<id>dist-with-jre</id>
								<phase>package</phase>
								<goals>
									<goal>native</goal>
								</goals>
							</execution>
							<execution>
								<id>dist-no-jre</id>
								<phase>package</phase>
								<goals>
									<goal>native</goal>
								</goals>
								<configuration>
									<bundleArguments>
										<runtime />
									</bundleArguments>
									<nativeOutputDir>${project.build.directory}/jfx/native-nojre</nativeOutputDir>
								</configuration>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		The jdb profile launches the defined ${main-class} in the jdb debugger.
		Launch it using: mvn -Pjdb exec:exec
		-->
		<profile>
			<id>jdb</id>
			<build>
				<plugins>
					<plugin>
						<groupId>org.codehaus.mojo</groupId>
						<artifactId>exec-maven-plugin</artifactId>
						<configuration>
							<executable>jdb</executable>
							<arguments>
								<argument>-classpath</argument>
								<classpath />
								<argument>${main-class}</argument>
							</arguments>
						</configuration>
						<executions>
							<execution>
								<goals>
									<goal>exec</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		For debugging. E.g. for Eclipse, pass -DdebugPort=8000,suspend=y
		and add a Debug Configuration for a Remote Java Application.
		-->
		<profile>
			<id>debug-port</id>
			<activation>
				<property><name>debugPort</name></property>
			</activation>
			<properties>
				<argLineDebug>-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=localhost:${debugPort}</argLineDebug>
			</properties>
		</profile>

		<!--
		Run integration tests when "-Prun-its" is passed.
		This works using the maven-invoker-plugin.
		-->
		<profile>
			<id>run-its</id>
			<build>
				<defaultGoal>integration-test</defaultGoal>
				<plugins>
					<plugin>
						<artifactId>maven-invoker-plugin</artifactId>
						<version>${maven-invoker-plugin.version}</version>
						<configuration>
							<debug>${invoker.debug}</debug>
							<showErrors>true</showErrors>
							<streamLogs>true</streamLogs>
							<projectsDirectory>src/it</projectsDirectory>
							<cloneProjectsTo>${project.build.directory}/it</cloneProjectsTo>
							<pomIncludes>
								<pomInclude>*/pom.xml</pomInclude>
							</pomIncludes>
							<settingsFile>src/it/settings.xml</settingsFile>
							<localRepositoryPath>${project.build.directory}/local-repo</localRepositoryPath>
							<preBuildHookScript>setup.bsh</preBuildHookScript>
							<postBuildHookScript>verify.bsh</postBuildHookScript>
						</configuration>
						<executions>
							<execution>
								<id>integration-test</id>
								<goals>
									<goal>install</goal>
									<goal>run</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!-- This profile enables deployment to the ImageJ Maven repository. -->
		<profile>
			<id>deploy-to-imagej</id>
			<build>
				<plugins>
					<plugin>
						<artifactId>maven-javadoc-plugin</artifactId>
						<configuration>
							<skip>${javadoc.skip}</skip>
						</configuration>
						<executions>
							<execution>
								<id>attach-javadocs</id>
								<goals>
									<goal>jar</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>

			<distributionManagement>
				<repository>
					<id>imagej.releases</id>
					<name>ImageJ Releases Repository</name>
					<url>dav:http://maven.imagej.net/content/repositories/releases</url>
				</repository>
				<snapshotRepository>
					<id>imagej.snapshots</id>
					<name>ImageJ Snapshots Repository</name>
					<url>dav:http://maven.imagej.net/content/repositories/snapshots</url>
				</snapshotRepository>
			</distributionManagement>
		</profile>

		<!-- This profile enables releasing to the OSS Sonatype repository. -->
		<profile>
			<id>sonatype-oss-release</id>
			<build>
				<plugins>
					<plugin>
						<groupId>org.sonatype.plugins</groupId>
						<artifactId>nexus-staging-maven-plugin</artifactId>
						<version>${nexus-staging-maven-plugin.version}</version>
						<extensions>true</extensions>
						<configuration>
							<serverId>sonatype-nexus-releases</serverId>
							<nexusUrl>https://oss.sonatype.org/</nexusUrl>
							<autoReleaseAfterClose>true</autoReleaseAfterClose>
							<stagingProgressTimeoutMinutes>15</stagingProgressTimeoutMinutes>
							<stagingProgressPauseDurationSeconds>12</stagingProgressPauseDurationSeconds>
							<!--
							By having no explicit stagingProfileId, we use
							Staging V2 in "auto" mode, profile will be
							matched server side
							-->
						</configuration>
					</plugin>
					<plugin>
						<artifactId>maven-deploy-plugin</artifactId>
						<inherited>true</inherited>
						<configuration>
							<skip>true</skip>
						</configuration>
					</plugin>
					<plugin>
						<artifactId>maven-gpg-plugin</artifactId>
					</plugin>
					<plugin>
						<artifactId>maven-javadoc-plugin</artifactId>
						<executions>
							<execution>
								<id>attach-javadocs</id>
								<goals>
									<goal>jar</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>

			<repositories>
				<repository>
					<id>sonatype-nexus-snapshots</id>
					<name>Sonatype Nexus Snapshots</name>
					<url>https://oss.sonatype.org/content/repositories/snapshots</url>
					<releases>
						<enabled>false</enabled>
					</releases>
					<snapshots>
						<enabled>true</enabled>
					</snapshots>
				</repository>
				<repository>
					<id>sonatype-nexus-releases</id>
					<name>Sonatype Nexus Releases</name>
					<url>https://oss.sonatype.org/content/repositories/releases</url>
					<releases>
						<enabled>true</enabled>
					</releases>
					<snapshots>
						<enabled>false</enabled>
					</snapshots>
				</repository>
			</repositories>

			<distributionManagement>
				<snapshotRepository>
					<id>sonatype-nexus-snapshots</id>
					<name>Sonatype Nexus Snapshots</name>
					<url>https://oss.sonatype.org/content/repositories/snapshots/</url>
				</snapshotRepository>
				<repository>
					<id>sonatype-nexus-staging</id>
					<name>Nexus Release Repository</name>
					<url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
				</repository>
			</distributionManagement>
		</profile>

		<!--
		This profile lets Eclipse parse SciJava annotations of imported projects,
		and maps Maven plugin goals to Eclipse executions.
		-->
		<profile>
			<id>only-eclipse</id>
			<activation>
				<property>
					<name>m2e.version</name>
				</property>
			</activation>
			<build>
				<pluginManagement>
					<plugins>
						<!--
						Configure the Eclipse m2e plugin to support needed plugins.
						-->
						<plugin>
							<groupId>org.eclipse.m2e</groupId>
							<artifactId>lifecycle-mapping</artifactId>
							<!--
							NB: Eclipse cannot handle an overridden version property here!
							The version needs to stay hardcoded at 1.0.0.
							-->
							<version>1.0.0</version>
							<configuration>
								<lifecycleMappingMetadata>
									<pluginExecutions>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.apache.maven.plugins</groupId>
												<artifactId>maven-enforcer-plugin</artifactId>
												<versionRange>${maven-enforcer-plugin.version}</versionRange>
												<goals>
													<goal>enforce</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnConfiguration>true</runOnConfiguration>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.apache.maven.plugins</groupId>
												<artifactId>maven-jar-plugin</artifactId>
												<versionRange>${maven-jar-plugin.version}</versionRange>
												<goals>
													<goal>jar</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnIncremental>true</runOnIncremental>
													<runOnConfiguration>true</runOnConfiguration>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.codehaus.mojo</groupId>
												<artifactId>build-helper-maven-plugin</artifactId>
												<versionRange>${build-helper-maven-plugin.version}</versionRange>
												<goals>
													<goal>regex-property</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnIncremental>true</runOnIncremental>
													<runOnConfiguration>true</runOnConfiguration>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.codehaus.mojo</groupId>
												<artifactId>build-helper-maven-plugin</artifactId>
												<versionRange>${build-helper-maven-plugin.version}</versionRange>
												<goals>
													<goal>add-source</goal>
													<goal>add-test-source</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnIncremental>false</runOnIncremental>
													<runOnConfiguration>true</runOnConfiguration>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.codehaus.mojo</groupId>
												<artifactId>buildnumber-maven-plugin</artifactId>
												<versionRange>${buildnumber-maven-plugin.version}</versionRange>
												<goals>
													<goal>create</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnIncremental>true</runOnIncremental>
													<runOnConfiguration>true</runOnConfiguration>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.codehaus.mojo</groupId>
												<artifactId>exec-maven-plugin</artifactId>
												<versionRange>${exec-maven-plugin.version}</versionRange>
												<goals>
													<goal>java</goal>
													<goal>exec</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<ignore />
											</action>
										</pluginExecution>
										<!--
										NB: Make Eclipse generate code in a full build; see:
										http://wiki.eclipse.org/M2E_plugin_execution_not_covered
										-->
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.codehaus.mojo</groupId>
												<artifactId>groovy-maven-plugin</artifactId>
												<versionRange>${groovy-maven-plugin.version}</versionRange>
												<goals>
													<goal>execute</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnConfiguration>true</runOnConfiguration>
													<runOnIncremental>false</runOnIncremental>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>com.googlecode.maven-download-plugin</groupId>
												<artifactId>download-maven-plugin</artifactId>
												<versionRange>${download-maven-plugin.version}</versionRange>
												<goals>
													<goal>wget</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<execute>
													<runOnConfiguration>true</runOnConfiguration>
												</execute>
											</action>
										</pluginExecution>
										<pluginExecution>
											<pluginExecutionFilter>
												<groupId>org.jetbrains.kotlin</groupId>
												<artifactId>kotlin-maven-plugin</artifactId>
												<versionRange>${kotlin-maven-plugin.version}</versionRange>
												<goals>
													<goal>kapt</goal>
												</goals>
											</pluginExecutionFilter>
											<action>
												<ignore />
											</action>
										</pluginExecution>
									</pluginExecutions>
								</lifecycleMappingMetadata>
							</configuration>
						</plugin>
					</plugins>
				</pluginManagement>
				<plugins>
					<!--
					HACK - Tell Eclipse to use the TEST source and target JVM version.
					This is necessary because the JVM version used for tests may be newer
					than that used for the main artifact. Maven is OK with this, but
					Eclipse wants only a single JVM version for both main and tests.
					See: https://gist.github.com/aslakknutsen/9648594#gistcomment-1588906
					-->
					<plugin>
						<artifactId>maven-compiler-plugin</artifactId>
						<configuration>
							<source>${scijava.jvm.test.version}</source>
							<target>${scijava.jvm.test.version}</target>
						</configuration>
					</plugin>
					<plugin>
						<groupId>org.scijava</groupId>
						<artifactId>scijava-maven-plugin</artifactId>
						<executions>
							<execution>
								<goals>
									<goal>eclipse-helper</goal>
								</goals>
								<phase>process-classes</phase>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		This profile signs artifacts using GPG.
		-->
		<profile>
			<id>sign</id>
			<build>
				<plugins>
					<plugin>
						<artifactId>maven-gpg-plugin</artifactId>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		This profile aggregates javadocs for the project
		and its direct dependencies.
		-->
		<profile>
			<id>build-javadoc</id>
			<build>
				<plugins>
					<plugin>
						<artifactId>maven-javadoc-plugin</artifactId>
						<executions>
							<execution>
								<id>attach-javadocs</id>
								<goals>
									<goal>jar</goal>
								</goals>
							</execution>
						</executions>
						<configuration>
							<!-- Include direct dependencies -->
							<includeDependencySources>true</includeDependencySources>

							<!-- Remove the "${project.version} API" from the default title -->
							<doctitle>${project.name}</doctitle>
						</configuration>
					</plugin>
				</plugins>
			</build>
		</profile>

		<!--
		The Findbugs profile executes a static code analysis for any bugs,
		using Findbugs analysis tool. It produces a findbugs.xml report in target
		folder. It may catch some undangerous bugs, so it is better to set the
		failOnError variable to false.
		-->

		<profile>
			<id>findbugs</id>
			<activation>
				<activeByDefault>false</activeByDefault>
			</activation>
			<properties>
				<findbugs.maven.version>3.0.5</findbugs.maven.version>
				<findbugs.failOnError>false</findbugs.failOnError>
			</properties>
			<build>
				<pluginManagement>
					<plugins>
						<plugin>
							<groupId>org.codehaus.mojo</groupId>
							<artifactId>findbugs-maven-plugin</artifactId>
							<version>${findbugs.maven.version}</version>
							<executions>
								<execution>
									<id>findbugs</id>
									<phase>verify</phase>
									<configuration>
										<failOnError>${findbugs.failOnError}</failOnError>
										<effort>Max</effort>
										<threshold>Default</threshold>
										<xmlOutput>true</xmlOutput>
									</configuration>
									<goals>
										<goal>check</goal>
									</goals>
								</execution>
							</executions>
						</plugin>
					</plugins>
				</pluginManagement>
				<plugins>
					<plugin>
						<groupId>org.codehaus.mojo</groupId>
						<artifactId>findbugs-maven-plugin</artifactId>
						<version>${findbugs.maven.version}</version>
						<executions>
							<execution>
								<id>findbugs</id>
								<phase>test</phase>
								<configuration>
								</configuration>
								<goals>
									<goal>findbugs</goal>
								</goals>
							</execution>
						</executions>
					</plugin>
				</plugins>
			</build>
		</profile>

	</profiles>
</project>