Index annotations even when running tests in Maven

dscho · dscho · commit ea4c3b934fe5 · 2013-12-13T09:07:58.000-06:00
There is an unfortunate interaction between Eclipse and Maven when the
developer runs the tests using Maven after Eclipse compiled code, failing
to run the annotation processors. The annotation index breaks down in that
case because no annotations got indexed.

Fix this by running the index annotation even when the tests are run from
Maven's surefire plugin (as opposed to from within Eclipse).

This will help us also when merging the annotation indexer into
scijava-common itself, because scijava-common has annotations itself that
need to be indexed, but after the merge, scijava-common itself is the
annotation processor (which needs to be disabled in order to compile
itself because of a chicken-and-egg problem).

While at it, remember which directories we already looked at (and clear
that cache when running the EclipseHelper unit test).

Signed-off-by: Johannes Schindelin &lt;johannes.schindelin@gmx.de&gt;
diff --git a/src/main/java/org/scijava/annotations/EclipseHelper.java b/src/main/java/org/scijava/annotations/EclipseHelper.java
@@ -35,8 +35,14 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.jar.Attributes.Name;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
 
 /**
  * Helps Eclipse's lack of support for annotation processing in incremental
@@ -91,6 +97,8 @@
  */
 public class EclipseHelper extends DirectoryIndexer {
 
+	static Set<URL> indexed = new HashSet<URL>();
+
 	/**
 	 * Updates the annotation index in the current Eclipse project.
 	 * <p>
@@ -109,24 +117,63 @@ public static void updateAnnotationIndex(final ClassLoader loader) {
 		if (!(loader instanceof URLClassLoader)) {
 			return;
 		}
-		EclipseHelper helper = null;
+		EclipseHelper helper = new EclipseHelper();
 		for (final URL url : ((URLClassLoader) loader).getURLs()) {
-			if (!"file".equals(url.getProtocol())) {
-				continue;
-			}
-			String path = url.getFile();
-			if (path.indexOf(':') >= 0) {
-				continue;
+			helper.maybeIndex(url, loader);
+		}
+	}
+
+	private void maybeIndex(final URL url, final ClassLoader loader) {
+		synchronized (indexed) {
+			if (indexed.contains(url)) {
+				return;
 			}
-			File directory = new File(path);
-			if (!directory.isDirectory()) {
-				continue;
+			indexed.add(url);
+		}
+		if (!"file".equals(url.getProtocol())) {
+			return;
+		}
+		String path = url.getFile();
+		if (path.indexOf(':') >= 0) {
+			return;
+		}
+		if (path.endsWith(".jar")) {
+			/*
+			 * To support mixed development with Eclipse and Maven, let's handle
+			 * the case where Eclipse compiled classes, did not run the annotation
+			 * processors, then the developer called "mvn test". In this case, we
+			 * have a surefirebooter.jar whose manifest contains the dependencies,
+			 * but crucially also the target/classes/ and target/test-classes/
+			 * directories which may need to be indexed.
+			 */
+			if (path.matches(".*/target/surefire/surefirebooter[0-9]*\\.jar")) try {
+				final JarFile jar = new JarFile(path);
+				Manifest manifest = jar.getManifest();
+				if (manifest != null) {
+					final String classPath =
+						manifest.getMainAttributes().getValue(Name.CLASS_PATH);
+					if (classPath != null) {
+						for (final String element : classPath.split(" +"))
+							try {
+								maybeIndex(new URL(element), loader);
+							}
+							catch (MalformedURLException e) {
+								e.printStackTrace();
+							}
+					}
+				}
 			}
-			if (helper == null) {
-				helper = new EclipseHelper();
+			catch (final IOException e) {
+				System.err.println("Warning: could not index annotations due to ");
+				e.printStackTrace();
 			}
-			helper.index(directory, loader);
+			return;
+		}
+		File directory = new File(path);
+		if (!directory.isDirectory()) {
+			return;
 		}
+		index(directory, loader);
 	}
 
 	private void index(File directory, ClassLoader loader) {
diff --git a/src/test/java/org/scijava/annotations/EclipseHelperTest.java b/src/test/java/org/scijava/annotations/EclipseHelperTest.java
@@ -79,6 +79,7 @@ public Class<?> loadClass(final String className)
 					return super.loadClass(className);
 				}
 			};
+		EclipseHelper.indexed.clear();
 		EclipseHelper.updateAnnotationIndex(loader);
 		for (final Class<?> clazz : new Class<?>[] { Complex.class, Simple.class })
 		{
@@ -96,6 +97,7 @@ public Class<?> loadClass(final String className)
 				.delete());
 		}
 		long now = System.currentTimeMillis();
+		EclipseHelper.indexed.clear();
 		EclipseHelper.updateAnnotationIndex(loader);
 		assertEquals(0, jsonDir.list().length);
 		/*

Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,7 @@ public Class<?> loadClass(final String className)`
`79`	`79`	`return super.loadClass(className);`
`80`	`80`	`}`
`81`	`81`	`};`
	`82`	`+ EclipseHelper.indexed.clear();`
`82`	`83`	`EclipseHelper.updateAnnotationIndex(loader);`
`83`	`84`	`for (final Class<?> clazz : new Class<?>[] { Complex.class, Simple.class })`
`84`	`85`	`{`
`@@ -96,6 +97,7 @@ public Class<?> loadClass(final String className)`
`96`	`97`	`.delete());`
`97`	`98`	`}`
`98`	`99`	`long now = System.currentTimeMillis();`
	`100`	`+ EclipseHelper.indexed.clear();`
`99`	`101`	`EclipseHelper.updateAnnotationIndex(loader);`
`100`	`102`	`assertEquals(0, jsonDir.list().length);`
`101`	`103`	`/*`