Reference Documentation 2.0.0

Table of Content

Following you will find the reference documentation corresponding to the 2.0.0 version. If you need an other version use one of our released versions.


The M2Doc project provides Word document (.docx files) generation based on a document template and EMF models.

The overall approach consists in creating templates in the OOXML format where static text authoring benefits from the WYSIWYG capabilities of Microsoft Word. Dynamic parts are inserted using a dedicated vocabulary of OOXML fields code. Fields are mainly used to insert page numbers, references, etc. M2Doc makes use of them to describe documentation generation directives. This allows a total separation between the document and the M2Doc directives.


As an example, here is a fragment of a M2Doc template used to generate the documentation of a database model:

DB Template

The generation looks like this:

DB Result

The template language makes an extensive use of the Acceleo Query Language which provides a full-fledged, extensible model query language and engine. The M2Doc templates can be validated. If errors are found, an annotated templates is produced describing the problems found.


Variable definition

  • Extraction of information by navigating the model (see the Template authoring section)
    • From the entry points
    • Using model relations

Extracting information

  • Formatting of the output information
    • Using Microsoft Word functionalities

Formatting template

Main steps

Main steps

M2Doc roles

Ready to try M2Doc! You might have one of the following roles:

Template user

You already have the template and want to generate the document:

Template developer

You want to create your own template:


You want to provide document generation in your own project using M2Doc:


The main workflow:

M2Doc Workflow

The template is parsed in an internal representation (the AST). From here you can bind the variables to their values, using elements from a model for instance and evaluate the template to generate the output document. An added benefit of using M2Doc is the hability to validate a template to produce an annotated template containing informations, warnings and errors the template might contain.

The architecture of M2Doc is organized around three building blocks:

  • Apache POI for the parsing and generation of OOXML documents
  • AQL for querying the models
  • EMF as a general platform

Technical architecture

Generating a document

To generate a document you will need at least a template file (.docx file) and a generation configuration model (.genconf file). If you don’t have the template you can read the template authoring section. To create a generation model file you can read the initialize generation section.

Launching a generation

To launch a generation you can right click on the generation configuration model (.genconf file) or the Generation object and select the «Generate Documentation menu» as shown here:

The Generate Documentation menu.

If you don’t have the the generation model configuration file you can create it using the initialize generation section.

Initializing a generation configuration

To initialize a generation configuration you will need a template file (.docx file). If you don’t have the template you can read the template authoring section.

Right click on the template file and select the «Initialize Documentation Configuration» menu:

The Initialize Documentation Configuration menu.

To edit the created generation model file you can use the Generation configuration wizard or the Generation configuration editor.

Validating a generation setup

To validate a generation setup (template plus generation configuration) you can right click on the generation configuration model (.genconf file) or the Generation object and select the «Validate Documentation menu» as shown here:

The Validate Documentation menu.

If you don’t have the the generation configuration model file you can create it using the initialize generation section. If the validation succeeds with no informations, warnings, or errors you will be prompted. If something went wrong a .docx file with the name of the template and suffixed with «info», «warning», or «error» will be created. This new file contains details of the validation issues. The template is not modified.

Generation configuration wizard

You can access the generation configuration wizard in two different ways, one for creating it and one for further edition when the .genconf file already exists.

To create and initialize the generation configuration, select the template .docx file to use for generation and right click on it:

The Initialize Documentation Configuration menu.

To edit an existing generation configuration .genconf file you can select the .genconf file and right click on it:

The Edit Documentation Configuration menu.

At this point you should be on the first page of the generation configuration wizard:

The Generation Configuration Wizard.

On this page you can select the path of the generation configuration .genconf file. It can be changed to create a copy of an existing file for instance. Other file paths are relative to the generation configuration file. This allow to move a folder containing all the files needed for a generation without breaking the generation configuration. The template can be selected from the workspace or the Template registry. In the later case the path will be absolute to reference the template in the deployed plug-ins.

The next page of the wizard is dedicated to variables and binding values to them:

The Generation Configuration Wizard.

To reference new values you can load new resources using the Load resource button. Note the Options (expert) tab that allow to set advanced options to find values from a Sirius session for instance.

When the Finish button is pushed the generation configuration file is created or edited.

Generation configuration editor

Note: This editor is deprecated and will be removed in future release. Use Generation configuration wizard instead.

The generation configuration model (.genconf file) references the template URI and the result URI. It also binds the variables defined using the Template properties wizard or the template editor to the desired value. It can also contain a set of options to configure specific services.

The generation configuration editor.

In this example we reference the template named «template.docx» using a relative URI and the result URI is set to «template-generated.docx». All relative URI are relative to the .genconf file, note absolute URI can be used as well.

The first table of the editor is used to bind variables. The first column is the variable name and the second column is its value. The value can be a reference to an EMF model element, or be a primitive type value. Two menus are accessible using right click on the variable table.

The variable menu.

  • Add variables will add all variables defined in the referenced template. To define variables you can use the Template properties wizard or the template editor
  • Remove definition will remove the selected bindings

Another menu can be useful to set EMF model values. It’s the «Load Resource…» menu. It adds the EMF elements of the selected resources to possible values of a variable.

The second table of the editor at the bottom can be used to set options for specific services. For instance if you use the Sirius integration an option should be set to define the Sirius session model. Three menus are accessible using right click on the option table.

The option menu.

Note that modifying option can modify the accessible variable values. For instance after referencing a Sirius session, semantic elements of the session are accessible.

Template authoring

The template should be edited using your Microsoft Word document editor. M2Doc uses Word fields to declare dynamic elements. To make fields visible during the edition of your template in Microsoft Word, use ALT+F9. To insert a new field, use CTRL+F9.


All syntax elements of M2Doc should be placed into fields using ALT+F9 to show fields and CTRL+F9 to insert a new field. M2Doc is an imperative template language built on top of AQL for querying. The language supports type inference and can be extended using custom services.

In order to create your AQL expressions with completion and see the result for a selected object you can use the Sirius interpreter after installing Sirius. The interpreter view is as follow and you should select Sirius interpreter and prefix your expressions with aql::

Sirius interpreter.

In the following explanations { and } will denote a Word field.

Note that fields are also used by Microsoft Word page number, table of contents, … Switching from field visualization mode to field edition mode will change the visualization of the document:

Fields edition.


Fields visualization.

Comment (example)

A simple comment, nothing is generated.

{m:comment any text}

Static statement

Anything that is not a M2Doc field is generated as is.

Query (example)

The AQL expression is evaluated and its result is inserted in the generated document. M2Doc services and provided services can be used. Some specific return types will be interpreted by M2Doc.

{m:AQL expression}

Conditional (example)

If the condition is true the «then block» is inserted in the generated document. if it’s false and the «else if» condition is true the «else if block» is inserted. if all condition are false the «else block» is inserted. You can have zero or more «elseif blocks», zero or one «else block». All AQL expressions should evaluate to a Boolean.

{m:if AQL expression}

...then block...

{m:elseif AQL expression}

...else if block...


...else block...

` {m:endif}`

Repetition (example)

Generates the «repetition block» for each value of the AQL expression.

{m:for variable | AQL expression} ...repetition block... {m:endfor}

Let (example)

Declares a variable named «variable» with the result of the AQL expression as its value. The variable is accessible in the «let block».

{m:let variable = AQL expression} ...let block... {m:endlet}

Bookmark (example)

Generates a bookmark with the result of the AQL expression as identifier and the «bookmark block» as content.

{m:bookmark AQL expression} ...bookmark block... {m:endbookmark}

Generates a link to the bookmark with the given identifier and text.

{m:link AQL expression AQL expression}

The first AQL expression id the identifier and the second one is the text to display.

User Documentation (example)

Generates a user content block in the resulting document. If the generated document exists and already has a user content with the same id the previous user content is preserved, otherwise the «userdoc block» is generated.

{m:userdoc AQL expression} ...user block... {m:enduserdoc}

If a user content exists in a previously generated document and the id is not re-generated, the user content will by removed from the generated document and saved in a «lost» file.

Template construct (example)

A template construct is basically a block of template with parameters that can be called like a service. When the template construct is called its contents is inserted after all dynamic parts have been interpreted by M2Doc.

{m:template myTemplate(a : Integer, b : Integer)} ...user block... {m:endtemplate}

This template can be called as follow using a simple query:


If you want more examples of M2Doc syntax you can have a look at the nominal cases in unit tests.


All AQL services are available. On top of that, specific services are provided by M2Doc. See the following reference documentation. If you don’t find your needs in this list, you can provide custom services.

Template properties wizard

To open the template properties wizard, you can select a template .docx file and right click on it:

The Edit Template properties menu.

The first page of the wizard let you select template metamodels and services packages.

The Edit Template properties wizard.

Note you can also use the nsURI (expert) and Services (expert) to select metamodels and services manually.

The second page is dedicated to variable declarations. The list of declarations is initialized from the variable used in the template.

The Edit Template properties wizard.

The M2Doc version to use with this template can be changed on this page. Not having this property set will trigger a warning while validating with M2Doc 2.0.0 or above.

Template editor

Note: This editor is deprecated and will be removed in future release. Use Template properties wizard instead.

The template editor can set M2Doc-specific custom properties in your Word template. Those properties are used to define variables, EMF packages URIs, and service imports. When editing a template you need to be in a Java or a plug-in project to be able to add services. The template editor modifies template custom properties. You can also read template custom properties section to change them manually.

To open a template with the template editor right click on the template .docx file and select open with. If the template editor is not in the list select other ...:

Open with menu.

Make sure to select Internal editors in the editor selection dialog:

Editor selection dialog.

You should then see the following editor:

The template editor.

The first table at the top lists variables needed by the template. Each variable has a declared type. This type is used to validate the template and to select a value in the Generation configuration wizard and the Generation configuration editor. Three menus are accessible using right click on the variable table.

The variables menu.

  • Add missing variables will add all variables used in the template but not declared yet.
  • Add variable will add a variable
  • Delete variable will delete selected variables

The second table in the middle lists packages used in the template. It reference EMF EPackages used to type expressions in the template. Two menus are accessible using right click on the package table.

The variables menu.

  • Add will open the following dialog to add selected packages

The package selection dialog.

  • Delete will remove the selected packages

The last table at the bottom lists services used in the template. If you have created your own services you can add them here to be able to use them in the template. Three menus are accessible using right click on the service table.

The variables menu.

  • Add will open a dialog where you can select a Java class

The service selection dialog.

If your class doesn’t appear in the dialog you might want to check the Window>Preferences>Plug-in Development>Include all plug-ins from target in Java search option. This will list deployed classes.

  • Delete will remove the selection
  • Select token will add/remove services according to the selected tokens in the dialog

The service token selection dialog.

Template custom properties

You can use the Template properties wizard or the template editor. But you can also edit them using your Microsoft Word document editor (see this page). This section will describe possible properties name and value used by M2Doc.

M2Doc version custom properties

To define the version of M2Doc to use with this template you can set a custom property as follow

  • Name: m:M2DocVersion
  • Value: M2Doc version

For example:

  • Name: m:M2DocVersion
  • Value: 2.0.0

Not having this property set will trigger a warning while validating with M2Doc 2.0.0 or above.

Variable custom properties

To define variables you can set a custom property as follow

  • Name: m:var:variable name
  • Value: variable type

For example:

  • Name: m:var:self
  • Value: ecore::EPackage

Package custom properties

To use new Ecore packages for typing you can add the following custom property:

  • Name: m:uri:EPackage nsURI
  • Value:

For example:

  • Name: m:uri:
  • Value:

Service custom properties

To import a service class with a default constructor. To use a service class with a custom constructor you can read the custom constructor section.

  • Name: m:import:qualified class name
  • Value: bundle symbolic name

For example:

  • Name: m:import:org.obeonetwork.m2doc.rcptt.a.ServiceClassA
  • Value: org.obeonetwork.m2doc.rcptt.a

Providing new services

You can extends M2Doc by adding services to your templates using the Template properties wizard or the template editor. A service is a simple Java method with at least one parameter and a return value.

Service class

There are two cases for the class containing the service: either it has a default constructor, or it has a constructor with a parameter.

Default constructor

When the class has no explicit constructor or the constructor doesn’t have any parameters. In this case you don’t need any specific development except for your service method. You can have a look at specific return types if you want to insert images, table, etc… To use your services in your template simply add them through the Template properties wizard or the template editor.

Custom constructor

When there is an explicit constructor with at least a parameter M2Doc can’t instantiate your class since there is no default constructor. You need to implement the IServicesConfigurator interface. This interface link one or more options in the generation configuration to the service class in order to instantiate it. You need to use the org.obeonetwork.m2doc.ide.servicesConfigurator extension point to declare your implementation of IServicesConfigurator. If you want to use your implementation in standalone you can register it programmatically using M2DocUtils.registerServicesConfigurator().

An example of implementation can be found in the Sirius integration plug-in see the class SiriusConfigurationProvider and the extension in the plugin.xml.

Special return types

The M2Doc evaluation engine converts any object to a string in order to insert it in the generated document. To add flexibility in the produced document we chose to expose some special types to service creators. Those types are MElement and allow directly inserting document artifacts:

  • MPagination to insert a table of contents, a new page, a new paragraph, a new column, or a new text wrapping.
  • MBookmark to insert a new bookmark or a reference to a bookmark.
  • MHyperLink to insert a new link to an URL.
  • MImage to insert a new image.
  • MTable to insert a new table.
  • MText to insert styled text.

Default implementations are also provided by M2Doc in this package.

Extension points

Services and packages token

The services and packages token extension point can be used to reference a set of service classes and packages using a token name. This token can be selected using «Select tokens» menu in the template editor or the Template properties wizard. You can find an example of this extension point here.

Template registry

It’s possible to package your templates and deploy them in Eclipse plugins. To register them you can use the extension point org.obeonetwork.m2doc.ide.templates.register, ther is an example here.

Import registered template

Once a template is registered (see the Template registry section), you can import it in the workspace for further modifications for instance:

Select the template import wizard:

The import menu.

Import Wizard Selection.

Select a template.

Select the target folder.

Template testing

To simplify unit testing while developing M2Doc, a JUnit test suite has been implemented. It uses a given folder as input and lists each sub directory following a naming pattern as a test case. You can use the same test suite for your own tests. An example of the test suite implementation QueryTests with the folder resources/query.


You can launch your generation using Maven and Tycho. An example is available here. You may probably need to have a look at the pom.xml file. To launch the build and the generation you can simply use the following command:

mvn clean verify

Using M2Doc programmatically

This section is for developers wanting to integrate M2Doc in their own project. It will show how to use the main features of M2Doc programmatically. Since M2Doc uses AQL for expressions it can be useful to have a look at Using AQL programmatically.


The following sample code shows how to load a template .docx file using M2Doc:

final IQueryEnvironment queryEnvironment = org.eclipse.acceleo.query.runtime.Query.newEnvironmentWithDefaultServices(null);
final Map<String, String> options = ...; // can be empty
M2DocUtils.prepareEnvironmentServices(queryEnvironment, templateURI, options); // delegate to IServicesConfigurator
final IClassProvider classProvider = new ClassProvider(this.getClass().getClassLoader()); // use M2DocPlugin.getClassProvider() when running inside Eclipse
try (DocumentTemplate template = M2DocUtils.parse(templateURI, queryEnvironment, classProvider)) {
  // use the template


The validation is optional:

final ValidationMessageLevel validationLevel = M2DocUtils.validate(template, queryEnvironment);
if (validationLevel != ValidationMessageLevel.OK) {
  final URI validationResulrURI = ...; // some place to serialize the result of the validation
  M2DocUtils.serializeValidatedDocumentTemplate(documentTemplate, validationResulrURI);


The generation will produce the final document where M2Doc template is evaluated against the given variables. There are two levels of API for the generation: directly from the DocumentTemplate or from the Generation.

Core generation API

final Map<String, Object> variables = ...; // your variables and values
final URI outputURI = ...; // some place to serialize the result of the generation
M2DocUtils.generate(template, queryEnvironment, variables, outputURI, monitor);

Generation configuration API

final Generation generation = ...; // load from a serialized EMF model or create in memory
final IClassProvider classProvider = new ClassProvider(this.getClass().getClassLoader()); // use M2DocPlugin.getClassProvider() when running inside Eclipse
GenconfUtils.generate(generation, classProvider, monitor);