Makes PackageScanner include jar files

Author: jqno

equalsverifier-core/src/main/java/nl/jqno/equalsverifier/internal/reflection/PackageScanner.java

@@ -3,8 +3,11 @@
 import static nl.jqno.equalsverifier.internal.util.Rethrow.rethrow;
 
 import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.*;
+import java.util.jar.JarFile;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -29,64 +32,79 @@ private PackageScanner() {}
      * @return the classes contained in the given package.
      */
     public static List<Class<?>> getClassesIn(String packageName, PackageScanOptions options) {
-        var result = getDirs(packageName, options)
-                .stream()
-                .flatMap(d -> getClassesInDir(packageName, d, options).stream())
-                .collect(Collectors.toList());
+        String packagePath = packageName.replace('.', '/');
+
+        List<Class<?>> result = getResources(packagePath)
+                .flatMap(r -> processResource(r, packagePath, options))
+                .map(f -> fileToClass(f, packagePath))
+                .filter(c -> !c.isAnonymousClass())
+                .filter(c -> !c.isLocalClass())
+                .filter(c -> !c.getName().endsWith("Test"))
+                .filter(
+                    c -> options.mustExtend() == null
+                            || (options.mustExtend().isAssignableFrom(c) && !options.mustExtend().equals(c)))
+                .collect(Collectors.toList()); // Need a mutable List for the next validations
 
         Validations.validateTypesAreKnown(options.exceptClasses(), result);
         result.removeAll(options.exceptClasses());
         result.removeIf(options.exclusionPredicate());
         return result;
     }
 
-    private static List<File> getDirs(String packageName, PackageScanOptions options) {
+    private static Stream<URL> getResources(String packagePath) {
         ClassLoader cl = Thread.currentThread().getContextClassLoader();
-        String path = packageName.replace('.', '/');
         return rethrow(
-            () -> Collections.list(cl.getResources(path)).stream().flatMap(r -> getResourcePath(r, options)).toList(),
-            e -> "Could not scan package " + packageName);
+            () -> Collections.list(cl.getResources(packagePath)).stream(),
+            e -> "Could not resolve package " + packagePath + ": " + e.getMessage());
     }
 
-    private static Stream<File> getResourcePath(URL r, PackageScanOptions options) {
-        String result = rethrow(() -> r.toURI().getPath(), e -> "Could not resolve resource path: " + e.getMessage());
-        if (result == null) {
-            if (options.ignoreExternalJars()) {
-                return Stream.empty();
-            }
-            throw new ReflectionException("Could not resolve third-party resource " + r);
-        }
-        return Stream.of(new File(result));
+    private static Stream<File> processResource(URL resource, String packagePath, PackageScanOptions options) {
+        return rethrow(() -> switch (resource.toURI().getScheme()) {
+            case "file" -> processDirectory(resource, options.scanRecursively());
+            case "jar" -> options.ignoreExternalJars()
+                    ? Stream.of()
+                    : walkJar(resource, packagePath, options.scanRecursively());
+            default -> throw new ReflectionException(
+                    "Could not resolve " + resource.toURI().getScheme() + " resource " + resource);
+        }, e -> "Could not resolve resource " + resource + ": " + e.getMessage());
+    }
+
+    private static Stream<File> processDirectory(URL resource, boolean scanRecursively) throws URISyntaxException {
+        String path = resource.toURI().getPath();
+        return walkDirectory(new File(path), scanRecursively);
     }
 
-    private static List<Class<?>> getClassesInDir(String packageName, File dir, PackageScanOptions options) {
+    private static Stream<File> walkDirectory(File dir, boolean scanRecursively) {
         if (!dir.exists()) {
-            return Collections.emptyList();
+            return Stream.of();
         }
         return Arrays
                 .stream(dir.listFiles())
-                .filter(f -> (options.scanRecursively() && f.isDirectory()) || f.getName().endsWith(".class"))
-                .flatMap(f -> {
-                    List<Class<?>> classes;
-                    if (f.isDirectory()) {
-                        classes = getClassesInDir(packageName + "." + f.getName(), f, options);
-                    }
-                    else {
-                        classes = List.of(fileToClass(packageName, f));
-                    }
-                    return classes.stream();
-                })
-                .filter(c -> !c.isAnonymousClass())
-                .filter(c -> !c.isLocalClass())
-                .filter(c -> !c.getName().endsWith("Test"))
-                .filter(
-                    c -> options.mustExtend() == null
-                            || (options.mustExtend().isAssignableFrom(c) && !options.mustExtend().equals(c)))
-                .toList();
+                .filter(f -> (scanRecursively && f.isDirectory()) || f.getName().endsWith(".class"))
+                .flatMap(f -> f.isDirectory() ? walkDirectory(f, scanRecursively) : Stream.of(f));
+    }
+
+    private static Stream<File> walkJar(URL resource, String packagePath, boolean scanRecursively) throws IOException {
+        String path = resource.getPath();
+        String jar = path.substring(5, path.indexOf("!"));
+        int packageSegments = packagePath.split("/").length;
+        try (var file = new JarFile(jar)) {
+            return file
+                    .stream()
+                    .map(e -> e.getName())
+                    .filter(e -> e.endsWith(".class"))
+                    .filter(e -> e.startsWith(packagePath))
+                    .filter(e -> scanRecursively || e.split("/").length == packageSegments + 1)
+                    .map(e -> new File(e))
+                    .toList()
+                    .stream();
+        }
     }
 
-    private static Class<?> fileToClass(String packageName, File file) {
-        String className = file.getName().substring(0, file.getName().length() - 6);
+    private static Class<?> fileToClass(File f, String packagePath) {
+        String className = f.getName().substring(0, f.getName().length() - 6);
+        String fullPath = f.getParent();
+        String packageName = fullPath.substring(fullPath.indexOf(packagePath)).replace("/", ".");
         return rethrow(
             () -> Class.forName(packageName + "." + className),
             e -> "Could not resolve class " + className + ", which was found in package " + packageName);

equalsverifier-core/src/test/java/nl/jqno/equalsverifier/internal/reflection/PackageScannerTest.java

@@ -1,12 +1,10 @@
 package nl.jqno.equalsverifier.internal.reflection;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import java.util.*;
 
 import nl.jqno.equalsverifier.ScanOption;
-import nl.jqno.equalsverifier.internal.exceptions.ReflectionException;
 import nl.jqno.equalsverifier.testhelpers.packages.correct.A;
 import nl.jqno.equalsverifier.testhelpers.packages.correct.B;
 import nl.jqno.equalsverifier.testhelpers.packages.correct.C;
@@ -131,16 +129,26 @@ void anonymousAndLocalClassesAreSkipped() {
     }
 
     @Test
-    void dependencyPackage() {
-        assertThatThrownBy(() -> PackageScanner.getClassesIn("org.junit", opts))
-                .isInstanceOf(ReflectionException.class)
-                .hasMessageContaining("Could not resolve third-party resource");
+    void jarPackage() {
+        List<Class<?>> classes = PackageScanner.getClassesIn("org.objenesis", opts);
+        assertThat(classes)
+                .anyMatch(c -> "org.objenesis.Objenesis".equals(c.getName()))
+                .noneMatch(c -> "org.objenesis.instantiator.ObjectInstantiator".equals(c.getName()));
+    }
+
+    @Test
+    void jarPackageRecursive() {
+        opts = PackageScanOptions.process(ScanOption.recursive());
+        List<Class<?>> classes = PackageScanner.getClassesIn("org.objenesis", opts);
+        assertThat(classes)
+                .anyMatch(c -> "org.objenesis.Objenesis".equals(c.getName()))
+                .anyMatch(c -> "org.objenesis.instantiator.ObjectInstantiator".equals(c.getName()));
     }
 
     @Test
-    void dependencyPackageWithIgnore() {
+    void jarPackageWithIgnore() {
         opts = PackageScanOptions.process(ScanOption.ignoreExternalJars());
-        List<Class<?>> classes = PackageScanner.getClassesIn("org.junit", opts);
+        List<Class<?>> classes = PackageScanner.getClassesIn("org.objenesis", opts);
         assertThat(classes).isEmpty();
     }