#16 Implement transpilation traces.

Author: alessiostalla

pylasu/playground/transpilation_trace.py

@@ -1,30 +1,54 @@
-from pyecore.ecore import EAttribute, EObject, EPackage, EReference, EString, MetaEClass
+from io import IOBase, BytesIO
+
+from pyecore.ecore import EAttribute, EObject, EReference, EString, MetaEClass
+from pyecore.resources import ResourceSet, URI
+from pyecore.resources.json import JsonResource as BaseJsonResource
 
 from pylasu.StrumentaLanguageSupport import Result, Issue
 
-TRANSPILATION_METAMODEL = EPackage(
-    name="StrumentaLanguageSupportTranspilation", nsURI="https://strumenta.com/kolasu/transpilation/v1")
+nsURI = "https://strumenta.com/kolasu/transpilation/v1"
+name = "StrumentaLanguageSupportTranspilation"
+
+
+class JsonResource(BaseJsonResource):
+
+    def open_out_stream(self, other=None):
+        if isinstance(other, IOBase):
+            return other
+        else:
+            return super().open_out_stream(other)
 
 
 class TranspilationTrace(EObject, metaclass=MetaEClass):
-    original_code = EAttribute(name="originalCode", eType=EString)
-    source_result = EReference(name="sourceResult", containment=True, eType=Result)
-    target_result = EReference(name="targetResult", containment=True, eType=Result)
-    generated_code = EAttribute(name="generatedCode", eType=EString)
+    # Note: we use camelCase here because Pyecore's JSON serialization doesn't handle having different names for
+    # Python attributes and their corresponding Ecore structural features.
+    originalCode = EAttribute(eType=EString)
+    sourceResult = EReference(containment=True, eType=Result)
+    targetResult = EReference(containment=True, eType=Result)
+    generatedCode = EAttribute(eType=EString)
     issues = EReference(containment=True, eType=Issue, upper=-1)
 
     def __init__(self, *, original_code=None, source_result=None, target_result=None, generated_code=None, issues=None):
         super().__init__()
         if original_code is not None:
-            self.original_code = original_code
+            self.originalCode = original_code
         if source_result is not None:
-            self.source_result = source_result
+            self.sourceResult = source_result
         if target_result is not None:
-            self.target_result = target_result
+            self.targetResult = target_result
         if generated_code is not None:
-            self.generated_code = generated_code
+            self.generatedCode = generated_code
         if issues:
             self.issues.extend(issues)
 
-
-TRANSPILATION_METAMODEL.eContents.append(TranspilationTrace)
+    def save_as_json(self, name, *packages):
+        rset = ResourceSet()
+        rset.resource_factory['json'] = JsonResource
+        resource = rset.create_resource(URI(name))
+        for pkg in packages:
+            package_resource = rset.create_resource(URI(pkg.nsURI))
+            package_resource.contents.add(pkg)
+        resource.contents.append(self)
+        with BytesIO() as out:
+            resource.save(out)
+            return out.getvalue().decode('utf-8')

setup.cfg

@@ -1,6 +1,14 @@
+[metadata]
+name = Pylasu
+version: 0.2.0
+
 [coverage:run]
 branch = True
 
 [coverage:report]
 show_missing = True
-skip_covered = True
+skip_covered = True
+
+[options.extras_require]
+ecore =
+    pyecore

setup.py

@@ -2,7 +2,7 @@
 setup(
     name='pylasu',
     packages=find_packages(exclude=["tests"]),
-    version='0.1.0',
+    version='0.2.0',
     description='Pylasu',
     author='Strumenta S.R.L.',
     license='Apache License V2',

tests/test_transpilation_trace.py

@@ -1,3 +1,4 @@
+import json
 import unittest
 
 import pylasu.StrumentaLanguageSupport as starlasu_metamodel
@@ -6,6 +7,10 @@
 from pyecore.ecore import EString, EAttribute, EInt
 
 
+nsURI = "http://mypackage.com"
+name = "StrumentaLanguageSupportTranspilationTest"
+
+
 class ANode(ASTNode):
     name = EAttribute(eType=EString)
     value = EAttribute(eType=EInt)
@@ -30,10 +35,35 @@ def test_serialize_transpilation_issue(self):
                 message="some issue",
                 severity=starlasu_metamodel.IssueSeverity.getEEnumLiteral("WARNING"))]
         )
-        self.assertEqual("a:1", tt.original_code)
-        self.assertEqual("b:2", tt.generated_code)
+        self.assertEqual("a:1", tt.originalCode)
+        self.assertEqual("b:2", tt.generatedCode)
         self.assertEqual("some issue", tt.issues[0].message)
-        self.assertEqual("a", tt.source_result.root.name)
-        self.assertEqual(1, tt.source_result.root.value)
-        self.assertEqual("b", tt.target_result.root.name)
-        self.assertEqual(2, tt.target_result.root.value)
+        self.assertEqual("a", tt.sourceResult.root.name)
+        self.assertEqual(1, tt.sourceResult.root.value)
+        self.assertEqual("b", tt.targetResult.root.name)
+        self.assertEqual(2, tt.targetResult.root.value)
+
+        expected = """{
+  "eClass" : "https://strumenta.com/kolasu/transpilation/v1#//TranspilationTrace",
+  "originalCode" : "a:1",
+  "sourceResult" : {
+    "root" : {
+      "eClass" : "http://mypackage.com#//ANode",
+      "name" : "a",
+      "value" : 1
+    }
+  },
+  "targetResult" : {
+    "root" : {
+      "eClass" : "http://mypackage.com#//ANode",
+      "name" : "b",
+      "value" : 2
+    }
+  },
+  "generatedCode" : "b:2",
+  "issues" : [ {
+    "message" : "some issue",
+    "severity" : "WARNING"
+  } ]
+}"""
+        self.assertEqual(json.loads(expected), json.loads(tt.save_as_json("foo.json")))