Merge branch 'master' into add-directive-creation

# Conflicts:
#	gradle.properties

Author: yarinvak

README.md

@@ -12,7 +12,7 @@ syntax for GraphQL schema definition.
 
 ```groovy
 dependencies {
-  compile "io.github.graphql-java:graphql-java-annotations:5.3"
+  compile "io.github.graphql-java:graphql-java-annotations:5.4"
 }
 ```
 
@@ -22,7 +22,7 @@ dependencies {
 <dependency>
     <groupId>io.github.graphql-java</groupId>
     <artifactId>graphql-java-annotations</artifactId>
-    <version>5.3</version>
+    <version>5.4</version>
 </dependency>
 ```
 

gradle.properties

@@ -7,4 +7,4 @@ org.gradle.jvmargs=-Dfile.encoding=UTF-8
 
 bintray.user=DUMMY_USER
 bintray.key=DUMMY_KEY
-version = 5.3.1
+version = 5.3.1

src/main/java/graphql/annotations/dataFetchers/MethodDataFetcher.java

@@ -23,14 +23,35 @@
 
 import java.lang.reflect.*;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 import static graphql.annotations.processor.util.NamingKit.toGraphqlName;
 import static graphql.annotations.processor.util.PrefixesUtil.addPrefixToPropertyName;
+import static graphql.annotations.processor.util.PrefixesUtil.extractPrefixedName;
 import static graphql.annotations.processor.util.ReflectionKit.constructNewInstance;
 import static graphql.annotations.processor.util.ReflectionKit.newInstance;
 
+
+/**
+ * This class is determining how to return value of a method from an api entity
+ * The order of the mapping:
+ * 1. If no source is provided to map between - invoking the method implementation
+ * 2. If annotated with @GraphQLInvokeDetached - invoking the method implementation
+ * 3. else If source is provided, and method name is matching a method name in the source object - execute source implementation
+ * i.e method name is: `name` ; existing method in the source object with name: `name`
+ * 4. else If source is provided, and method name is matching a method name with a `get` prefix in the source object - execute source implementation
+ * i.e method name is: `name` ; existing method in the source object with name: `getName`
+ * 5. else If source is provided, and method name is matching a method name with a `is` prefix in the source object - execute source implementation
+ * i.e method name is: `name` ; existing method in the source object with name: isName
+ * 6. else If source is provided, and method name is matching a field name in the source object - return field value from the source object
+ * i.e method name is: `name` ; field name in source object is: `name`
+ * 7. else If source is provided, and method name is prefixed with `get` or `is` - and it matches to a field name (without the prefix) in the source object - return field value from the source object
+ * i.e method name is: `getName` ; field name in source object is: `name`
+ *
+ * @param <T> type of the returned value
+ */
 public class MethodDataFetcher<T> implements DataFetcher<T> {
     private final Method method;
     private final ProcessingElementsContainer container;
@@ -47,7 +68,10 @@ public MethodDataFetcher(Method method, TypeFunction typeFunction, ProcessingEle
     public T get(DataFetchingEnvironment environment) {
         try {
             T obj;
-            if (method.isAnnotationPresent(GraphQLBatched.class) || method.isAnnotationPresent(GraphQLInvokeDetached.class)) {
+            if (Modifier.isStatic(method.getModifiers())){
+                return (T) method.invoke(null, invocationArgs(environment, container));
+            }
+            else if (method.isAnnotationPresent(GraphQLBatched.class) || method.isAnnotationPresent(GraphQLInvokeDetached.class)) {
                 obj = newInstance((Class<T>) method.getDeclaringClass());
             } else if (!method.getDeclaringClass().isInstance(environment.getSource())) {
                 obj = newInstance((Class<T>) method.getDeclaringClass(), environment.getSource());
@@ -59,7 +83,7 @@ public T get(DataFetchingEnvironment environment) {
             }
 
             if (obj == null && environment.getSource() != null) {
-                Object value = getGraphQLFieldValue(environment.getSource(), environment.getField().getName());
+                Object value = getGraphQLFieldValue(environment.getSource(), method.getName());
                 return (T) value;
             }
 
@@ -140,20 +164,43 @@ private Object getGraphQLFieldValue(Object source, String fieldName) throws Ille
         Object methodValue = getValueFromMethod(source, fieldName);
         if (methodValue != null) return methodValue;
 
-        Field field = getField(source.getClass(), fieldName);
-        if (getValueFromField(field)) return field.get(source);
+        Object fieldValue = getValueFromField(source, fieldName);
+        if (fieldValue != null) return fieldValue;
 
         throw new NoSuchFieldException("No GraphQL field found");
     }
 
-    private boolean getValueFromField(Field field) throws IllegalAccessException {
+    private Object getValueFromField(Object source, String fieldName) throws IllegalAccessException {
+        List<String> namesToSearchFor = Arrays.asList(fieldName, extractPrefixedName(fieldName));
+        for (String name : namesToSearchFor) {
+            Field field = getField(source.getClass(), name);
+            if (isFieldContainsValue(field)) {
+                return field.get(source);
+            }
+        }
+        return null;
+    }
+
+    private boolean isFieldContainsValue(Field field) throws IllegalAccessException {
         if (field != null) {
             field.setAccessible(true);
             return true;
         }
         return false;
     }
 
+    private Field getField(Class<?> clazz, String name) {
+        Field field = null;
+        while (clazz != null && field == null) {
+            try {
+                field = clazz.getDeclaredField(name);
+            } catch (Exception ignored) {
+            }
+            clazz = clazz.getSuperclass();
+        }
+        return field;
+    }
+
     private Object getValueFromMethod(Object source, String fieldName) throws IllegalAccessException, InvocationTargetException {
         String[] orderedPrefixes = new String[]{"", "get", "is"};
         for (String orderedPrefix : orderedPrefixes) {
@@ -166,7 +213,13 @@ private Object getValueFromMethod(Object source, String fieldName) throws Illega
     }
 
     private Method getMethod(Class<?> clazz, String name, String prefix) {
-        String prefixedName = addPrefixToPropertyName(prefix, name);
+        String prefixedName;
+        if (prefix.isEmpty()) {
+            prefixedName = name;
+        } else {
+            prefixedName = addPrefixToPropertyName(prefix, name);
+        }
+
         Method method = null;
         while (clazz != null && method == null) {
             try {
@@ -179,16 +232,4 @@ private Method getMethod(Class<?> clazz, String name, String prefix) {
         return method;
     }
 
-    private Field getField(Class<?> clazz, String name) {
-        Field field = null;
-        while (clazz != null && field == null) {
-            try {
-                field = clazz.getDeclaredField(name);
-            } catch (Exception ignored) {
-            }
-            clazz = clazz.getSuperclass();
-        }
-        return field;
-    }
-
 }

src/main/java/graphql/annotations/processor/retrievers/GraphQLFieldRetriever.java

@@ -58,6 +58,8 @@ public class GraphQLFieldRetriever {
 
     private DataFetcherConstructor dataFetcherConstructor;
 
+    private boolean alwaysPrettify = false;
+
     public GraphQLFieldRetriever(DataFetcherConstructor dataFetcherConstructor) {
         this.dataFetcherConstructor = dataFetcherConstructor;
     }
@@ -69,7 +71,7 @@ public GraphQLFieldRetriever() {
     public GraphQLFieldDefinition getField(Method method, ProcessingElementsContainer container) throws GraphQLAnnotationsException {
         GraphQLFieldDefinition.Builder builder = newFieldDefinition();
         TypeFunction typeFunction = getTypeFunction(method, container);
-        builder.name(new MethodNameBuilder(method).build());
+        builder.name(new MethodNameBuilder(method).alwaysPrettify(alwaysPrettify).build());
         GraphQLOutputType outputType = (GraphQLOutputType) new MethodTypeBuilder(method, typeFunction, container, false).build();
 
         boolean isConnection = ConnectionUtil.isConnection(method, outputType);
@@ -91,7 +93,7 @@ public GraphQLFieldDefinition getField(Method method, ProcessingElementsContaine
 
     public GraphQLFieldDefinition getField(Field field, ProcessingElementsContainer container) throws GraphQLAnnotationsException {
         GraphQLFieldDefinition.Builder builder = newFieldDefinition();
-        builder.name(new FieldNameBuilder(field).build());
+        builder.name(new FieldNameBuilder(field).alwaysPrettify(alwaysPrettify).build());
         TypeFunction typeFunction = getTypeFunction(field, container);
 
         GraphQLType outputType = typeFunction.buildType(field.getType(), field.getAnnotatedType(), container);
@@ -113,15 +115,15 @@ public GraphQLFieldDefinition getField(Field field, ProcessingElementsContainer
 
     public GraphQLInputObjectField getInputField(Method method, ProcessingElementsContainer container) throws GraphQLAnnotationsException {
         GraphQLInputObjectField.Builder builder = newInputObjectField();
-        builder.name(new MethodNameBuilder(method).build());
+        builder.name(new MethodNameBuilder(method).alwaysPrettify(alwaysPrettify).build());
         TypeFunction typeFunction = getTypeFunction(method, container);
         GraphQLInputType inputType = (GraphQLInputType) new MethodTypeBuilder(method, typeFunction, container, true).build();
         return builder.type(inputType).description(new DescriptionBuilder(method).build()).build();
     }
 
     public GraphQLInputObjectField getInputField(Field field, ProcessingElementsContainer container) throws GraphQLAnnotationsException {
         GraphQLInputObjectField.Builder builder = newInputObjectField();
-        builder.name(new FieldNameBuilder(field).build());
+        builder.name(new FieldNameBuilder(field).alwaysPrettify(alwaysPrettify).build());
         TypeFunction typeFunction = getTypeFunction(field, container);
         GraphQLType graphQLType = typeFunction.buildType(true, field.getType(), field.getAnnotatedType(), container);
         return builder.type((GraphQLInputType) graphQLType).description(new DescriptionBuilder(field).build()).build();
@@ -204,6 +206,10 @@ private GraphQLObjectType getActualType(GraphQLObjectType type, Map<String, grap
         return type;
     }
 
+    public void setAlwaysPrettify(boolean alwaysPrettify) {
+        this.alwaysPrettify = alwaysPrettify;
+    }
+
     @Reference(policy = ReferencePolicy.DYNAMIC, policyOption = ReferencePolicyOption.GREEDY)
     public void setDataFetcherConstructor(DataFetcherConstructor dataFetcherConstructor) {
         this.dataFetcherConstructor = dataFetcherConstructor;

src/main/java/graphql/annotations/processor/retrievers/fieldBuilders/field/FieldNameBuilder.java

@@ -25,13 +25,20 @@
 public class FieldNameBuilder implements Builder<String> {
     private Field field;
 
+    private boolean alwaysPrettify = false;
+
     public FieldNameBuilder(Field field) {
         this.field = field;
     }
 
+    public FieldNameBuilder alwaysPrettify(boolean alwaysPrettify) {
+        this.alwaysPrettify = alwaysPrettify;
+        return this;
+    }
+
     @Override
     public String build() {
-        if (field.isAnnotationPresent(GraphQLPrettify.class) && !field.isAnnotationPresent(GraphQLName.class)) {
+        if ((alwaysPrettify || field.isAnnotationPresent(GraphQLPrettify.class)) && !field.isAnnotationPresent(GraphQLName.class)) {
             return toGraphqlName(prettifyName(field.getName()));
         }
         GraphQLName name = field.getAnnotation(GraphQLName.class);

src/main/java/graphql/annotations/processor/retrievers/fieldBuilders/method/MethodNameBuilder.java

@@ -17,6 +17,7 @@
 import graphql.annotations.annotationTypes.GraphQLName;
 import graphql.annotations.annotationTypes.GraphQLPrettify;
 import graphql.annotations.processor.retrievers.fieldBuilders.Builder;
+import graphql.annotations.processor.retrievers.fieldBuilders.field.FieldNameBuilder;
 
 import java.lang.reflect.Method;
 
@@ -25,13 +26,20 @@
 public class MethodNameBuilder implements Builder<String> {
     private Method method;
 
+    private boolean alwaysPrettify = false;
+
     public MethodNameBuilder(Method method) {
         this.method = method;
     }
 
+    public MethodNameBuilder alwaysPrettify(boolean alwaysPrettify) {
+        this.alwaysPrettify = alwaysPrettify;
+        return this;
+    }
+
     @Override
     public String build() {
-        if (method.isAnnotationPresent(GraphQLPrettify.class) && !method.isAnnotationPresent(GraphQLName.class)) {
+        if ((alwaysPrettify || method.isAnnotationPresent(GraphQLPrettify.class)) && !method.isAnnotationPresent(GraphQLName.class)) {
             return toGraphqlName(prettifyName(method.getName()));
         }
         GraphQLName name = method.getAnnotation(GraphQLName.class);

src/main/java/graphql/annotations/processor/util/PrefixesUtil.java

@@ -18,4 +18,13 @@ public class PrefixesUtil {
     public static String addPrefixToPropertyName(String prefix, String propertyName) {
         return prefix + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
     }
+
+    public static String extractPrefixedName(String name) {
+        if (name.startsWith("is")) {
+            return name.replaceFirst("^is", "").toLowerCase();
+        } else if (name.startsWith("get")) {
+            return name.replaceFirst("^get", "").toLowerCase();
+        }
+        return name;
+    }
 }