DATAMONGO-479 - Add support for calling functions.

Use more explicit wording and add methods for checking existence of functions via name as well as listing names of available scripts. Updated javaDoc and reference documentation.

Author: christophstrobl

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultScriptOperations.java

@@ -19,22 +19,26 @@
 import static org.springframework.data.mongodb.core.query.Criteria.*;
 import static org.springframework.data.mongodb.core.query.Query.*;
 
-import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
+import org.bson.types.ObjectId;
 import org.springframework.dao.DataAccessException;
 import org.springframework.data.mongodb.core.script.CallableMongoScript;
-import org.springframework.data.mongodb.core.script.MongoScript;
+import org.springframework.data.mongodb.core.script.ServerSideJavaScript;
 import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
 import com.mongodb.DB;
 import com.mongodb.MongoException;
 
 /**
- * Default implementation of {@link ScriptOperations} capable of saving and executing simple {@link MongoScript}.
+ * Default implementation of {@link ScriptOperations} capable of saving and executing {@link ServerSideJavaScript}.
  * 
  * @author Christoph Strobl
  * @since 1.7
@@ -53,6 +57,7 @@ public class DefaultScriptOperations implements ScriptOperations {
 	public DefaultScriptOperations(MongoOperations mongoOperations) {
 
 		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
+
 		this.mongoOperations = mongoOperations;
 	}
 
@@ -61,17 +66,12 @@ public DefaultScriptOperations(MongoOperations mongoOperations) {
 	 * @see org.springframework.data.mongodb.core.ScriptOperations#save(org.springframework.data.mongodb.core.script.MongoScript)
 	 */
 	@Override
-	public CallableMongoScript save(MongoScript script) {
+	public CallableMongoScript register(ServerSideJavaScript script) {
 
 		Assert.notNull(script, "Script must not be null!");
-		CallableMongoScript callableScript = null;
-
-		if (script instanceof CallableMongoScript) {
-			callableScript = (CallableMongoScript) script;
-		} else {
-			callableScript = new CallableMongoScript(generateScriptName(), script);
-		}
 
+		CallableMongoScript callableScript = (script instanceof CallableMongoScript) ? (CallableMongoScript) script
+				: new CallableMongoScript(generateScriptName(), script);
 		mongoOperations.save(callableScript, SCRIPT_COLLECTION_NAME);
 		return callableScript;
 	}
@@ -81,41 +81,83 @@ public CallableMongoScript save(MongoScript script) {
 	 * @see org.springframework.data.mongodb.core.ScriptOperations#execute(org.springframework.data.mongodb.core.script.MongoScript, java.lang.Object[])
 	 */
 	@Override
-	public Object execute(final MongoScript script, final Object... args) {
+	public Object execute(final ServerSideJavaScript script, final Object... args) {
 
 		Assert.notNull(script, "Script must not be null!");
+
+		if (script instanceof CallableMongoScript) {
+			return call(((CallableMongoScript) script).getName(), args);
+		}
+
 		return mongoOperations.execute(new DbCallback<Object>() {
 
 			@Override
 			public Object doInDB(DB db) throws MongoException, DataAccessException {
 
-				if (script instanceof CallableMongoScript) {
+				Assert.notNull(script.getCode(), "Script.code must not be null!");
+
+				return db.eval(script.getCode(), convertScriptArgs(args));
+			}
+		});
+	}
 
-					String evalString = ((CallableMongoScript) script).getName() + "(" + convertAndJoinScriptArgs(args) + ")";
-					return db.eval(evalString);
-				}
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#call(java.lang.String, java.lang.Object[])
+	 */
+	@Override
+	public Object call(final String scriptName, final Object... args) {
 
-				Assert.notNull(script.getCode(), "Script.code must not be null!");
-				return db.eval(script.getCode().toString(), convertScriptArgs(args));
+		Assert.hasText(scriptName, "ScriptName must not be null or empty!");
+
+		return mongoOperations.execute(new DbCallback<Object>() {
+
+			@Override
+			public Object doInDB(DB db) throws MongoException, DataAccessException {
+
+				String evalString = scriptName + "(" + convertAndJoinScriptArgs(args) + ")";
+				return db.eval(evalString);
 			}
 		});
 	}
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.ScriptOperations#load(java.io.Serializable)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#exists(java.lang.String)
+	 */
+	@Override
+	public Boolean exists(String scriptName) {
+
+		Assert.hasText(scriptName, "ScriptName must not be null or empty!");
+
+		return mongoOperations.exists(query(where("name").is(scriptName)), CallableMongoScript.class,
+				SCRIPT_COLLECTION_NAME);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#scriptNames()
 	 */
 	@Override
-	public CallableMongoScript load(Serializable name) {
+	public Set<String> scriptNames() {
 
-		Assert.notNull(name, "Name must not be null!");
-		return mongoOperations.findOne(query(where("name").is(name)), CallableMongoScript.class, SCRIPT_COLLECTION_NAME);
+		List<CallableMongoScript> scripts = (mongoOperations.findAll(CallableMongoScript.class, SCRIPT_COLLECTION_NAME));
+
+		if (CollectionUtils.isEmpty(scripts)) {
+			return Collections.emptySet();
+		}
+
+		Set<String> scriptNames = new HashSet<String>();
+		for (CallableMongoScript script : scripts) {
+			scriptNames.add(script.getName());
+		}
+		return scriptNames;
 	}
 
 	/**
-	 * Generate a valid name for the script. MongoDB requires a script id of type String. Calling scripts having ObjectId
-	 * as id fails. Therefore we create a random UUID without {@code -} (as this won't work) an prefix the result with
-	 * {@link #SCRIPT_NAME_PREFIX}.
+	 * Generate a valid name for the {@literal JavaScript}. MongoDB requires an id of type String for scripts. Calling
+	 * scripts having {@link ObjectId} as id fails. Therefore we create a random UUID without {@code -} (as this won't
+	 * work) an prefix the result with {@link #SCRIPT_NAME_PREFIX}.
 	 * 
 	 * @return
 	 */

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ScriptOperations.java

@@ -15,43 +15,62 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.io.Serializable;
+import java.util.Set;
 
 import org.springframework.data.mongodb.core.script.CallableMongoScript;
-import org.springframework.data.mongodb.core.script.MongoScript;
+import org.springframework.data.mongodb.core.script.ServerSideJavaScript;
+
+import com.mongodb.DB;
 
 /**
- * Script operations on {@link com.mongodb.DB} level.
+ * Script operations on {@link com.mongodb.DB} level. Allows interaction with server side {@literal JavaScript}
+ * functions.
  * 
  * @author Christoph Strobl
  * @since 1.7
  */
 public interface ScriptOperations {
 
 	/**
-	 * Saves given {@literal script} to currently used {@link com.mongodb.DB}.
+	 * Store given {@literal script} to {@link com.mongodb.DB} so it can be called via its name.
 	 * 
 	 * @param script must not be {@literal null}.
-	 * @return
+	 * @return {@link CallableMongoScript} with name under which the {@literal JavaScript} function can be called.
 	 */
-	CallableMongoScript save(MongoScript script);
+	CallableMongoScript register(ServerSideJavaScript script);
 
 	/**
-	 * Executes the {@literal script} by either calling it via its {@literal _id} or directly sending it.
+	 * Executes the {@literal script} by either calling it via its {@literal name} or directly sending it.
 	 * 
 	 * @param script must not be {@literal null}.
 	 * @param args arguments to pass on for script execution.
 	 * @return the script evaluation result.
 	 * @throws org.springframework.dao.DataAccessException
 	 */
-	Object execute(MongoScript script, Object... args);
+	Object execute(ServerSideJavaScript script, Object... args);
+
+	/**
+	 * Call the {@literal JavaScript} by its name.
+	 * 
+	 * @param scriptName must not be {@literal null} or empty.
+	 * @param args
+	 * @return
+	 */
+	Object call(String scriptName, Object... args);
+
+	/**
+	 * Checks {@link DB} for existence of {@link ServerSideJavaScript} with given name.
+	 * 
+	 * @param scriptName must not be {@literal null} or empty.
+	 * @return false if no {@link ServerSideJavaScript} with given name exists.
+	 */
+	Boolean exists(String scriptName);
 
 	/**
-	 * Retrieves the {@link CallableMongoScript} by its {@literal id}.
+	 * Returns names of {@literal JavaScript} functions that can be called.
 	 * 
-	 * @param name
-	 * @return {@literal null} if not found.
+	 * @return empty {@link Set} if no scripts found.
 	 */
-	CallableMongoScript load(Serializable name);
+	Set<String> scriptNames();
 
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java

@@ -20,6 +20,7 @@
 import java.net.MalformedURLException;
 import java.net.URL;
 
+import org.bson.types.Code;
 import org.bson.types.ObjectId;
 import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.TypeDescriptor;
@@ -201,11 +202,7 @@ public CallableMongoScript convert(DBObject source) {
 			String id = source.get("_id").toString();
 			Object rawValue = source.get("value");
 
-			if (rawValue != null) {
-				return new CallableMongoScript(id, rawValue.toString());
-			}
-
-			return new CallableMongoScript(id);
+			return new CallableMongoScript(id, rawValue.toString());
 		}
 	}
 
@@ -229,7 +226,7 @@ public DBObject convert(CallableMongoScript source) {
 
 			builder.append("_id", source.getName());
 			if (source.getCode() != null) {
-				builder.append("value", source.getCode());
+				builder.append("value", new Code(source.getCode()));
 			}
 
 			return builder.get();

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/script/CallableMongoScript.java

@@ -15,37 +15,27 @@
  */
 package org.springframework.data.mongodb.core.script;
 
-import org.bson.types.Code;
 import org.springframework.data.annotation.Id;
 import org.springframework.util.Assert;
 
 /**
- * A {@link MongoScript} implementation that allows calling the function by its {@literal id} once it has been saved to
- * the {@link com.mongodb.DB} instance.
+ * A {@link ServerSideJavaScript} implementation that allows calling the function by its {@literal name} once it has
+ * been saved to the {@link com.mongodb.DB} instance.
  * 
  * @author Christoph Strobl
  * @since 1.7
  */
-public class CallableMongoScript implements MongoScript {
+public class CallableMongoScript implements ServerSideJavaScript {
 
 	private final @Id String name;
-	private final MongoScript script;
-
-	/**
-	 * Creates new {@link CallableMongoScript} that uses the given {@literal id} to call the function on the server.
-	 * 
-	 * @param name must not be {@literal null} or {@literal empty}.
-	 */
-	public CallableMongoScript(String name) {
-		this(name, (MongoScript) null);
-	}
+	private final ServerSideJavaScript script;
 
 	/**
 	 * Creates new {@link CallableMongoScript} that can be saved to the {@link com.mongodb.DB} instance.
 	 * 
 	 * @param name must not be {@literal null} or {@literal empty}.
-	 * @param rawScript the {@link String} representation of the javascript function. Must not be {@literal null} or
-	 *          {@literal empty}.
+	 * @param rawScript the {@link String} representation of the {@literal JavaScript} function. Must not be
+	 *          {@literal null} or {@literal empty}.
 	 */
 	public CallableMongoScript(String name, String rawScript) {
 		this(name, new ExecutableMongoScript(rawScript));
@@ -57,7 +47,7 @@ public CallableMongoScript(String name, String rawScript) {
 	 * @param name must not be {@literal null} or {@literal empty}.
 	 * @param script can be {@literal null}.
 	 */
-	public CallableMongoScript(String name, MongoScript script) {
+	public CallableMongoScript(String name, ServerSideJavaScript script) {
 
 		Assert.hasText(name, "Name must not be null or empty!");
 		this.name = name;
@@ -69,7 +59,7 @@ public CallableMongoScript(String name, MongoScript script) {
 	 * @see org.springframework.data.mongodb.core.script.MongoScript#getCode()
 	 */
 	@Override
-	public Code getCode() {
+	public String getCode() {
 
 		if (script == null) {
 			return null;
@@ -79,7 +69,7 @@ public Code getCode() {
 	}
 
 	/**
-	 * Get the id of the callable script.
+	 * Get the name of the {@link CallableMongoScript} script.
 	 * 
 	 * @return
 	 */

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/script/ExecutableMongoScript.java

@@ -15,37 +15,36 @@
  */
 package org.springframework.data.mongodb.core.script;
 
-import org.bson.types.Code;
 import org.springframework.util.Assert;
 
 /**
- * {@link MongoScript} implementation that can be saved or directly executed.
+ * {@link ServerSideJavaScript} implementation that can be saved or directly executed.
  * 
  * @author Christoph Strobl
  * @since 1.7
  */
-public class ExecutableMongoScript implements MongoScript {
+public class ExecutableMongoScript implements ServerSideJavaScript {
 
-	private final String rawScript;
+	private final String code;
 
 	/**
 	 * Creates new {@link ExecutableMongoScript}.
 	 * 
-	 * @param rawScript must not be {@literal null} or {@literal empty}.
+	 * @param code must not be {@literal null} or {@literal empty}.
 	 */
-	public ExecutableMongoScript(String rawScript) {
+	public ExecutableMongoScript(String code) {
 
-		Assert.hasText(rawScript, "RawScript must not be null or empty!");
-		this.rawScript = rawScript;
+		Assert.hasText(code, "Code must not be null or empty!");
+		this.code = code;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.script.MongoScript#getCode()
 	 */
 	@Override
-	public Code getCode() {
-		return new Code(this.rawScript);
+	public String getCode() {
+		return this.code;
 	}
 
 }