Introduce OfficeStamperErrorHandler for custom error handling

Implemented a new interface, OfficeStamperErrorHandler, and integrated it into various classes to allow users to define custom error resolution strategies. This change replaces the use of Function<ReflectiveOperationException, TypedValue> with the new interface for more flexibility and improved error handling consistency.
verronpro · Sep 17, 2024 · 65cf573 · 65cf573
1 parent 7550ae5
commit 65cf573
Show file tree

Hide file tree

Showing 8 changed files with 34 additions and 30 deletions.
diff --git a/engine/src/main/java/pro/verron/officestamper/api/OfficeStamperConfiguration.java b/engine/src/main/java/pro/verron/officestamper/api/OfficeStamperConfiguration.java
@@ -6,11 +6,13 @@
 import java.util.Map;
 import java.util.function.Function;
 
-/**
- * Represents the configuration for the OfficeStamper class.
- */
 public interface OfficeStamperConfiguration {
 
+    static UnresolvedExpressionHandler getUnresolvedExpressionHandler(OfficeStamperConfiguration configuration) {
+        return configuration.isFailOnUnresolvedExpression()
+                ? OfficeStamperException::sneakyThrow
+                : exception -> null;
+    }
 
     /**
      * Checks if the failOnUnresolvedExpression flag is set to true or false.

diff --git a/engine/src/main/java/pro/verron/officestamper/api/OfficeStamperErrorHandler.java b/engine/src/main/java/pro/verron/officestamper/api/OfficeStamperErrorHandler.java
@@ -0,0 +1,7 @@
+package pro.verron.officestamper.api;
+
+import org.springframework.lang.Nullable;
+
+public interface OfficeStamperErrorHandler {
+    @Nullable Object resolve(Exception exception);
+}
diff --git a/engine/src/main/java/pro/verron/officestamper/api/UnresolvedExpressionHandler.java b/engine/src/main/java/pro/verron/officestamper/api/UnresolvedExpressionHandler.java
@@ -0,0 +1,5 @@
+package pro.verron.officestamper.api;
+
+public interface UnresolvedExpressionHandler
+        extends OfficeStamperErrorHandler {
+}
diff --git a/engine/src/main/java/pro/verron/officestamper/core/DocxStamper.java b/engine/src/main/java/pro/verron/officestamper/core/DocxStamper.java
@@ -3,7 +3,6 @@
 import org.docx4j.openpackaging.exceptions.Docx4JException;
 import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
 import org.docx4j.openpackaging.parts.relationships.Namespaces;
-import org.springframework.expression.TypedValue;
 import org.springframework.expression.spel.SpelParserConfiguration;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.expression.spel.support.StandardEvaluationContext;
@@ -12,6 +11,7 @@
 
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -49,7 +49,8 @@ public DocxStamper(OfficeStamperConfiguration configuration) {
                 configuration.getResolvers(),
                 configuration.getCommentProcessors(),
                 configuration.getPreprocessors(),
-                configuration.getSpelParserConfiguration());
+                configuration.getSpelParserConfiguration(),
+                OfficeStamperConfiguration.getUnresolvedExpressionHandler(configuration));
     }
 
     private DocxStamper(
@@ -63,23 +64,19 @@ private DocxStamper(
             List<ObjectResolver> resolvers,
             Map<Class<?>, Function<ParagraphPlaceholderReplacer, CommentProcessor>> configurationCommentProcessors,
             List<PreProcessor> preprocessors,
-            SpelParserConfiguration spelParserConfiguration
+            SpelParserConfiguration spelParserConfiguration,
+            UnresolvedExpressionHandler unresolvedExpressionHandler
     ) {
         var commentProcessors = new HashMap<Class<?>, Object>();
 
-        Function<ReflectiveOperationException, TypedValue> onResolutionFail = failOnUnresolvedExpression
-                ? DocxStamper::throwException
-                : exception -> new TypedValue(null);
-
         final StandardMethodResolver methodResolver = new StandardMethodResolver(commentProcessors,
                 expressionFunctions,
-                onResolutionFail);
+                unresolvedExpressionHandler);
 
         var evaluationContext = new StandardEvaluationContext();
         evaluationContextConfigurer.configureEvaluationContext(evaluationContext);
         evaluationContext.addMethodResolver(methodResolver);
 
-
         var expressionParser = new SpelExpressionParser(spelParserConfiguration);
         var expressionResolver = new ExpressionResolver(evaluationContext, expressionParser);
 
@@ -100,18 +97,12 @@ private DocxStamper(
             commentProcessors.put(aClass, value);
         }
 
-
         this.commentProcessorRegistrySupplier = source -> new CommentProcessorRegistry(source,
                 expressionResolver,
                 commentProcessors,
                 failOnUnresolvedExpression);
 
-        this.preprocessors = preprocessors.stream()
-                                          .toList();
-    }
-
-    private static TypedValue throwException(ReflectiveOperationException exception) {
-        throw new OfficeStamperException("Error calling method", exception);
+        this.preprocessors = new ArrayList<>(preprocessors);
     }
 
     /**

diff --git a/engine/src/main/java/pro/verron/officestamper/core/DocxStamperConfiguration.java b/engine/src/main/java/pro/verron/officestamper/core/DocxStamperConfiguration.java
@@ -46,8 +46,7 @@ public class DocxStamperConfiguration
     public DocxStamperConfiguration() {
         CommentProcessorFactory pf = new CommentProcessorFactory(this);
         commentProcessors.put(CommentProcessorFactory.IRepeatProcessor.class, pf::repeat);
-        commentProcessors.put(CommentProcessorFactory.IParagraphRepeatProcessor.class,
-                pf::repeatParagraph);
+        commentProcessors.put(CommentProcessorFactory.IParagraphRepeatProcessor.class, pf::repeatParagraph);
         commentProcessors.put(CommentProcessorFactory.IRepeatDocPartProcessor.class, pf::repeatDocPart);
         commentProcessors.put(CommentProcessorFactory.ITableResolver.class, pf::tableResolver);
         commentProcessors.put(CommentProcessorFactory.IDisplayIfProcessor.class, pf::displayIf);

diff --git a/engine/src/main/java/pro/verron/officestamper/core/PlaceholderReplacer.java b/engine/src/main/java/pro/verron/officestamper/core/PlaceholderReplacer.java
@@ -87,7 +87,8 @@ public void resolveExpressions(DocxPart document, Object expressionContext) {
      * @param context   the context root
      */
     @Override public void resolveExpressionsForParagraph(
-            DocxPart docxPart, Paragraph paragraph,
+            DocxPart docxPart,
+            Paragraph paragraph,
             Object context
     ) {
 

diff --git a/engine/src/main/java/pro/verron/officestamper/core/StandardMethodExecutor.java b/engine/src/main/java/pro/verron/officestamper/core/StandardMethodExecutor.java
@@ -4,9 +4,9 @@
 import org.springframework.expression.MethodExecutor;
 import org.springframework.expression.TypedValue;
 import org.springframework.lang.NonNull;
+import pro.verron.officestamper.api.UnresolvedExpressionHandler;
 
 import java.lang.reflect.InvocationTargetException;
-import java.util.function.Function;
 
 /**
  * This class is a wrapper around a method call which can be executed by the Spring Expression Language.
@@ -19,7 +19,7 @@
 public class StandardMethodExecutor implements MethodExecutor {
 
 	private final Invoker invoker;
-	private final Function<ReflectiveOperationException, TypedValue> onFail;
+	private final UnresolvedExpressionHandler onFail;
 
 	/**
 	 * <p>Constructor for StandardMethodExecutor.</p>
@@ -28,7 +28,7 @@ public class StandardMethodExecutor implements MethodExecutor {
 	 * @param onFail  a function that is called if the invoker throws an exception. The function may return a default
 	 *                value to be returned by the {@link #execute(EvaluationContext, Object, Object...)} method.
 	 */
-	public StandardMethodExecutor(Invoker invoker, Function<ReflectiveOperationException, TypedValue> onFail) {
+	public StandardMethodExecutor(Invoker invoker, UnresolvedExpressionHandler onFail) {
 		this.invoker = invoker;
 		this.onFail = onFail;
 	}
@@ -45,7 +45,7 @@ public TypedValue execute(
 			Object value = invoker.invoke(arguments);
 			return new TypedValue(value);
 		} catch (InvocationTargetException | IllegalAccessException e) {
-			return onFail.apply(e);
+			return new TypedValue(onFail.resolve(e));
 		}
 	}
 

diff --git a/engine/src/main/java/pro/verron/officestamper/core/StandardMethodResolver.java b/engine/src/main/java/pro/verron/officestamper/core/StandardMethodResolver.java
@@ -4,14 +4,13 @@
 import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.MethodExecutor;
 import org.springframework.expression.MethodResolver;
-import org.springframework.expression.TypedValue;
 import org.springframework.lang.NonNull;
+import pro.verron.officestamper.api.UnresolvedExpressionHandler;
 
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.function.Function;
 
 /**
  * Resolves methods that are used as expression functions or comment processors.
@@ -23,7 +22,7 @@
 public class StandardMethodResolver implements MethodResolver {
 	private final Map<Class<?>, Object> commentProcessors;
 	private final Map<Class<?>, Object> expressionFunctions;
-	private final Function<ReflectiveOperationException, TypedValue> onFail;
+	private final UnresolvedExpressionHandler onFail;
 
 	/**
 	 * <p>Constructor for StandardMethodResolver.</p>
@@ -35,7 +34,7 @@ public class StandardMethodResolver implements MethodResolver {
 	public StandardMethodResolver(
 			Map<Class<?>, Object> commentProcessors,
 			Map<Class<?>, Object> expressionFunctions,
-			Function<ReflectiveOperationException, TypedValue> onResolutionFail
+			UnresolvedExpressionHandler onResolutionFail
 	) {
 		this.commentProcessors = commentProcessors;
 		this.expressionFunctions = expressionFunctions;