Skip to main content

Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.

Jump to: navigation, search

Difference between revisions of "Texo"

(→‎Interested Parties)
(154 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 
==Introduction==
 
==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 [http://www.eclipse.org/emf Eclipse Modeling Framework (EMF)] and [http://www.eclipse.org/modeling/emft/ Eclipse Modeling Framework Technology (EMFT)] projects. Texo is a proposed open source component in the [http://www.eclipse.org/modeling/emft/ Eclipse Modeling Framework Technology (EMFT)] project.
+
'''Texo''' supports EMF-model concepts in (web)server environments through JPA-annotated code generation and JSON web service functionality at runtime.  
  
−
This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process document) and is written to declare its intent and scope. This proposal is written to solicit additional participation and input from the Eclipse community. You are invited to comment on and/or join the component. Please send all feedback to the eclipse.technology.emft newsgroup (please prefix the subject with [texo]).  
+
For the latest news on Texo visit the [http://martintaal.wordpress.com/category/texo/ Texo blog].
  
−
==Background==
+
Texo uses components currently present in the [http://www.eclipse.org/emf Eclipse Modeling Framework (EMF)] and [http://www.eclipse.org/modeling/emft/ Eclipse Modeling Framework Technology (EMFT)] projects.  
−
Although EMF is very popular in RCP and Eclipse tool development environments, it is largely unknown in the web application development world. This eventhough web application development projects can benefit greatly from template and model-driven techniques such as provided by the Eclipse Modeling Framework. Model and template driven generation techniques are especially usefull for data-driven web applications. In this environment standard templates for common web-ui constructs (e.g. file-upload, one-to-many editing etc.) can result in large productivity gains in the development phase and increase the quality of the developed solution. In addition, runtime availability of the domain model (like EMF provides) is very usefull in a web application for supporting common tasks such as import/export and security and tracking and tracing.
+
  
−
The Texo project will provide web application development teams with EMF-like functionality. The solution is targeted to small as well as larger teams. Smaller teams can benefit from the availability of high-quality and function-rich templates, larger teams can benefit from the extendability of the proposed solution.
+
Texo (incubation) is an open source component in the [http://www.eclipse.org/modeling/emft/ Eclipse Modeling Framework Technology (EMFT)] project.
  
−
The solution should be complete in that it should support generation of most (if not all) artifacts which are relevant for a web application project: java beans, ui-backing beans, property files, configuration files, navigation definitions etc. Next to delivering a focused toolset to support artifact generation, the solution will provide a set of high-quality, function-rich templates for common web application constructs. These templates can be overridden and extended by users of the solution.
 
  
−
==Scope==
+
[[Image:texo-client-server.png|center|600px]]
−
The initial scope of the Texo project is to provide generation functionality for the following artifact types:
+
−
# Java Bean classes: annotated pojos which are specifically annotated for different target platforms (for example Spring)
+
−
# UI backing beans: in the web app environment views are typically backed by a backing bean which provides access to the model and handle ui-specific actions. Initially the focus will be on backing beans for JSF
+
−
# Bean configuration: web frameworks offer different ways of configuring backing and model beans, the solution will initially support JSF
+
−
# I18n support: generation of property files for i18n of labels, possibly resource backing beans to provide labels for specific web frameworks
+
−
# Page flow: JSF provides a navigation model, also Spring Web Flow and other frameworks have their own navigation model, initially the focus will be on supporting the generation of JSF navigation definitions.
+
−
# Web Page: generation of JSF web pages using macro templates for complete web pages and micro templates for generating ui-code for specific efeatures covering for example one-to-many editing, many-to-one, primitive list types, primitive type editing, etc.
+
  
−
Initially the solution will focus on application generation for JSF (with Ajax components) environments with Facelets and Spring/Seam as target server side frameworks.
+
== Benefits of using Texo ==
  
−
In a later phase the following topics are covered:
+
Benefits of using current Texo (November 2012):
−
# Extend UI component support: within another initiative, the Presentation Modeling Framework, a ui-model for standard dialogs and ui-use-cases is being developed. Texo will build further upon this standard ui-model and provide an implementation specific for JSF web application environments.
+
* Code Generation:
−
# Generation of test cases: test cases and a test-driven approach are an important part of any development project. However developing testcases is often considered to be tedious work by many developers. A solution which can also automatically generate test cases or at least skeletons for test cases will make it much easier for web developers to adopt a test-driven approach and will result in higher quality and more robust web applications.
+
** [[#Code_generation_topics|Generates]]''' true pojo's from an Ecore/Xcore model or XSD''' without direct compile time link from generated entities to EMF, Texo or other framework types. '''Facilitates integration of EMF concepts with other frameworks''' such as Google Web Toolkit or Object Relational Mapping solutions
−
# Merging of generated and manually edited artifacts: merging of generated and manually edited artifacts is important for supporting an incremental development scenario. The solution will use JMerge for java code merging. Many generated artifacts (jsf, configuration files) are however expressed in xml. There are currently no solutions for automatic merging of generated xml pages. This topic will therefore require more study and will be covered in a later phase. Also merging of property files will be handled in a later phase.
+
** Supports '''manual change of generated code''' (the same approach as EMF)
 +
** '''[[Template_Overriding|Overridable and Extendable code generation]]''' with support for EMF-like merge, formatting, import-organizing
  
−
==Description==
+
* '''[[#ORM.2FJPA_generation_topics|ORM/JPA generation]]''', Texo generates JPA annotations in the source code or can generate the orm.xml mapping from the ecore/xcore models, there are specific JPA model annotations which can be used to control JPA/ORM generation.
−
The use scenario of the solution: the user of the solution starts from an ecore model. The ecore model can be enriched with additional jpa and ui annotations. By right-clicking on an ecore model and selecting a Texo menu option a separate view opens which shows the epackages and eclasses in a tree structure. When right-clicking on an eclass the user can select from the available (i.e. registered) generation workflows and generate a set of artifacts for that eclass (and its ui/jpa annotations) using the selected workflow. On project level it is possible to define some common generation properties, for example target project.
+
  
−
The solution consists of the following parts:
+
* Supports most '''XML Schema constructs''' (as EMF)
−
* Toolset
+
−
* (UI) Annotations
+
−
* Templates for java beans, JSF pages, etc.
+
−
* Runtime layer
+
  
−
===(UI)Annotations===
+
* Generic CRUD and Query web service layer: [[JSON_REST_Web_Services|JSON]] as well as [[XML_REST_Web_Services|XML]]
−
Annotations play an important role in the solution. The solution will define a set of ui annotations which can be used on model level. The ui annotations will control how model elements are translated to ui dialogs. An example of a ui annotation is the @Password which tags a String EFeature of being a password field which needs to be displayed/edited in a specific way, other annotations are for example @File for fileupload, @Text(lines=2) to denote a text box instead of a single line string, etc.
+
  
−
In addition Texo will support standard annotation definitions such as jpa and other framework specific annotation sets.
+
* '''[[#Runtime_topics|Runtime support]]''': model@runtime, key to implementing generic functionality as security, archiving, query generation and generic web services.
  
−
The current ui-annotation model can be found [http://www.elver.org/uiannotation.ecore here].
+
* [[Direct_Java_Annotations|Support]] for '''java annotations''' and '''annotations defined in the model''', to drive code generation and to be translated into java source code annotation
  
−
===Templates===
+
New functionality which is being developed right now gives these additional benefits:
−
Templates are an important part of the solution as they should implement best-practices for web application development. Templates define the usability of the solution. See the artifact types above for a list of the template types which will be provided. Templates are initially developed using the m2t XPand language. The user can override templates and work flow definitions using the XPand and MWE aspect oriented techniques. In addition it will be possible to extend the artifact generation
+
* '''Multiple annotation models''' (JPA, Hibernate Search, etc.) supported
−
tooling with own templates and work flows. This extendability will be supported through extension points and through scanning of current development
+
* '''Generic RIA/HTML5 model maintenance UI'''
−
projects for template and work flow definitions. This is similar to how current EMF works.
+
  
−
===Persistence===
+
These developments will give additional benefits in terms of increased developer productiviy and quality.
−
The solution will make use of the Teneo project to generate jpa annotations in the source code. The generated jpa code will be fully standards compliant. This means that the generated annotated pojos can be used in any jpa enabled environment.  
+
  
−
===Runtime===
+
== Download & Install ==
−
At runtime there will also be support for a model-driven development philosophy. At runtime the domain model will be provided using an in-memory representation (provided by EMF). For example it will be possible to identify the EClass for a specific pojo and instantiate a pojo using the EClass. The runtime support will also include (de-)serialization for xmi/xml.
+
  
−
===Tooling===
+
Texo is installed through the Eclipse update manager. For more details see the [[Texo/Download_and_Install|Download & Install]] page.
−
The tooling will mainly support easy selection of an eclass and generating artifacts for the selected eclass. In addition the tooling will support extendability of templates and work flows.
+
  
−
===Styling/Look===
+
== Quick Start ==
−
Styling is an important topic in a web application. The solution should generate web applications which are nice to look at. The user should want to use and demo the generated web application right from the start. Styling is covered in the templates.
+
  
−
===Design Principles===
+
The [[Texo/QuickStart|quick start]] page lets you generate code in just a few steps...
−
The solution will be developed using the following main principles:
+
−
* Simple, low cost of entry: the solution should be simple to use and users should not require an extensive modeling background, it should be possible to create a model and generate a fully working app in less than 10 minutes.
+
−
* Generate standard code/artifacts: the generated code and artifacts should conform as much as possible to the standard way-of-working in the target environments.
+
−
* No framework, generate!: the runtime part of the solution should be as small as possible, the focus is on generating artifacts not on replacing them by additional frameworks. The only exception is runtime support for in-memory models which is often not supplied by web frameworks.
+
−
* Generate a good-looking directly usable app: the goal of the solution is to generate web applications which users want to use and demo right out-of-the-box.  
+
  
−
==Relationship with other Eclipse-based Projects==
+
== Documentation ==
−
Texo will build upon and make use of the following Eclipse projects/components:
+
−
* [http://www.eclipse.org/emf EMF]: ecore, jmerge and xmi serialization
+
−
* [http://wiki.eclipse.org/Ecore_Tools Ecore Tools project]: maintenance of ecore models and code generation integration
+
−
* [http://www.eclipse.org/modeling/m2t/?project=xpand#xpand M2T - XPAND]: templates and artifact generation
+
−
* [http://wiki.eclipse.org/Modeling_Workflow_Engine_%28MWE%29 MWE]: for artifact generation workflow
+
−
* [http://www.eclipse.org/modeling/emft/?project=teneo Teneo]: model to jpa persistence generation
+
  
−
In addition the generated artifacts will be maintainable using tools provided by the following Eclipse projects:
+
The following pages contain detailed information on different parts of the Texo solution.  
−
* [http://www.eclipse.org/webtools/jsf/main.php JSF Tools project]
+
−
* [http://www.eclipse.org/webtools/dali/main.php Dali project]
+
  
−
==Organization==
+
=== Blog ===
 +
For general announcement and other information visit the [http://martintaal.wordpress.com/category/texo/ Texo Blog].
  
−
===Initial Committers===
+
=== Code generation topics ===
−
* Martin Taal
+
* [[Texo/Generate_Artifacts|Code Generation Introduction]]: describes how to generate code from one or more xsd/ecore/xcore files.
 +
* [[Texo/Code_Generation_Details|Code Generation Details]]: describes how the code generation can be controlled in detail by annotating the model.
 +
* [[Texo/Automatic_Code_Generation|Automatic Code Generation]]: code can be generated automatically when a model file is changed.
 +
* [[Texo/Integrate code generation in a build|Generate code as part of a build]]: discusses how you can integrate Texo artifact generation within your automated build process.
 +
* [[Texo/Code_Generation_Patterns|Code Generation Patterns]]: discusses several common code generation patterns which are supported by Texo (as a default or through setting annotations).
 +
* [[Texo/Template_Overriding|Extending/Overriding Code generation]]: discusses how the Texo templates can be overridden in a development project, while still maintaining the advantages of using Texo (EMF-like-merge, organize-import, formatting).
 +
* [[Texo/Direct_Java_Annotations|Java annotations from model-to-code]]: Texo can transfer java annotations defined in the model into the generated code.
  
−
===Code Contributions===
+
=== ORM/JPA generation topics ===
−
Code will be completely new, based on current experience with code generation in web application environments.
+
* [[Texo/Generate_JPA-ORM_Introduction|ORM/JPA Generation Introduction]]: introduces the ORM generation implemented by Texo.
 +
* [[Texo/ORM_JPA_Options|ORM/JPA Generation Options]]: you can set generation options at development project level.
 +
* [[Texo/ORM_JPA_Annotations_Details|ORM/JPA Annotations Model]]: for even more control on ORM/JPA generation, the model can be annotated with ORM/JPA annotations.
  
−
===Interested Parties===
+
=== Runtime topics ===
−
* Ed Merks, IBM
+
−
* Jim van Dam, Hipes
+
−
* Dimitar Giormov, SAP
+
  
−
==Tentative Plan==
+
==== JPA/Persistence integration ====
−
* April/May 2008: proposal
+
* [[Texo/EntityManagerHandling|EntityManager]]: describes how Texo generated code and Texo framework code integrates with the EntityManagerFactory.
−
* June 2008: pojo/backing bean generation, initial tooling
+
* [[Texo/Dao|DAO support, Texo generated Dao classes]]: Texo is capable of generating Dao classes which make it easier to query and access objects in the database, in addition the generated Dao classes support cross referencing functionality.
−
* July 2008: templates for standard UI components, JSF page and navigation generation  
+
* [[Texo/ObjectStore|Object Store concept]]: the object store integrates the Texo model layer with the JPA layer. You can query the database using EClasses and do cross-reference checks.
−
* September 2008: first fully functional and public release, incl property files and configuration file generation
+
 
 +
==== XML/JSON REST Web Service Support ====
 +
* [[Texo/JSON_REST_Web_Services|JSON REST Web Services]]
 +
* [[Texo/XML_REST_Web_Services|XML REST Web Services]]
 +
 
 +
==== Framework ====
 +
* [[Texo/Components|Components]]: discusses how you can replace internal Texo components with your own implementation to override specific Texo behavior.
 +
* [[Texo/Runtime_Model|Runtime Model]]: describes the runtime model access to Texo generated objects.
 +
 
 +
==== RCP Persistence using EMF Resources and Texo ====
 +
* [[Texo/EMFResource|Texo EMF Resource]]: describes the implementation of Texo EMF resources allowing you to persist data from your RCP in a 2- and 3-tier architecture.
 +
 
 +
==== EMF/XML/XMI ====
 +
* [[Texo/XML and XMI Serialization|XML-XMI Serialization]]: covers the main api to convert Texo generated pojo's from and to XML and XMI.
 +
* [[Texo/Convert to EMF|EMF Conversion]]: discusses the Texo-EMF conversion API which make it possible to convert any Texo generated pojo from/to an EObject. This is useful for when you want to make use of other EMF components like EMF Compare.
 +
* [[Texo/Xcore Support|Xcore Support]]: Texo supports xcore in the same way as standard ecore and xsd files. You can generate JPA annotated code, orm.xml etc. directly from an xcore file.
 +
 
 +
==== Miscellaneous ====
 +
* [[Texo/Test_Data_Generation|Test data generation]]: Texo is tested with about 40 models, the test-cases involve conversion from and to EMF, XML and XMI. An important foundation of the test cases is the automatic generation of test data on the basis of the model. This gives a better test coverage and makes it very easy to add new test models to the system and integrate them in the main test runs.
 +
 
 +
== Main Design Concepts ==
 +
 
 +
The Texo project is based on a number of main design concepts and philosophies.
 +
* Annotated Models and Model Annotations: Texo uses annotated models for artifact generation. The goal is to support multiple annotation models (JPA, model oriented, etc.), model annotations can be converted to java annotations or other output. Annotations are set manually and further created by Model Annotators.
 +
* Runtime model: Texo (just as EMF) supports working with the domain model at runtime. Texo generates Model wrappers to give generated pojo's a Model api.
 +
* Working with generated artifacts: Texo follows the same philosophy as EMF: generated code can be manually changed, manual changes will be kept/maintained when re-generating the code.
 +
 
 +
For a more detailed description visit the [[Texo/Design%20Concepts|Design Concepts]] 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 in Java. There are however several distinctive differences between the approach chosen and code generation implemented by EMF and Texo. This is covered in detail on [[Texo/Texo_and_EMF|this page]].
 +
 
 +
== Support & Troubleshooting & Bugzilla ==
 +
 
 +
For troubleshooting and issues encountered by other users see the [[Texo/Troubleshooting|trouble shooting]] page.
 +
 
 +
To enter a new bugzilla you can use the following link:
 +
 
 +
https://bugs.eclipse.org/bugs/enter_bug.cgi?product=EMFT&component=Texo&version=0.5
 +
 
 +
Support is given on the EMFT newsgroup which you can find here:
 +
* nntp: news://news.eclipse.org/eclipse.technology.emft
 +
* forum: http://www.eclipse.org/forums/eclipse.technology.emft
 +
 
 +
== Developing ==
 +
 
 +
Developer information (GIT, how to setup a developers environment) can be found on the [[Texo/Developing|Developers]] page.
 +
 
 +
== Future Topics ==
 +
 
 +
This is a list of future topics which we may (or may not) work on in the future, it is a list of ideas:
 +
* develop a generic (and extendable) mobile/html5 model editor which can/should support most models out of the box
 +
* use this generic model editor as a basis for a generated model editor in html5/mobile
 +
* support code generation which generates separate source files which can be manually changed, so not following the @generated pattern used in standard EMF
 +
* integrate with full text indexing and search for the JSON/XML web service layer, incorporate this in the generic model editor
 +
* support for no-sql databases on the server side
 +
* integrate with OLAP/Mondrian solutions, back-end and front-end
 +
 
 +
Feel free to react on the EMFT newsgroup with more ideas.
 +
 
 +
== See also ==
 +
 
 +
* [[Teneo]]
 +
* [[CDO]]
 +
 
 +
[[Category:EMFT]] [[Category:EMF]] [[Category:Texo]]

Revision as of 05:41, 14 December 2013

Introduction

Texo supports EMF-model concepts in (web)server environments through JPA-annotated code generation and JSON web service functionality at runtime.

For the latest news on Texo visit the Texo blog.

Texo uses components currently present in the Eclipse Modeling Framework (EMF) and Eclipse Modeling Framework Technology (EMFT) projects.

Texo (incubation) is an open source component in the Eclipse Modeling Framework Technology (EMFT) project.


Texo-client-server.png

Benefits of using Texo

Benefits of using current Texo (November 2012):

  • Code Generation:
    • Generates true pojo's from an Ecore/Xcore model or XSD without direct compile time link from generated entities to EMF, Texo or other framework types. Facilitates integration of EMF concepts with other frameworks such as Google Web Toolkit or Object Relational Mapping solutions
    • Supports manual change of generated code (the same approach as EMF)
    • Overridable and Extendable code generation with support for EMF-like merge, formatting, import-organizing
  • ORM/JPA generation, Texo generates JPA annotations in the source code or can generate the orm.xml mapping from the ecore/xcore models, there are specific JPA model annotations which can be used to control JPA/ORM generation.
  • Supports most XML Schema constructs (as EMF)
  • Generic CRUD and Query web service layer: JSON as well as XML
  • Runtime support: model@runtime, key to implementing generic functionality as security, archiving, query generation and generic web services.
  • Support for java annotations and 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:

  • Multiple annotation models (JPA, Hibernate Search, etc.) supported
  • Generic RIA/HTML5 model maintenance UI

These developments will give additional benefits in terms of increased developer productiviy and quality.

Download & Install

Texo is installed through the Eclipse update manager. For more details see the Download & Install page.

Quick Start

The quick start page lets you generate code in just a few steps...

Documentation

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

Blog

For general announcement and other information visit the Texo Blog.

Code generation topics

ORM/JPA generation topics

Runtime topics

JPA/Persistence integration

  • EntityManager: describes how Texo generated code and Texo framework code integrates with the EntityManagerFactory.
  • DAO support, Texo generated Dao classes: Texo is capable of generating Dao classes which make it easier to query and access objects in the database, in addition the generated Dao classes support cross referencing functionality.
  • Object Store concept: the object store integrates the Texo model layer with the JPA layer. You can query the database using EClasses and do cross-reference checks.

XML/JSON REST Web Service Support

Framework

  • Components: discusses how you can replace internal Texo components with your own implementation to override specific Texo behavior.
  • Runtime Model: describes the runtime model access to Texo generated objects.

RCP Persistence using EMF Resources and Texo

  • Texo EMF Resource: describes the implementation of Texo EMF resources allowing you to persist data from your RCP in a 2- and 3-tier architecture.

EMF/XML/XMI

  • XML-XMI Serialization: covers the main api to convert Texo generated pojo's from and to XML and XMI.
  • EMF Conversion: discusses the Texo-EMF conversion API which make it possible to convert any Texo generated pojo from/to an EObject. This is useful for when you want to make use of other EMF components like EMF Compare.
  • Xcore Support: Texo supports xcore in the same way as standard ecore and xsd files. You can generate JPA annotated code, orm.xml etc. directly from an xcore file.

Miscellaneous

  • Test data generation: Texo is tested with about 40 models, the test-cases involve conversion from and to EMF, XML and XMI. An important foundation of the test cases is the automatic generation of test data on the basis of the model. This gives a better test coverage and makes it very easy to add new test models to the system and integrate them in the main test runs.

Main Design Concepts

The Texo project is based on a number of main design concepts and philosophies.

  • Annotated Models and Model Annotations: Texo uses annotated models for artifact generation. The goal is to support multiple annotation models (JPA, model oriented, etc.), model annotations can be converted to java annotations or other output. Annotations are set manually and further created by Model Annotators.
  • Runtime model: Texo (just as EMF) supports working with the domain model at runtime. Texo generates Model wrappers to give generated pojo's a Model api.
  • Working with generated artifacts: Texo follows the same philosophy as EMF: generated code can be manually changed, manual changes will be kept/maintained when re-generating the code.

For a more detailed description visit the Design Concepts 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 in Java. There are however several distinctive differences between the approach chosen and code generation implemented by EMF and Texo. This is covered in detail on this page.

Support & Troubleshooting & Bugzilla

For troubleshooting and issues encountered by other users see the trouble shooting page.

To enter a new bugzilla you can use the following link:

https://bugs.eclipse.org/bugs/enter_bug.cgi?product=EMFT&component=Texo&version=0.5

Support is given on the EMFT newsgroup which you can find here:

Developing

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

Future Topics

This is a list of future topics which we may (or may not) work on in the future, it is a list of ideas:

  • develop a generic (and extendable) mobile/html5 model editor which can/should support most models out of the box
  • use this generic model editor as a basis for a generated model editor in html5/mobile
  • support code generation which generates separate source files which can be manually changed, so not following the @generated pattern used in standard EMF
  • integrate with full text indexing and search for the JSON/XML web service layer, incorporate this in the generic model editor
  • support for no-sql databases on the server side
  • integrate with OLAP/Mondrian solutions, back-end and front-end

Feel free to react on the EMFT newsgroup with more ideas.

See also

Retrieved from "https://wiki.eclipse.org/index.php?title=Texo&oldid=353690"

Back to the top