Story 3511 setting non reference metadata on function output

rosetta-ide/src/main/java/com/regnosys/rosetta/ide/semantictokens/RosettaSemanticTokensService.java

@@ -222,9 +222,9 @@ public List<SemanticToken> markOperation(Operation operation) {
 			}
 		}
 		for (Segment seg : operation.pathAsSegmentList()) {
-			Attribute segAttr = seg.getAttribute();
+			RosettaFeature segAttr = seg.getFeature();
 			if (extensions.isResolved(segAttr)) {
-				SemanticToken segmentToken = markAttribute(seg, SEGMENT__ATTRIBUTE, segAttr, AttributeType.OUTPUT);
+				SemanticToken segmentToken = markFeature(seg, SEGMENT__FEATURE, segAttr, AttributeType.OUTPUT);
 				if (segmentToken != null) {
 					result.add(segmentToken);
 				}

rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorMetaTest.java

@@ -0,0 +1,175 @@
+package com.regnosys.rosetta.generator.java.function;
+
+import com.regnosys.rosetta.generator.java.RosettaJavaPackages;
+import com.regnosys.rosetta.tests.RosettaTestInjectorProvider;
+import com.regnosys.rosetta.tests.util.CodeGeneratorTestHelper;
+import com.rosetta.model.lib.RosettaModelObject;
+import com.rosetta.model.lib.meta.FieldWithMeta;
+import com.rosetta.model.metafields.MetaFields;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import javax.inject.Inject;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(RosettaTestInjectorProvider.class)
+public class FunctionGeneratorMetaTest {
+
+    @Inject
+    FunctionGeneratorHelper functionGeneratorHelper;
+    @Inject
+    CodeGeneratorTestHelper generatorTestHelper;
+
+    @Disabled //TODO: implement setting external key reference
+    @Test
+    void canSetExternalKeyOnFunctionObjectOutput() {
+        var model = """
+        type Foo:
+          [metadata key]
+            a string (1..1)
+
+        func MyFunc:
+            inputs:
+                myKey string (1..1)
+
+            output:
+                result Foo (1..1)
+                  [metadata reference]
+            set result -> reference: myKey
+        """;
+
+        var code = generatorTestHelper.generateCode(model);
+        var classes = generatorTestHelper.compileToClasses(code);
+
+        //TODO: add assertions
+    }
+
+    @Disabled //TODO: implement setting meta address
+    @Test
+    void canSetMetaAddressOnFunctionBasicOutput() {
+        var model = """
+        metaType address string
+
+        func MyFunc:
+            output:
+                result string (1..1)
+                    [metadata address]
+            set result:  "someValue"
+            set result -> address: "someAddress"
+       """;
+
+        var code = generatorTestHelper.generateCode(model);
+        var classes = generatorTestHelper.compileToClasses(code);
+        var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc");
+
+        var result = functionGeneratorHelper.invokeFunc(myFunc, FieldWithMeta.class);
+
+        var expected = generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model.metafields"), "FieldWithMetaString", Map.of(
+                "value", "someValue",
+                "meta", MetaFields.builder().setAddress("someAddress")
+        ));
+
+        assertEquals(expected, result);
+    }
+
+    @Disabled  //TODO: implement setting nested meta
+    @Test
+    void canSetMetaOnFunctionObjectOutputAndNestedMetaField() {
+        var model = """
+        type Foo:
+            a string (1..1)
+            b string (1..1)
+                [metadata scheme]
+
+        func MyFunc:
+            output:
+                result Foo (1..1)
+                    [metadata scheme]
+            set result -> scheme: "outerScheme"
+            set result -> a:  "someValueA"
+            set result -> b: "someValueB"
+            set result -> b -> scheme: "innerScheme"
+        """;
+
+        var code = generatorTestHelper.generateCode(model);
+        var classes = generatorTestHelper.compileToClasses(code);
+        var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc");
+
+        var result = functionGeneratorHelper.invokeFunc(myFunc, RosettaModelObject.class);
+
+        var expected = generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model.metafields"), "FieldWithMetaFoo", Map.of(
+                "value", generatorTestHelper.createInstanceUsingBuilder(classes, "Foo", Map.of(
+                        "a", "someValueA",
+                        "b", generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.model.metafields"), "FieldWithMetaString", Map.of(
+                                "value", "someValueB",
+                                "meta", MetaFields.builder().setScheme("innerScheme")
+                        ))
+                )),
+                "meta", MetaFields.builder().setScheme("outerScheme")
+        ));
+
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void canSetMetaSchemeOnFunctionObjectOutput() {
+        var model = """
+        type Foo:
+            a string (1..1)
+            b string (1..1)
+
+        func MyFunc:
+            output:
+                result Foo (1..1)
+                    [metadata scheme]
+            set result -> scheme: "outerScheme"
+            set result -> a:  "someValueA"
+            set result -> b: "someValueB"
+        """;
+
+        var code = generatorTestHelper.generateCode(model);
+        var classes = generatorTestHelper.compileToClasses(code);
+        var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc");
+
+        var result = functionGeneratorHelper.invokeFunc(myFunc, RosettaModelObject.class);
+
+        var expected = generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model.metafields"), "FieldWithMetaFoo", Map.of(
+                "value", generatorTestHelper.createInstanceUsingBuilder(classes, "Foo", Map.of(
+                        "a", "someValueA",
+                        "b", "someValueB"
+                )),
+                "meta", MetaFields.builder().setScheme("outerScheme")
+        ));
+
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void canSetMetaSchemeOnFunctionBasicOutput() {
+        var model = """
+        func MyFunc:
+            output:
+                result string (1..1)
+                  [metadata scheme]
+            set result:  "someValue"
+            set result -> scheme: "someScheme"
+        """;
+
+        var code = generatorTestHelper.generateCode(model);
+        var classes = generatorTestHelper.compileToClasses(code);
+
+        var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc");
+
+        var result =  functionGeneratorHelper.invokeFunc(myFunc, FieldWithMeta.class);
+
+        var expected = generatorTestHelper.createFieldWithMetaString(classes, "someValue", "someScheme");
+
+        assertEquals(expected, result);
+    }
+}

rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorTest.xtend

@@ -1,20 +1,25 @@
 package com.regnosys.rosetta.generator.java.function
 
 import com.google.common.collect.ImmutableList
-import com.regnosys.rosetta.rosetta.simple.SimplePackage
+import com.regnosys.rosetta.generator.java.RosettaJavaPackages.RootPackage
 import com.regnosys.rosetta.tests.RosettaTestInjectorProvider
 import com.regnosys.rosetta.tests.util.CodeGeneratorTestHelper
 import com.regnosys.rosetta.tests.util.ModelHelper
-import com.regnosys.rosetta.validation.RosettaIssueCodes
 import com.rosetta.model.lib.RosettaModelObject
+import com.rosetta.model.lib.meta.FieldWithMeta
+import com.rosetta.model.lib.meta.Key
+import com.rosetta.model.lib.meta.Reference
 import com.rosetta.model.lib.records.Date
+import com.rosetta.model.metafields.MetaFields
 import java.math.BigDecimal
+import java.time.LocalDateTime
 import java.time.LocalTime
 import java.time.ZoneId
 import java.time.ZonedDateTime
 import java.util.Arrays
 import java.util.List
 import java.util.Map
+import javax.inject.Inject
 import org.eclipse.xtext.testing.InjectWith
 import org.eclipse.xtext.testing.extensions.InjectionExtension
 import org.eclipse.xtext.testing.validation.ValidationTestHelper
@@ -26,14 +31,8 @@ import static com.google.common.collect.ImmutableMap.*
 import static com.regnosys.rosetta.rosetta.expression.ExpressionPackage.Literals.*
 import static org.hamcrest.MatcherAssert.assertThat
 import static org.hamcrest.core.IsCollectionContaining.hasItems
-import static org.junit.jupiter.api.Assertions.*
 import static org.junit.Assert.assertThrows
-import javax.inject.Inject
-import java.time.LocalDateTime
-import com.regnosys.rosetta.generator.java.RosettaJavaPackages.RootPackage
-import com.rosetta.model.lib.meta.Key
-import com.rosetta.model.lib.meta.Reference
-import com.rosetta.model.metafields.MetaFields
+import static org.junit.jupiter.api.Assertions.*
 
 @ExtendWith(InjectionExtension)
 @InjectWith(RosettaTestInjectorProvider)
@@ -43,7 +42,7 @@ class FunctionGeneratorTest {
 	@Inject extension CodeGeneratorTestHelper
 	@Inject extension ModelHelper
 	@Inject extension ValidationTestHelper
-	
+
 	@Test
 	def void reportingRuleSupportsRecursion() {
 		val code = '''
@@ -3148,6 +3147,7 @@ class FunctionGeneratorTest {
 
 			'''
 		].generateCode
+
 		code.compileToClasses
 	}
 

rosetta-integration-tests/src/test/java/com/regnosys/rosetta/types/RosettaTypeProviderTest.xtend

@@ -52,7 +52,7 @@ class RosettaTypeProviderTest {
 	RMetaAttribute SCHEME
 	@BeforeAll
 	def void setup() {
-		SCHEME = new RMetaAttribute("scheme", UNCONSTRAINED_STRING, null)
+		SCHEME = new RMetaAttribute("scheme", UNCONSTRAINED_STRING)
 	}
 
 	private def void assertIsValidWithType(CharSequence expr, RMetaAnnotatedType expectedType, boolean expectedIsMulti, List<RosettaModel> context, String... attributes) {

rosetta-lang/.checkstyle

@@ -1,10 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<fileset-config file-format-version="1.2.0" simple-config="true" sync-formatter="false">
+<fileset-config file-format-version="1.2.0" simple-config="false" sync-formatter="false">
   <local-check-config name="Custom" location="/com.regnosys.rosetta.parent/checkstyle.xml" type="project" description="">
     <additional-data name="protect-config-file" value="false"/>
   </local-check-config>
-  <fileset name="all" enabled="true" check-config-name="Custom" local="true">
-    <file-match-pattern match-pattern="." include-pattern="true"/>
+  <local-check-config name="maven-checkstyle-plugin Check style" location="file:/Users/davidalk/Developer/rune-dsl/checkstyle.xml" type="remote" description="maven-checkstyle-plugin configuration Check style">
+    <property name="checkstyle.header.file" value="/Users/davidalk/eclipse-workspace/.metadata/.plugins/org.eclipse.core.resources/.projects/com.regnosys.rosetta/com.basistech.m2e.code.quality.checkstyleConfigurator/checkstyle-header-Check_style.txt"/>
+    <property name="checkstyle.cache.file" value="${project_loc}/target/checkstyle-cachefile"/>
+  </local-check-config>
+  <fileset name="java-sources-Check_style" enabled="true" check-config-name="maven-checkstyle-plugin Check style" local="true">
+    <file-match-pattern match-pattern="^src/test/java.*\/.*\.java" include-pattern="true"/>
+    <file-match-pattern match-pattern="^xtend-gen/test/java.*\/.*\.java" include-pattern="true"/>
+    <file-match-pattern match-pattern="^xtend-gen/main/java/.*\/.*\.java" include-pattern="true"/>
+    <file-match-pattern match-pattern="^src/main/java.*\/.*\.java" include-pattern="true"/>
+    <file-match-pattern match-pattern="^.*\.properties" include-pattern="true"/>
+    <file-match-pattern match-pattern="^src-gen/main/java/.*\.properties" include-pattern="true"/>
+    <file-match-pattern match-pattern="^src/test/resources/.*\.properties" include-pattern="true"/>
   </fileset>
 </fileset-config>

rosetta-lang/model/RosettaSimple.xcore

@@ -23,6 +23,7 @@ import com.regnosys.rosetta.rosetta.RosettaAttributeReferenceSegment
 import com.regnosys.rosetta.rosetta.RosettaCardinality
 import com.regnosys.rosetta.rosetta.RosettaFactory
 import com.regnosys.rosetta.rosetta.expression.ExpressionFactory
+import com.regnosys.rosetta.rosetta.RosettaFeature
 
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils
 import org.eclipse.emf.common.util.EList
@@ -183,7 +184,7 @@ class Operation extends RosettaDefinable {
 }
 
 class Segment {
-	refers Attribute attribute
+	refers RosettaFeature feature
 	contains Segment next opposite prev
 	container Segment prev opposite next
 

rosetta-lang/src/main/java/com/regnosys/rosetta/Rosetta.xtext

@@ -139,7 +139,7 @@ Operation:
 ;
 
 Segment:
-	'->' attribute = [Attribute|ValidID] (next = Segment)?;
+	'->' feature = [RosettaTypedFeature|ValidID] (next = Segment)?;
 
 EnumValueReference returns RosettaEnumValueReference:
 	enumeration=[RosettaEnumeration|QualifiedName] '->' value=[RosettaEnumValue|ValidID]