cleanup ExpressionGenerator and revert back to DSL v9.28.2

Author: dschwartz-ftadvisory

pom.xml

@@ -156,13 +156,13 @@
         <repoServerHost>s01.oss.sonatype.org</repoServerHost>
         <stagingTimeoutInMinutes>10</stagingTimeoutInMinutes>
 
+        <!--
         <rosetta.dsl.version>9.47.0</rosetta.dsl.version>
         <rosetta.bundle.version>11.57.1</rosetta.bundle.version>
+        -->
 
-        <!--
         <rosetta.dsl.version>9.28.2</rosetta.dsl.version>
         <rosetta.bundle.version>11.34.0</rosetta.bundle.version>
-        -->
 
         <xtext.version>2.27.0</xtext.version>
 

src/main/java/com/regnosys/rosetta/generator/python/expressions/PythonExpressionGenerator.xtend

@@ -71,7 +71,7 @@ class PythonExpressionGenerator {
             if (cond.isConstraintCondition)
                 result += generateConstraintCondition(cls, cond)
             else
-                result += generateExpressionCondition(cond)
+                result += generateIfThenElseOrSwitch(cond)
             nConditions++
         }
         return result
@@ -82,7 +82,7 @@ class PythonExpressionGenerator {
         var result = '';
         for (Condition cond : conditions) {
             result += generateFunctionConditionBoilerPlate(cond, nConditions, condition_type)
-            result += generateExpressionCondition(cond)
+            result += generateIfThenElseOrSwitch(cond)
             nConditions++
         }
 
@@ -196,23 +196,17 @@ class PythonExpressionGenerator {
         '''
     }
 
-    private def generateExpressionCondition(Condition c) {
+    private def generateIfThenElseOrSwitch(Condition c) {
         ifCondBlocks.clear()
-        switchCondBlocks = new ArrayList<String>()
+        switchCondBlocks.clear()
         var expr = generateExpression(c.expression, 0, false)
-        var blocks = ""
-        var switch_blocks = ""
-        if (!ifCondBlocks.isEmpty()) {
-            blocks = '''    «FOR arg : ifCondBlocks»«arg»«ENDFOR»'''
-        }
         if (!switchCondBlocks.isEmpty()) {
-            switch_blocks = '''    «FOR arg : switchCondBlocks»«arg»«ENDFOR»'''
+            var switchBlocks = '''    «FOR arg : switchCondBlocks»«arg»«ENDFOR»'''
+            return '''«switchBlocks»    «expr»'''
         }
-        if (switch_blocks.equals(""))
-            return '''«blocks»    return «expr»
-            '''
-        else
-            return '''«switch_blocks»    «expr»'''
+        var blocks = (ifCondBlocks.isEmpty()) ? "" : '''    «FOR arg : ifCondBlocks»«arg»«ENDFOR»'''
+        return '''«blocks»    return «expr»
+        '''
     }
 
     private def String generateConditionalExpression(RosettaConditionalExpression expr, int ifLevel, boolean isLambda) {
@@ -292,6 +286,7 @@ class PythonExpressionGenerator {
     }
 
     private def String generateSwitchOperation(SwitchOperation expr, int ifLevel, boolean isLambda) {
+        // translate switch into a series of if / elif statements
         val attr = generateExpression(expr.argument, 0, isLambda)
         val arg = expr.argument as RosettaSymbolReference
 

src/main/java/com/regnosys/rosetta/generator/python/func/PythonFunctionGenerator.xtend

@@ -12,10 +12,6 @@ import com.regnosys.rosetta.rosetta.simple.Data
 import com.regnosys.rosetta.rosetta.simple.Function
 import com.regnosys.rosetta.rosetta.simple.Operation
 import com.regnosys.rosetta.rosetta.simple.Segment
-import com.regnosys.rosetta.rosetta.simple.ShortcutDeclaration
-import com.regnosys.rosetta.rosetta.simple.Condition
-import com.regnosys.rosetta.rosetta.RosettaFeature
-import com.regnosys.rosetta.rosetta.RosettaTyped
 import java.util.ArrayList
 import java.util.Collections
 import java.util.HashMap
@@ -287,7 +283,7 @@ class PythonFunctionGenerator {
     private def generateAddOperation(AssignPathRoot root, Operation operation, Function function, String expression) {
         val lineSeparator = System.getProperty("line.separator")
         val attribute = root as Attribute
-        val fullPath = generateFullPath(operation.getPath().getReversedFeatures(), root.name)
+        val fullPath = generateFullPath(operation.getPath().getReversedAttributes, root.name)
 
         var result = ""
         if (attribute.typeCall.type instanceof RosettaEnumeration) {
@@ -328,7 +324,7 @@ class PythonFunctionGenerator {
         var result = new StringBuilder()
         result.append("'")
         while (currentPath !== null) {
-            result.append(currentPath.getFeature().name)
+            result.append(currentPath.getAttribute().name)
             if (currentPath.next !== null) {
                 result.append("->")
             }
@@ -340,8 +336,8 @@ class PythonFunctionGenerator {
 
     private def getNextPathElementName(Segment path) {
         if (path !== null) {
-            val feature = path.getFeature()
-            return "'" + feature.name + "'"
+            val attribute = path.getAttribute()
+            return "'" + attribute.name + "'"
         }
         return null
     }
@@ -351,39 +347,36 @@ class PythonFunctionGenerator {
             return expression;
         }
 
-        val feature = path.getFeature();
-        if (feature instanceof RosettaTyped) {
-        	return '''_get_rosetta_object('«feature.typeCall.type.name»', «getNextPathElementName(path.next)», «buildObject(expression, path.next)»)'''
-        }
-        throw new IllegalArgumentException("Cannot build object for feature " + feature.getName() + " of type " + feature.class.simpleName)
+        val attribute = path.getAttribute();
+        return '''_get_rune_object('«attribute.typeCall.type.name»', «getNextPathElementName(path.next)», «buildObject(expression, path.next)»)'''
     }
 
-    private def String generateFullPath(Iterable<RosettaFeature> features, String root) {
-        if (features.isEmpty) {
+    private def String generateFullPath(Iterable<Attribute> attrs, String root) {
+        if (attrs.isEmpty) {
             return "self"
         }
 
-        val attr = features.head
-        val remainingAttrs = features.tail.toList
+        val attr = attrs.head
+        val remainingAttrs = attrs.tail.toList
 
-        val nextPath = if (remainingAttrs.isEmpty) '''rosetta_resolve_attr(self, «root»)''' else generateFullPath(
+        val nextPath = if (remainingAttrs.isEmpty) '''rune_resolve_attr(self, «root»)''' else generateFullPath(
                 remainingAttrs, root)
 
-        return '''rosetta_resolve_attr(«nextPath», '«attr.name»')'''
+        return '''rune_resolve_attr(«nextPath», '«attr.name»')'''
     }
 
-    private def getReversedFeatures(Segment segment) {
-        val features = new ArrayList<RosettaFeature>();
+    private def getReversedAttributes(Segment segment) {
+        val attributes = new ArrayList<Attribute>();
         var current = segment;
 
         while (current !== null) {
-            features.add(current.getFeature());
+            attributes.add(current.getAttribute());
             current = current.getNext();
         }
 
-        Collections.reverse(features);
+        Collections.reverse(attributes);
 
-        return features;
+        return attributes;
     }
 
     def addImportsFromConditions(String variable, String namespace) {