fix: make private methods static where possible (#214)

dwalluck · web-flow · commit f16a2ebd23b0 · 2025-03-21T11:30:07.000-04:00
diff --git a/src/main/java/com/github/packageurl/PackageURL.java b/src/main/java/com/github/packageurl/PackageURL.java
@@ -155,8 +155,8 @@ public PackageURL(
             final @Nullable String subpath)
             throws MalformedPackageURLException {
         this.type = toLowerCase(validateType(requireNonNull(type, "type")));
-        this.namespace = validateNamespace(namespace);
-        this.name = validateName(requireNonNull(name, "name"));
+        this.namespace = validateNamespace(this.type, namespace);
+        this.name = validateName(this.type, requireNonNull(name, "name"));
         this.version = validateVersion(type, version);
         this.qualifiers = parseQualifiers(qualifiers);
         this.subpath = validateSubpath(subpath);
@@ -274,7 +274,7 @@ public Map<String, String> getQualifiers() {
         return subpath;
     }
 
-    private void validateScheme(final String value) throws MalformedPackageURLException {
+    private static void validateScheme(final String value) throws MalformedPackageURLException {
         if (!SCHEME.equals(value)) {
             throw new MalformedPackageURLException(
                     "The PackageURL scheme '" + value + "' is invalid. It should be '" + SCHEME + "'");
@@ -319,14 +319,16 @@ private static void validateChars(String value, IntPredicate predicate, String c
         }
     }
 
-    private @Nullable String validateNamespace(final @Nullable String value) throws MalformedPackageURLException {
+    private static @Nullable String validateNamespace(final String type, final @Nullable String value)
+            throws MalformedPackageURLException {
         if (isEmpty(value)) {
             return null;
         }
-        return validateNamespace(value.split("/"));
+        return validateNamespace(type, value.split("/"));
     }
 
-    private @Nullable String validateNamespace(final String[] values) throws MalformedPackageURLException {
+    private static @Nullable String validateNamespace(final String type, final String[] values)
+            throws MalformedPackageURLException {
         if (values.length == 0) {
             return null;
         }
@@ -360,7 +362,7 @@ private static void validateChars(String value, IntPredicate predicate, String c
         return retVal;
     }
 
-    private String validateName(final String value) throws MalformedPackageURLException {
+    private static String validateName(final String type, final String value) throws MalformedPackageURLException {
         if (value.isEmpty()) {
             throw new MalformedPackageURLException("The PackageURL name specified is invalid");
         }
@@ -391,7 +393,7 @@ private String validateName(final String value) throws MalformedPackageURLExcept
         return temp;
     }
 
-    private @Nullable String validateVersion(final String type, final @Nullable String value) {
+    private static @Nullable String validateVersion(final String type, final @Nullable String value) {
         if (value == null) {
             return null;
         }
@@ -406,7 +408,7 @@ private String validateName(final String value) throws MalformedPackageURLExcept
         }
     }
 
-    private @Nullable Map<String, String> validateQualifiers(final @Nullable Map<String, String> values)
+    private static @Nullable Map<String, String> validateQualifiers(final @Nullable Map<String, String> values)
             throws MalformedPackageURLException {
         if (values == null || values.isEmpty()) {
             return null;
@@ -436,7 +438,7 @@ private static void validateValue(final String key, final @Nullable String value
         }
     }
 
-    private @Nullable String validateSubpath(final @Nullable String value) throws MalformedPackageURLException {
+    private static @Nullable String validateSubpath(final @Nullable String value) throws MalformedPackageURLException {
         if (isEmpty(value)) {
             return null;
         }
@@ -764,11 +766,11 @@ private void parse(final String purl) throws MalformedPackageURLException {
             // The 'remainder' should now consist of an optional namespace and the name
             index = remainder.lastIndexOf('/');
             if (index <= start) {
-                this.name = validateName(percentDecode(remainder.substring(start)));
+                this.name = validateName(this.type, percentDecode(remainder.substring(start)));
             } else {
-                this.name = validateName(percentDecode(remainder.substring(index + 1)));
+                this.name = validateName(this.type, percentDecode(remainder.substring(index + 1)));
                 remainder = remainder.substring(0, index);
-                this.namespace = validateNamespace(parsePath(remainder.substring(start), false));
+                this.namespace = validateNamespace(this.type, parsePath(remainder.substring(start), false));
             }
             verifyTypeConstraints(this.type, this.namespace, this.name);
         } catch (URISyntaxException e) {
@@ -782,7 +784,7 @@ private void parse(final String purl) throws MalformedPackageURLException {
      * @param namespace the purl namespace
      * @throws MalformedPackageURLException if constraints are not met
      */
-    private void verifyTypeConstraints(String type, @Nullable String namespace, @Nullable String name)
+    private static void verifyTypeConstraints(String type, @Nullable String namespace, @Nullable String name)
             throws MalformedPackageURLException {
         if (StandardTypes.MAVEN.equals(type)) {
             if (isEmpty(namespace) || isEmpty(name)) {
@@ -792,7 +794,7 @@ private void verifyTypeConstraints(String type, @Nullable String namespace, @Nul
         }
     }
 
-    private @Nullable Map<String, String> parseQualifiers(final @Nullable Map<String, String> qualifiers)
+    private static @Nullable Map<String, String> parseQualifiers(final @Nullable Map<String, String> qualifiers)
             throws MalformedPackageURLException {
         if (qualifiers == null || qualifiers.isEmpty()) {
             return null;
@@ -812,7 +814,7 @@ private void verifyTypeConstraints(String type, @Nullable String namespace, @Nul
     }
 
     @SuppressWarnings("StringSplitter") // reason: surprising behavior is okay in this case
-    private @Nullable Map<String, String> parseQualifiers(final String encodedString)
+    private static @Nullable Map<String, String> parseQualifiers(final String encodedString)
             throws MalformedPackageURLException {
         try {
             final TreeMap<String, String> results = Arrays.stream(encodedString.split("&"))
@@ -836,14 +838,14 @@ private void verifyTypeConstraints(String type, @Nullable String namespace, @Nul
         }
     }
 
-    private String[] parsePath(final String path, final boolean isSubpath) {
+    private static String[] parsePath(final String path, final boolean isSubpath) {
         return Arrays.stream(path.split("/"))
                 .filter(segment -> !segment.isEmpty() && !(isSubpath && (".".equals(segment) || "..".equals(segment))))
                 .map(PackageURL::percentDecode)
                 .toArray(String[]::new);
     }
 
-    private String encodePath(final String path) {
+    private static String encodePath(final String path) {
         return Arrays.stream(path.split("/")).map(PackageURL::percentEncode).collect(Collectors.joining("/"));
     }
 

Original file line number	Diff line number	Diff line change
`@@ -155,8 +155,8 @@ public PackageURL(`
`155`	`155`	`final @Nullable String subpath)`
`156`	`156`	`throws MalformedPackageURLException {`
`157`	`157`	`this.type = toLowerCase(validateType(requireNonNull(type, "type")));`
`158`		`- this.namespace = validateNamespace(namespace);`
`159`		`- this.name = validateName(requireNonNull(name, "name"));`
	`158`	`+ this.namespace = validateNamespace(this.type, namespace);`
	`159`	`+ this.name = validateName(this.type, requireNonNull(name, "name"));`
`160`	`160`	`this.version = validateVersion(type, version);`
`161`	`161`	`this.qualifiers = parseQualifiers(qualifiers);`
`162`	`162`	`this.subpath = validateSubpath(subpath);`
`@@ -274,7 +274,7 @@ public Map<String, String> getQualifiers() {`
`274`	`274`	`return subpath;`
`275`	`275`	`}`
`276`	`276`
`277`		`- private void validateScheme(final String value) throws MalformedPackageURLException {`
	`277`	`+ private static void validateScheme(final String value) throws MalformedPackageURLException {`
`278`	`278`	`if (!SCHEME.equals(value)) {`
`279`	`279`	`throw new MalformedPackageURLException(`
`280`	`280`	`"The PackageURL scheme '" + value + "' is invalid. It should be '" + SCHEME + "'");`
`@@ -319,14 +319,16 @@ private static void validateChars(String value, IntPredicate predicate, String c`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
`322`		`- private @Nullable String validateNamespace(final @Nullable String value) throws MalformedPackageURLException {`
	`322`	`+ private static @Nullable String validateNamespace(final String type, final @Nullable String value)`
	`323`	`+ throws MalformedPackageURLException {`
`323`	`324`	`if (isEmpty(value)) {`
`324`	`325`	`return null;`
`325`	`326`	`}`
`326`		`- return validateNamespace(value.split("/"));`
	`327`	`+ return validateNamespace(type, value.split("/"));`
`327`	`328`	`}`
`328`	`329`
`329`		`- private @Nullable String validateNamespace(final String[] values) throws MalformedPackageURLException {`
	`330`	`+ private static @Nullable String validateNamespace(final String type, final String[] values)`
	`331`	`+ throws MalformedPackageURLException {`
`330`	`332`	`if (values.length == 0) {`
`331`	`333`	`return null;`
`332`	`334`	`}`
`@@ -360,7 +362,7 @@ private static void validateChars(String value, IntPredicate predicate, String c`
`360`	`362`	`return retVal;`
`361`	`363`	`}`
`362`	`364`
`363`		`- private String validateName(final String value) throws MalformedPackageURLException {`
	`365`	`+ private static String validateName(final String type, final String value) throws MalformedPackageURLException {`
`364`	`366`	`if (value.isEmpty()) {`
`365`	`367`	`throw new MalformedPackageURLException("The PackageURL name specified is invalid");`
`366`	`368`	`}`
`@@ -391,7 +393,7 @@ private String validateName(final String value) throws MalformedPackageURLExcept`
`391`	`393`	`return temp;`
`392`	`394`	`}`
`393`	`395`
`394`		`- private @Nullable String validateVersion(final String type, final @Nullable String value) {`
	`396`	`+ private static @Nullable String validateVersion(final String type, final @Nullable String value) {`
`395`	`397`	`if (value == null) {`
`396`	`398`	`return null;`
`397`	`399`	`}`
`@@ -406,7 +408,7 @@ private String validateName(final String value) throws MalformedPackageURLExcept`
`406`	`408`	`}`
`407`	`409`	`}`
`408`	`410`
`409`		`- private @Nullable Map<String, String> validateQualifiers(final @Nullable Map<String, String> values)`
	`411`	`+ private static @Nullable Map<String, String> validateQualifiers(final @Nullable Map<String, String> values)`
`410`	`412`	`throws MalformedPackageURLException {`
`411`	`413`	`if (values == null \|\| values.isEmpty()) {`
`412`	`414`	`return null;`
`@@ -436,7 +438,7 @@ private static void validateValue(final String key, final @Nullable String value`
`436`	`438`	`}`
`437`	`439`	`}`
`438`	`440`
`439`		`- private @Nullable String validateSubpath(final @Nullable String value) throws MalformedPackageURLException {`
	`441`	`+ private static @Nullable String validateSubpath(final @Nullable String value) throws MalformedPackageURLException {`
`440`	`442`	`if (isEmpty(value)) {`
`441`	`443`	`return null;`
`442`	`444`	`}`
`@@ -764,11 +766,11 @@ private void parse(final String purl) throws MalformedPackageURLException {`
`764`	`766`	`// The 'remainder' should now consist of an optional namespace and the name`
`765`	`767`	`index = remainder.lastIndexOf('/');`
`766`	`768`	`if (index <= start) {`
`767`		`- this.name = validateName(percentDecode(remainder.substring(start)));`
	`769`	`+ this.name = validateName(this.type, percentDecode(remainder.substring(start)));`
`768`	`770`	`} else {`
`769`		`- this.name = validateName(percentDecode(remainder.substring(index + 1)));`
	`771`	`+ this.name = validateName(this.type, percentDecode(remainder.substring(index + 1)));`
`770`	`772`	`remainder = remainder.substring(0, index);`
`771`		`- this.namespace = validateNamespace(parsePath(remainder.substring(start), false));`
	`773`	`+ this.namespace = validateNamespace(this.type, parsePath(remainder.substring(start), false));`
`772`	`774`	`}`
`773`	`775`	`verifyTypeConstraints(this.type, this.namespace, this.name);`
`774`	`776`	`} catch (URISyntaxException e) {`
`@@ -782,7 +784,7 @@ private void parse(final String purl) throws MalformedPackageURLException {`
`782`	`784`	`* @param namespace the purl namespace`
`783`	`785`	`* @throws MalformedPackageURLException if constraints are not met`
`784`	`786`	`*/`
`785`		`- private void verifyTypeConstraints(String type, @Nullable String namespace, @Nullable String name)`
	`787`	`+ private static void verifyTypeConstraints(String type, @Nullable String namespace, @Nullable String name)`
`786`	`788`	`throws MalformedPackageURLException {`
`787`	`789`	`if (StandardTypes.MAVEN.equals(type)) {`
`788`	`790`	`if (isEmpty(namespace) \|\| isEmpty(name)) {`
`@@ -792,7 +794,7 @@ private void verifyTypeConstraints(String type, @Nullable String namespace, @Nul`
`792`	`794`	`}`
`793`	`795`	`}`
`794`	`796`
`795`		`- private @Nullable Map<String, String> parseQualifiers(final @Nullable Map<String, String> qualifiers)`
	`797`	`+ private static @Nullable Map<String, String> parseQualifiers(final @Nullable Map<String, String> qualifiers)`
`796`	`798`	`throws MalformedPackageURLException {`
`797`	`799`	`if (qualifiers == null \|\| qualifiers.isEmpty()) {`
`798`	`800`	`return null;`
`@@ -812,7 +814,7 @@ private void verifyTypeConstraints(String type, @Nullable String namespace, @Nul`
`812`	`814`	`}`
`813`	`815`
`814`	`816`	`@SuppressWarnings("StringSplitter") // reason: surprising behavior is okay in this case`
`815`		`- private @Nullable Map<String, String> parseQualifiers(final String encodedString)`
	`817`	`+ private static @Nullable Map<String, String> parseQualifiers(final String encodedString)`
`816`	`818`	`throws MalformedPackageURLException {`
`817`	`819`	`try {`
`818`	`820`	`final TreeMap<String, String> results = Arrays.stream(encodedString.split("&"))`
`@@ -836,14 +838,14 @@ private void verifyTypeConstraints(String type, @Nullable String namespace, @Nul`
`836`	`838`	`}`
`837`	`839`	`}`
`838`	`840`
`839`		`- private String[] parsePath(final String path, final boolean isSubpath) {`
	`841`	`+ private static String[] parsePath(final String path, final boolean isSubpath) {`
`840`	`842`	`return Arrays.stream(path.split("/"))`
`841`	`843`	`.filter(segment -> !segment.isEmpty() && !(isSubpath && (".".equals(segment) \|\| "..".equals(segment))))`
`842`	`844`	`.map(PackageURL::percentDecode)`
`843`	`845`	`.toArray(String[]::new);`
`844`	`846`	`}`
`845`	`847`
`846`		`- private String encodePath(final String path) {`
	`848`	`+ private static String encodePath(final String path) {`
`847`	`849`	`return Arrays.stream(path.split("/")).map(PackageURL::percentEncode).collect(Collectors.joining("/"));`
`848`	`850`	`}`
`849`	`851`