Eclipse Advanced Scripting Environment (EASE)

×

Warning message

Committer Arthur Daussy must create an Eclipse Foundation Account.
×

Status message

This proposal has been approved and the Eclipse Advanced Scripting Environment (EASE) project has been created.
Basics

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the community. Please add your feedback in the comments section.

Parent Project: 
Background: 

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.

Scope: 

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.

Included components:

  • script interpreters for dedicated scripting languages
    (such as rhino, jython, groovy, ruby, nashorn - depending on their licensing policy)
  • UI components
    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
Description: 

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:

  1. Execute scripts within the running IDE.
  2. Support multiple script languages via a generic service that creates (multiple) script interpreters.
  3. Scripts are capable of interacting with the IDE, like accessing classes on the Eclipse/JRE classpath and calling methods upon them.
  4. Seamless integration of scripts into UI
  5. Scripts should be attachable to toolbars and menus
  6. Debuggers are aware of the script language/Java classes co-existence by providing variables access
  7. Provide means to sign scripts.
Why Here?: 

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!

Project Scheduling: 

An initial contribution is already available. A first release is planned with Luna (but not as part of the release train).

Future Work: 

Planned functionality:

  1. Implement a Jython debugger
  2. Implement Groovy and JRuby if possible (due to licensing issues)
  3. Implement a visual way of writing scripts by using Sirius
  4. Security mechanism to validate scripts before execution (avoid malicious scripts from external sources)

Community efforts:

  1. Jython debugger planned as GSoC project.
  2. EclipseCon Talks (continued)
  3. Different companies and communities already interested in the project (TOPCASED, Obeo)
  4. Blog, Twitter, the usual way of advertising :)

 

People
Project Leads: 
Committers: 
Interested Parties: 

Airbus

PolarSys

Source Code
Initial Contribution: 

There exists already a code contribution hosted in the e4 incubator project. It is maintained by two committers and already provides a lot of initial functionality. The EASE project will grow out of the permanent incubator and start providing releases.

The current status includes the core scripting framework with a JavaScript engine, launch support, debug support and a neat extension mechanism for script libraries. Currently a lot of these libraries focus on the modelling and EMF.

Source Repository Type: 

Comments

pgaufillet's picture

Hi!

This proposal is a great piece of news (thanks Christian :)

Can you please add AIRBUS and PolarSys as interested parties? It would be nice also to say somewhere that it includes model-oriented (EMF/UML) scripting modules. Note also that TOPCASED is a project / community, not a company.

Pierre

cpontesegger's picture

Thanks for the comments Pierre. I updated the proposal accordingly.