HSEARCH-5021 Include annotation attributes in the params map for value binders

Author: marko-bekhta

mapper/pojo-base/src/main/java/org/hibernate/search/mapper/pojo/logging/impl/Log.java

@@ -920,4 +920,15 @@ SearchException invalidFieldEncodingForVectorFieldMapping(IndexFieldTypeOptionsS
 			+ "i.e. extraction must be set to DEFAULT and a nonempty array of container value extractor names provided, "
 			+ "e.g. @ContainerExtraction(extract = ContainerExtract.DEFAULT, value = { ... }).")
 	SearchException vectorFieldMustUseExplicitExtractorPath();
+
+	@Message(id = ID_OFFSET + 147, value = "Unable to obtain annotation attributes from '%1$s': %2$s")
+	SearchException unexpectedExceptionWhenObtainingAnnotationAttributes(@FormatWith(ClassFormatter.class) Class<?> annotation,
+			String message, @Cause Exception e);
+
+	@LogMessage(level = Logger.Level.WARN)
+	@Message(id = ID_OFFSET + 148,
+			value = "The attribute value '%3$s' of '%1$s annotation got overridden with a @org.hibernate.search.mapper.pojo.common.annotation.Param(name = \"%2$s\", value=%4$s). "
+					+ "If access to the annotation attribute is required, consider using a different parameter name for this @Param.")
+	void annotationAttributeOverriddenWithParameter(@FormatWith(ClassFormatter.class) Class<?> annotation, String parameterName,
+			Object overriddenValue, Object parameterValue);
 }

mapper/pojo-base/src/main/java/org/hibernate/search/mapper/pojo/mapping/definition/annotation/processing/MappingAnnotationProcessorContext.java

@@ -6,6 +6,7 @@
  */
 package org.hibernate.search.mapper.pojo.mapping.definition.annotation.processing;
 
+import java.lang.annotation.Annotation;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -104,6 +105,28 @@ default Map<String, Object> toMap(Param[] params) {
 		return MappingAnnotationProcessorUtils.toMap( params );
 	}
 
+	/**
+	 * @param annotation The original annotation.
+	 * @return A {@link Map map} containing annotation attributes.
+	 * Use {@link #annotationAttributeMapKey(Class, String)} to build a map key for a corresponding annotation attribute.
+	 * @param <A> The type of the annotation.
+	 * @see #annotationAttributeMapKey(Class, String)
+	 */
+	default <A extends Annotation> Map<String, Object> toMap(A annotation) {
+		return MappingAnnotationProcessorUtils.toMap( annotation );
+	}
+
+	/**
+	 * @param annotation Tha annotation for which the map key should be created.
+	 * @param attribute The name of an annotation attribute.
+	 * @return The map key to retrieve annotation attributes from the parameters map.
+	 * @param <A> The type of the annotation.
+	 * @see #toMap(Annotation)
+	 */
+	default <A extends Annotation> String annotationAttributeMapKey(Class<A> annotation, String attribute) {
+		return MappingAnnotationProcessorUtils.annotationAttributeMapKey( annotation, attribute );
+	}
+
 	/**
 	 * @param value A value extracted from an annotation attribute.
 	 * @param defaultValue A default value for that annotation attribute.

mapper/pojo-base/src/main/java/org/hibernate/search/mapper/pojo/mapping/definition/annotation/processing/impl/AbstractFieldAnnotationProcessor.java

@@ -46,8 +46,15 @@ public final void process(PropertyMappingStep mappingContext, A annotation,
 				valueBinder,
 				context
 		);
+		Map<String, Object> params = context.toMap( annotation );
+		for ( Map.Entry<String, Object> entry : context.toMap( valueBinder.params() ).entrySet() ) {
+			Object overriddenValue = params.put( entry.getKey(), entry.getValue() );
+			if ( overriddenValue != null ) {
+				log.annotationAttributeOverriddenWithParameter( annotation.annotationType(), entry.getKey(), overriddenValue,
+						entry.getValue() );
+			}
+		}
 
-		Map<String, Object> params = context.toMap( valueBinder.params() );
 		fieldContext.valueBinder( binder, params );
 
 		ContainerExtractorPath extractorPath = context.toContainerExtractorPath( getExtraction( annotation ) );

mapper/pojo-base/src/main/java/org/hibernate/search/mapper/pojo/mapping/definition/annotation/processing/impl/MappingAnnotationProcessorUtils.java

@@ -6,9 +6,13 @@
  */
 package org.hibernate.search.mapper.pojo.mapping.definition.annotation.processing.impl;
 
+import java.lang.annotation.Annotation;
 import java.lang.invoke.MethodHandles;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -112,4 +116,28 @@ public static Set<String> cleanUpPaths(String[] pathsArray) {
 		}
 		return paths;
 	}
+
+	public static <A extends Annotation> Map<String, Object> toMap(A annotation) {
+		if ( annotation == null ) {
+			return Collections.emptyMap();
+		}
+		Map<String, Object> attributes = new HashMap<>();
+		Class<? extends Annotation> annotationType = annotation.annotationType();
+		for ( Method method : annotationType.getDeclaredMethods() ) {
+			try {
+				attributes.put( annotationAttributeMapKey( annotationType, method.getName() ), method.invoke( annotation ) );
+			}
+			catch (InvocationTargetException | IllegalAccessException e) {
+				throw log.unexpectedExceptionWhenObtainingAnnotationAttributes( annotationType, e.getMessage(), e );
+			}
+		}
+
+		return attributes;
+	}
+
+	public static <A extends Annotation> String annotationAttributeMapKey(Class<A> annotation, String attribute) {
+		Contracts.assertNotNull( annotation, "annotation" );
+		Contracts.assertNotNullNorEmpty( attribute, "attribute" );
+		return annotation.getName() + "#" + attribute;
+	}
 }

mapper/pojo-base/src/test/java/org/hibernate/search/mapper/pojo/mapping/definition/annotation/processing/impl/MappingAnnotationProcessorUtilsTest.java

@@ -0,0 +1,45 @@
+/*
+ * Hibernate Search, full-text search for your domain model
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.search.mapper.pojo.mapping.definition.annotation.processing.impl;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hibernate.search.mapper.pojo.mapping.definition.annotation.processing.impl.MappingAnnotationProcessorUtils.annotationAttributeMapKey;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.jupiter.api.Test;
+
+class MappingAnnotationProcessorUtilsTest {
+
+	@Test
+	void toMap() {
+		MyAnnotation annotation = Annotated.class.getAnnotation( MyAnnotation.class );
+
+		assertThat( MappingAnnotationProcessorUtils.toMap( annotation ) )
+				.containsEntry( annotationAttributeMapKey( MyAnnotation.class, "string" ), "" )
+				.containsEntry( annotationAttributeMapKey( MyAnnotation.class, "integer" ), 100 )
+				.containsEntry( annotationAttributeMapKey( MyAnnotation.class, "type" ), Annotated.class );
+	}
+
+	@Target(ElementType.TYPE)
+	@Retention(RetentionPolicy.RUNTIME)
+	@interface MyAnnotation {
+		String string() default "";
+
+		int integer();
+
+		Class<?> type() default Object.class;
+
+	}
+
+	@MyAnnotation(integer = 100, type = Annotated.class)
+	private static class Annotated {
+	}
+}