Eclipse allows users to write source code for various languages. To programmatically add functionality to Eclipse itself, one needs to undergo a quite complicated procedure in writing Java code, packaging it as plug-ins, hosting them on an update site, and finally installing as a feature in the target application.
With scripting embedded in the IDE itself, users may enrich their application by adding new functionality to the IDE by simply providing script files and registering them using preferences. Users are not necessarily bound to install new features, they might simply consume scripts available on the network. In contrast to simply executing scripts externally, embedding means that the scripts have access to the current Eclipse runtime and JRE.
Scripting also allows to automate everyday tasks, and provides a simple playground for developers to try out new things without the need of writing boilerplate code to make test features callable from the UI.
EASE provides a uniform environment to create, store, modify and execute user generated scripts that run within the Eclipse RCP context.
Such scripts typically make use of the components of the running Eclipse application, although this is not mandatory.
script interpreters for dedicated scripting languages
(such as rhino, jython, groovy, ruby, nashorn - depending on their licensing policy)
like run targets, debugger, script management, consoles and workspace integration
common libraries to be used by script interpreters for most common used tasks
(workspace interaction, UI interaction)
Security mechanisms allowing to sign/verify scripts
as scripts may be consumed from external sources, users should be able to execute signed scripts only or get warnings on unsigned scripts
EASE allows the execution of script code (using scripting languages such as JS, Python, ...) within the context of the Eclipse Platform/RCP. As they are running in the same JRE as Eclipse itself, these scripts have direct access to any class of your application and may interact with your workbench.
Through keywords within header data, scripts might be integrated seamlessly into the UI as toolbar and/or menu contributions. Thus the functionality could be extended by providing scripts only. No need to build, export and install a new feature, just provide a script and add it to your application at runtime.
Scripting allows to easily extend an existing application, helps in automating everyday tasks and aids in rapid prototyping during application development.
Following goals for the project have been defined:
- Execute scripts within the running IDE.
- Support multiple script languages via a generic service that creates (multiple) script interpreters.
- Scripts are capable of interacting with the IDE, like accessing classes on the Eclipse/JRE classpath and calling methods upon them.
- Seamless integration of scripts into UI
- Scripts should be attachable to toolbars and menus
- Debuggers are aware of the script language/Java classes co-existence by providing variables access
- Provide means to sign scripts.
Script languages are already used by several projects (like BIRT, XORED) but there is no common approach to manage scripts and interpreters. This project should provide a centralized platform for all your scripting needs!
An initial contribution is already available. A first release is planned with Luna (but not as part of the release train).
- Implement a Jython debugger
- Implement Groovy and JRuby if possible (due to licensing issues)
- Implement a visual way of writing scripts by using Sirius
- Security mechanism to validate scripts before execution (avoid malicious scripts from external sources)
- Jython debugger planned as GSoC project.
- EclipseCon Talks (continued)
- Different companies and communities already interested in the project (TOPCASED, Obeo)
- Blog, Twitter, the usual way of advertising :)