Can't use several times the same JSR-223 ScriptContext for differents groovy script

I have a vague idea about what you want but am not sure of the specifics. Can what you are asking for be expressed in a simple Groovy script calling back into Groovy via JSR-223 or is it tightly coupled to xwiki?

To see if I am slightly on track, can you take a look here:
http://webtest.canoo.com/webtest/manual/scriptStep.html
at the 'keep' attribute and its use in the 'GroovyTrafficLightWithKeepTest' test.
Is this the kind of thing you want but for JSR-223 not BSF? Basically a shared binding or is that not what you want?

No it's not specific to XWiki but i don't know groovy very well. To reproduce the use cas i have in XWiki simply in java:

// The script context is shared between all engines called in the same request so it's created "by hand" and not asked to one specific engine
ScriptContext scriptContext = new SimpleScriptContext();

ScriptEngineManager sem = new ScriptEngineManager();

ScriptEngine engine1 = sem.getEngineByName("groovy");
StringWriter stringWriter1 = new StringWriter();
scriptContext.setWriter(stringWriter1);
engine.eval("print \"world1\"", scriptContext)
System.out.print(stringWriter1.toString())

ScriptEngine engine2 = sem.getEngineByName("groovy");
StringWriter stringWriter2 = new StringWriter();
scriptContext.setWriter(stringWriter1);
engine.eval("print \"word2\"", scriptContext)
System.out.print(stringWriter2.toString())

This print only word1 because in the second call the engine does not take into account what is configured in the ScriptContext.

This is what append in XWiki when the script macro is called twice like in:

{{script language="groovy"}}
print "word1"
{{/script}}
{{script language="groovy"}}
print "word1"
{{/script}}

Basically a shared binding or is that not what you want?

Yes something like that, i want to use the same ScriptContext binding for several different script and engines.

(Seems i can't edit my comment)
I made a mistake: it's scriptContext.setWriter(stringWriter2); and not scriptContext.setWriter(stringWriter1); the second time

So, to restate your comments - to make sure I am clear - the script below produces 'world1' but you would also like 'world2':

import javax.script.*
import static javax.script.ScriptContext.ENGINE_SCOPE

def context = new SimpleScriptContext()
def sem = new ScriptEngineManager()

def engine1 = sem.getEngineByName("groovy")
def sw1 = new StringWriter()
context.writer = sw1
engine1.eval("print 'world1'", context)
println sw1.toString()

def engine2 = sem.getEngineByName("groovy")
def sw2 = new StringWriter()
context.writer = sw2
//context.setAttribute("out", sw2, ENGINE_SCOPE)
engine2.eval("print 'world2'", context)
println sw2.toString()

You don't want to uncomment the commented out line as that looks to be an internal thing.
Also, I presume that using sw2 is being forced upon you? You can't just keep using sw1. Is that correct? Otherwise I see no problem.

Now my remaining question is how to fix for your case but still leave variables in place normally. The idea being if you don't change the context, any binding variable set in the first snippet would be available in the second.

Again as a workaround, what about just adding this line before the second eval:

context.removeAttribute("context", ENGINE_SCOPE)

I don't think we want to remove 'out' or 'context' as they provide fairly standard hooks back to the output stream and engine respectively - while the script is running.
E.g. your script might use 'out << 'hello'' or you might use the context to set a attribute or something.

Perhaps the fix for Groovy is to include that as the last line inside the eval method. Perhaps 'out' also. They will both be added back in if needed with a very small performance hit.

context.removeAttribute("context", ENGINE_SCOPE) is what i do currently for groovy but it's a hack, i should not have to do it. Removing a binding that should not be there to make sure the configuration is taken into account does not makes sense to me.

Be able to use 'out << 'hello' in a groovy script mean that it has to be in the internal groovy binding not in the ScriptContext. Also even if out is useful it's not a common JSR-223 reserved keyword so if anyone want to use this binding for something else it will not work even it should. IMO JSR-223 implementation should set as less binding as possible and let JSR-223 API user set needed bindings.

The script context is cleaned up (no more 'context' and 'out') and setting the writer on the script context is now taken into account.

Great, thanks !

You're welcome Thomas!
We'll be releasing Groovy 1.6.5 tomorrow, so you'll be able to use that fix soon