use of groovy.lang.Script in project groovy-core by groovy.
the class InvokerHelperTest method testCreateScriptWithNullClass.
public void testCreateScriptWithNullClass() {
Script script = InvokerHelper.createScript(null, new Binding(bindingVariables));
assertEquals(bindingVariables, script.getBinding().getVariables());
}
use of groovy.lang.Script in project grails-core by grails.
the class DefaultUrlMappingEvaluatorTests method testResourceMappingsWithVersionAndNamespace.
public void testResourceMappingsWithVersionAndNamespace() throws Exception {
GroovyShell shell = new GroovyShell();
Binding binding = new Binding();
// Resource Entry: "/api/foo"(resources:"foo", version:'1.0', namespace:'v1')
Script script = shell.parse("mappings = {\n" + "\"/api/foo\"(resources: 'foo', version: '1.0', namespace: 'v1')\n" + "}");
script.setBinding(binding);
script.run();
Closure closure = (Closure) binding.getVariable("mappings");
List<UrlMapping> mappings = evaluator.evaluateMappings(closure);
assertTrue(mappings.size() > 0);
//Check that version and namespace are correct for each mapping
for (UrlMapping mapping : mappings) {
assertEquals("1.0", mapping.getVersion());
assertEquals("v1", mapping.getNamespace());
}
}
use of groovy.lang.Script in project grails-core by grails.
the class DefaultUrlMappingEvaluatorTests method testNewMethod.
public void testNewMethod() throws Exception {
GroovyShell shell = new GroovyShell();
Binding binding = new Binding();
Script script = shell.parse("mappings = {\n" + " \"/$controller/$action?/$id?\" { \n" + " constraints {\n" + " id(matches:/\\d+/)\n" + " }\n" + " }\n" + "}\n");
script.setBinding(binding);
script.run();
Closure closure = (Closure) binding.getVariable("mappings");
List mappings = evaluator.evaluateMappings(closure);
assertEquals(1, mappings.size());
UrlMapping mapping = (UrlMapping) mappings.get(0);
assertNull(mapping.getActionName());
assertNull(mapping.getControllerName());
assertEquals("(*)", mapping.getUrlData().getTokens()[0]);
assertEquals("(*)?", mapping.getUrlData().getTokens()[1]);
assertEquals("(*)?", mapping.getUrlData().getTokens()[2]);
assertNotNull(mapping.getConstraints());
assertTrue(makeSureMatchesConstraintExistsOnId(mapping));
GrailsWebRequest r = GrailsWebMockUtil.bindMockWebRequest();
UrlMappingInfo info = mapping.match("/mycontroller");
info.configure(r);
assertEquals("mycontroller", info.getControllerName());
assertNull(mapping.match("/mycontroller").getActionName());
assertNull(mapping.match("/mycontroller").getId());
UrlMappingInfo info2 = mapping.match("/mycontroller/test");
info2.configure(r);
assertEquals("test", info2.getActionName());
assertNull(mapping.match("/mycontroller/test").getId());
assertEquals("234", mapping.match("/blog/test/234").getId());
}
use of groovy.lang.Script in project grails-core by grails.
the class DefaultUrlMappingEvaluatorTests method testNamedMappings.
public void testNamedMappings() throws Exception {
GroovyShell shell = new GroovyShell();
Binding binding = new Binding();
Script script = shell.parse("mappings = {\n" + "name firstMapping: \"/first/one\" {\n" + "}\n" + "\"/second/one\" {" + "}\n" + "name thirdMapping: \"/third/one\" {\n" + "}\n" + "}");
script.setBinding(binding);
script.run();
Closure closure = (Closure) binding.getVariable("mappings");
List mappings = evaluator.evaluateMappings(closure);
assertEquals(3, mappings.size());
}
use of groovy.lang.Script in project groovy-core by groovy.
the class GroovyScriptEngineImpl method eval.
// package-privates
Object eval(Class scriptClass, final ScriptContext ctx) throws ScriptException {
// Only initialize once.
if (null == ctx.getAttribute("context", ScriptContext.ENGINE_SCOPE)) {
// add context to bindings
ctx.setAttribute("context", ctx, ScriptContext.ENGINE_SCOPE);
// direct output to ctx.getWriter
// If we're wrapping with a PrintWriter here,
// enable autoFlush because otherwise it might not get done!
final Writer writer = ctx.getWriter();
ctx.setAttribute("out", (writer instanceof PrintWriter) ? writer : new PrintWriter(writer, true), ScriptContext.ENGINE_SCOPE);
// Not going to do this after all (at least for now).
// Scripts can use context.{reader, writer, errorWriter}.
// That is a modern version of System.{in, out, err} or Console.{reader, writer}().
//
// // New I/O names consistent with ScriptContext and java.io.Console.
//
// ctx.setAttribute("writer", writer, ScriptContext.ENGINE_SCOPE);
//
// // Direct errors to ctx.getErrorWriter
// final Writer errorWriter = ctx.getErrorWriter();
// ctx.setAttribute("errorWriter", (errorWriter instanceof PrintWriter) ?
// errorWriter :
// new PrintWriter(errorWriter),
// ScriptContext.ENGINE_SCOPE);
//
// // Get input from ctx.getReader
// // We don't wrap with BufferedReader here because we expect that if
// // the host wants that they do it. Either way Groovy scripts will
// // always have readLine because the GDK supplies it for Reader.
// ctx.setAttribute("reader", ctx.getReader(), ScriptContext.ENGINE_SCOPE);
}
// Fix for GROOVY-3669: Can't use several times the same JSR-223 ScriptContext for differents groovy script
if (ctx.getWriter() != null) {
ctx.setAttribute("out", new PrintWriter(ctx.getWriter(), true), ScriptContext.ENGINE_SCOPE);
}
/*
* We use the following Binding instance so that global variable lookup
* will be done in the current ScriptContext instance.
*/
Binding binding = new Binding(ctx.getBindings(ScriptContext.ENGINE_SCOPE)) {
@Override
public Object getVariable(String name) {
synchronized (ctx) {
int scope = ctx.getAttributesScope(name);
if (scope != -1) {
return ctx.getAttribute(name, scope);
}
}
throw new MissingPropertyException(name, getClass());
}
@Override
public void setVariable(String name, Object value) {
synchronized (ctx) {
int scope = ctx.getAttributesScope(name);
if (scope == -1) {
scope = ScriptContext.ENGINE_SCOPE;
}
ctx.setAttribute(name, value, scope);
}
}
};
try {
// then simply return that class
if (!Script.class.isAssignableFrom(scriptClass)) {
return scriptClass;
} else {
// it's a script
Script scriptObject = InvokerHelper.createScript(scriptClass, binding);
// save all current closures into global closures map
Method[] methods = scriptClass.getMethods();
for (Method m : methods) {
String name = m.getName();
globalClosures.put(name, new MethodClosure(scriptObject, name));
}
MetaClass oldMetaClass = scriptObject.getMetaClass();
/*
* We override the MetaClass of this script object so that we can
* forward calls to global closures (of previous or future "eval" calls)
* This gives the illusion of working on the same "global" scope.
*/
scriptObject.setMetaClass(new DelegatingMetaClass(oldMetaClass) {
@Override
public Object invokeMethod(Object object, String name, Object args) {
if (args == null) {
return invokeMethod(object, name, MetaClassHelper.EMPTY_ARRAY);
}
if (args instanceof Tuple) {
return invokeMethod(object, name, ((Tuple) args).toArray());
}
if (args instanceof Object[]) {
return invokeMethod(object, name, (Object[]) args);
} else {
return invokeMethod(object, name, new Object[] { args });
}
}
@Override
public Object invokeMethod(Object object, String name, Object[] args) {
try {
return super.invokeMethod(object, name, args);
} catch (MissingMethodException mme) {
return callGlobal(name, args, ctx);
}
}
@Override
public Object invokeStaticMethod(Object object, String name, Object[] args) {
try {
return super.invokeStaticMethod(object, name, args);
} catch (MissingMethodException mme) {
return callGlobal(name, args, ctx);
}
}
});
return scriptObject.run();
}
} catch (Exception e) {
throw new ScriptException(e);
} finally {
// Fix for GROOVY-3669: Can't use several times the same JSR-223 ScriptContext for different groovy script
// Groovy's scripting engine implementation adds those two variables in the binding
// but should clean up afterwards
ctx.removeAttribute("context", ScriptContext.ENGINE_SCOPE);
ctx.removeAttribute("out", ScriptContext.ENGINE_SCOPE);
}
}
Aggregations