Distinguish versions vs. classifiers more robustly

This fixes the failing do-not-delete-natives test after the
earlier "Simplify encroaching version logic" commit broke it.

Finally now, the case of jinput-2.0.9.jar and
jinput-2.0.9-natives-all.jar is handled correctly: the "natives-all"
classifier is recognized properly, so they are treated as separate
artifacts, avoiding the spurious behavior:

  [INFO] Copying jinput-2.0.9.jar to Fiji.app/jars
  [INFO] Deleted overridden jinput-2.0.9.jar
  [INFO] Copying jinput-2.0.9-natives-all.jar to Fiji.app/jars

Author: ctrueden

pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.scijava</groupId>
 		<artifactId>pom-scijava</artifactId>
-		<version>26.0.0</version>
+		<version>28.0.0</version>
 		<relativePath />
 	</parent>
 

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

@@ -230,9 +230,10 @@ else if (isBioFormatsArtifact(artifact)) {
 					final String majorVersionToInstall = majorVersion(toInstall);
 					final String majorVersionOther = majorVersion(otherVersion);
 					if (!majorVersionToInstall.equals(majorVersionOther)) {
-						getLog().warn("Version " + otherVersion + " of " + artifact +
-							" is incompatible according to SemVer: " +
-							majorVersionToInstall + " != " + majorVersionOther);
+						getLog().warn("Version " + versionToString(otherVersion) + //
+							" of " + artifact + " is incompatible according to SemVer: " +
+							majorVersionToInstall + " != " + //
+							versionToString(majorVersionOther));
 					}
 					if (newerVersion) break;
 					//$FALL-THROUGH$
@@ -260,6 +261,10 @@ else if (newerVersion) {
 		}
 	}
 
+	private static String versionToString(final String v) {
+		return v == null || v.isEmpty() ? "(none)" : v;
+	}
+
 	private static boolean isBioFormatsArtifact(final Artifact artifact) {
 		final String fileName = artifact.getFile().getName();
 		return "ome".equals(artifact.getGroupId()) ||
@@ -343,19 +348,40 @@ private Map<Path, String> getEncroachingVersions(final Path directory,
 		// artifactId-version-classifier.type
 		//
 		// with '-classifier' absent for the main classifier.
-		final String classifier = artifact.getClassifier();
-		final String patternString = artifact.getArtifactId() + "-?(.*)" +
-			(classifier != null && !classifier.isEmpty() ? "-" + classifier : "") +
-			"\\." + artifact.getType();
+
+		final String artifactPattern = Pattern.quote(artifact.getArtifactId());
+
+		final String normalVersion = "[0-9].*?"; // begin with a digit (non-greedy)
+		final String jitpackVersion = "[0-9a-f]{5}[0-9a-f]*"; // git hash
+		final String versionPattern = "(-" + normalVersion + "|-" + jitpackVersion + ")?";
+
+		// For the main artifact, matching is tricky, because we don't want to
+		// delete artifacts of other classifiers. For example, for lib-1.2.3.jar,
+		// we _do_ want to delete lib-1.2.3-beta-1.jar (i.e. v1.2.3-beta-1), but
+		// _not_ lib-1.2.3-natives-macosx.jar (i.e. classifier natives-macosx).
+		// Unfortunately, we cannot easily tell these cases apart. :-(
+		// So we hardcode known classifiers into the regex as a heuristic.
+		final String rawClassifier = artifact.getClassifier();
+		final String classifier = rawClassifier == null ? "" : rawClassifier;
+		final List<String> classifiers = new ArrayList<>();
+		classifiers.add(classifier);
+		classifiers.addAll(KnownPlatforms.nativeClassifiers());
+		final String[] quotedClassifiers = classifiers.stream() //
+			.map(c -> c.isEmpty() ? "" : "-" + Pattern.quote(c)) //
+			.toArray(String[]::new);
+		final String classifierPattern = //
+			"(" + String.join("|", quotedClassifiers) + ")?";
+
+		final String typePattern = Pattern.quote("." + artifact.getType());
+
+		final String patternString = artifactPattern + //
+			versionPattern + classifierPattern + typePattern;
 		final Pattern pattern = Pattern.compile(patternString);
 
 		try {
 			Files.walk(directory, 1).forEach(path -> {
-				final Matcher m = pattern.matcher(path.getFileName().toString());
-				if (m.matches()) {
-					final String version = m.group(1);
-					result.put(path, version);
-				}
+				final String version = getEncroachingVersion(path, pattern, classifier);
+				if (version != null) result.put(path, version);
 			});
 		}
 		catch (IOException e) {
@@ -364,4 +390,23 @@ private Map<Path, String> getEncroachingVersions(final Path directory,
 
 		return result;
 	}
+
+	private static String getEncroachingVersion(final Path path,
+		final Pattern pattern, final String expectedClassifier)
+	{
+		final Matcher m = pattern.matcher(path.getFileName().toString());
+		if (!m.matches()) return null; // not a candidate for a clash
+
+		final String classifier = trimLeadingDash(m.group(2));
+		if (!expectedClassifier.equals(classifier)) return null;
+
+		final String version = trimLeadingDash(m.group(1));
+		return version;
+	}
+
+	private static String trimLeadingDash(final String s) {
+		if (s == null) return "";
+		if (s.startsWith("-")) return s.substring(1);
+		return s;
+	}
 }

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

@@ -76,6 +76,37 @@ public static String shortName(final String family, final String arch) {
 		return null;
 	}
 
+	/**
+	 * Gets a list of {@link SubdirectoryPattern}s corresponding to known native
+	 * classifiers. This list includes the following patterns:
+	 * <ul>
+	 * <li>{@code <family>-<arch>}</li>
+	 * <li>{@code native-<family>-<arch>}</li>
+	 * <li>{@code natives-<family>-<arch>}</li>
+	 * <li>{@code <family>}</li>
+	 * <li>{@code native-<family>}</li>
+	 * <li>{@code natives-<family>}</li>
+	 * </ul>
+	 * <p>
+	 * For every {@code <family>} in {@link #FAMILIES} and every {@code <arch>} in
+	 * {@link #ARCHES}.
+	 * </p>
+	 */
+	public static List<String> nativeClassifiers() {
+		final List<String> classifiers = new ArrayList<>();
+		for (final String family : FAMILIES) {
+			for (final String arch : ARCHES) {
+				classifiers.add(family + "-" + arch);
+				classifiers.add("native-" + family + "-" + arch);
+				classifiers.add("natives-" + family + "-" + arch);
+			}
+			classifiers.add(family);
+			classifiers.add("native-" + family);
+			classifiers.add("natives-" + family);
+		}
+		return classifiers;
+	}
+
 	/**
 	 * Gets a list of {@link SubdirectoryPattern}s corresponding to known native
 	 * classifiers. E.g.: