Merge pull request #11 from pyecore/feature/userclass

--user-module option added

Author: moltob

CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project 
+adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+### Added
+
+- Added option to auto-register generated package in global registry, see the
+  `--auto-register-package` option.
+- Added option to specify a user module, from where mixin classes. These mixins must then implement
+  all end-user specific code like operations and derived attributes. See the `--user-module`
+  command line option.
+  
+### Fixed
+
+- EDatatype registration.
+- Various derived attribute fixes.

MANIFEST.in

@@ -1 +1 @@
-include README.rst LICENSE
+include README.rst CHANGELOG.md LICENSE

README.rst

@@ -4,10 +4,10 @@ pyecoregen - Python code generation from pyecore models
 |pypi-version| |master-build| |coverage| |license|
 
 .. |master-build| image:: https://travis-ci.org/pyecore/pyecoregen.svg?branch=master
-    :target: https://travis-ci.org/pyecore/pyecoregen
+:target: https://travis-ci.org/pyecore/pyecoregen
 
 .. |pypi-version| image:: https://badge.fury.io/py/pyecoregen.svg
-    :target: https://badge.fury.io/py/pyecoregen
+:target: https://badge.fury.io/py/pyecoregen
 
 .. |coverage| image:: https://coveralls.io/repos/github/pyecore/pyecoregen/badge.svg?branch=master
     :target: https://coveralls.io/github/pyecore/pyecoregen?branch=master
@@ -83,3 +83,23 @@ hold it's root package in ``library_pkg``, you would generate with:
 
     generator = EcoreGenerator()
     generator.generate(library_pkg, 'some/folder')
+
+Generator options
+~~~~~~~~~~~~~~~~~
+
+The end user can control some of the features how the metamodel code is generated. This can be done
+at the command line as well as via programmatic invocation. A command line parameter ``--my-param``
+is then turning into a keyword argument ``my_param``.
+
+``--auto-register-package`` (Default: ``False``)
+    If enabled, the generated packages are automatically added to pyecore's global namespace
+    registry, which makes them available during XMI deserialization.
+
+``--user-module`` (Default: ``None``)
+    If specified, the given string is interpreted as a dotted Python module path. E.g.
+    ``--user-module my.custom_mod`` will make the generated code import mixin classes from a module
+    ``my.custom_mod``. A generated class with name ``<name>`` then derives from a mixin
+    ``<name>Mixin``, which is expected to be part of the user module. If this option is used, the
+    generator also produces a skeleton file which contains all required mixin classes and methods.
+    Usually you copy parts of this template to your own module, which is then checked into version
+    control all your other code.

pyecoregen/cli.py

@@ -8,7 +8,6 @@
 import pyecore.resources
 from pyecoregen.ecore import EcoreGenerator
 
-
 URL_PATTERN = re.compile('^http(s)?://.*')
 
 
@@ -36,6 +35,10 @@ def generate_from_cli(args):
         help="Generate package auto-registration for the PyEcore 'global_registry'.",
         action='store_true'
     )
+    parser.add_argument(
+        '--user-module',
+        help="Dotted name of module with user-provided mixins to import from generated classes.",
+    )
     parser.add_argument(
         '--verbose',
         '-v',
@@ -47,7 +50,10 @@ def generate_from_cli(args):
 
     configure_logging(parsed_args)
     model = load_model(parsed_args.ecore_model)
-    EcoreGenerator(parsed_args.auto_register_package).generate(model, parsed_args.out_folder)
+    EcoreGenerator(
+        auto_register_package=parsed_args.auto_register_package,
+        user_module=parsed_args.user_module
+    ).generate(model, parsed_args.out_folder)
 
 
 def configure_logging(parsed_args):

pyecoregen/ecore.py

@@ -95,21 +95,43 @@ def create_template_context(self, element, **kwargs):
         )
 
 
+class EcorePackageMixinTask(EcorePackageModuleTask):
+    """Generation of optional mixins for user implementations."""
+    template_name = 'mixins.py.skeleton.tpl'
+
+    @staticmethod
+    def filename_for_element(package: ecore.EPackage):
+        return '{}_mixins.py.skeleton'.format(package.name)
+
+
 class EcoreGenerator(multigen.jinja.JinjaGenerator):
-    """Generation of static ecore model classes."""
+    """
+    Generation of static Pyecore model classes.
 
-    tasks = [
-        EcorePackageInitTask(formatter=multigen.formatter.format_autopep8),
-        EcorePackageModuleTask(formatter=multigen.formatter.format_autopep8),
-    ]
+    Attributes:
+        user_module (str): Dotted module name with user-defined implementations for operations and
+            derived attributes.
+
+        auto_register_package (bool): Flag, whether all generated packages are automatically added
+            to Pyecore's package registry.
+    """
 
     templates_path = os.path.join(
         os.path.abspath(os.path.dirname(__file__)),
         'templates'
     )
 
-    def __init__(self, auto_register_package=False, **kwargs):
+    def __init__(self, *, user_module=None, auto_register_package=False, **kwargs):
+        self.user_module = user_module
         self.auto_register_package = auto_register_package
+
+        self.tasks = [
+            EcorePackageInitTask(formatter=multigen.formatter.format_autopep8),
+            EcorePackageModuleTask(formatter=multigen.formatter.format_autopep8),
+        ]
+        if self.user_module:
+            self.tasks.append(EcorePackageMixinTask(formatter=multigen.formatter.format_autopep8))
+
         super().__init__(**kwargs)
 
     @staticmethod
@@ -212,7 +234,10 @@ def filter_set(value):
         return set(value)
 
     def create_global_context(self, **kwargs):
-        return super().create_global_context(auto_register_package=self.auto_register_package)
+        return super().create_global_context(
+            user_module=self.user_module,
+            auto_register_package=self.auto_register_package
+        )
 
     def create_environment(self, **kwargs):
         """

pyecoregen/templates/mixins.py.skeleton.tpl

@@ -0,0 +1,6 @@
+{% import 'module_utilities.tpl' as modutil with context -%}
+"""Mixins to be implemented by user."""
+
+{%- for c in classes -%}
+{{ modutil.generate_mixin(c) }}
+{%- endfor %}

pyecoregen/templates/module.py.tpl

@@ -1,10 +1,14 @@
+{% import 'module_utilities.tpl' as modutil with context -%}
 """Definition of meta model '{{ element.name }}'."""
 from functools import partial
 import pyecore.ecore as Ecore
 from pyecore.ecore import *
 {% for c in imported_classifiers -%}
     from {{ c.ePackage | pyfqn }} import {{ c.name }}
 {% endfor %}
+{% if user_module -%}
+    import {{ user_module }} as _user_module
+{% endif %}
 
 name = '{{ element.name }}'
 nsURI = '{{ element.nsURI | default(boolean=True) }}'
@@ -15,137 +19,13 @@ eClass = EPackage(name=name, nsURI=nsURI, nsPrefix=nsPrefix)
 eClassifiers = {}
 getEClassifier = partial(Ecore.getEClassifier, searchspace=eClassifiers)
 
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_enum(e) %}
-{{ e.name }} = EEnum('{{ e.name }}', literals=[{{ e.eLiterals | map(attribute='name') | map('pyquotesingle') | join(', ') }}])
-{% endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_edatatype(e) %}
-{{ e.name }} = EDataType('{{ e.name }}', instanceClassName='{{ e.instanceClassName }}')
-{% endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_class_header(c) -%}
-class {{ c.name }}({{ c | supertypes }}):
-    {{ c | docstringline -}}
-{% endmacro -%}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_attribute(a) -%}
-    {% if a.derived %}_{% endif -%}
-    {{ a.name }} = EAttribute({{ a | attrqualifiers }})
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_reference(r) -%}
-    {{ r.name }} = EReference({{ r | refqualifiers }})
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_derived_attribute(d) -%}
-    @property
-    def {{ d.name }}(self):
-        return self._{{ d.name }}
-
-    {%- if d.changeable %}
-
-    @{{ d.name }}.setter
-    def {{ d.name }}(self, value):
-        self._{{ d.name }} = value
-    {% endif %}
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_class_init_args(c) -%}
-    {% if c.eStructuralFeatures %}, *, {% endif -%}
-    {{ c.eStructuralFeatures | map(attribute='name') | map('re_sub', '$', '=None') | join(', ') }}
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_feature_init(feature) %}
-    {%- if feature.upperBound == 1 %}
-        if {{ feature.name }} is not None:
-            self.{{ feature.name }} = {{ feature.name }}
-    {%- else %}
-        if {{ feature.name }}:
-            self.{{ feature.name }}.extend({{ feature.name }})
-    {%- endif %}
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_class_init(c) %}
-    def __init__(self{{ generate_class_init_args(c) }}, **kwargs):
-    {%- if not c.eSuperTypes %}
-        if kwargs:
-            raise AttributeError('unexpected arguments: {}'.format(kwargs))
-    {%- endif %}
-
-        super().__init__({% if c.eSuperTypes %}**kwargs{% endif %})
-    {%- for feature in c.eStructuralFeatures | reject('type', ecore.EReference) %}
-    {{ generate_feature_init(feature) }}
-    {%- endfor %}
-    {%- for feature in c.eStructuralFeatures | select('type', ecore.EReference) %}
-    {{ generate_feature_init(feature) }}
-    {%- endfor %}
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_operation_args(o) -%}
-    {% for p in o.eParameters -%}
-        , {{ p.name }}{% if not p.required %}=None{% endif -%}
-    {% endfor -%}
-{%- endmacro  %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_operation(o) %}
-    def {{ o.name }}(self{{ generate_operation_args(o) }}):
-        {{ o | docstringline }}
-        raise NotImplementedError('operation {{ o.name }}(...) not yet implemented')
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
-{%- macro generate_class(c) %}
-
-{% if c.abstract %}@abstract
-{% endif -%}
-{{ generate_class_header(c) }}
-{%- for a in c.eAttributes %}
-    {{ generate_attribute(a) -}}
-{% endfor %}
-{%- for r in c.eReferences %}
-    {{ generate_reference(r) -}}
-{% endfor %}
-{% for d in c.eAttributes | selectattr('derived')  %}
-    {{ generate_derived_attribute(d) }}
-{% endfor %}
-{{- generate_class_init(c) }}
-{% for o in c.eOperations %}
-    {{ generate_operation(o) }}
-{% endfor %}
-{%- endmacro %}
-
-{#- -------------------------------------------------------------------------------------------- -#}
-
 {%- for c in element.eClassifiers if c is type(ecore.EEnum) -%}
-{{ generate_enum(c) }}
+{{ modutil.generate_enum(c) }}
 {%- endfor %}
 {% for c in element.eClassifiers if c is type(ecore.EDataType) -%}
-{{ generate_edatatype(c) }}
+{{ modutil.generate_edatatype(c) }}
 {%- endfor %}
 
 {%- for c in classes -%}
-{{ generate_class(c) }}
+{{ modutil.generate_class(c) }}
 {%- endfor %}