Script context

It is possible to use a global context in Scripts. Note that it is not necessary to do anything to set the context for scripts, the framework will do it "under the hood".

The context is available through the context field in your script. For example:

   public void apply() {
      context.echo("Hello World");
   }

Context interface

The context have the following interface:

Echoing messages

The following methods allow to echo simple messages:

• The ScriptContext.echo(String) method print a message in the script console area
• The ScriptContext.echo(Number) method print a numeric value
• The ScriptContext.error(String) method print an error message in the script console area

General methods

• The ScriptContext.getScriptFile() method returns the script file
• The ScriptContext.getPath(String) method returns the absolute path of a file defined relative to the script file
• The ScriptContext.getHelper() method returns the script helper
• The ScriptContext.getScriptLogger() method returns the associated ScriptLogger
• The ScriptContext.abort(String) method aborts the current script. The Scripting engine will use the throwable exception to stop the execution
• The ScriptContext.getLoggerTab() method return the current logger tab value as a String

Note that abort(String message) will abort the script. It can be listened by an Exception listener

Calling an additional script

It is possible to use a script in an installed script. It allows to have more modular code in your scripts. For example:

   public String execute() {
      var other = context.createScript("otherScript.groovy");
      return other.compute();
   }

Getting loaded scripts

These methods allow to get the Script created by the ScriptWrapper, or additional scripts knowing their name or their associated file:

• The ScriptContext.getMainScriptObject() method returns the Script created by the ScriptWrapper
• The ScriptContext.getScriptObject(File) method returns an additional script by its associated file
• The ScriptContext.getScriptObject(String) method returns an additional script by its name (without the extension)

Constraint on script languages

If the ScriptWrapper.isMultiImplementSupported() method returns true, then the scripting language implementation support having one class implementing more than one Java interface. In that case, there is no constraint on the Script.

If the ScriptWrapper.isMultiImplementSupported() method returns false, to be able to use the context, the script interface must extend the ContextListener interface. For example:

   public interface Script extends ContextListener {
     public int computeResult(int value) {
     }
   }

Note that:

• The Groovy implementation support the implementation of multiple interfaces
• The Ruby implementation does not support the implementation of multiple interfaces

Using the context

The context is available as a context field in the script. For example to show a message on the logger:

   public void execute(int value) {
     context.echo("My value:" + value);
   }

Setting a custom context

It is possible to set a context with any class implementing the ScriptContext interface by calling the:

• ScriptWrapper.setScriptContext(ScriptContext) method

Note that you can override the DefaultScriptContext class.

You will not need to do anything special in that case in your script, which will have your custom class imported by default.

Adding a Script helper

If you want to have a script helper, you must implement the ScriptContext.getHelper() Method.

Not using a context

If you don't want to use a context in your scripts, just extend the ScriptWrapper.getScriptContext() method to return null. For example:

   ScriptWrapper<Script> wrapper = new GroovyScriptWrapper<Script>() {
     protected ScriptContext getScriptContext() {
       return null;
     }
   };