Merge branch 'master' into package-url-builder-with-qualifiers

jeremylong · web-flow · commit 6659ce728bf0 · 2025-03-11T06:02:18.000-04:00
diff --git a/src/main/java/com/github/packageurl/PackageURL.java b/src/main/java/com/github/packageurl/PackageURL.java
@@ -31,6 +31,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.TreeMap;
+import java.util.function.IntPredicate;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -98,13 +99,31 @@ public PackageURL(final String type, final String namespace, final String name,
         this.namespace = validateNamespace(namespace);
         this.name = validateName(name);
         this.version = validateVersion(version);
-        this.qualifiers = validateQualifiers(qualifiers);
+        this.qualifiers = parseQualifiers(qualifiers);
         this.subpath = validatePath(subpath, true);
         verifyTypeConstraints(this.type, this.namespace, this.name);
     }
 
     /**
-     * The PackageURL scheme constant.
+     * Constructs a new PackageURL object.
+     *
+     * @param type the type of package (i.e. maven, npm, gem, etc)
+     * @param namespace the name prefix (i.e. group, owner, organization)
+     * @param name the name of the package
+     * @param version the version of the package
+     * @param qualifiers an array of key/value pair qualifiers
+     * @param subpath the subpath string
+     * @throws MalformedPackageURLException if parsing fails
+     * @since 1.6.0
+     */
+    public PackageURL(final String type, final String namespace, final String name, final String version,
+                      final Map<String, String> qualifiers, final String subpath)
+            throws MalformedPackageURLException {
+        this(type, namespace, name, version, (qualifiers != null) ? new TreeMap<>(qualifiers) : null, subpath);
+    }
+
+    /**
+     * The PackageURL scheme constant
      */
     public static final String SCHEME = "pkg";
 
@@ -223,7 +242,7 @@ public String getVersion() {
      * @since 1.0.0
      */
     public Map<String, String> getQualifiers() {
-        return (qualifiers != null)? Collections.unmodifiableMap(qualifiers) : null;
+        return (qualifiers != null) ? Collections.unmodifiableMap(qualifiers) : null;
     }
 
     /**
@@ -247,18 +266,31 @@ private String validateType(final String value) throws MalformedPackageURLExcept
             throw new MalformedPackageURLException("The PackageURL type cannot be null or empty");
         }
 
-        if (isDigit(value.charAt(0))) {
-            throw new MalformedPackageURLException("The PackageURL type cannot start with a number");
-        }
+        validateChars(value, PackageURL::isValidCharForType, "type");
+
+        return value;
+    }
+
+    private static boolean isValidCharForType(int c) {
+        return (isAlphaNumeric(c) || c == '.' || c == '+' || c == '-');
+    }
 
-        if (!value.chars().allMatch(c -> (c == '.' || c == '+' || c == '-'
-                || isUpperCase(c)
-                || isLowerCase(c)
-                || isDigit(c)))) {
-            throw new MalformedPackageURLException("The PackageURL type contains invalid characters");
+    private static boolean isValidCharForKey(int c) {
+        return (isAlphaNumeric(c) || c == '.' || c == '_' || c == '-');
+    }
+
+    private static void validateChars(String value, IntPredicate predicate, String component) throws MalformedPackageURLException {
+        char firstChar = value.charAt(0);
+
+        if (isDigit(firstChar)) {
+            throw new MalformedPackageURLException("The PackageURL " + component + " cannot start with a number: " + firstChar);
         }
 
-        return value;
+        String invalidChars = value.chars().filter(predicate.negate()).mapToObj(c -> String.valueOf((char) c)).collect(Collectors.joining(", "));
+
+        if (!invalidChars.isEmpty()) {
+            throw new MalformedPackageURLException("The PackageURL " + component + " '" + value + "' contains invalid characters: " + invalidChars);
+        }
     }
 
     private String validateNamespace(final String value) throws MalformedPackageURLException {
@@ -319,7 +351,7 @@ private String validateVersion(final String value) {
     }
 
     private Map<String, String> validateQualifiers(final Map<String, String> values) throws MalformedPackageURLException {
-        if (values == null) {
+        if (values == null || values.isEmpty()) {
             return null;
         }
         for (Map.Entry<String, String> entry : values.entrySet()) {
@@ -337,10 +369,7 @@ private void validateKey(final String value) throws MalformedPackageURLException
             throw new MalformedPackageURLException("Qualifier key is invalid: " + value);
         }
 
-        if (isDigit(value.charAt(0))
-                || !value.chars().allMatch(c -> isLowerCase(c) || (isDigit(c)) || c == '.' || c == '-' || c == '_')) {
-            throw new MalformedPackageURLException("Qualifier key is invalid: " + value);
-        }
+        validateChars(value, PackageURL::isValidCharForKey, "qualifier key");
     }
 
     private String validatePath(final String value, final boolean isSubpath) throws MalformedPackageURLException {
@@ -463,7 +492,7 @@ private static String uriEncode(String source, Charset charset) {
     }
 
     private static boolean isUnreserved(int c) {
-        return (isAlpha(c) || isDigit(c) || '-' == c || '.' == c || '_' == c || '~' == c);
+        return (isValidCharForKey(c) || c == '~');
     }
 
     private static boolean isAlpha(int c) {
@@ -474,6 +503,10 @@ private static boolean isDigit(int c) {
         return (c >= '0' && c <= '9');
     }
 
+    private static boolean isAlphaNumeric(int c) {
+        return (isDigit(c) || isAlpha(c));
+    }
+
     private static boolean isUpperCase(int c) {
         return (c >= 'A' && c <= 'Z');
     }
@@ -656,6 +689,23 @@ private void verifyTypeConstraints(String type, String namespace, String name) t
         }
     }
 
+    private Map<String, String> parseQualifiers(final Map<String, String> qualifiers) throws MalformedPackageURLException {
+        if (qualifiers == null || qualifiers.isEmpty()) {
+            return null;
+        }
+
+        try {
+            final TreeMap<String, String> results = qualifiers.entrySet().stream()
+                    .filter(entry -> entry.getValue() != null && !entry.getValue().isEmpty())
+                    .collect(TreeMap::new,
+                            (map, value) -> map.put(toLowerCase(value.getKey()), value.getValue()),
+                            TreeMap::putAll);
+            return validateQualifiers(results);
+        } catch (ValidationException ex) {
+            throw new MalformedPackageURLException(ex.getMessage());
+        }
+    }
+
     @SuppressWarnings("StringSplitter")//reason: surprising behavior is okay in this case
     private Map<String, String> parseQualifiers(final String encodedString) throws MalformedPackageURLException {
         try {
diff --git a/src/main/java/com/github/packageurl/PackageURLBuilder.java b/src/main/java/com/github/packageurl/PackageURLBuilder.java
@@ -23,6 +23,8 @@
 
 import java.util.Map;
 import java.util.Set;
+import java.util.Collections;
+import java.util.Map;
 import java.util.TreeMap;
 
 /**
@@ -240,11 +242,11 @@ public String getSubpath() {
      * An empty map is returned if no qualifiers is set.
      * @return all qualifiers set in this builder, or an empty map if none are set.
      */
-    public TreeMap<String, String> getQualifiers() {
+    public Map<String, String> getQualifiers() {
         if (qualifiers == null) {
-            return new TreeMap<>();
+            return null;
         }
-        return new TreeMap<>(qualifiers);
+        return Collections.unmodifiableMap(qualifiers);
     }
 
     /**
diff --git a/src/test/java/com/github/packageurl/PackageURLBuilderTest.java b/src/test/java/com/github/packageurl/PackageURLBuilderTest.java
@@ -97,26 +97,22 @@ public void testPackageURLBuilder() throws MalformedPackageURLException {
 
     @Test
     public void testPackageURLBuilderException1() throws MalformedPackageURLException {
-        exception.expect(MalformedPackageURLException.class);
-        exception.expectMessage("contains a qualifier key with an empty or null");
         PackageURL purl = PackageURLBuilder.aPackageURL()
                 .withType("type")
                 .withName("name")
                 .withQualifier("key","")
                 .build();
-        Assert.fail("Build should fail due to invalid qualifier (empty value)");
+        assertNull(purl.getQualifiers());
     }
 
     @Test
     public void testPackageURLBuilderException1Null() throws MalformedPackageURLException {
-        exception.expect(MalformedPackageURLException.class);
-        exception.expectMessage("contains a qualifier key with an empty or null");
-        PackageURLBuilder.aPackageURL()
+        PackageURL purl = PackageURLBuilder.aPackageURL()
                 .withType("type")
                 .withName("name")
                 .withQualifier("key",null)
                 .build();
-        Assert.fail("Build should fail due to invalid qualifier (null value)");
+        assertNull(purl.getQualifiers());
     }
 
     @Test
@@ -230,15 +226,13 @@ private void assertBuilderMatch(PackageURL expected, PackageURLBuilder actual) t
         Map<String, String> eQualifiers = expected.getQualifiers();
         Map<String, String> aQualifiers = actual.getQualifiers();
 
-        if (eQualifiers != null) {
-            eQualifiers.forEach((k,v)-> {
-                Assert.assertEquals(v, aQualifiers.remove(k));
+        assertEquals(eQualifiers, aQualifiers);
+
+        if (eQualifiers != null && aQualifiers != null) {
+            eQualifiers.forEach((k,v) -> {
                 Assert.assertEquals(v, actual.getQualifier(k));
             });
         }
-
-        Assert.assertTrue(aQualifiers.isEmpty());
-
     }
 
 }
diff --git a/src/test/java/com/github/packageurl/PackageURLTest.java b/src/test/java/com/github/packageurl/PackageURLTest.java
