Merge branch 'null-plugin-infos'

This branch fixes a problem where Services and Gateways, even though
they implement RichPlugin (and therefore HasPluginInfo) would not
retain their associated PluginInfo, causing getInfo() to return null.

It introduces some utility method in the PluginInfo class to aid in
retrieve and constructing PluginInfos corresponding to Class objects.

Author: ctrueden

src/main/java/org/scijava/AbstractGateway.java

@@ -54,6 +54,7 @@
 import org.scijava.platform.AppEventService;
 import org.scijava.platform.PlatformService;
 import org.scijava.plugin.AbstractRichPlugin;
+import org.scijava.plugin.PluginInfo;
 import org.scijava.plugin.PluginService;
 import org.scijava.prefs.PrefService;
 import org.scijava.script.ScriptService;
@@ -86,7 +87,15 @@ public AbstractGateway() {
 
 	public AbstractGateway(final String appName, final Context context) {
 		this.appName = appName;
-		if (context != null) setContext(context);
+		if (context != null) {
+			setContext(context);
+
+			// NB: Make a best effort to inject plugin metadata.
+			final PluginInfo<?> info = PluginInfo.getOrCreate(getClass(),
+				Gateway.class, context.getPluginIndex());
+			info.inject(this);
+			Priority.inject(this, info.getPriority());
+		}
 	}
 
 	// -- Gateway methods --
@@ -114,6 +123,8 @@ public void launch(final String... args) {
 
 	@Override
 	public String getShortName() {
+		final String pluginName = getInfo() == null ? null : getInfo().getName();
+		if (pluginName != null && !pluginName.isEmpty()) return pluginName;
 		return getClass().getSimpleName().toLowerCase();
 	}
 

src/main/java/org/scijava/SciJava.java

@@ -45,7 +45,7 @@
  * 
  * @author Curtis Rueden
  */
-@Plugin(type = Gateway.class)
+@Plugin(type = Gateway.class, name = "sj")
 public class SciJava extends AbstractGateway {
 
 	// -- Constructors --
@@ -113,12 +113,4 @@ public SciJava(final Collection<Class<? extends Service>> serviceClasses) {
 	public SciJava(final Context context) {
 		super(SciJavaApp.NAME, context);
 	}
-
-	// -- Gateway methods --
-
-	@Override
-	public String getShortName() {
-		return "sj";
-	}
-
 }

src/main/java/org/scijava/plugin/PluginInfo.java

@@ -33,6 +33,8 @@
 package org.scijava.plugin;
 
 import java.net.URL;
+import java.util.Collection;
+import java.util.Optional;
 
 import org.scijava.AbstractUIDetails;
 import org.scijava.Identifiable;
@@ -45,7 +47,6 @@
 import org.scijava.UIDetails;
 import org.scijava.Versioned;
 import org.scijava.input.Accelerator;
-import org.scijava.util.ClassUtils;
 import org.scijava.util.StringMaker;
 import org.scijava.util.Types;
 import org.scijava.util.VersionUtils;
@@ -352,6 +353,143 @@ public String getVersion() {
 		}
 	}
 
+	// -- Utility methods --
+
+	/**
+	 * Finds a {@link PluginInfo} of the given plugin class in the specified
+	 * {@link PluginIndex}. <em>Note that to avoid loading plugin classes, class
+	 * identity is determined by class name equality only.</em>
+	 * 
+	 * @param pluginClass The concrete class of the plugin whose
+	 *          {@link PluginInfo} is desired.
+	 * @param pluginIndex The {@link PluginIndex} to search for a matching
+	 *          {@link PluginInfo}.
+	 * @return The matching {@link PluginInfo}, or null if none found.
+	 */
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public static <P extends SciJavaPlugin> PluginInfo<?> get(
+		final Class<P> pluginClass, final PluginIndex pluginIndex)
+	{
+		return get(pluginClass, (Collection) pluginIndex.getAll());
+	}
+
+	/**
+	 * Finds a {@link PluginInfo} of the given plugin class and plugin type in the
+	 * specified {@link PluginIndex}. <em>Note that to avoid loading plugin
+	 * classes, class identity is determined by class name equality only.</em>
+	 * 
+	 * @param pluginClass The concrete class of the plugin whose
+	 *          {@link PluginInfo} is desired.
+	 * @param pluginType The type of the plugin; see {@link #getPluginType()}.
+	 * @param pluginIndex The {@link PluginIndex} to search for a matching
+	 *          {@link PluginInfo}.
+	 * @return The matching {@link PluginInfo}, or null if none found.
+	 */
+	public static <P extends PT, PT extends SciJavaPlugin> PluginInfo<PT> get(
+		final Class<P> pluginClass, final Class<PT> pluginType,
+		final PluginIndex pluginIndex)
+	{
+		return get(pluginClass, pluginIndex.getPlugins(pluginType));
+	}
+
+	/**
+	 * Finds a {@link PluginInfo} of the given plugin class in the specified list
+	 * of plugins. <em>Note that to avoid loading plugin classes, class identity
+	 * is determined by class name equality only.</em>
+	 * 
+	 * @param pluginClass The concrete class of the plugin whose
+	 *          {@link PluginInfo} is desired.
+	 * @param plugins The list of plugins to search for a match.
+	 * @return The matching {@link PluginInfo}, or null if none found.
+	 */
+	public static <P extends PT, PT extends SciJavaPlugin> PluginInfo<PT> get(
+		final Class<P> pluginClass,
+		final Collection<? extends PluginInfo<PT>> plugins)
+	{
+		final String className = pluginClass.getName();
+		final Optional<? extends PluginInfo<PT>> result = plugins.stream() //
+			.filter(info -> info.getClassName().equals(className)) //
+			.findFirst();
+		return result.isPresent() ? result.get() : null;
+	}
+
+	/**
+	 * Creates a {@link PluginInfo} for the given plugin class. The class must be
+	 * a concrete class annotated with the @{@link Plugin} annotation, from which
+	 * the plugin type will be inferred.
+	 * 
+	 * @param pluginClass The concrete class of the plugin for which a new
+	 *          {@link PluginInfo} is desired.
+	 * @return A newly created {@link PluginInfo} for the given plugin class.
+	 * @throws IllegalArgumentException if the given class is not annotated
+	 *           with @{@link Plugin}, or its annotated {@link Plugin#type()
+	 *           type()} is not a supertype of the plugin class.
+	 */
+	public static PluginInfo<?> create(
+		final Class<? extends SciJavaPlugin> pluginClass)
+	{
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		final PluginInfo<?> info = new PluginInfo(pluginClass, //
+			pluginType(pluginClass));
+		return info;
+	}
+
+	/**
+	 * Creates a {@link PluginInfo} for the given plugin class of the specified
+	 * plugin type.
+	 * 
+	 * @param pluginClass The concrete class of the plugin for which a new
+	 *          {@link PluginInfo} is desired.
+	 * @param pluginType The type of the plugin; see {@link #getPluginType()}.
+	 * @return A newly created {@link PluginInfo} for the given plugin class.
+	 */
+	public static <P extends PT, PT extends SciJavaPlugin> PluginInfo<PT> create(
+		final Class<P> pluginClass, final Class<PT> pluginType)
+	{
+		return new PluginInfo<>(pluginClass, pluginType);
+	}
+
+	/**
+	 * Obtains a {@link PluginInfo} for the given plugin class. If one already
+	 * exists in the specified {@link PluginIndex}, it is retrieved (see
+	 * {@link #get(Class, PluginIndex)}); otherwise, a new one is created (see
+	 * {@link #create(Class)}) but not added to the index.
+	 * 
+	 * @param pluginClass The concrete class of the plugin whose
+	 *          {@link PluginInfo} is desired.
+	 * @param pluginIndex The {@link PluginIndex} to search for a matching
+	 *          {@link PluginInfo}.
+	 * @throws IllegalArgumentException when creating a new {@link PluginInfo} if
+	 *           the associated plugin type cannot be inferred; see
+	 *           {@link #create(Class)}.
+	 */
+	public static <P extends SciJavaPlugin> PluginInfo<?> getOrCreate(
+		final Class<P> pluginClass, final PluginIndex pluginIndex)
+	{
+		final PluginInfo<?> existing = get(pluginClass, pluginIndex);
+		return existing == null ? create(pluginClass) : existing;
+	}
+
+	/**
+	 * Obtains a {@link PluginInfo} for the given plugin class. If one already
+	 * exists in the specified {@link PluginIndex}, it is retrieved (see
+	 * {@link #get(Class, PluginIndex)}); otherwise, a new one is created (see
+	 * {@link #create(Class)}) but not added to the index.
+	 * 
+	 * @param pluginClass The concrete class of the plugin whose
+	 *          {@link PluginInfo} is desired.
+	 * @param pluginType The type of the plugin; see {@link #getPluginType()}.
+	 * @param pluginIndex The {@link PluginIndex} to search for a matching
+	 *          {@link PluginInfo}.
+	 */
+	public static <P extends PT, PT extends SciJavaPlugin> PluginInfo<PT>
+		getOrCreate(final Class<P> pluginClass, final Class<PT> pluginType,
+			final PluginIndex pluginIndex)
+	{
+		final PluginInfo<PT> existing = get(pluginClass, pluginType, pluginIndex);
+		return existing == null ? create(pluginClass, pluginType) : existing;
+	}
+
 	// -- Helper methods --
 
 	/** Populates the entry to match the associated @{@link Plugin} annotation. */
@@ -413,4 +551,23 @@ private MenuPath parseMenuPath(final Menu[] menu) {
 		return menuPath;
 	}
 
+	/** Extracts the plugin type from a class's @{@link Plugin} annotation. */
+	private static <P extends SciJavaPlugin> Class<? super P> pluginType(
+		final Class<P> pluginClass)
+	{
+		final Plugin annotation = pluginClass.getAnnotation(Plugin.class);
+		if (annotation == null) {
+			throw new IllegalArgumentException(
+				"Cannot infer plugin type from class '" + pluginClass.getName() +
+					"' with no @Plugin annotation.");
+		}
+		final Class<?> type = annotation.type();
+		if (!type.isAssignableFrom(pluginClass)) {
+			throw new IllegalArgumentException("Invalid plugin type '" + //
+				type.getName() + "' for class '" + pluginClass.getName() + "'");
+		}
+		@SuppressWarnings("unchecked")
+		final Class<? super P> pluginType = (Class<? super P>) type;
+		return pluginType;
+	}
 }

src/main/java/org/scijava/service/ServiceHelper.java

@@ -65,7 +65,7 @@ public class ServiceHelper extends AbstractContextual {
 	 * Classes to scan when searching for dependencies. Data structure is a map
 	 * with keys being relevant classes, and values being associated priorities.
 	 */
-	private final Map<Class<? extends Service>, Double> classPoolMap;
+	private final Map<Class<? extends Service>, PluginInfo<?>> classPoolMap;
 
 	/** Classes to scan when searching for dependencies, sorted by priority. */
 	private final List<Class<? extends Service>> classPoolList;
@@ -303,9 +303,10 @@ private <S extends Service> S createServiceRecursively(final Class<S> c)
 		final S service = c.newInstance();
 		service.setContext(getContext());
 
-		// propagate priority if known
-		final Double priority = classPoolMap.get(c);
-		if (priority != null) service.setPriority(priority);
+		// propagate plugin metadata and priority if known
+		final PluginInfo<?> info = classPoolMap.get(c);
+		service.setInfo(info);
+		if (info != null) service.setPriority(info.getPriority());
 
 		// NB: If there are any @EventHandler annotated methods, we treat the
 		// EventService as a required dependency, _unless_ there is also an
@@ -358,7 +359,7 @@ private <S extends Service> S createServiceRecursively(final Class<S> c)
 
 	/** Asks the plugin index for all available service implementations. */
 	private void findServiceClasses(
-		final Map<Class<? extends Service>, Double> serviceMap,
+		final Map<Class<? extends Service>, PluginInfo<?>> serviceMap,
 		final List<Class<? extends Service>> serviceList)
 	{
 		// ask the plugin index for the (sorted) list of available services
@@ -368,8 +369,7 @@ private void findServiceClasses(
 		for (final PluginInfo<Service> info : services) {
 			try {
 				final Class<? extends Service> c = info.loadClass();
-				final double priority = info.getPriority();
-				serviceMap.put(c, priority);
+				serviceMap.put(c, info);
 				serviceList.add(c);
 			}
 			catch (final Throwable e) {

src/test/java/org/scijava/SciJavaTest.java

@@ -0,0 +1,68 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, Max Planck
+ * Institute of Molecular Cell Biology and Genetics, University of
+ * Konstanz, and KNIME GmbH.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+import org.scijava.plugin.PluginInfo;
+
+/**
+ * Tests {@link SciJava}.
+ * 
+ * @author Curtis Rueden
+ */
+public class SciJavaTest {
+
+	@Test
+	public void testInfo() {
+		final SciJava sj = new SciJava();
+
+		final PluginInfo<?> infoFromObject = sj.getInfo();
+		final PluginInfo<?> infoFromServiceNoType = //
+			sj.plugin().getPlugin(SciJava.class);
+		final PluginInfo<Gateway> infoFromServiceWithType = //
+			sj.plugin().getPlugin(SciJava.class, Gateway.class);
+		assertSame(infoFromServiceNoType, infoFromObject);
+		assertSame(infoFromServiceWithType, infoFromObject);
+
+		assertNotNull(infoFromObject);
+		assertSame(Gateway.class, infoFromObject.getPluginType());
+
+		assertEquals(Priority.NORMAL, sj.getPriority(), 0);
+
+		sj.dispose();
+	}
+}