Enumerate native classifiers more exhaustively

Now we generate all combinations of OS family + architectures matching
all observed naming conventions. It's still a hack, but these suffixes
are highly unlikely to be part of any version number.

And we use these generated platform strings in two places: the version
pattern regex, and the default list of subdirectory classifiers.

Author: ctrueden

src/main/java/org/scijava/maven/plugin/install/AbstractInstallMojo.java

@@ -35,6 +35,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -50,7 +51,6 @@
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecution;
 import org.apache.maven.plugin.MojoExecutionException;
-import org.apache.maven.plugin.logging.Log;
 import org.apache.maven.plugins.annotations.Parameter;
 import org.apache.maven.project.MavenProject;
 import org.codehaus.plexus.interpolation.EnvarBasedValueSource;
@@ -228,7 +228,7 @@ else if (isBioFormatsArtifact(artifact)) {
 						break;
 					case older:
 						final String toInstall = artifact.getVersion();
-						final Matcher matcher = versionPattern.matcher(otherName.toString());
+						final Matcher matcher = VERSION_PATTERN.matcher(otherName.toString());
 						if (!matcher.matches()) break;
 						final String group = matcher.group(VERSION_INDEX);
 						if (group == null) {
@@ -319,9 +319,30 @@ private String subdirectory(final Artifact artifact) {
 		return null;
 	}
 
-	private final static Pattern versionPattern = Pattern.compile("(.+?)"
-		+ "(-\\d+(\\.\\d+|\\d{7})+[a-z]?\\d?(-[A-Za-z0-9.]+?|\\.GA)*?)?"
-		+ "((-(swing|swt|sources|javadoc|native|linux-x86|linux-x86_64|linux-armhf|linux-ppc64le|macosx-x86_64|windows-x86|windows-x86_64|android-x86|android-x86_64|android-arm|android-arm64|ios-x86_64|ios-arm64|natives-windows|natives-macos|natives-linux))?(\\.jar(-[a-z]*)?))");
+	private final static Pattern VERSION_PATTERN = Pattern.compile(versionPattern());
+
+	private static String versionPattern() {
+		final String[] other = {
+			"javadoc", "native", "sources", "swing", "swt"
+		};
+		final List<String> classifiers = new ArrayList<>();
+		for (final String family : KnownPlatforms.FAMILIES) {
+			classifiers.add(family);
+			classifiers.add("native-" + family);
+			classifiers.add("natives-" + family);
+			for (final String arch : KnownPlatforms.ARCHES) {
+				final String slug = family + "-" + arch;
+				classifiers.add(slug);
+				classifiers.add("native-" + slug);
+				classifiers.add("natives-" + slug);
+			}
+		}
+		classifiers.addAll(Arrays.asList(other));
+		return "(.+?)"
+			+ "(-\\d+(\\.\\d+|\\d{7})+[a-z]?\\d?(-[A-Za-z0-9.]+?|\\.GA)*?)?"
+			+ "((-(" + String.join("|", classifiers) + "))?(\\.jar(-[a-z]*)?))";
+	}
+
 	private final static int PREFIX_INDEX = 1;
 	private final static int VERSION_INDEX = 2;
 	private final static int SUFFIX_INDEX = 5;
@@ -350,7 +371,7 @@ private static String majorVersion( String v )
 	 * @return A collection of {@link Path}s to files of the same base name.
 	 */
 	private Collection<Path> getEncroachingVersions(final Path directory, final Path file) {
-		final Matcher matcher = versionPattern.matcher(file.getFileName().toString());
+		final Matcher matcher = VERSION_PATTERN.matcher(file.getFileName().toString());
 		if (!matcher.matches()) return null;
 
 		final String prefix = matcher.group(PREFIX_INDEX);
@@ -361,7 +382,7 @@ private Collection<Path> getEncroachingVersions(final Path directory, final Path
 			result = Files.walk(directory)
 			.filter(path -> path.getFileName().toString().startsWith(prefix))
 			.filter(path -> {
-				final Matcher matcherIterator = versionPattern.matcher(path.getFileName().toString());
+				final Matcher matcherIterator = VERSION_PATTERN.matcher(path.getFileName().toString());
 				return matcherIterator.matches() &&
 					prefix.equals(matcherIterator.group(PREFIX_INDEX)) &&
 					suffix.equals(matcherIterator.group(SUFFIX_INDEX));

src/main/java/org/scijava/maven/plugin/install/KnownPlatforms.java

@@ -0,0 +1,91 @@
+/*
+ * #%L
+ * A plugin for managing SciJava-based projects.
+ * %%
+ * Copyright (C) 2014 - 2020 SciJava developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.maven.plugin.install;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Data structure enumerating known platform strings.
+ * 
+ * @author Curtis Rueden
+ */
+public final class KnownPlatforms {
+
+	public static final List<String> FAMILIES = Arrays.asList(
+		"android",
+		"ios",
+		"linux",
+		"macos",
+		"macosx",
+		"osx",
+		"windows"
+	);
+
+	public static final List<String> ARCHES = Arrays.asList(
+		"aarch64",
+		"all",
+		"amd64",
+		"arm",
+		"arm64",
+		"armhf",
+		"i586",
+		"ppc64le",
+		"universal",
+		"x86",
+		"x86_64"
+	);
+
+	public static String shortName(final String family, final String arch) {
+		if (isMacOS(family)) return "macosx";
+		if (isWindows(family) && isArch32(arch)) return "win32";
+		if (isWindows(family) && isArch64(arch)) return "win64";
+		if (isLinux(family) && isArch32(arch)) return "linux32";
+		if (isLinux(family) && isArch64(arch)) return "linux64";
+		return null;
+	}
+
+	private static boolean isWindows(final String family) {
+		return "windows".equals(family);
+	}
+	private static boolean isLinux(final String family) {
+		return "linux".equals(family);
+	}
+	private static boolean isMacOS(final String family) {
+		final String[] macFamily = {"macos", "macosx", "osx"};
+		return Arrays.asList(macFamily).contains(family);
+	}
+	private static boolean isArch32(final String arch) {
+		return "i586".equals(arch) || "x86".equals(arch);
+	}
+	private static boolean isArch64(final String arch) {
+		return arch == null || "amd64".equals(arch) || "x86_64".equals(arch);
+	}
+}

src/main/java/org/scijava/maven/plugin/install/SubdirectoryPattern.java

@@ -29,8 +29,11 @@
 
 package org.scijava.maven.plugin.install;
 
-import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * Data structure for mapping classifiers to subdirectories.
@@ -48,87 +51,45 @@ public class SubdirectoryPattern {
 	public List<String> classifiers;
 
 	public static List<SubdirectoryPattern> defaultPatterns() {
-		return Arrays.asList(
-			pattern("jars/win64",
-				"windows",
-				"windows-amd64",
-				"windows-x86_64",
-				"native-windows",
-				"native-windows-amd64",
-				"native-windows-x86_64",
-				"natives-windows",
-				"natives-windows-amd64",
-				"natives-windows-x64_64"),
-			pattern("jars/win32",
-				"windows-x86",
-				"windows-x86_32",
-				"native-windows-x86",
-				"native-windows-x86_32",
-				"natives-windows-x86",
-				"natives-windows-x86_32"),
-			pattern("jars/macosx",
-				"macos",
-				"macos-amd64",
-				"macos-universal",
-				"macos-x86_64",
-				"macosx",
-				"macosx-amd64",
-				"macosx-universal",
-				"macosx-x86_64",
-				"osx",
-				"osx-amd64",
-				"osx-universal",
-				"osx-x86_64",
-				"native-macos",
-				"native-macos-amd64",
-				"native-macos-universal",
-				"native-macos-x86_64",
-				"native-macosx",
-				"native-macosx-amd64",
-				"native-macosx-universal",
-				"native-macosx-x86_64",
-				"native-osx",
-				"native-osx-amd64",
-				"native-osx-universal",
-				"native-osx-x86_64",
-				"natives-macos",
-				"natives-macos-amd64",
-				"natives-macos-universal",
-				"natives-macos-x86_64",
-				"natives-macosx",
-				"natives-macosx-amd64",
-				"natives-macosx-universal",
-				"natives-macosx-x86_64",
-				"natives-osx",
-				"natives-osx-amd64",
-				"natives-osx-universal",
-				"natives-osx-x86_64"),
-			pattern("jars/linux64",
-				"linux",
-				"linux-amd64",
-				"linux-x86_64",
-				"native-linux",
-				"native-linux-amd64",
-				"native-linux-x86_64",
-				"natives-linux",
-				"natives-linux-amd64",
-				"natives-linux-x64_64"),
-			pattern("jars/linux32",
-				"linux-x86",
-				"linux-x86_32",
-				"native-linux-x86",
-				"native-linux-x86_32",
-				"natives-linux-x86",
-				"natives-linux-x86_32")
-		);
+		final Map<String, List<String>> patterns = new HashMap<>();
+
+		for (final String family : KnownPlatforms.FAMILIES) {
+			for (final String arch : KnownPlatforms.ARCHES) {
+				// NB: Convert family+arch to short name --
+				// e.g. win32, win64, macosx, linux32, linux64.
+				final String shortName = KnownPlatforms.shortName(family, arch);
+				if (shortName == null) continue;
+				addClassifier(patterns, "jars/" + shortName, family + "-" + arch);
+			}
+			// NB: Convert family alone (no arch) to short name --
+			// e.g. windows -> win64, osx -> macosx, linux -> linux64.
+			final String shortName = KnownPlatforms.shortName(family, null);
+			if (shortName == null) continue;
+			addClassifier(patterns, "jars/" + shortName, family);
+		}
+
+		return patterns.entrySet().stream() //
+			.map(entry -> pattern(entry.getKey(), entry.getValue())) //
+			.collect(Collectors.toList());
+	}
+
+	private static void addClassifier(final Map<String, List<String>> patterns,
+		final String name, final String classifier)
+	{
+		final String[] prefixes = { "", "native-", "natives-" };
+		final List<String> classifiers = //
+			patterns.computeIfAbsent(name, l -> new ArrayList<>());
+		for (final String prefix : prefixes) {
+			classifiers.add(prefix + classifier);
+		}
 	}
 
 	private static SubdirectoryPattern pattern(final String name,
-		final String... classifiers)
+		final List<String> classifiers)
 	{
 		final SubdirectoryPattern pattern = new SubdirectoryPattern();
 		pattern.name = name;
-		pattern.classifiers = Arrays.asList(classifiers);
+		pattern.classifiers = classifiers;
 		return pattern;
 	}
 }