Fix for AnnotationIntrospector to support overridden methods.

Some utility methods from the Spring Framework project have
been included to support this.

Author: UnquietCode

src/main/java/unquietcode/tools/flapi/SpringMethodUtils.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package unquietcode.tools.flapi;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Method reflection methods copied from Spring Framework's ReflectionUtils class,
+ * with the minimum modifications.
+ */
+public class SpringMethodUtils {
+
+
+	/**
+	 * Perform the given callback operation on all matching methods of the given
+	 * class and superclasses.
+	 * <p>The same named method occurring on subclass and superclass will appear
+	 * twice, unless excluded by a {@link MethodFilter}.
+	 * @param clazz class to start looking at
+	 * @param mc the callback to invoke for each method
+	 * @see #doWithMethods(Class, MethodCallback, MethodFilter)
+	 */
+	public static void doWithMethods(Class<?> clazz, MethodCallback mc) throws IllegalArgumentException {
+		doWithMethods(clazz, mc, null);
+	}
+
+	/**
+	 * Perform the given callback operation on all matching methods of the given
+	 * class and superclasses (or given interface and super-interfaces).
+	 * <p>The same named method occurring on subclass and superclass will appear
+	 * twice, unless excluded by the specified {@link MethodFilter}.
+	 * @param clazz class to start looking at
+	 * @param mc the callback to invoke for each method
+	 * @param mf the filter that determines the methods to apply the callback to
+	 */
+	public static void doWithMethods(Class<?> clazz, MethodCallback mc, MethodFilter mf)
+			throws IllegalArgumentException {
+
+		// Keep backing up the inheritance hierarchy.
+		Method[] methods = clazz.getDeclaredMethods();
+		for (Method method : methods) {
+			if (mf != null && !mf.matches(method)) {
+				continue;
+			}
+			try {
+				mc.doWith(method);
+			}
+			catch (IllegalAccessException ex) {
+				throw new IllegalStateException("Shouldn't be illegal to access method '" + method.getName() + "': " + ex);
+			}
+		}
+		if (clazz.getSuperclass() != null) {
+			doWithMethods(clazz.getSuperclass(), mc, mf);
+		}
+		else if (clazz.isInterface()) {
+			for (Class<?> superIfc : clazz.getInterfaces()) {
+				doWithMethods(superIfc, mc, mf);
+			}
+		}
+	}
+	/**
+	 * Get the unique set of declared methods on the leaf class and all superclasses. Leaf
+	 * class methods are included first and while traversing the superclass hierarchy any methods found
+	 * with signatures matching a method already included are filtered out.
+	 */
+	public static Method[] getUniqueDeclaredMethods(Class<?> leafClass) throws IllegalArgumentException {
+		final List<Method> methods = new ArrayList<Method>(32);
+		doWithMethods(leafClass, new MethodCallback() {
+			@Override
+			public void doWith(Method method) {
+				boolean knownSignature = false;
+				Method methodBeingOverriddenWithCovariantReturnType = null;
+				for (Method existingMethod : methods) {
+					if (method.getName().equals(existingMethod.getName()) &&
+							Arrays.equals(method.getParameterTypes(), existingMethod.getParameterTypes())) {
+						// Is this a covariant return type situation?
+						if (existingMethod.getReturnType() != method.getReturnType() &&
+								existingMethod.getReturnType().isAssignableFrom(method.getReturnType())) {
+							methodBeingOverriddenWithCovariantReturnType = existingMethod;
+						}
+						else {
+							knownSignature = true;
+						}
+						break;
+					}
+				}
+				if (methodBeingOverriddenWithCovariantReturnType != null) {
+					methods.remove(methodBeingOverriddenWithCovariantReturnType);
+				}
+				if (!knownSignature) {
+					methods.add(method);
+				}
+			}
+		});
+		return methods.toArray(new Method[methods.size()]);
+	}
+
+
+	/**
+	 * Action to take on each method.
+	 */
+	public interface MethodCallback {
+
+		/**
+		 * Perform an operation using the given method.
+		 * @param method the method to operate on
+		 */
+		void doWith(Method method) throws IllegalArgumentException, IllegalAccessException;
+	}
+
+
+	/**
+	 * Callback optionally used to filter methods to be operated on by a method callback.
+	 */
+	public interface MethodFilter {
+
+		/**
+		 * Determine whether the given method matches.
+		 * @param method the method to check
+		 */
+		boolean matches(Method method);
+	}
+}

src/main/java/unquietcode/tools/flapi/annotations/AnnotationIntrospector.java

@@ -21,6 +21,7 @@
 import unquietcode.tools.flapi.Constants;
 import unquietcode.tools.flapi.DescriptorBuilderException;
 import unquietcode.tools.flapi.IntrospectorSupport;
+import unquietcode.tools.flapi.SpringMethodUtils;
 import unquietcode.tools.flapi.beans.BeanIntrospector;
 import unquietcode.tools.flapi.helpers.AnnotationsHelperImpl;
 import unquietcode.tools.flapi.helpers.DocumentationHelperImpl;
@@ -32,10 +33,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
@@ -49,7 +47,7 @@ public class AnnotationIntrospector extends IntrospectorSupport {
 	public static boolean isAnnotated(Class<?> clazz) {
 
 		// for every method in the class
-		for (Method method : clazz.getDeclaredMethods()) {
+		for (Method method : getAllMethods(clazz)) {
 			List<Annotation> methodQuantifiers = findAnnotatedElements(MethodQuantifier.class, method.getAnnotations());
 
 			// if the method has at least one marker
@@ -65,6 +63,11 @@ public static boolean isAnnotated(Class<?> clazz) {
 		return false;
 	}
 
+	private static Set<Method> getAllMethods(Class<?> clazz) {
+		Method[] methods = SpringMethodUtils.getUniqueDeclaredMethods(clazz);
+		return new HashSet<Method>(Arrays.asList(methods));
+	}
+
 	public DescriptorOutline createDescriptor(Class<?> clazz) {
 		DescriptorOutline descriptor = new DescriptorOutline();
 		descriptor.setPackageName(clazz.getPackage().getName() + ".builder");
@@ -107,7 +110,7 @@ private boolean handleClass(BlockOutline blockOutline, Class<?> blockClass) {
 
 		boolean atLeastOne = false;
 
-		for (Method method : blockClass.getDeclaredMethods()) {
+		for (Method method : getAllMethods(blockClass)) {
 			List<Annotation> methodQuantifiers = findAnnotatedElements(MethodQuantifier.class, method.getAnnotations());
 
 			// skip methods which are not annotated