Texo

Introduction

The goal of the proposed Texo project is to provide model and template driven development technology for web application development projects. Texo will be based on and use components currently present in the Eclipse Modeling Framework (EMF) and Eclipse Modeling Framework Technology (EMFT) projects. Texo is a proposed open source component in the Eclipse Modeling Framework Technology (EMFT) project.

The original project proposal can be found here.

Benefits of using Texo

Benefits of using current Texo (January 2010):

• Code Generation:
  • Generates true pojo's from an ecore model or XSD without direct compile time link to EMF, Texo or other framework types. Facilitates integration with other frameworks such as Google Web Toolkit or Object Relational Mapping solutions
  • Supports manual change of generated code (the same approach as EMF)
  • Code generation based on easy readable and overridable templates
• XML support
  • Supports XML Schema constructs (as EMF)
  • XML and XMI Serialization
• Runtime model support, key to implementing generic functionality as security, archiving, query generation and generic web service.
• Supports annotations defined in the model, to drive code generation and to be translated into java source code annotation

New functionality which is being developed right now gives these additional benefits:

• Artifact generation can be controlled in detail using model annotations.
• Multiple annotation models (JPA, Hibernate Search, etc.) supported
• Easy integration with RIA user interface through a generic model-driven JSON service

Further in the future, Texo will be extended to generate the web user interface layer. This will give additional benefits in terms of increased developer productiviy and quality.

Texo Components

The initial release of Texo will consist of several components:

• Code generation for server oriented applications with support for in-model and in-source annotations, manual code changes are supported in the EMF way. Templates can be added/overridden by users.
• XML Serialization
• Tool support for creating annotated models
• JPA annotation generation
• Model-driven JSON serialization support

Next phase:

• Add more annotation models (for example: Hibernate Search, jaxb, Seam, EJB3)
• The next phase will focus on generating User Interface code for GWT or RIA frameworks such as Smartclient or Extjs.
• Test case/class generation

Documentation

The following pages contain detailed information on different parts of the Texo solution:

• ModelGenerator: describes the model generator functionality of Texo including the ModelGenerator annotations which can be used to drive influence the code generation.
• EMF Conversion: describes how Texo generated pojo's can be converted to EMF EObjects. This is very useful for when you want to make use of other EMF components like EMF Compare.
• XML Serialization: covers the main api to convert Texo generated pojo's from and to XML.
• JSON Web Service: describes how the model-driven JSON webservice is implemented and how it can be used by RIA web ui's
• Test data generation: Texo is tested with about 20 models, the testcases involve conversion from and to EMF, XML and XMI. An important foundation of the test cases is that the data is automatically generated on the basis of the model. This makes it very easy to add new test models to the system and integrate them in the main test runs.

Developing

Developer information (CVS, how to setup a developers environment) can be found on the Developers page.

Texo and EMF

Texo is related to EMF and makes use of specific EMF components. Both Texo and EMF generate java code representing an ecore model. There are however many distinctive differences between the approach chosen and code generation implemented by EMF and Texo. This is covered in detail on this page.

Eclipse Components and Projects used by Texo

• EMF Ecore: for runtime model support
• EMF XMI/XML: for XML Serialization
• Xpand/Xtend: for code generation
• MWE: code generation workflow
• JMerge (part of EMF): for merging generated code with
• JDT: for postprocessing of generated classes (organize imports)

The build environment has been setup using Buckminster and Hudson.

For the future (generation of web ui's) the Presentation Framework Project will probably be used.

Current Status

Currently (January 2010) the following has been implemented:

• pojo generation with runtime model
• Featuremap support
• XML Serialization

We are currently working on:

• Code generation: EOperation support, support for unsettable
• Support template overriding
• Model-driven JSON service
• some initial tool support for creating annotated models
• JPA Annotation model

In the next phase support for Generic/Parameterized types will be added.