ecore

Ecore (EMOF) JavaScript Implementation

Ecore (EMOF) implementation in JavaScript.

Download Ecore.js from dist/ folder, and include it in your html along with underscore.js.

<script src="underscore.js"></script>
<script src="ecore.js"></script>

Alternatively you can use the dependency manager Bower to install Ecore.js in your project.

bower install ecore

Ecore.js is available on npm and can be use as a Node module. To install it simply use the following command from your terminal:

npm install ecore

Importing Ecore.js in a Node module is done as follow:

var Ecore = require('ecore');
 
// Resources contain model elements and are identified by a URI. 
 
var resourceSet = Ecore.ResourceSet.create();
var resource = resourceSet.create({ uri: '/model.json' });
 
// EClass are used to define domain elements, they are identified 
// by name and a set of structural features (attributes and references). 
 
var User = Ecore.EClass.create({
    name: 'User',
    eStructuralFeatures: [
        // EAttributes are used to define domain elements 
        // elements properties. 
        Ecore.EAttribute.create({
            name: 'name',
            upperBound: 1,
            eType: Ecore.EString
        }),
        // EReferences are used to define links between domain 
        // elements. 
        Ecore.EReferences.create({
            name: 'friends',
            upperBound: -1,
            containment: false,
            eTypefunction() { return User; }
        })
    ]
});
 
// EPackages represent namespaces for a set of EClasses. 
// It's properties name, nsURI and nsPrefix must be set. 
 
var SamplePackage = Ecore.EPackage.create({
    name: 'sample',
    nsURI: 'http://www.example.org/sample',
    nsPrefix: 'sample',
    eClassifiers: [
        User
    ]
});
 
// Packages must be added directly to the model's Resource. 
 
resource.add(SamplePackage);
 

Model Elements can also be created separately.

var User = Ecore.EClass.create({ name: 'User' });
var User_name = Ecore.EAttribute.create({
   name: 'name',
   eType: Ecore.EString
});
var User_friends = Ecore.EReference.create({
   name: 'friends',
   upperBound: -1,
   eType: User
});
User.get('eStructuralFeatures').add(User_name);
User.get('eStructuralFeatures').add(User_friends);
var u1 = User.create({ name: 'u1' });
var u2 = User.create({ name: 'u2' });
u1.get('friends').add(u2);
 
u1.get('friends').each(function(friend) { console.log(friend) });

JSON is the default serialization format supported by ecore.js. The JSON format is described here and looks like this:

{
    "eClass" : "/model.json#//User",
    "name" : "u1",
    "friends" : [
        { "$ref" : '/u2.json#/', eClass: '/model.json#//User' },
        { "$ref" : '/u3.json#/', eClass: '/model.json#//User' }
    ]
}

Support for XMI has been added in version 0.3.0. This support requires sax.js.

var resourceSet = Ecore.ResourceSet.create();
var resource = resourceSet.create({ uri: 'test2.xmi' });
 
resource.parse(data, Ecore.XMI); // data being a string containing the XMI. 
 
resource.to(Ecore.XMI, true); // returns the XMI string 
 
  • create(eClass): EObject
  • create(): Resource
  • getEObject(uri): EObject
  • add(value)
  • addAll(values)
  • clear()
  • each(iterator, [context])
  • save([sucess], [error])
  • load([sucess], [error], [data])
  • toJSON(): Object
  • getEObject(fragment): EObject
  • has(property): Boolean
  • isSet(property): Boolean
  • set(property, value)
  • get(property): EObject or EList
  • isTypeOf(type): Boolean
  • isKindOf(type): Boolean
  • eResource(): Resource
  • eURI(): String
  • getEStructuralFeature(name)
  • add(element)
  • addAll(elements)
  • remove(element)
  • size()
  • at(position)
  • first()
  • last()
  • rest(index)
  • each(iterator, [context])
  • filter(iterator, [context])
  • find(iterator, [context])
  • map(iterator, [context])
  • reject(iterator, [context])
  • contains(iterator, [context])
  • indexOf(iterator, [context])

If you want to contribute to this project or simply build from the source, you first need to clone the project by executing the following command in your terminal.

> git clone https://github.com/ghillairet/ecore.js.git

To build the project or run the tests you first need to install Node, npm (distributed with Node) and Grunt.

Once these are installed, go back to your terminal and enter the ecore.js directory.

> cd ecore.js

The tests are written using the mocha library. To run them, execute the following command:

> grunt test

Running a build will create a new distribution in the folder dist. This is done by executing the command:

> grunt build

That's it, you are now ready to contribute to the project.

  • add events
  • add XMI support
  • add support for derived features
  • add support for eOperations
  • add ResourceSet
  • add Resource support
  • add JSON parsing serialization
  • add new syntax to define EModelElements
  • move create methods to Ecore
  • initial version
  • bootstraps ecore model

This software is distributed under the terms of the Eclipse Public License 1.0 - http://www.eclipse.org/legal/epl-v10.html.