Merge branch 'run-classes'

This migrates the JavaRunner plugin type, and corresponding JavaService,
from the scijava/scripting-java component, and generalizes them to
support running other flavors of code besides Java classes.

This branch also introduces a ParseService which generalizes and exposes
the ScriptInfo parseAttrs method as public API, backed by the new
SciJava Expression Parser 3.0.0.

Thanks to these new services, the "--run" CLI flag is now implemented by
a single ConsoleArgument plugin (org.scijava.run.console.RunArgument),
which leans on the RunService and ParseService to do most of the work.

Closes #226.

Author: ctrueden

pom.xml

@@ -10,7 +10,7 @@
 	</parent>
 
 	<artifactId>scijava-common</artifactId>
-	<version>2.53.2-SNAPSHOT</version>
+	<version>2.54.0-SNAPSHOT</version>
 
 	<name>SciJava Common</name>
 	<description>SciJava Common is a shared library for SciJava software. It provides a plugin framework, with an extensible mechanism for service discovery, backed by its own annotation processor, so that plugins can be loaded dynamically. It is used by both ImageJ and SCIFIO.</description>

src/main/java/org/scijava/command/console/RunArgument.java

@@ -44,25 +44,22 @@
 import org.scijava.plugin.Plugin;
 
 /**
- * Handles the {@code --run} command line argument.
- *
- * @author Curtis Rueden
- * @author Johannes Schindelin
- * @author Mark Hiner hinerm at gmail.com
+ * @deprecated Use {@link org.scijava.run.console.RunArgument} instead.
  */
+@Deprecated
 @Plugin(type = ConsoleArgument.class)
 public class RunArgument extends AbstractConsoleArgument {
 
 	@Parameter
 	private CommandService commandService;
 
 	@Parameter
-	private LogService logService;
+	private LogService log;
 
 	// -- Constructor --
 
 	public RunArgument() {
-		super(2, "--run", "--class");
+		super(2, "--class");
 	}
 
 	// -- ConsoleArgument methods --
@@ -72,7 +69,10 @@ public void handle(final LinkedList<String> args) {
 		if (!supports(args))
 			return;
 
-		args.removeFirst(); // --run
+		log.warn("The --class flag is deprecated, and will\n" +
+			"be removed in a future release. Use --run instead.");
+
+		args.removeFirst(); // --class
 		final String commandToRun = args.removeFirst();
 		final String paramString = ConsoleUtils.hasParam(args) ? args.removeFirst() : "";
 
@@ -100,12 +100,12 @@ private void run(final String commandToRun, final String optionString) {
 			return;
 
 		// TODO: parse the optionString a la ImageJ1
-		final Map<String, Object> inputMap = ConsoleUtils.parseParameterString(optionString, info, logService);
+		final Map<String, Object> inputMap = ConsoleUtils.parseParameterString(optionString, info, log);
 
 		try {
 			commandService.run(info, true, inputMap).get();
 		} catch (final Exception exc) {
-			logService.error(exc);
+			log.error(exc);
 		}
 	}
 

src/main/java/org/scijava/command/run/CommandCodeRunner.java

@@ -0,0 +1,113 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2016 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * 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.command.run;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Map;
+
+import org.scijava.command.Command;
+import org.scijava.command.CommandInfo;
+import org.scijava.command.CommandService;
+import org.scijava.plugin.Parameter;
+import org.scijava.plugin.Plugin;
+import org.scijava.run.AbstractCodeRunner;
+import org.scijava.run.CodeRunner;
+
+/**
+ * Runs the given {@link Command} class.
+ * 
+ * @author Curtis Rueden
+ */
+@Plugin(type = CodeRunner.class)
+public class CommandCodeRunner extends AbstractCodeRunner {
+
+	@Parameter
+	private CommandService commandService;
+
+	// -- CodeRunner methods --
+
+	@Override
+	public void run(final Object code, final Object... args)
+		throws InvocationTargetException
+	{
+		final Class<? extends Command> c = getCommandClass(code);
+		if (c != null) waitFor(commandService.run(c, true, args));
+
+		final CommandInfo info = getCommandInfo(code);
+		if (info != null) waitFor(commandService.run(info, true, args));
+	}
+
+	@Override
+	public void run(final Object code, final Map<String, Object> inputMap)
+		throws InvocationTargetException
+	{
+		final Class<? extends Command> c = getCommandClass(code);
+		if (c != null) waitFor(commandService.run(c, true, inputMap));
+
+		final CommandInfo info = getCommandInfo(code);
+		if (info != null) waitFor(commandService.run(info, true, inputMap));
+	}
+
+	// -- Typed methods --
+
+	@Override
+	public boolean supports(final Object code) {
+		return getCommandClass(code) != null || getCommandInfo(code) != null;
+	}
+
+	// -- Helper methods --
+
+	private Class<? extends Command> getCommandClass(final Object code) {
+		if (!(code instanceof Class)) return null;
+		final Class<?> c = (Class<?>) code;
+		if (!Command.class.isAssignableFrom(c)) return null;
+		@SuppressWarnings("unchecked")
+		final Class<? extends Command> commandClass = (Class<? extends Command>) c;
+		return commandClass;
+	}
+
+	private CommandInfo getCommandInfo(final Object code) {
+		if (!(code instanceof String)) return null;
+		final String command = (String) code;
+
+		final CommandInfo info = commandService.getCommand(command);
+		if (info != null) return info;
+
+		// command was not a class name; search for command by title instead
+		for (final CommandInfo ci : commandService.getCommands()) {
+			if (command.equals(ci.getTitle())) return ci;
+		}
+
+		return null;
+	}
+
+}

src/main/java/org/scijava/console/AbstractConsoleArgument.java

@@ -86,4 +86,17 @@ public Class<LinkedList<String>> getType() {
 	protected boolean isFlag(final LinkedList<String> args) {
 		return flags.isEmpty() || flags.contains(args.getFirst());
 	}
+
+	/**
+	 * If the next argument is an appropriate parameter to a
+	 * {@link ConsoleArgument}, retrieves it; otherwise, returns null.
+	 *
+	 * @return The first argument of the given list, if it does not
+	 *         start with a {@code '-'} character; or null otherwise.
+	 */
+	protected String getParam(final LinkedList<String> args) {
+		if (args.isEmpty()) return null;
+		final String arg = args.getFirst();
+		return arg.startsWith("-") ? null : arg;
+	}
 }

src/main/java/org/scijava/console/ConsoleUtils.java

@@ -39,45 +39,33 @@
 import org.scijava.log.LogService;
 import org.scijava.module.ModuleInfo;
 import org.scijava.module.ModuleItem;
+import org.scijava.parse.ParseService;
 
-/**
- * Helper class for {@link ConsoleArgument}s.
- *
- * @author Mark Hiner hinerm at gmail.com
- */
+/** @deprecated Use alternatives instead (see individual method docs). */
+@Deprecated
 public final class ConsoleUtils {
 
-	/**
-	 * @see #parseParameterString(String, ModuleInfo, LogService)
-	 */
+	/** @deprecated Use {@link ParseService} instead. */
+	@Deprecated
 	public static Map<String, Object> parseParameterString(final String parameterString) {
 		return parseParameterString(parameterString, (CommandInfo)null);
 	}
 
-	/**
-	 * @see #parseParameterString(String, ModuleInfo, LogService)
-	 */
+	/** @deprecated Use {@link ParseService} instead. */
+	@Deprecated
 	public static Map<String, Object> parseParameterString(final String parameterString, final ModuleInfo info) {
 		return parseParameterString(parameterString, info, null);
 	}
 
-	/**
-	 * @see #parseParameterString(String, ModuleInfo, LogService)
-	 */
-	public static Map<String, Object> parseParameterString(final String parameterString, final LogService logService) {
-		return parseParameterString(parameterString, null, logService);
+	/** @deprecated Use {@link ParseService} instead. */
+	@Deprecated
+	public static Map<String, Object> parseParameterString(final String parameterString, final LogService log) {
+		return parseParameterString(parameterString, null, log);
 	}
 
-	/**
-	 * Helper method for turning a parameter string into a {@code Map} of
-	 * key:value pairs. If a {@link ModuleInfo} is provided, the parameter
-	 * string is assumed to be a comma-separated list of values, ordered
-	 * according to the {@code ModuleInfo's} inputs. Otherwise, the parameter
-	 * string is assumed to be a comma-separated list of "key=value" pairs.
-	 *
-	 * TODO reconcile with attribute parsing of {@link ScriptInfo}
-	 */
-	public static Map<String, Object> parseParameterString(final String parameterString, final ModuleInfo info, final LogService logService) {
+	/** @deprecated Use {@link ParseService} instead. */
+	@Deprecated
+	public static Map<String, Object> parseParameterString(final String parameterString, final ModuleInfo info, final LogService log) {
 		final Map<String, Object> inputMap = new HashMap<String, Object>();
 
 		if (!parameterString.isEmpty()) {
@@ -93,8 +81,8 @@ public static Map<String, Object> parseParameterString(final String parameterStr
 				else if (inputs != null && inputs.hasNext() && split.length == 1) {
 					inputMap.put(inputs.next().getName(), split[0]);
 				}
-				else if (logService != null)
-					logService.error("Parameters must be formatted as a comma-separated list of key=value pairs");
+				else if (log != null)
+					log.error("Parameters must be formatted as a comma-separated list of key=value pairs");
 
 			}
 		}
@@ -104,12 +92,10 @@ else if (logService != null)
 	}
 
 	/**
-	 * Test if the next argument is an appropriate parameter to a
-	 * {@link ConsoleArgument}.
-	 *
-	 * @return {@code true} if the first argument of the given list does not
-	 *         start with a {@code '-'} character.
+	 * @deprecated Use {@link AbstractConsoleArgument#getParam(LinkedList)}
+	 *             instead.
 	 */
+	@Deprecated
 	public static boolean hasParam(final LinkedList<String> args) {
 		return !(args.isEmpty() || args.getFirst().startsWith("-"));
 	}

src/main/java/org/scijava/console/HeadlessArgument.java

@@ -42,7 +42,7 @@
  * and the enclosing {@link Context} will not be used after the
  * {@link ConsoleService} argument processing is complete.
  *
- * @author Mark Hiner hinerm at gmail.com
+ * @author Mark Hiner
  */
 @Plugin(type = ConsoleArgument.class)
 public class HeadlessArgument extends AbstractConsoleArgument {

src/main/java/org/scijava/convert/CastingConverter.java

@@ -39,7 +39,7 @@
 /**
  * Minimal {@link Converter} implementation to do direct casting.
  *
- * @author Mark Hiner hinerm at gmail.com
+ * @author Mark Hiner
  */
 @Plugin(type = Converter.class, priority = Priority.FIRST_PRIORITY)
 public class CastingConverter extends AbstractConverter<Object, Object> {