add version comparator

Author: uschindler

src/main/java/de/thetaphi/forbiddenapis/Constants.java

@@ -27,6 +27,7 @@ public interface Constants {
   final String BS_JDK_NONPORTABLE = "jdk-non-portable";
 
   final Pattern JDK_SIG_PATTERN = Pattern.compile("(jdk\\-.*?\\-)(\\d+)(\\.\\d+)?(\\.\\d+)*");
+  final Pattern ENDS_WITH_VERSION_PATTERN = Pattern.compile("(.*?)\\-(\\d+(\\.\\d+)*)");
 
   final String DEPRECATED_WARN_FAIL_ON_UNRESOLVABLE_SIGNATURES =
       "The setting 'failOnUnresolvableSignatures' was deprecated and will be removed in next version. Use 'ignoreSignaturesOfMissingClasses' instead.";

src/main/java/de/thetaphi/forbiddenapis/Signatures.java

@@ -64,7 +64,7 @@ public final class Signatures implements Constants {
   static {
     try (final InputStream in = Checker.class.getResourceAsStream("signatures/list");
         final BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
-      final SortedSet<String> names = new TreeSet<String>();
+      final SortedSet<String> names = new TreeSet<String>(VersionCompare.BUNDLED_SIGNATURES_COMPARATOR);
       String name;
       while ((name = reader.readLine()) != null) {
         names.add(name);
@@ -302,7 +302,7 @@ private void addBundledSignatures(String name, String jdkTargetVersion, boolean
     if (readExternal) {
       name = fixTargetVersion(name);
       // automatically expand the compiler version in here (for jdk-* signatures without version):
-      if (!BUNDLED_SIGNATURES_NAMES.contains(name) && jdkTargetVersion != null && name.startsWith("jdk-") && !name.matches(".*?\\-\\d+(\\.\\d+)*")) {
+      if (!BUNDLED_SIGNATURES_NAMES.contains(name) && jdkTargetVersion != null && name.startsWith("jdk-") && !ENDS_WITH_VERSION_PATTERN.matcher(name).matches()) {
         name = name + "-" + jdkTargetVersion;
         name = fixTargetVersion(name);
       }

src/main/java/de/thetaphi/forbiddenapis/VersionCompare.java

@@ -0,0 +1,70 @@
+/*
+ * (C) Copyright Uwe Schindler (Generics Policeman) and others.
+ *
+ * Licensed 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.
+ */
+
+package de.thetaphi.forbiddenapis;
+
+import java.util.Comparator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** Some static utilities for analyzing with ASM, also constants. */
+final class VersionCompare {
+  
+  private static final Pattern DOT_SPLITTER_PATTERN = Pattern.compile("\\.");
+
+  private VersionCompare() {}
+  
+  public static int compareVersions(String version1, String version2) {
+    final String[] version1Splits = DOT_SPLITTER_PATTERN.split(version1),
+        version2Splits = DOT_SPLITTER_PATTERN.split(version2);
+    final int maxLengthOfVersionSplits = Math.max(version1Splits.length, version2Splits.length);
+    
+    for (int i = 0; i < maxLengthOfVersionSplits; i++) {
+      final int v1 = i < version1Splits.length ? Integer.parseInt(version1Splits[i]) : 0;
+      final int v2 = i < version2Splits.length ? Integer.parseInt(version2Splits[i]) : 0;
+      final int compare = Integer.compare(v1, v2);
+      if (compare != 0) {
+        return compare;
+      }
+    }
+    return 0;
+  }
+  
+  public static Comparator<String> VERSION_COMPARATOR = new Comparator<String>() {
+    @Override
+    public int compare(String version1, String version2) {
+      return compareVersions(version1, version2);
+    }
+  };
+
+  public static Comparator<String> BUNDLED_SIGNATURES_COMPARATOR = new Comparator<String>() {
+    @Override
+    public int compare(String bs1, String bs2) {
+      final Matcher m1 = Constants.ENDS_WITH_VERSION_PATTERN.matcher(bs1),
+          m2 = Constants.ENDS_WITH_VERSION_PATTERN.matcher(bs2);
+      if (m1.matches() && m2.matches()) {
+        final int prefixCmp = m1.group(1).compareTo(m2.group(1));
+        if (prefixCmp != 0) {
+          return prefixCmp;
+        }
+        return compareVersions(m1.group(2), m2.group(2));
+      } else {
+        return bs1.compareTo(bs2);
+      }
+    }
+  };
+
+}