JCR-5140: Improve support for generating namespace prefixes (#255)

Author: reschke

jackrabbit-jcr-commons/src/main/java/org/apache/jackrabbit/commons/NamespaceHelper.java

@@ -16,8 +16,15 @@
  */
 package org.apache.jackrabbit.commons;
 
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.util.HashMap;
+import java.util.Locale;
 import java.util.Map;
+import java.util.UUID;
+import java.util.function.UnaryOperator;
 
 import javax.jcr.NamespaceException;
 import javax.jcr.NamespaceRegistry;
@@ -220,26 +227,31 @@ public String registerNamespace(String prefix, String uri)
             // Check if the namespace is registered
             registry.getPrefix(uri);
         } catch (NamespaceException e1) {
-             // Replace troublesome prefix hints
+             // Throw away Troublesome prefix hints
             if (prefix == null || prefix.isEmpty()
                     || prefix.toLowerCase().startsWith("xml")
                     || !XMLChar.isValidNCName(prefix)) {
-                prefix = "ns"; // ns, ns2, ns3, ns4, ...
+                prefix = null;
             }
 
-            // Loop until an unused prefix is found
-            try {
-                String base = prefix;
-                for (int i = 2; true; i++) {
-                    registry.getURI(prefix);
-                    prefix = base + i;
-                }
-            } catch (NamespaceException e2) {
-                // Exit the loop
-            } 
+            if (prefix == null) {
+                prefix = suggestPrefix(uri, pref -> {
+                    // prefix checker
+                    try {
+                        return registry.getURI(pref);
+                    } catch (RepositoryException e) {
+                        return null;
+                    }
+                });
+            }
 
             // Register the namespace
-            registry.registerNamespace(prefix, uri);
+            try {
+                registry.registerNamespace(prefix, uri);
+            } catch (NamespaceException ex) {
+                // likely prefix is already in use; retry with null prefix
+                return registerNamespace(null, uri);
+            }
         }
 
         return session.getNamespacePrefix(uri);
@@ -258,4 +270,113 @@ public void registerNamespaces(Map<String,String> namespaces) throws RepositoryE
         }
     }
 
+    // non-public supporting code
+
+    // map with 'optimal' prefix mappings; hard-wired should be ok for now
+    private static final Map<String, String> KNOWN_PREFIXES =
+            Map.of("http://creativecommons.org/ns#", "cc",
+                    "http://purl.org/dc/terms/", "dc",
+                    "http://ns.adobe.com/DICOM/", "DICOM",
+                    "http://ns.adobe.com/exif/1.0/", "exif",
+                    "http://ns.adobe.com/pdf/1.3/", "pdf",
+                    "http://ns.adobe.com/pdfx/1.3/", "pdfx",
+                    "http://ns.adobe.com/photoshop/1.0/", "photoshop",
+                    "http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf",
+                    "http://ns.adobe.com/tiff/1.0/", "tiff",
+                    "http://ns.adobe.com/xap/1.0/", "xmp");
+
+
+    // suggest an available prefix for the provided namespace, based on a random UUID
+    // (last resort)
+    private static String devisePrefixByUUID(String namespace, UnaryOperator<String> lookupNamespace) {
+        String prefix;
+
+        do {
+            prefix = "u-" + UUID.randomUUID();
+        } while (namespace.equals(lookupNamespace.apply(prefix)));
+
+        return prefix;
+    }
+
+    // compute SHA-256, null when NoSuchAlgorithmException
+    private static String getSha256(String namespace) {
+        try {
+            byte[] bytes = MessageDigest.getInstance("SHA-256").digest(namespace.getBytes(StandardCharsets.UTF_8));
+            return new BigInteger(1, bytes).toString(16);
+        } catch (NoSuchAlgorithmException e) {
+            // this really, really should not happen
+            return null;
+        }
+    }
+
+    // suggest an available prefix for the provided namespace, based on the sha-256
+    // of the namespace name, and a final fallback to UUID based (while considering pre-existing mappings)
+    private static String devisePrefixTrySha256(String namespace, UnaryOperator<String> lookupNamespace) {
+
+        String sha = getSha256(namespace);
+        if (sha != null) {
+            for (int i = 7; i <= sha.length(); i++) {
+                String prefix = "s-" + sha.substring(0, i);
+                String lookedUpPrefix = lookupNamespace.apply(prefix);
+                if (lookedUpPrefix == null) {
+                    // unused, so go ahead with this prefix
+                    return prefix;
+                }
+            }
+        }
+
+        // fallback to UUID
+        return devisePrefixByUUID(namespace, lookupNamespace);
+    }
+
+    // suggest an available prefix for the provided namespace, based on the characters
+    // in the namespace name (while considering pre-existing mappings)
+    private static String devisePrefix(String namespace, UnaryOperator<String> lookupNamespace) {
+        String prefix = namespace.toLowerCase(Locale.ENGLISH);
+
+        // strip scheme when http(s)
+        if (prefix.startsWith("http://")) {
+            prefix = prefix.substring("http://".length());
+        } else if (prefix.startsWith("https://")) {
+            prefix = prefix.substring("https://".length());
+        }
+
+        // strip common host name prefixes
+        if (prefix.startsWith("www.")) {
+            prefix = prefix.substring("www.".length());
+        } else if (prefix.startsWith("ns.")) {
+            prefix = prefix.substring("ns.".length());
+        }
+
+        // replace characters not allowed in prefix (here: '\', '/' and :)
+        prefix = prefix.replaceAll("[\\/:]+", "-");
+
+        // strip trailing replacement character
+        while (prefix.endsWith("-")) {
+            prefix = prefix.substring(0, prefix.length() - 1);
+        }
+
+        String lookedUpNamespace = lookupNamespace.apply(prefix);
+        if (lookedUpNamespace == null || lookedUpNamespace.equals(namespace)) {
+            return prefix;
+        } else {
+            return devisePrefixTrySha256(namespace, lookupNamespace);
+        }
+    }
+
+    // suggest an available prefix for the provided namespace (while considering pre-existing mappings)
+    private static String suggestPrefix(String namespace, UnaryOperator<String> lookupPrefix) {
+        // try hard-wired map
+        String known = KNOWN_PREFIXES.get(namespace);
+
+        // lookup using supplied mapper as well
+        String lookedUpNamespace = known != null ? lookupPrefix.apply(known) : null;
+
+        // return hardwired prefix if unused or mapper has the prefix mapped to the same namespace
+        if (known != null && (lookedUpNamespace == null || namespace.equals(lookedUpNamespace))) {
+            return known;
+        } else {
+            return devisePrefix(namespace, lookupPrefix);
+        }
+    }
 }