Formatter Maven plugin

rosetta-lang/src/main/java/com/regnosys/rosetta/formatting2/RosettaExpressionFormatter.xtend

@@ -250,11 +250,13 @@ class RosettaExpressionFormatter extends AbstractRosettaFormatter2 {
 	}
 
 	private def dispatch void unsafeFormatExpression(RosettaSymbolReference expr, extension IFormattableDocument document, FormattingMode mode) {
+		val extension referenceCallGrammarAccess = rosettaReferenceOrFunctionCallAccess
+
 		if (expr.explicitArguments) {
 			expr.regionFor.keywords(',').forEach[
 				prepend[noSpace]
 			]
-			expr.regionFor.keyword('(')
+			expr.regionFor.keyword(explicitArgumentsLeftParenthesisKeyword_0_2_0_0)
 				.prepend[noSpace]
 
 			formatInlineOrMultiline(document, expr, mode.singleLineIf(expr.shouldBeOnSingleLine),

rosetta-lang/src/main/java/com/regnosys/rosetta/formatting2/RosettaFormatter.xtend

@@ -56,6 +56,7 @@ import com.regnosys.rosetta.rosetta.TypeParameter
 import com.regnosys.rosetta.rosetta.TypeCallArgument
 import javax.inject.Inject
 import com.regnosys.rosetta.rosetta.RosettaRule
+import com.regnosys.rosetta.rosetta.simple.Choice
 
 class RosettaFormatter extends AbstractRosettaFormatter2 {
 
@@ -236,6 +237,18 @@ class RosettaFormatter extends AbstractRosettaFormatter2 {
 		ele.regionFor.assignment(nameAssignment_1)
 			.prepend[oneSpace]
 	}
+
+	def dispatch void format(Choice ele, extension IFormattableDocument document) {
+		ele.regionFor.keyword('choice')
+			.append[oneSpace]
+		ele.regionFor.keyword(':')
+			.prepend[noSpace]
+		ele.indentInner(document)
+		ele.attributes.forEach[
+			prepend[newLine]
+			format
+		]
+	}
 
 
 	def dispatch void format(Data ele, extension IFormattableDocument document) {

rosetta-lang/src/main/java/com/regnosys/rosetta/formatting2/XtextResourceFormatter.java

@@ -1,6 +1,7 @@
 package com.regnosys.rosetta.formatting2;
 
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.io.ByteArrayInputStream;
@@ -9,6 +10,7 @@
 import java.io.UncheckedIOException;
 
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.formatting2.ConflictingFormattingException;
 import org.eclipse.xtext.formatting2.FormatterRequest;
 import org.eclipse.xtext.formatting2.IFormatter2;
 import org.eclipse.xtext.formatting2.regionaccess.ITextRegionAccess;
@@ -48,16 +50,37 @@ public void formatCollection(Collection<Resource> resources, ITypedPreferenceVal
 
 	@Override
 	public void formatXtextResource(XtextResource resource, ITypedPreferenceValues preferenceValues) {
+		LOGGER.info("Formatting file at location " + resource.getURI());
+
 		// setup request and formatter
 		FormatterRequest req = formatterRequestProvider.get();
 		req.setPreferences(preferenceValues);
 		IFormatter2 formatter = iFormatter2Provider.get();
 
-		ITextRegionAccess regionAccess = regionBuilder.forNodeModel(resource).create();
+		ITextRegionAccess regionAccess = null;
+		try {
+			regionAccess = regionBuilder.forNodeModel(resource).create();
+		} catch (Exception e) {
+			LOGGER.info("Resource " + resource.getURI() + " is empty.");
+			return;
+		}
+
 		req.setTextRegionAccess(regionAccess);
 
 		// list contains all the replacements which should be applied to resource
-		List<ITextReplacement> replacements = formatter.format(req);
+		List<ITextReplacement> replacements = new ArrayList<>();
+		try {
+			replacements = formatter.format(req); // throws exception
+		} catch (RuntimeException e) {
+			LOGGER.error("RuntimeException in " + resource.getURI() + ": " + e.getMessage());
+		}
+
+		// Abort if replacements is empty (either because nothing to format or method
+		// throws exception
+		if (replacements.isEmpty()) {
+			LOGGER.info("No replacements to apply, skipping file");
+			return;
+		}
 
 		// formatting using TextRegionRewriter
 		ITextRegionRewriter regionRewriter = regionAccess.getRewriter();
@@ -72,5 +95,7 @@ public void formatXtextResource(XtextResource resource, ITypedPreferenceValues p
 			throw new UncheckedIOException(
 					"Since the resource is an in-memory string, this exception is not expected to be ever thrown.", e);
 		}
+
 	}
+
 }

rosetta-lang/src/main/java/com/regnosys/rosetta/serialization/RosettaTransientValueService.java

@@ -17,36 +17,51 @@
 package com.regnosys.rosetta.serialization;
 
 import java.util.List;
+import java.util.Set;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.xtext.parsetree.reconstr.impl.DefaultTransientValueService;
 
 import com.regnosys.rosetta.rosetta.expression.ExpressionPackage;
 import com.regnosys.rosetta.rosetta.expression.RosettaExpression;
+import com.regnosys.rosetta.rosetta.simple.SimplePackage;
 
 public class RosettaTransientValueService extends DefaultTransientValueService {
-	private EStructuralFeature generatedInputWasSetFeature = ExpressionPackage.eINSTANCE.getHasGeneratedInput_GeneratedInputWasSet();
-	private EStructuralFeature implicitVariableIsInContextFeature = ExpressionPackage.eINSTANCE.getRosettaSymbolReference_ImplicitVariableIsInContext();
-
+	private final Set<EStructuralFeature> ignoredFeatures;
+
+	public RosettaTransientValueService() {
+		EStructuralFeature generatedInputWasSetFeature = ExpressionPackage.eINSTANCE
+				.getHasGeneratedInput_GeneratedInputWasSet();
+		EStructuralFeature implicitVariableIsInContextFeature = ExpressionPackage.eINSTANCE
+				.getRosettaSymbolReference_ImplicitVariableIsInContext();
+		EStructuralFeature hardcodedConditionFeature = SimplePackage.eINSTANCE.getChoice__hardcodedConditions();
+		EStructuralFeature hardcodedNameFeature = SimplePackage.eINSTANCE.getChoiceOption__hardcodedName();
+		EStructuralFeature hardcodedCardinalityFeature = SimplePackage.eINSTANCE
+				.getChoiceOption__hardcodedCardinality();
+		ignoredFeatures = Set.of(generatedInputWasSetFeature, implicitVariableIsInContextFeature,
+				hardcodedConditionFeature, hardcodedNameFeature, hardcodedCardinalityFeature);
+
+	}
+
 	@Override
 	public boolean isCheckElementsIndividually(EObject owner, EStructuralFeature feature) {
 		return true;
 	}
-	
+
 	@Override
 	public boolean isTransient(EObject owner, EStructuralFeature feature, int index) {
 		if (super.isTransient(owner, feature, index)) {
 			return true;
 		}
-		if (feature.equals(generatedInputWasSetFeature) || feature.equals(implicitVariableIsInContextFeature)) {
+		if (ignoredFeatures.contains(feature)) {
 			return true;
 		}
 		Object value = owner.eGet(feature);
 		if (index >= 0 && value instanceof List<?>) {
-			value = ((List<?>)value).get(index);
+			value = ((List<?>) value).get(index);
 		}
-		if (value instanceof RosettaExpression && ((RosettaExpression)value).isGenerated()) {
+		if (value instanceof RosettaExpression && ((RosettaExpression) value).isGenerated()) {
 			return true;
 		}
 		return false;

rosetta-maven-plugin/src/main/java/com/regnosys/rosetta/maven/ResourceFormatterMojo.java

@@ -0,0 +1,72 @@
+package com.regnosys.rosetta.maven;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.inject.Injector;
+import com.regnosys.rosetta.RosettaStandaloneSetup;
+import com.regnosys.rosetta.builtin.RosettaBuiltinsService;
+import com.regnosys.rosetta.formatting2.ResourceFormatterService;
+
+@Mojo(name = "format")
+public class ResourceFormatterMojo extends AbstractMojo {
+	private static Logger LOGGER = LoggerFactory.getLogger(ResourceFormatterMojo.class);
+
+	@Parameter(property = "path", required = true)
+	private String path;
+
+	@Override
+	public void execute() throws MojoExecutionException, MojoFailureException {
+		Path directory = Paths.get(path);
+		LOGGER.info("Mojo running on path:" + directory.toString());
+
+		Injector inj = new RosettaStandaloneSetup().createInjectorAndDoEMFRegistration();
+		ResourceSet resourceSet = inj.getInstance(ResourceSet.class);
+		ResourceFormatterService formatterService = inj.getInstance(ResourceFormatterService.class);
+
+		RosettaBuiltinsService builtins = inj.getInstance(RosettaBuiltinsService.class);
+		resourceSet.getResource(builtins.basicTypesURI, true);
+		resourceSet.getResource(builtins.annotationsURI, true);
+
+		try {
+			// Find all .rosetta files in the directory and load them from disk
+			List<Resource> resources = Files.walk(directory).filter(path -> path.toString().endsWith(".rosetta"))
+					.map(file -> resourceSet.getResource(URI.createFileURI(file.toString()), true))
+					.collect(Collectors.toList());
+
+			// format resources
+			formatterService.formatCollection(resources, null);
+
+			// save each resource
+			resources.forEach(resource -> {
+				try {
+					resource.save(null);
+					LOGGER.info("Successfully formatted and saved file at location " + resource.getURI());
+				} catch (IOException e) {
+					LOGGER.error("Error saving file at location " + resource.getURI() + ": " + e.getMessage());
+				} catch (RuntimeException e) {
+					LOGGER.error("RuntimeException while saving in following file: " + resource.getURI() + ": "
+							+ e.getMessage());
+				}
+			});
+		} catch (IOException e) {
+			LOGGER.error("Error processing files: " + e.getMessage());
+		}
+
+	}
+}

rosetta-testing/src/test/java/com/regnosys/rosetta/formatting2/RosettaExpressionFormattingTest.xtend

@@ -761,4 +761,26 @@ class RosettaExpressionFormattingTest {
 			(["This", "is", "a", "loooooooooooooooooooooooong", "list"] count > 10)
 		'''
 	}
+
+	@Test
+	def void testFunctionCallInParenthesis() {
+		'''
+		(SomeFunc 
+		 ( 
+		   ))
+		''' -> '''
+		(SomeFunc())
+		'''
+	}
+
+	@Test
+	def void testConditionalInParenthesis() {
+		'''
+		(if  True 
+				  then 10)
+		''' -> '''
+		(if True then 10)
+		'''
+	}
+
 }

rosetta-testing/src/test/java/com/regnosys/rosetta/formatting2/RosettaFormattingTest.xtend

@@ -588,4 +588,25 @@ class RosettaFormattingTest {
 				add out -> other: [in1, in1, in1, in1]
 		'''
 	}
+
+	@Test
+	def void testChoice() {
+		'''
+		namespace "test"
+								version "test"
+		choice Test: 
+		    A
+
+		    	B
+
+		''' -> '''
+		namespace "test"
+		version "test"
+
+		choice Test:
+			A
+			B
+		'''
+	}
+
 }