Add a rudimentary input validation mechanism

Now, if you want to validate that the value of an input is
acceptable, you can specify a validater method which will be
called when that input is marked as resolved.

Admittedly, this is a bit late in the module execution process,
and dynamic validation would still be nice in the future (e.g., to
provide feedback as values are updated in input harvester UIs).
But the good thing about this scheme is that regardless of which
preprocessor locks in the parameter value, validation will be
called immediately afterward, before the next preprocessor runs.

Thanks to Richard Domander for the idea and discussion.

Author: ctrueden

src/main/java/org/scijava/command/CommandModuleItem.java

@@ -123,6 +123,11 @@ public String getInitializer() {
 		return getParameter().initializer();
 	}
 
+	@Override
+	public String getValidater() {
+		return getParameter().validater();
+	}
+
 	@Override
 	public String getCallback() {
 		return getParameter().callback();

src/main/java/org/scijava/module/AbstractModule.java

@@ -149,6 +149,16 @@ public boolean isOutputResolved(final String name) {
 
 	@Override
 	public void resolveInput(final String name) {
+		final ModuleItem<?> item = getInputItem(name);
+		if (item != null) {
+			try {
+				item.validate(this);
+			}
+			catch (final MethodCallException exc) {
+				// NB: Hacky, but avoids changing the API signature.
+				throw new RuntimeException(exc);
+			}
+		}
 		resolvedInputs.add(name);
 	}
 
@@ -181,4 +191,10 @@ private Map<String, Object> createMap(final Iterable<ModuleItem<?>> items,
 		return map;
 	}
 
+	private ModuleItem<?> getInputItem(final String name) {
+		for (final ModuleItem<?> item : getInfo().inputs()) {
+			if (item.getName().equals(name)) return item;
+		}
+		return null;
+	}
 }

src/main/java/org/scijava/module/AbstractModuleItem.java

@@ -56,6 +56,7 @@ public abstract class AbstractModuleItem<T> extends AbstractBasicDetails
 	private final ModuleInfo info;
 
 	private MethodRef initializerRef;
+	private MethodRef validaterRef;
 	private MethodRef callbackRef;
 
 	public AbstractModuleItem(final ModuleInfo info) {
@@ -200,6 +201,20 @@ public void initialize(final Module module) throws MethodCallException {
 		initializerRef.execute(module.getDelegateObject());
 	}
 
+	@Override
+	public String getValidater() {
+		return null;
+	}
+
+	@Override
+	public void validate(final Module module) throws MethodCallException {
+		final Object delegateObject = module.getDelegateObject();
+		if (validaterRef == null) {
+			validaterRef = new MethodRef(delegateObject.getClass(), getValidater());
+		}
+		validaterRef.execute(module.getDelegateObject());
+	}
+
 	@Override
 	public String getCallback() {
 		return null;

src/main/java/org/scijava/module/DefaultMutableModuleItem.java

@@ -57,6 +57,7 @@ public class DefaultMutableModuleItem<T> extends AbstractModuleItem<T>
 	private boolean persisted;
 	private String persistKey;
 	private String initializer;
+	private String validater;
 	private String callback;
 	private String widgetStyle;
 	private T defaultValue;
@@ -162,6 +163,11 @@ public void setInitializer(final String initializer) {
 		this.initializer = initializer;
 	}
 
+	@Override
+	public void setValidater(final String validater) {
+		this.validater = validater;
+	}
+
 	@Override
 	public void setCallback(final String callback) {
 		this.callback = callback;
@@ -255,6 +261,11 @@ public String getInitializer() {
 		return initializer;
 	}
 
+	@Override
+	public String getValidater() {
+		return validater;
+	}
+
 	@Override
 	public String getCallback() {
 		return callback;

src/main/java/org/scijava/module/ModuleItem.java

@@ -123,6 +123,16 @@ public interface ModuleItem<T> extends BasicDetails {
 	 */
 	void initialize(Module module) throws MethodCallException;
 
+	/** Gets the function that is called to validate the item's value. */
+	String getValidater();
+
+	/**
+	 * Invokes this item's validation function, if any, on the given module.
+	 * 
+	 * @see #getValidater()
+	 */
+	void validate(Module module) throws MethodCallException;
+
 	/**
 	 * Gets the function that is called whenever this item changes.
 	 * <p>

src/main/java/org/scijava/module/MutableModuleItem.java

@@ -56,6 +56,8 @@ public interface MutableModuleItem<T> extends ModuleItem<T> {
 
 	void setInitializer(String initializer);
 
+	void setValidater(String validater);
+
 	void setCallback(String callback);
 
 	void setWidgetStyle(String widgetStyle);

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

@@ -38,6 +38,7 @@
 
 import org.scijava.ItemIO;
 import org.scijava.ItemVisibility;
+import org.scijava.module.Module;
 
 /**
  * An annotation for indicating a field is an input or output parameter. This
@@ -119,6 +120,14 @@
 	/** Defines a function that is called to initialize the parameter. */
 	String initializer() default "";
 
+	/**
+	 * Defines a function that is called to validate the parameter value after it
+	 * is marked as resolved.
+	 * 
+	 * @see Module#resolveInput(String)
+	 */
+	String validater() default "";
+
 	/**
 	 * Defines a function that is called whenever this parameter changes.
 	 * <p>

src/main/java/org/scijava/script/ScriptInfo.java

@@ -488,6 +488,7 @@ private <T> void assignAttribute(final DefaultMutableModuleItem<T> item,
 		else if (is(k, "columns")) item.setColumnCount(as(v, int.class));
 		else if (is(k, "description")) item.setDescription(as(v, String.class));
 		else if (is(k, "initializer")) item.setInitializer(as(v, String.class));
+		else if (is(k, "validater")) item.setValidater(as(v, String.class));
 		else if (is(k, "type")) item.setIOType(as(v, ItemIO.class));
 		else if (is(k, "label")) item.setLabel(as(v, String.class));
 		else if (is(k, "max")) item.setMaximumValue(as(v, item.getType()));