Formatter Maven plugin

rosetta-lang/model/RosettaExpression.xcore

@@ -244,6 +244,7 @@ class JoinOperation extends RosettaBinaryOperation {
 
 class RosettaOnlyExistsExpression extends RosettaExpression {
 	contains RosettaExpression[] args
+	boolean hasParentheses
 }
 
 /**

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

@@ -789,7 +789,7 @@ RosettaCalcConditionalExpression returns RosettaExpression:
 ;
 
 RosettaCalcOnlyExists returns RosettaExpression:
-	{RosettaOnlyExistsExpression} (args+=RosettaOnlyExistsElement | ('(' args+=RosettaOnlyExistsElement (',' args+=RosettaOnlyExistsElement)* ')')) 'only' 'exists'
+	{RosettaOnlyExistsExpression} (args+=RosettaOnlyExistsElement | (hasParentheses?='(' args+=RosettaOnlyExistsElement (',' args+=RosettaOnlyExistsElement)* ')')) 'only' 'exists'
 ;
 
 RosettaOnlyExistsElement returns RosettaExpression:

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

@@ -0,0 +1,25 @@
+package com.regnosys.rosetta.formatting2;
+
+import org.eclipse.emf.ecore.resource.Resource;
+
+/**
+ * Functional interface for handling a formatted resource and its corresponding
+ * formatted text.
+ * <p>
+ * This interface allows customization of how formatted resources are processed,
+ * such as saving the content, logging it, or using it for validations or
+ * assertions in tests.
+ * </p>
+ */
+@FunctionalInterface
+public interface IFormattedResourceAcceptor {
+
+	/**
+	 * Accepts a formatted resource and its formatted content for further
+	 * processing.
+	 *
+	 * @param resource      the {@link Resource} that was formatted
+	 * @param formattedText the formatted content as a {@link String}
+	 */
+	void accept(Resource resource, String formattedText);
+}

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

@@ -7,64 +7,124 @@
 import org.eclipse.xtext.resource.XtextResource;
 
 public interface ResourceFormatterService {
-	
+
 	/**
-	 * Formats each {@link XtextResource} in the provided collection in-memory.
+	 * Formats each {@link XtextResource} in the provided collection in-memory and
+	 * passes the formatted content to a handler for further processing.
 	 * <p>
-	 * This method iterates over the given collection of resources and applies formatting 
-	 * directly to each resource. Formatting may include indentation, spacing adjustments, 
-	 * and other stylistic improvements to ensure consistency and readability of the resources.
+	 * This method iterates over the given collection of resources and applies
+	 * formatting directly to each resource. Formatting may include indentation,
+	 * spacing adjustments, and other stylistic improvements to ensure consistency
+	 * and readability of the resources.
 	 * </p>
 	 * 
-	 * @param resources a collection of {@link XtextResource} objects to be formatted
+	 * <p>
+	 * The handler, represented as a {@link java.util.function.BiConsumer}, is
+	 * called with two arguments: the {@link Resource} being formatted, and the
+	 * resulting formatted text as a {@link String}. This allows the caller to
+	 * specify actions such as saving the formatted content, logging it, or
+	 * collecting it for assertions in a test.
+	 * </p>
+	 * 
+	 * @param resources a collection of {@link XtextResource} objects to be
+	 *                  formatted
+	 * @param acceptor  an {@link IFormattedResourceAcceptor} to process the
+	 *                  formatted resource and its content
 	 */
-	default void formatCollection(Collection<Resource> resources) {
-		formatCollection(resources, null);
+	default void formatCollection(Collection<Resource> resources, IFormattedResourceAcceptor acceptor) {
+		formatCollection(resources, null, acceptor);
 	}
-	
+
 	/**
-	 * Formats the given {@link XtextResource} in-memory.
+	 * Formats the given {@link XtextResource} in-memory and passes the formatted
+	 * content to a handler for further processing.
 	 * <p>
-	 * This method applies formatting directly to the specified resource. Formatting can include
-	 * adjustments to indentation, spacing, and other stylistic elements to ensure consistency
-	 * and readability of the resource content.
+	 * This method applies formatting directly to the specified resource. Formatting
+	 * can include adjustments to indentation, spacing, and other stylistic elements
+	 * to ensure consistency and readability of the resource content.
+	 * </p>
+	 * 
+	 * <p>
+	 * The handler, represented as a {@link java.util.function.BiConsumer}, is
+	 * called with two arguments: the {@link Resource} being formatted, and the
+	 * resulting formatted text as a {@link String}. This allows the caller to
+	 * specify actions such as saving the formatted content, logging it, or
+	 * collecting it for assertions in a test.
 	 * </p>
 	 * 
 	 * @param resources the {@link XtextResource} to format
-	 * @param preferenceValues an {@link ITypedPreferenceValues} object containing formatting preferences, 
-	 *                         or {@code null} if no preferences are specified
+	 * @param acceptor  an {@link IFormattedResourceAcceptor} to process the
+	 *                  formatted resource and its content
 	 */
-	default void formatXtextResource(XtextResource resource) {
-		formatXtextResource(resource, null);
+	default void formatXtextResource(XtextResource resource, IFormattedResourceAcceptor acceptor) {
+		formatXtextResource(resource, null, acceptor);
 	}
-	
+
 	/**
-	 * Formats each {@link XtextResource} in the provided collection in-memory, with specified formatting preferences.
+	 * Formats each {@link XtextResource} in the provided collection in-memory,
+	 * applying specified formatting preferences, and passes the formatted content
+	 * to a handler for further processing.
 	 * <p>
-	 * This method iterates over the given collection of resources and applies formatting 
-	 * directly to each resource. Formatting may include indentation, spacing adjustments, 
-	 * and other stylistic improvements to ensure consistency and readability of the resources.
-	 * The formatting can be customized based on the specified {@link ITypedPreferenceValues}.
-	 * If no preferences are required, {@code preferenceValues} can be set to {@code null}.
+	 * This method iterates over the given collection of resources, formats each
+	 * resource according to the provided preferences, and invokes a handler to
+	 * process the formatted content. Formatting includes indentation, spacing
+	 * adjustments, and other stylistic refinements to ensure consistency and
+	 * readability of the resources. The formatting behavior can be customized based
+	 * on the provided {@link ITypedPreferenceValues}.
+	 * </p>
+	 * <p>
+	 * The handler, represented as a {@link java.util.function.BiConsumer}, is
+	 * called for each resource with two arguments: the {@link Resource} being
+	 * formatted, and the resulting formatted text as a {@link String}. This allows
+	 * the caller to specify actions such as saving the formatted content, logging
+	 * it, or collecting it for assertions in a test.
+	 * </p>
+	 * <p>
+	 * If no formatting preferences are required, the {@code preferenceValues}
+	 * parameter can be set to {@code null}.
 	 * </p>
 	 * 
-	 * @param resources a collection of {@link XtextResource} objects to be formatted
-	 * @param preferenceValues an {@link ITypedPreferenceValues} object containing formatting preferences, 
-	 *                         or {@code null} if no preferences are specified
+	 * @param resources        a collection of {@link XtextResource} objects to be
+	 *                         formatted
+	 * @param preferenceValues an {@link ITypedPreferenceValues} object containing
+	 *                         formatting preferences, or {@code null} if no
+	 *                         preferences are specified
+	 * @param acceptor         an {@link IFormattedResourceAcceptor} to process the
+	 *                         formatted resource and its content
 	 */
-	void formatCollection(Collection<Resource> resources, ITypedPreferenceValues preferenceValues); 
-
+	void formatCollection(Collection<Resource> resources, ITypedPreferenceValues preferenceValues,
+			IFormattedResourceAcceptor acceptor);
+
 	/**
-	 * Formats the given {@link XtextResource} in-memory.
+	 * Formats the given {@link XtextResource} in-memory, applying specified
+	 * formatting preferences, and passes the formatted content to a handler for
+	 * further processing.
 	 * <p>
-	 * This method applies formatting directly to the specified resource. Formatting can include
-	 * adjustments to indentation, spacing, and other stylistic elements to ensure consistency
-	 * and readability of the resource content.
-	 * The formatting can be customized based on the specified {@link ITypedPreferenceValues}.
-	 * If no preferences are required, {@code preferenceValues} can be set to {@code null}.
+	 * This method formats each resource according to the provided preferences, and
+	 * invokes a handler to process the formatted content. Formatting includes
+	 * indentation, spacing adjustments, and other stylistic refinements to ensure
+	 * consistency and readability of the resources. The formatting behavior can be
+	 * customized based on the provided {@link ITypedPreferenceValues}.
 	 * </p>
-	 *
-	 * @param resource the {@link XtextResource} to format
+	 * <p>
+	 * The handler, represented as a {@link java.util.function.BiConsumer}, is
+	 * called with two arguments: the {@link Resource} being formatted, and the
+	 * resulting formatted text as a {@link String}. This allows the caller to
+	 * specify actions such as saving the formatted content, logging it, or
+	 * collecting it for assertions in a test.
+	 * </p>
+	 * <p>
+	 * If no formatting preferences are required, the {@code preferenceValues}
+	 * parameter can be set to {@code null}.
+	 * </p>
+	 * 
+	 * @param resource         the {@link XtextResource} to be formatted
+	 * @param preferenceValues an {@link ITypedPreferenceValues} object containing
+	 *                         formatting preferences, or {@code null} if no
+	 *                         preferences are specified
+	 * @param acceptor         an {@link IFormattedResourceAcceptor} to process the
+	 *                         formatted resource and its content
 	 */
-	void formatXtextResource(XtextResource resource, ITypedPreferenceValues preferenceValues);
+	void formatXtextResource(XtextResource resource, ITypedPreferenceValues preferenceValues,
+			IFormattedResourceAcceptor acceptor);
 }

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

@@ -31,6 +31,7 @@ import com.regnosys.rosetta.rosetta.expression.RosettaOperation
 import com.regnosys.rosetta.rosetta.expression.ThenOperation
 import com.regnosys.rosetta.rosetta.expression.RosettaConstructorExpression
 import com.regnosys.rosetta.rosetta.expression.RosettaDeepFeatureCall
+import com.regnosys.rosetta.rosetta.expression.ConstructorKeyValuePair
 
 class RosettaExpressionFormatter extends AbstractRosettaFormatter2 {
 
@@ -114,30 +115,47 @@ class RosettaExpressionFormatter extends AbstractRosettaFormatter2 {
 
 	private def dispatch void unsafeFormatExpression(RosettaConstructorExpression expr, extension IFormattableDocument document, FormattingMode mode) {
 		val extension constructorGrammarAccess = rosettaCalcConstructorExpressionAccess
-
+
+		val innermostConstructorChild = findInnermostConstructorChild(expr) as RosettaConstructorExpression
 		interior(
 			expr.regionFor.keyword(leftCurlyBracketKeyword_2)
 				.prepend[oneSpace]
 				.append[newLine],
-			expr.regionFor.keyword(rightCurlyBracketKeyword_4)
-				.prepend[newLine],
+			innermostConstructorChild.regionFor.keyword(rightCurlyBracketKeyword_4)
+				.prepend[if (hasLastChildConstructor(expr)) noSpace else newLine],
 			[indent]
 		)
 
+		expr.regionFor.keyword(rightCurlyBracketKeyword_4)
+			.prepend[if (hasLastChildConstructor(expr)) noSpace else newLine]		
+
 		expr.regionFor.keywords(',').forEach[
 			prepend[noSpace]
 			append[newLine]
 		]
 
 		expr.values.forEach[
-			indentInner(document)
-			regionFor.keyword(':').
-				prepend[noSpace]
+			regionFor.keyword(':')
+				.prepend[noSpace]
 				.append[oneSpace]
 			value.formatExpression(document, mode)
 		]
 	}
 
+	private def findInnermostConstructorChild(RosettaConstructorExpression expr) {
+		if (hasLastChildConstructor(expr)) {
+			val lastChild = expr.values.last
+			findInnermostConstructorChild(lastChild.value as RosettaConstructorExpression)
+		} else {
+			expr
+		}
+	}
+
+	private def hasLastChildConstructor(RosettaConstructorExpression expr) {
+		val lastChild = expr.values.last
+		!expr.implicitEmpty && lastChild instanceof ConstructorKeyValuePair && lastChild.value instanceof RosettaConstructorExpression
+	}
+
 	private def dispatch void unsafeFormatExpression(ListLiteral expr, extension IFormattableDocument document, FormattingMode mode) {
 		expr.regionFor.keywords(',').forEach[
 			prepend[noSpace]
@@ -250,11 +268,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,22 @@ class RosettaFormatter extends AbstractRosettaFormatter2 {
 		ele.regionFor.assignment(nameAssignment_1)
 			.prepend[oneSpace]
 	}
+
+	def dispatch void format(Choice ele, extension IFormattableDocument document) {
+		ele.regionFor.keyword(choiceAccess.choiceKeyword_0)
+			.append[oneSpace]
+		ele.regionFor.keyword(':')
+			.prepend[noSpace]
+		ele.indentInner(document)
+		ele.formatDefinition(document)
+		ele.attributes.head
+			.prepend[setNewLines(1, 2, 2)]
+			.format
+		ele.attributes.tail.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,12 +1,8 @@
 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;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.UncheckedIOException;
 
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.xtext.formatting2.FormatterRequest;
@@ -35,10 +31,11 @@ public class XtextResourceFormatter implements ResourceFormatterService {
 	private TextRegionAccessBuilder regionBuilder;
 
 	@Override
-	public void formatCollection(Collection<Resource> resources, ITypedPreferenceValues preferenceValues) {
+	public void formatCollection(Collection<Resource> resources, ITypedPreferenceValues preferenceValues,
+			IFormattedResourceAcceptor acceptor) {
 		resources.stream().forEach(resource -> {
 			if (resource instanceof XtextResource) {
-				formatXtextResource((XtextResource) resource, preferenceValues);
+				formatXtextResource((XtextResource) resource, preferenceValues, acceptor);
 
 			} else {
 				LOGGER.debug("Resource is not of type XtextResource and will be skipped: " + resource.getURI());
@@ -47,7 +44,15 @@ public void formatCollection(Collection<Resource> resources, ITypedPreferenceVal
 	}
 
 	@Override
-	public void formatXtextResource(XtextResource resource, ITypedPreferenceValues preferenceValues) {
+	public void formatXtextResource(XtextResource resource, ITypedPreferenceValues preferenceValues,
+			IFormattedResourceAcceptor acceptor) {
+		if (!resource.getAllContents().hasNext()) {
+			LOGGER.info("Resource " + resource.getURI() + " is empty.");
+			return;
+		}
+
+		LOGGER.info("Formatting file at location " + resource.getURI());
+
 		// setup request and formatter
 		FormatterRequest req = formatterRequestProvider.get();
 		req.setPreferences(preferenceValues);
@@ -57,20 +62,20 @@ public void formatXtextResource(XtextResource resource, ITypedPreferenceValues p
 		req.setTextRegionAccess(regionAccess);
 
 		// list contains all the replacements which should be applied to resource
-		List<ITextReplacement> replacements = formatter.format(req);
+		List<ITextReplacement> replacements;
+		try {
+			replacements = formatter.format(req); // throws exception
+		} catch (RuntimeException e) {
+			LOGGER.error("RuntimeException in " + resource.getURI() + ": " + e.getMessage(), e);
+			replacements = new ArrayList<>();
+		}
 
 		// formatting using TextRegionRewriter
 		ITextRegionRewriter regionRewriter = regionAccess.getRewriter();
 		String formattedString = regionRewriter.renderToString(regionAccess.regionForDocument(), replacements);
 
-		// With the formatted text, update the resource
-		InputStream resultStream = new ByteArrayInputStream(formattedString.getBytes(StandardCharsets.UTF_8));
-		resource.unload();
-		try {
-			resource.load(resultStream, null);
-		} catch (IOException e) {
-			throw new UncheckedIOException(
-					"Since the resource is an in-memory string, this exception is not expected to be ever thrown.", e);
-		}
+		// Perform handler operation
+		acceptor.accept(resource, formattedString);
 	}
+
 }