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 "EMF Compare/Roadmap"

(2011)
(2011)
Line 76: Line 76:
  
 
* [[EMF Compare 1.2.0 New And Noteworthy | New and Noteworthy : 1.2.0]]
 
* [[EMF Compare 1.2.0 New And Noteworthy | New and Noteworthy : 1.2.0]]
 
+
* [[EMF Compare/CompareUMLPapyrusAPI | EMF Compare enhancements (tree editor, API, UML, Papyrus)]]
=== Enhance the existing tree editor ===
+
 
+
* Specific team handler for model resources managed through Git with eGit. This handler enables the comparison and merge of files managed with Git.
+
* Capability to switch between the tree and textual editor by using a popup menu, without losing the selection.
+
* Capability to restrict the comparison on the current selection
+
* Capability to group differences by:
+
** File
+
** Modification type
+
** Meta model element
+
** Flat text elements (?)
+
 
+
* Capability to dynamically hide/show the displayed elements with filters:
+
** Filter add changes
+
** Filter delete changes
+
** Filter modify changes
+
** Filter element order changes
+
+
* Propose a Preference page to define default settings for EMF compare filter
+
* Provide an API enabling the contribution of new filters.
+
 
+
=== Specific support of UML Model ===
+
 
+
In order to provide the best possible accuracy and precision when comparing and merging UML models, it is necessary to implement a specific comparison engine which handles the UML meta-model directly (according to the UML metamodel defined with EMF in Eclipse / Modeling Tools / UML).
+
 
+
For example, for the addition (or deletion or modification) of an association at the UML level, there is 3 additions (or deletions, or potential modifications) in the EMF representation : one "association", and two "property ends". We will define specific UML extensions for EMF Compare using the DiffExtension API to create the UML level operations (AddAssociation, DeleteAssociation, ModifyAssociation) and write the recognition code to identify these UML level change operations from the EMF level change operations. So, the end-user who diffs and merges a UML model will only see UML level change operations, and the changes will be applied atomically on the model to avoid model inconsistency.
+
 
+
Additionally, EMF Compare will support diff and merge of fragmented UML models, that is UML models stored in several physical resources, and of sets of UML model fragments. The fact that UML level operations are atomically applied will be specifically addressed in the case of merging of model fragments to forbid partial merges in one fragment that would corrupt the whole model.
+
 
+
Another transversal UML issue to be addressed is the support of UML profiles.
+
 
+
We will also ensure that generic APIs are adapted to work at the UML level. More specifically, we will provide UML level APIs for:
+
 
+
* API to request a UML diff between two models providing the result as a list of structural differences or serialized to a file
+
* API to retrieve the UML modification types  (e.g. add, delete, change, move, separation/fragment, join/fragment)
+
 
+
Then, we identify separate sets of UML diagram meta-models which will be supported incrementally:
+
 
+
* Support first set of Structural metamodels : Package, Class
+
* Support second set of structural metamodels : Composite
+
* Support first set of behavioral metamodels : Use Case , Sequence, Activity
+
* Support second set of behavioral metamodels : State, Communication
+
 
+
=== GMF Diagram Comparison ===
+
 
+
With diagram comparison, a user must be able to graphically visualize the changes between two or three diagrams. Diagram comparison will contribute a new comparison editor, in addition to the tree and textual comparison editors. This new editor will be available when the compared resources are GMF diagrams. Typically, the diagram comparison editor will display one version of the diagram without decoration (the original diagram) alongside another version of the diagram with graphical decorations to show the differences.
+
 
+
* Additions of nodes or edges must be highlighted with a specific graphical decoration.
+
* Modifications of nodes and edges must be highlighted with a specific decoration.
+
* Layout changes must be displayable, but must also be filtered with a configurable threshold. This threshold must be configurable either through an API, or an Eclipse preference.
+
 
+
=== Support fo various UML diagrams comparison in Papyrus ===
+
 
+
Beyond the generic implementation of GMF graphical diagrams comparison, we will integrate diagram comparison in the Eclipse foundation open source tool Papyrus. We will incrementally implement the different diagrams supported in Papyrus:
+
 
+
* Support first set of Structural diagram metamodels : Package, Class
+
* Support second set of structural diagram metamodels : Composite
+
* Support first set of behavioral diagram metamodels : Use Case , Sequence, Activity
+
* Support second set of behavioral diagram metamodels : State, Communication
+
 
+
A specific communication and contribution channel will be established to ensure that the UML model comparison is integrated with the mainstream Papyrus releases.
+
 
+
=== Others generic APIs ===
+
 
+
The following APIs will be implemented to work both with the Tree and diagram comparison editors:
+
 
+
* API to create a viewer listing all structural changes resulting from a model comparison which includes the filtering and grouping options as mentioned previously. This API will offer the capability to programmatically retrieve the Meta model class (type) e.g. Documentation, stereotype)
+
* API to query the viewer for the list of visible changes (e.g. not filtered out) The type of elements returned in the list of structural differences should offer an API to retrieve the location information of the affected elements, in order to trigger the selection of the affected elements in both the Project Explorer and Editor.
+
* API to handle and serialize a set of graphical elements under comparison so that it is possible to pass them on to another tool.
+
* API to launch an Eclipse Model Compare editor with two specified versions of model files and be able to programmatically request the selection of a structural change based on a previously obtained location.
+
  
 
== 2012 ==
 
== 2012 ==

Revision as of 04:45, 21 February 2011

Plan

Long Term

EMF Compare's focus is on providing a powerful, stable and proven framework for model comparison and merging. The API should be usable in any context from the plain Java application to the complete IDE customization.

Framework Enhancements

per namespace MatchEngine selection and dynamic switching

Right now EMF compare allows adopters to define specific match or diff engines associated with file extensions. As EMF is more and more broadly used we often encounter cases where a given file contains model elements conformed to several Ecore models.

A MatchEngine (and respectively Diff Engine) should be associated with one or several EPackages and not with the serialization mechanism. Furthermore that would require the Match process in general to be able to switch from a MatchEngine to another depending on the elements it is matching.


Two ways and Three ways merge robustness =

We have a bunch of issues reported by the adopters about the merge support, we need to work on building a strong test basis to make sure the merge is perfect in any kind of scenarios for instance fragmented models, scoped matching ...

High Performances during matching phase

The matching phase is critical for performances, several optimization could be done (some being addressed by the Google Summer of Code 2010).

Match/Diff/Merge on elements not contained in a EMF Resource

The framework can be used on any kind of EObjects, but as historically it was about providing model comparison support for file based models many parts of the code are making assumptions about a resource being there or not.

We should build a strong test basis with eObjects not being in resources, being compared and merged.

MatchModel maintenance on incremental changes

Right now the match process is not split in several parts, and as such when one of the matched models has been changed all the resource set needs to be matched again. We should be able to maintain parts of the match model and update those when the matched models have been changed.

DiffModel maintenance on incremental changes

Once the match model is maintained incrementaly, the next step is to maintain the diff model accordingly.

Re-Usable Comparison UI Component

Several adopters expressed their will to reuse parts of the compare UI. Right now it's nor really doable as the UI is pretty tied to the Eclipse compare framework.

This task is about defining a new API one can easily reuse splitting content provider and viewers just like JFace.

Undo/Redo support in comparison editor

This involve having a proper editing domain and using commands for merging. It can quickly become tricky as our editing domain would need to operate on 2 resourcesets keeping them separated.

ChangeModel to DiffModel and DiffModel to ChangeModel

The ChangeModel is a model defined in EMF representing changes. It semantically overlap a bit with the DiffModel from EMF compare. It would be interesting to at least bridge these models or even try to replace our DiffModel by the EMF ChangeModel if possible.

Tooling Enhancements

CodeGen

When you starts your own Ecore model you quickly want to :

  • compare instances in an controlled and efficient way
  • process these deltas

We'll work on integrating EMF Compare more with EMF providing you codegen facility to get, with a single click :

  • an efficient dedicated match engine with areas providing you the ability to customize the process
  • an efficient dedicated delta processor so that you can easily plug your own logic to process deltas

A user will be able to generate these artifacts directly from the genmodel with a right-click action. The generated code will be very similar to the XYZSwitch generated by EMF Core.

Integration with the Team Model Synchronization UI

The Eclipse Compare API provides what they call a "Comparison Model" which might be used in the synchronization view. It would allow to display the differences grouping them by dependencies even when several resources are involved.


Generating a Custom Match Engine from Ecore Annotations

The Generic Match Engine is pretty powerful though based on heuristics. When you defined your own Ecore model you often want's to make sure you control the way elements are being matched and not rely on statistics. Right now to do so you have to write your own match engine as Java code but this induce un-necessary overhead for many cases. We could define a small set of annotations at the Ecore level so that one can specify for instance :

  • attributes to ignore during the match
  • features which - if they are different - means the elements can't be matched.

the GenericMatchEngine would either adapt its behavior depending on these annotations, or we could provide a code generator generating the MatchEngine from the annotated Ecore model.

2011

2012

2013

Released bits

2010

2009

2008

Back to the top